code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
if __name__ == "__main__":
N = int(input())
mod = N % 1000
q = N // 1000
if mod != 0:
q += 1
ans = 1000 * q - N
print(ans) | d,t,s = input().split()
gool = int(d) / int(s)
if gool <= int(t):
print('Yes')
else:
print('No') | 0 | null | 6,013,648,184,960 | 108 | 81 |
#dp[n][t]=max(dp[n-1][t],dp[n-1][t-A[n]]+B[n])
#dp[0][t]=0, dp[n][0]=0,0<=t<=T+max(B)-1, 0<=n<=N
def solve():
N, T = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(N)]
X.sort()
dp = [[0]*(T+3000) for _ in range(N+1)]
for n in range(1,N+1):
for t in range(1,T+X[n-1][0]):
dp[n][t]=dp[n-1][t]
if t>=X[n-1][0]:
dp[n][t]=max(dp[n][t],dp[n-1][t-X[n-1][0]]+X[n-1][1])
ans = max(dp[N])
return ans
print(solve()) | import sys
import numpy as np
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def main():
N,T = MI()
max_T = -1
dish = []
for i in range(N):
A,B = MI()
dish.append([A,B])
dish.sort(key=lambda x : x[0])
max_T = max(max_T, A)
dp=np.array([-1 for _ in range(T+max_T)])
dp[0] = 0
upper = 1
for i in range(N):
ch = (dp>=0)
ch[T:] = False
ch2 = np.roll(ch, dish[i][0])
ch2[:dish[i][0]]=False
dp[ch2] = np.maximum(dp[ch2] , dp[ch] + dish[i][1])
print(max(dp))
main() | 1 | 151,288,156,011,232 | null | 282 | 282 |
N = int(input())
p = 10**9 + 7
A = [int(i) for i in input().split()]
S = sum(A)%p
ans = S**2 % p
B = [(i**2%p) for i in A]
ans -= sum(B)%p
if ans < 0:
ans += p
if ans % 2 == 0:
print(ans//2)
else:
print((ans+p)//2) | num = int(input())
input_line = input().split()
law = 10 ** 9 + 7
num_list = [int(input_line[i])%law for i in range(num)]
sigma = 0
temp_sum = 0
for j in range(num):
temp_sum += num_list[j]
for i in range(num):
num_a = num_list[i]
temp_sum -= num_a
sigma += num_a * temp_sum
sigma %= law
print(sigma) | 1 | 3,786,112,805,382 | null | 83 | 83 |
n, m = map(int, raw_input().split())
a, b, result = list(), list(), list()
for _ in range(n):
a.append(map(int, raw_input().split()))
for _ in range(m):
b.append(int(raw_input()))
for i in range(n):
temp = 0
for j in range(m):
temp += a[i][j] * b[j]
result.append(temp)
for i in result:
print(i) | from itertools import*
c=[f'{x} {y}'for x,y in product('SHCD',range(1,14))]
exec('c.remove(input());'*int(input()))
if c:print(*c,sep='\n')
| 0 | null | 1,104,149,434,272 | 56 | 54 |
N, M = map(int, input().split())
A = input().split()
work_days = 0
for i in range(M):
work_days += int(A[i])
if work_days > N:
print(-1)
else:
print(N - work_days) | h,n=map(int,input().split())
inf=100000000000
dp=[inf]*(h+1)
dp[h]=0
for i in range(n):
a,b=map(int,input().split())
for j in range(h,-1,-1):
dp[max(j-a,0)]=min(dp[max(j-a,0)],dp[j]+b)
print(dp[0]) | 0 | null | 56,724,057,053,332 | 168 | 229 |
# -*- coding: UTF-8 -*-
lst = [int(raw_input()) for i in range(10)]
lst.sort()
lst.reverse()
print lst[0]
print lst[1]
print lst[2] | def main():
n, m = map(int, (input().split()))
a = [list(map(int, list(input().split()))) for item in range(n)]
b = [int(input()) for item in range(m)]
c = [sum(a_im * b_m for (a_im, b_m) in zip(a_i, b)) for a_i in a]
for c_i in c:
print(c_i)
main() | 0 | null | 585,336,829,572 | 2 | 56 |
#axino's copy
def move(up, bottom, right, left, front, back, direction):
if direction == 'N':
return(front, back, right, left, bottom, up)
elif direction == 'S':
return(back, front, right, left, up, bottom)
elif direction == 'E':
return(left, right, up, bottom, front, back)
elif direction == 'W':
return(right, left, bottom, up, front, back)
def check(up, bottom, right, left, front, back, up_current, front_current):
if front_current == front and up_current == up:
print(right)
elif front_current == front:
if left == up_current:
print(up)
elif bottom == up_current:
print(left)
elif right == up_current:
print(bottom)
elif up_current == up:
if right == front_current:
print(back)
elif back == front_current:
print(left)
elif left == front_current:
print(front)
else:
up, bottom, right, left, front, back = move(up, bottom, right, left, front, back, 'S')
check(up, bottom, right, left, front, back, up_current, front_current)
up, front, right, left, back, bottom = input().split()
times = int(input())
for i in range(times):
up_current, front_current = input().split()
check(up, bottom, right, left, front, back, up_current, front_current) | rot_set = [
(1,2,4,3,1), #0
(0,3,5,2,0), #1
(0,1,5,4,0), #2
(0,4,5,1,0), #3
(0,2,5,3,0), #4
(1,3,4,2,1) #5
]
dice_int = list(map(int, input().split()))
q = int(input())
right_face = []
for _ in range(q):
a, b = map(int, input().split())
a_idx = dice_int.index(a)
b_idx = dice_int.index(b)
for i in range(6):
for j in range(4):
if (a_idx, b_idx) == (rot_set[i][j], rot_set[i][j+1]):
right_face.append(dice_int[i])
for i in range(q):
print(right_face[i])
| 1 | 246,046,107,370 | null | 34 | 34 |
import itertools
N = int(input())
P=tuple(int(c) for c in input().split())
Q=tuple(int(c) for c in input().split())
l=list(c for c in itertools.permutations(range(1,N+1),N))
print(abs(l.index(P)-l.index(Q))) | 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) | 0 | null | 110,896,520,710,132 | 246 | 262 |
from sys import stdin
import sys
import math
from functools import reduce
import itertools
n = int(stdin.readline().rstrip())
a = [int(x) for x in stdin.readline().rstrip().split()]
if len(set(a)) == n:
print('YES')
else:
print('NO') | n = int(input())
a = list(map(int, input().split()))
b = set(a)
a.sort()
if len(a) != len(b):
print("NO")
else:
print("YES") | 1 | 73,742,379,546,414 | null | 222 | 222 |
import sys
import numpy as np
import numba
from numba import njit
i8 = numba.int64
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
@njit((i8[:], ), cache=True)
def main(S):
N = len(S)
L = np.empty(N, np.int64)
R = np.empty(N, np.int64)
x = y = 0
n = 0
for s in S:
if s == 0:
y += 1
elif s == 1:
if y:
y -= 1
else:
x += 1
else:
L[n], R[n] = x, y
n += 1
x = y = 0
L, R = L[:n], R[:n]
L1, R1 = L[L > R], R[L > R]
L2, R2 = L[L <= R], R[L <= R]
ind = R1.argsort()
L1, R1 = L1[ind], R1[ind]
ind = L2.argsort()[::-1]
L2, R2 = L2[ind], R2[ind]
L = np.concatenate((L1, L2))
R = np.concatenate((R1, R2))
n = 0
for i in range(len(L)):
if n < R[i]:
return False
n += L[i] - R[i]
return n == 0
N = int(readline())
S = np.array(list(read()), np.int64) - ord('(')
print('Yes' if main(S) else 'No') | from sys import stdin
input = stdin.readline
def main():
N, K = map(int, input().rstrip().split())
A = list(map(int, input().rstrip().split()))
F = list(map(int, input().rstrip().split()))
A.sort()
F.sort(reverse=True)
l = -1
r = 10 ** 12
while(r - l > 1):
c = (l + r) // 2
s = 0
for i in range(N):
d = A[i] - (c // F[i])
s += max(0, d)
if s <= K:
r = c
else:
l = c
print(r)
if __name__ == "__main__":
main()
| 0 | null | 93,864,994,423,410 | 152 | 290 |
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()]
Type = 26
Last = [0]*Type
Sats = 0
for TD in range(0,D):
Test = int(input())-1
Last[Test] = TD+1
Sats += S[TD][Test]
for TC in range(0,Type):
Sats -= C[TC]*(TD+1-Last[TC])
print(Sats) | def main():
D = int(input())
C = [0] * 26
C = list(map(int,input().split()))
S = [ list(map(int,input().split(" "))) for i in range(D)]
score = 0
last = [0] * 26
for i in range(D):
t = int(input())
for j in range(26):
if j+1 == t:
last[j] = 0
score += S[i][j]
else:
last[j] += 1
score -= last[j]*C[j]
print(score)
if __name__ == '__main__':
main() | 1 | 10,072,529,148,260 | null | 114 | 114 |
n = int(input())
l = list(map(int,input().split()))+[0]
l.sort(reverse=True)
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
left = j
right = n
while right - left > 1:
middle = (left + right)//2
if l[i]-l[j] < l[middle]:
left = middle
else:
right = middle
ans += (left-j)
print(ans) | import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np
from functools import reduce
rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7
a, b, x = rm()
x /= a
if a*b / 2 >= x:
a = 2*x / b
print(90 - math.degrees(math.atan(a/b)))
else:
x = a*b - x
b = 2*x / a
print(math.degrees(math.atan(b/a)))
| 0 | null | 166,812,329,809,330 | 294 | 289 |
class HashTable:
def __init__(self, size = 1000003):
self.size = size
self.hash_table = [None] * size
def _gen_key(self, val):
raw_hash_val = hash(val)
h1 = raw_hash_val % self.size
h2 = 1 + (raw_hash_val % (self.size - 1))
for i in range(self.size):
candidate_key = (h1 + i * h2) % self.size
if not self.hash_table[candidate_key] or self.hash_table[candidate_key] == val:
return candidate_key
def insert(self, val):
key = self._gen_key(val)
self.hash_table[key] = val
def search(self, val):
key = self._gen_key(val)
if self.hash_table[key]:
print('yes')
else:
print('no')
import sys
n = int(sys.stdin.readline())
simple_dict = HashTable()
ans = ''
for i in range(n):
operation = sys.stdin.readline()
if operation[0] == 'i':
simple_dict.insert(operation[7:])
else:
simple_dict.search(operation[5:]) | N = int(input())
s = input()
num_R = s.count('R')
print(s[:num_R].count('W')) | 0 | null | 3,180,668,439,808 | 23 | 98 |
N=int(input())
A=list(map(int,input().split()))
if A[0]:
if N==0 and A[0]==1:
print(1)
else:
print(-1)
exit()
B=[0 for _ in range(N)]
B.append(A[-1])
for i in range(N)[::-1]:
B[i]=B[i+1]+A[i]
r=1
ans=1
for i in range(1,N+1):
t=min(r*2,B[i])
ans+=t
r=t-A[i]
if r<0:
print(-1)
exit()
print(ans) | import sys
# import time
input = lambda: sys.stdin.readline().rstrip()
r, c, k = map(int, input().split())
# dp = [[[0] * 3 for _ in range(c + 5)] for _ in range(r + 5)]
pt = [[0 for _ in range(c + 5)] for _ in range(r + 5)]
for i in range(k):
r1, c1, v = map(int, input().split())
# dp[r1][c1][0] = v
pt[r1][c1] = v
# start = time.time()
a = 0
def solve():
memo = [[0] * 4 for _ in range(c + 1)]
prev = [[0] * 4 for _ in range(c + 1)]
for i in range(1, r + 1):
memo, prev = prev, memo
for j in range(1, c + 1):
V = pt[i][j]
memo[j][0] = max(prev[j][3], memo[j - 1][0])
memo[j][1] = max(memo[j][0] + V, memo[j - 1][1])
memo[j][2] = max(memo[j][1], memo[j - 1][1] + V, memo[j - 1][2])
memo[j][3] = max(memo[j][2], memo[j - 1][2] + V, memo[j - 1][3])
# dp[i][j][0] = max(dp[i - 1][j][2] + V, dp[i][j - 1][0])
# dp[i][j][1] = max(dp[i][j - 1][0] + V, dp[i][j - 1][1],
# dp[i][j][0])
# dp[i][j][2] = max(dp[i][j - 1][1] + V, dp[i][j - 1][2],
# dp[i][j][1])
# process_time = time.time() - start
# print(process_time)
# print(dp[r][c][2])
return memo[-1][3]
if __name__ == '__main__':
print(solve())
| 0 | null | 12,249,510,760,112 | 141 | 94 |
import math
numbers = input().split(" ")
numbers = [int(x) for x in numbers]
N = numbers[0]
D = numbers[1]
return_value =0
for i in range(N):
coordinates = input().split(" ")
coordinates = [int(x) for x in coordinates]
x_coor = coordinates[0]
y_coor = coordinates[1]
distance = math.sqrt((x_coor ** 2) + (y_coor ** 2))
if distance <= D:
return_value += 1
print(return_value) | N,D = map(int,input().split())
ans = 0
for i in range(N):
X1,Y1 = map(int,input().split())
if X1*X1+Y1*Y1 <= D*D:
ans += 1
print(ans) | 1 | 5,935,351,849,988 | null | 96 | 96 |
S = input()
S = list(S)
x = 'x'
for i in range(len(S)):
S[i] = x
print("".join(S)) | # B - I miss you...
# S
S = input()
answer = '0'
for i in range(0, len(S)):
answer += 'x'
print(answer[1:len(S) + 1])
| 1 | 72,947,808,232,170 | null | 221 | 221 |
import sys
sys.setrecursionlimit(10**9)
from collections import deque
n = int(input())
u = [[] for i in range(n+1)] #隣接リスト
for i in range(n):
v = list(map(int, input().split()))
u[v[0]] = v[1:] #v = [次数, 頂点...]
d = [-1] * (n+1)
f = [-1] * (n+1)
visited = [False] * (n+1)
visited[0] = True
time = 1
#再帰
def dfs(c):
global time
d[c] = time
time += 1
visited[c] = True
for i in range(1, u[c][0]+1):
if not visited[u[c][i]]:
dfs(u[c][i])
f[c] = time
time += 1
"""
探索は元の始点から到達可能なすべての頂点を発見するまで続き、
未発見の頂点が残っていれば、
その中の番号が一番小さい１つを新たな始点として探索を続けます。
"""
while False in visited:
dfs(visited.index(False))
for i in range(1, n+1):
print(i, d[i], f[i])
| n = int(input())
points = []
seen = []
find_time = []
end_time = []
for _ in range(n):
input_text = list(map(int, input().split()))
u, k, v_list = input_text[0], input_text[1], input_text[2:]
seen.append(False)
points.append(v_list)
find_time.append(0)
end_time.append(0)
count = [0]
def dfs(graph, v, count):
seen[v] = True
find_time[v] = count[0]
for next_v in graph[v]:
if seen[next_v - 1]:
continue
count[0] += 1
dfs(graph, next_v - 1, count)
count[0] += 1
end_time[v] = count[0]
for index, seen_point in enumerate(seen):
if seen_point:
pass
else:
count[0] += 1
dfs(points, index, count)
# print(find_time)
# print(end_time)
count = 1
for f, e in zip(find_time, end_time):
print(count, f, e)
count += 1
| 1 | 3,217,042,092 | null | 8 | 8 |
def GCD(a, b):
b %= a
return b if a%b == 0 else GCD(b, a)
while True:
try:
a, b = list(map(float, input().split()))
except EOFError:
break
if a >= b:
a, b = b, a
gcd = GCD(a, b) if b%a != 0 else a
print("{0} {1}".format(int(gcd), int(a*b/gcd))) | import math
while True:
try:
a, b = list(map(int, input().split()))
print('{0} {1}'.format(math.gcd(a, b), int(a * b / math.gcd(a, b))))
except EOFError:
break
| 1 | 559,846,236 | null | 5 | 5 |
n = int(input())
s = input()
if n % 2 == 1:
res = "No"
else:
if s[:n//2] == s[n//2:]:
res = "Yes"
else:
res = "No"
print(res) | N = int(input())
ret = False
if N % 2 == 0:
S = input()
if S[:N//2] == S[N//2:]:
ret = True
if ret:
print("Yes")
else:
print("No") | 1 | 146,909,819,071,680 | null | 279 | 279 |
from decimal import Decimal as D
a,b=map(str,input().split())
print(int(D(a)*D(b))) | import numpy as np
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
from numba import njit
def getInputs():
D = int(readline())
CS = np.array(read().split(), np.int32)
C = CS[:26]
S = CS[26:].reshape((-1, 26))
return D, C, S
def _compute_score(output, i, d, last):
mask = np.ones((26, ), np.int32)
mask[i] = 0
score = S[d][i] - np.sum(C * (d + 1 - last) * mask)
return score
def _evaluate(output, i, d, last, k):
score = _compute_score(output, i, d, last)
score -= np.sum(C * (d + k + 1 - last))
return score
def solve(k):
output = np.array([], np.int32)
last = np.zeros((26, ), np.int32)
SCORE = 0
for d in range(D):
max_score = float('-inf')
best_i = 0
for i in range(26):
output = np.append(output, i)
#score = _compute_score(output, i, d, last)
score = _evaluate(output, i, d, last, k)
if max_score < score:
max_score = score
best_i = i + 1
output = output[:-1]
output = np.append(output, best_i)
last[best_i - 1] = d + 1
SCORE += max_score
return output, SCORE
D, C, S = getInputs()
max_score = float('-inf')
for k in range(7, 14):
ans, score = solve(k)
if max_score < score:
max_score = score
ANS = ans
print('\n'.join(ANS.astype(str).tolist())) | 0 | null | 13,096,727,535,080 | 135 | 113 |
nums = input()
a,b,c = nums.split(' ')
nd = 0
for i in range(int(a),int(b)+1):
if int(c)%i == 0:
nd = nd + 1
print(nd)
| def selection_sort(A, N):
count = 0
for i in range(N):
min_j = i
for j in range(i, N):
if A[j] < A[min_j]:
min_j = j
if i != min_j:
A[i], A[min_j] = A[min_j], A[i]
count += 1
print " ".join(map(str, A))
print count
N = input()
A = map(int, raw_input().split())
selection_sort(A, N) | 0 | null | 287,320,531,414 | 44 | 15 |
# import math
# import statistics
a=input()
b=input()
#b,c=int(input()),int(input())
c,d=[],[]
for i in a:
c.append(i)
for i in b:
d.append(i)
#e1,e2 = map(int,input().split())
# f = list(map(int,input().split()))
#g = [input() for _ in range(a)]
# h = []
# for i in range(e1):
# h.append(list(map(int,input().split())))
ma=[]
if b in a:
print(0)
else:
for i in range(len(c)-len(d)+1):
count=0
for k in range(len(d)):
if c[i:len(d)+i][k]!=d[k]:
count+=1
ma.append(count)
print(min(ma)) | def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x,y):
x = find(x)
y = find(y)
if x == y: return False
#sizeの大きいほうがx
if par[x] > par[y]: x,y = y,x
par[x] += par[y]
par[y] = x
return True
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
#xが属する集合の個数
def size(x):
return -par[find(x)]
n, m, k = map(int, input().split())
friend = [[] for _ in range(n)]
enemy = [[] for _ in range(n)]
par = [-1]*n
for _ in range(m):
a, b = map(int, input().split())
unite(a-1, b-1)
friend[a-1].append(b-1)
friend[b-1].append(a-1)
for _ in range(k):
a, b = map(int, input().split())
enemy[a-1].append(b-1)
enemy[b-1].append(a-1)
ans = []
for i in range(n):
block = 0
for j in enemy[i]:
if same(i, j): block += 1
ans.append(size(i)-len(friend[i])-block-1)
print(*ans) | 0 | null | 32,511,812,667,660 | 82 | 209 |
n = int(input())
a = list(map(int, input().split()))
M = max(a)
biggest_prime = [0] * (M+10)
for i in range(2, M+10):
if biggest_prime[i] == 0:
biggest_prime[i] = i
for j in range(i*i, M+1, i):
biggest_prime[j] = i
def fact(n):
arr=[]
while n>1:
now=n
cnt=0
p=biggest_prime[now]
while now % p == 0:
now//=p
cnt+=1
arr.append([p,cnt])
n=now
return arr
from collections import defaultdict
cntd=defaultdict(int)
for i in range(len(a)):
lis = fact(a[i])
for num,cnt in lis:
if num==1:
continue
cntd[num]+=1
flg=False
for c in cntd.values():
if c==n:
print("not coprime")
exit()
if c>1:
flg=True
if flg:
print("setwise coprime")
else:
print("pairwise coprime") | import sys
input = sys.stdin.readline
def gcd(a,b):
while b:
a,b=b,a%b
return a
def prime_factor(n):
a=[]
while n%2==0:
a.append(2)
n//=2
f=3
while f*f<=n:
if n%f==0:
a.append(f)
n//=f
else:
f+=2
if n!=1:
a.append(n)
return set(a)
n=int(input())
L=list(map(int,input().split()))
val = L[0]
for i in range(1,n):
val = gcd(L[i],val)
if val!=1:
print('not coprime')
sys.exit()
d={}
for i in range(n):
factor=prime_factor(L[i])
for j in factor:
if j not in d:
d[j]=1
else:
print('setwise coprime')
sys.exit()
print('pairwise coprime')
| 1 | 4,114,072,487,060 | null | 85 | 85 |
n=int(input())
ans=[]
tes=[[] for _ in range(n)]
for j in range(n):
a=int(input())
for h in range(a):
x,y=map(int,input().split())
tes[j].append(x)
tes[j].append(y)
for i in range(2**n):
f=0
m=0
rel=[0 for _ in range(n)]
for j in range(n):
if (i>>j)&1:
rel[j]=1
m+=1
for j in range(n):
for q in range(len(tes[j])//2):
if rel[j]==1 and tes[j][2*q+1]!=rel[tes[j][2*q]-1]:
f=1
if f==0:
ans.append(m)
print(max(ans))
| X, K, D =map(int,input().split())
X = abs(X)
if X > K*D:
print(X-K*D)
else:
greed = X//D
if (K - greed)%2 == 0:
print(X-greed*D)
else:
print((1+greed)*D -X) | 0 | null | 63,493,555,423,100 | 262 | 92 |
n=int(input())
arr=list(map(int,input().split()))
acum1=[0]
acum2=[0]
for i in range(n):
if i%2==0:
acum1.append(acum1[-1]+arr[i])
acum2.append(acum2[-1]+0)
else:
acum1.append(acum1[-1]+0)
acum2.append(acum2[-1]+arr[i])
if n%2==0:
ans=max(acum1[n-1]-acum1[0],acum2[n]-acum2[1])
for i in range(1,n+1,2):
if i+3>n:
continue
tmp=(acum1[i]-acum1[0])+(acum2[n]-acum2[i+2])
ans=max(ans,tmp)
else:
ans=max(acum1[n-2]-acum1[0],acum2[n-1]-acum2[1],acum1[n]-acum1[2])
for i in range(1,n+1,2):
if i+3>n-1:
continue
tmp=(acum1[i]-acum1[0])+(acum2[n-1]-acum2[i+2])
ans=max(ans,tmp)
for i in range(2,n+1,2):
if i+3>n:
continue
tmp=(acum2[i]-acum2[1])+(acum1[n]-acum1[i+2])
ans=max(ans,tmp)
for i in range(1,n+1,2):
if i+4>n:
continue
tmp=(acum1[i]-acum1[0])+(acum1[n]-acum1[i+3])
ans=max(ans,tmp)
acummax=[-10**18]
for i in range(1,n+1):
if i+2>n:
acummax.append(-10**18)
else:
if i%2==0:
acummax.append(acum2[i]+acum1[n]-acum1[i+2])
else:
acummax.append(-10**18)
for i in range(n-1,-1,-1):
acummax[i]=max(acummax[i],acummax[i+1])
for i in range(1,n+1,2):
if i+6>n:
continue
tmp=(acum1[i]-acum1[0]-acum2[i+2])+acummax[i+3]
ans=max(ans,tmp)
print(ans) | import sys
n = int(input())
a = list(map(int, input().split()))
if n%2 == 0:
dp = [[-10**20 for _ in range(2)] for _ in range(n)]
dp[0][0] = a[0]
dp[0][1] = 0
dp[1][1] = a[1]
for i in range(1, n):
if i%2 == 0:
dp[i][0] = dp[i-2][0] + a[i]
dp[i][1] = max(dp[i-1][0], dp[i-1][1])
else:
dp[i][0] = dp[i-1][0]
if i > 1:
dp[i][1] = max(dp[i-2][1] + a[i], dp[i-3][0] + a[i])
else:
dp = [[-10**20 for _ in range(3)] for _ in range(n)]
dp[0][0] = a[0]
dp[0][1] = 0
dp[1][1] = a[1]
dp[0][2] = 0
dp[1][2] = 0
dp[2][2] = a[2]
for i in range(1, n):
if i%2 == 0:
if i < n-1:
dp[i][0] = dp[i-2][0] + a[i]
else:
dp[i][0] = dp[i-1][0]
dp[i][1] = max(dp[i-1][1], dp[i-2][0])
if i > 2:
dp[i][2] = max(dp[i-2][2] + a[i], dp[i-4][0] + a[i], dp[i-3][1] + a[i])
else:
dp[i][0] = dp[i-1][0]
if i > 1:
dp[i][1] = max(dp[i-2][0] + a[i], dp[i-2][1] + a[i])
dp[i][2] = max(dp[i-1][2], dp[i-2][1], dp[i-3][0])
print(max(dp[n-1])) | 1 | 37,508,630,480,594 | null | 177 | 177 |
n = int(input())
print((n+2-1)//2)
| N,M=list(map(int, input().split()))
src=[i+1 for i in range(M*2+1)]
if M%2==0:
for m in range(M//2):
a=src[m]
b=src[M-m]
print('{} {}'.format(a,b))
for m in range(M//2):
a=src[M+1+m]
b=src[-(m+1)]
print('{} {}'.format(a,b))
else:
for m in range(M//2):
a=src[m]
b=src[M-1-m]
print('{} {}'.format(a,b))
for m in range(M-(M//2)):
a=src[M+m]
b=src[-(m+1)]
print('{} {}'.format(a,b)) | 0 | null | 43,884,512,399,548 | 206 | 162 |
from math import gcd
def lcm(a,b):return (a*b)//(gcd(a,b))
def f(x):
cnt=0
while(x%2==0):
cnt+=1
x=x//2
return cnt
n,m=map(int,input().split())
a=list(map(int,input().split()))
a=list(map(lambda x: x//2,a))
t=f(a[0])
for i in range(n):
if(f(a[i])!=t):
print(0)
exit()
a[i]=a[i]//(2**t)
m=m//(2**t)
l=1
for i in range(n):
l=lcm(l,a[i])
if(l>m):
print(0)
exit()
m=m//l
print((m+1)//2) | def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
def two(val):
ret = 0
tmp = val
while True:
if tmp != 0 and tmp % 2 == 0:
ret += 1
tmp = tmp // 2
else:
break
return ret
n, m = map(int, input().split())
a_list = list(map(int, input().split()))
b_list = []
for item in a_list:
b_list.append(item // 2)
cnt = -1
for item in b_list:
ret = two(item)
if cnt == -1:
cnt = ret
elif cnt != ret:
print(0)
exit()
val = b_list[0]
for item in b_list:
val = lcm(item, val)
ret = m // val
tmp1 = ret // 2
tmp2 = ret % 2
print(tmp1 + tmp2)
| 1 | 102,088,563,250,620 | null | 247 | 247 |
input_line = input()
stack = []
area = 0
pond_area = 0
pond_areas = []
for i,s in enumerate(input_line):
if s == '\\':
stack.append(i)
if pond_area:
pond_areas.append((l, pond_area))
pond_area = 0
elif stack and s == '/':
l = stack.pop()
area += i - l
while True:
if not pond_areas or pond_areas[-1][0] < l: break
else:
pond_area += pond_areas.pop()[1]
pond_area += i-l
if pond_area > 0: pond_areas.append((l, pond_area))
print(area)
print( " ".join([str(len(pond_areas))] + [str(a[1]) for a in pond_areas]) )
| li = []
for i, s in enumerate(input()):
if s == "\\":
li.append([i, 0])
elif s == "/":
if li:
if li[-1][1] == 0:
li[-1][1] = i - li[-1][0]
else:
for j in range(len(li) - 1, -1, -1):
if li[j][1] == 0:
li = li[:j] + [[li[j][0], sum(tuple(zip(*li[j + 1:]))[1]) + i - li[j][0]]]
break
ans = []
for a in li:
if a[1] != 0:
ans.append(a[1])
print(sum(ans))
print(len(ans), *ans)
| 1 | 58,607,170,238 | null | 21 | 21 |
A,B=map(int,input().strip().split())
print(max(A-2*B,0)) | A, B = map(int, input().split())
print(A-B*2) if A>B*2 else print(0) | 1 | 166,775,788,747,930 | null | 291 | 291 |
s = input()
big = 0
small = 0
n = 0
big2 =0
for i in range(len(s)):
if s[i]=='<':
big += 1
n += big
small =0
big2 = big
else:
small += 1
n += small
if small<=big2:
n-=1
big =0
print(n) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M, K = map(int, input().split())
c = [0] * (N + 1)
C = [0] * K
D = [0] * K
uf = UnionFind(N)
for i in range(M):
a, b = map(int, input().split())
uf.union(a-1, b-1)
c[a] += 1
c[b] += 1
for i in range(K):
C[i], D[i] = map(int, input().split())
for i in range(1,N + 1):
c[i] = uf.size(i-1) - c[i] - 1
for i in range(K):
if uf.same(C[i]-1, D[i]-1):
c[C[i]] -= 1
c[D[i]] -= 1
for i in range(1, N+1):
print(c[i], end=" ") | 0 | null | 109,138,075,612,540 | 285 | 209 |
N, M = map(int, raw_input().split())
matrix = [map(int, raw_input().split()) for n in range(N)]
array = [input() for m in range(M)]
for n in range(N):
c = 0
for m in range(M):
c += matrix[n][m] * array[m]
print c | def main():
n, m = map(int, (input().split()))
a = [list(map(int, list(input().split()))) for item in range(n)]
b = [int(input()) for item in range(m)]
c = [sum(a_im * b_m for (a_im, b_m) in zip(a_i, b)) for a_i in a]
for c_i in c:
print(c_i)
main() | 1 | 1,166,881,641,760 | null | 56 | 56 |
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
from collections import Counter
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
from collections import Counter
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
def my_pow(base, n, mod):
if n == 0:
return 1
x = base
y = 1
while n > 1:
if n % 2 == 0:
x *= x
n //= 2
else:
y *= x
n -= 1
x %= mod
y %= mod
return x * y % mod
N, P = map(int, input().split())
S = input()
if P == 2 or P == 5:
ans = 0
for i, c in enumerate(S[::-1]):
if int(c) % P == 0:
ans += N - i
print(ans)
exit()
cnt = [0] * P
base = 1
cur = 0
for c in S[::-1]:
cur += (base * int(c)) % P
cnt[cur % P] += 1
base *= 10
base %= P
ans = 0
for i in cnt:
if i == 0:
continue
ans += i * (i - 1) // 2
print(ans + cnt[0])
| n, p = map(int, input().split())
s = input()
if 10%p==0:
ans = 0
for r in range(n):
if int(s[r])%p == 0:
ans += r+1
print(ans)
exit()
d = [0]*(n+1)
ten = 1
for i in range(n-1, -1, -1):
a = int(s[i])*ten%p
d[i] = (d[i+1]+a)%p
ten *= 10
ten %= p
cnt = [0]*p
ans = 0
for i in range(n, -1, -1):
ans += cnt[d[i]]
cnt[d[i]] += 1
print(ans) | 1 | 58,158,697,465,750 | null | 205 | 205 |
import sys,math
def solve():
a = float(input())
print(a**2*math.pi ,a*2*math.pi)
solve()
| import math
r = float(raw_input())
print "%.8f %.8f" % (r*r*math.pi, 2*r*math.pi)
| 1 | 634,999,291,488 | null | 46 | 46 |
k=int(input())
s=str(input())
long =len(s)
i =0
ans = str()
if k>long:
print(s)
else:
for i in range(long):
if i<k:
ans = str(ans+s[i])
else:
ans = str(ans+"...")
break
print(ans) | l = input().split()
stack = []
for op in l:
if op.isdigit():
stack.append(int(op))
elif op == '+':
stack.append(stack.pop() + stack.pop())
elif op == '-':
stack.append(- stack.pop() + stack.pop())
elif op == '*':
stack.append(stack.pop() * stack.pop())
print(stack[-1]) | 0 | null | 9,862,115,868,120 | 143 | 18 |
from collections import defaultdict,deque
n = int(input())
d = defaultdict(list)
l = []
for i in range(n-1):
a,b = map(int,input().split())
d[a].append(b)
d[b].append(a)
l.append((a,b))
# print(d)
que = deque([a])
visited = [-1] + [False]*n
visited[a] = True
preans = defaultdict(list)
ans = defaultdict(int)
maxi = 1
while que:
v = que.popleft()
cnt = 1
for x in d[v]:
if not visited[x]:
while cnt in preans[v]:
cnt += 1
maxi = max(maxi,cnt)
preans[x].append(cnt)
ans[(v,x)] = cnt
ans[(x,v)] = cnt
que.append(x)
visited[x] = True
cnt += 1
# print(preans)
# print(ans)
print(maxi)
for i in l:
print(ans[i]) | K = int(input())
if K % 2 == 0 or K % 5 == 0:
print(-1)
else:
i = 1
r = 7 % K
while(True):
if r == 0:
print(i)
break
r = (r * 10 + 7) % K
i += 1
| 0 | null | 71,133,700,100,108 | 272 | 97 |
A,B,C = input().split()
print(C,A,B)
| s = list(map(int,input().split()))
print(s[2],s[0],s[1]) | 1 | 37,942,586,689,568 | null | 178 | 178 |
import sys
from collections import deque
n = int(sys.stdin.readline().strip())
edges = [[] for _ in range(n)]
for _ in range(n):
tmp = list(map(int, sys.stdin.readline().strip().split(" ")))
for node in tmp[2:]:
edges[tmp[0] - 1].append(node-1)
# print(edges)
distance = [0] * n
q = deque()
q.append((0, 0))
visited = set()
while q:
node, d = q.popleft()
# print(node, d)
if node in visited:
continue
distance[node] = d
visited.add(node)
for next in edges[node]:
# print("next", next)
q.append((next, d + 1))
for i, d in enumerate(distance):
if i == 0:
print(1, 0)
else:
print(i + 1, d if d > 0 else -1)
| n,m = map(int,input().split())
ans = 0
class UnionFind:
def __init__(self,n):
self.root = [i for i in range(n+1)]
def Root_Find(self,x):
if self.root[x] == x:
return x
else:
self.root[x] = self.Root_Find(self.root[x])
return self.root[x]
def Unite(self,x,y):
x = self.Root_Find(x)
y = self.Root_Find(y)
if x == y:
return
self.root[y] = x
tree = UnionFind(n)
for i in range(m):
a,b = map(int,input().split())
tree.Unite(a,b)
for i in range(n+1):
tree.Root_Find(i)
ans = len(list(set(tree.root))) - 2
print(ans) | 0 | null | 1,161,621,589,010 | 9 | 70 |
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 = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()
n=k()
l=l()
a=[]
for i in range(n):
a.append(0)
for i in range(n-1):
a[l[i]-1]+=1
for i in range(n):
print(a[i])
| #!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import itertools
import math
import sys
INF = float('inf')
def solve(N: int, A: "List[int]"):
c = collections.Counter(A+[i+1 for i in range(N)])
return "\n".join([f'{c[i+1]-1}' for i in range(N)])
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N - 2 + 1)] # type: "List[int]"
print(solve(N, A))
if __name__ == '__main__':
main()
| 1 | 32,569,650,614,382 | null | 169 | 169 |
u, s, e, w, n, b = map(int, input().split())
roll = input()
for i in roll:
if i == "E":
e,u,w,b = u,w,b,e
elif i == "S":
s,u,n,b = u,n,b,s
elif i == "W":
w,u,e,b = u,e,b,w
elif i == "N":
n,u,s,b = u,s,b,n
print(u) | class Dice(object):
def __init__(self,List):
self.face=List
def n_spin(self,List):
temp=List[0]
List[0]=List[1]
List[1]=List[5]
List[5]=List[4]
List[4]=temp
def s_spin(self,List):
temp=List[0]
List[0]=List[4]
List[4]=List[5]
List[5]=List[1]
List[1]=temp
def e_spin(self,List):
temp=List[0]
List[0]=List[3]
List[3]=List[5]
List[5]=List[2]
List[2]=temp
def w_spin(self,List):
temp=List[0]
List[0]=List[2]
List[2]=List[5]
List[5]=List[3]
List[3]=temp
dice = Dice(map(int,raw_input().split()))
command = list(raw_input())
for k in command:
if k=='N':
dice.n_spin(dice.face)
elif k=='S':
dice.s_spin(dice.face)
elif k=='E':
dice.e_spin(dice.face)
else:
dice.w_spin(dice.face)
print dice.face[0] | 1 | 228,175,709,300 | null | 33 | 33 |
r = int(input())
print((r + r) * 3.14) | #from sys import stdin
#input = stdin.readline
#inputRstrip = stdin.readline().rstrip
#x = input().rstrip()
#n = int(input())
#a,b,c = input().split()
#a,b,c = map(int, input().split())
ST = [input() for i in range(2)]
S = ST[0]
T = ST[1]
ans = len(T)
for i in range(len(S) - len(T) + 1):
count = len(T)
for j in range(len(T)):
if(T[j] == S[i + j]):
count -= 1
if(ans > count):
ans = count
print(ans) | 0 | null | 17,558,888,290,808 | 167 | 82 |
a, b = map(int, raw_input().split())
print("%d %d %f" %(int(a / b), a % b, float(a) / b)) | values = input()
a, b = [int(x) for x in values.split()]
print('{0} {1} {2:.5f}'.format(a // b, a % b, a / b)) | 1 | 591,667,177,308 | null | 45 | 45 |
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
t1, t2 = list(map(int, sys.stdin.buffer.readline().split()))
a1, a2 = list(map(int, sys.stdin.buffer.readline().split()))
b1, b2 = list(map(int, sys.stdin.buffer.readline().split()))
da1 = t1 * a1
da2 = t2 * a2
db1 = t1 * b1
db2 = t2 * b2
if da1 + da2 > db1 + db2:
a1, b1 = b1, a1
a2, b2 = b2, a2
da1, db1 = db1, da1
da2, db2 = db2, da2
# b のほうがはやい
# 無限
if da1 + da2 == db1 + db2:
print('infinity')
exit()
# 1回も会わない
if da1 < db1:
print(0)
exit()
# t1 で出会う回数
cnt = abs(da1 - db1) / abs(da1 + da2 - db1 - db2)
ans = int(cnt) * 2 + 1
if cnt == int(cnt):
ans -= 1
print(ans)
| t1,t2=map(int,input().split())
a1,a2=map(int,input().split())
b1,b2=map(int,input().split())
if (a1*t1-b1*t1)*(a1*t1+a2*t2-b1*t1-b2*t2)>0:print(0)
elif (a1*t1-b1*t1)*(a1*t1+a2*t2-b1*t1-b2*t2)==0:print('infinity')
else:print(-(a1*t1-b1*t1)//(a1*t1+a2*t2-b1*t1-b2*t2)*2+((a1*t1-b1*t1)%(a1*t1+a2*t2-b1*t1-b2*t2)!=0)) | 1 | 131,228,369,118,414 | null | 269 | 269 |
# -*- coding: utf-8 -*-
import sys
import fractions
def lcm(a,b):
return a / fractions.gcd(a,b) * b
for s in sys.stdin:
a,b = map(int,s.split())
gcd_ab = fractions.gcd(a,b)
lcm_ab = lcm(a,b)
print gcd_ab,lcm_ab | import sys
import numpy as np
from math import ceil as C, floor as F, sqrt
from collections import defaultdict as D, Counter as CNT
from functools import reduce as R
ALP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
alp = 'abcdefghijklmnopqrstuvwxyz'
def _X(): return sys.stdin.readline().rstrip().split(' ')
def _S(ss): return tuple(ss) if len(ss) > 1 else ss[0]
def S(): return _S(_X())
def Ss(): return list(S())
def _I(ss): return tuple([int(s) for s in ss]) if isinstance(ss, tuple) else int(ss)
def I(): return _I(S())
def _Is(ss): return list(ss) if isinstance(ss, tuple) else [ss]
def Is(): return _Is(I())
x = I()
A = []
As = []
B = []
Bs = []
for i in range(250):
n = i ** 5
A.append(i)
As.append(n)
B.append(i)
Bs.append(n)
B.append(-i)
Bs.append(-n)
xs = [a-x for a in As]
for i, x in enumerate(xs):
if x in Bs:
print(A[i], B[Bs.index(x)])
break
| 0 | null | 12,895,453,132,132 | 5 | 156 |
M=10**9+7
n,k=map(int,input().split())
l=[0]*(k+1)
a=0
for i in range(k,0,-1):
l[i]=pow(k//i,n,M)
for j in range(i*2,k+1,i):
l[i]-=l[j]
a+=i*l[i]
print(a%M)
| def main():
N, K = map(int, input().split())
mod = 10**9 + 7
r = 0
D = [0] * (K + 1)
for i in reversed(range(1, K + 1)):
D[i] = pow(K // i, N, mod) - sum(D[::i])
return sum(i * j for i, j in enumerate(D)) % mod
print(main())
| 1 | 36,703,442,618,908 | null | 176 | 176 |
import math
a=float(input())
print("{0:.9f} {1:.9f}".format(a*a*math.pi,a*2*math.pi))
| import math
a=input()
a=float(a)
p=math.pi
b= a*a*p
c= a*2*p
print('%03.7f' % b,'%03.7f' % c) | 1 | 650,209,755,960 | null | 46 | 46 |
import math
n = int(input())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
for p in range(1, 4):
sum = 0
for i in range(n):
sum += math.fabs(x[i]-y[i])**p
print(sum**(1/p))
a = []
for i in range(n):
a.append(math.fabs(x[i]-y[i]))
a.sort()
print(a[n-1]) | import itertools
n = int(input())
X = list(map(int, input().split()))
Y = list(map(int, input().split()))
Z = list(itertools.product(X,Y))
Z = Z[::len(X)+1]
def fn(p):
D = 0
for z in Z:
D += abs(z[0]-z[1])**p
else:
print(D**(1/p))
fn(1)
fn(2)
fn(3)
MA = []
for z in Z:
MA.append(abs(z[0]-z[1]))
print(max(MA))
| 1 | 214,563,998,662 | null | 32 | 32 |
D=int(input())
c=list(map(int,input().split()))
s=[list(map(int,input().split())) for i in range(D)]
t=[int(input())-1 for i in range(D)]
v=[]
S=0
last=[0]*27
for d in range(D):
S+=s[d][t[d]]
last[t[d]]=d+1
for i in range(26):
S-=c[i]*(d+1 - last[i])
print(S)
| D = int(input())
C = list(map(int,input().split()))
S = [list(map(int,input().split())) for _ in range(D)]
# B
T = [int(input()) for _ in range(D)]
# 初期化
ans = 0 # 満足度
last = [-1]*26
# 満足度を計算
for d in range(D):
# 開催するコンテストID
contest_id = T[d]-1
# 満足度をプラス
ans += S[d][contest_id]
# 最終開催日を更新
last[contest_id] = d
# 開催されなかったコンテストの処理
for i in range(26):
ans -= C[i]*(d - last[i])
# 出力
print(ans)
| 1 | 9,909,754,590,272 | null | 114 | 114 |
def main():
N, X, T = (int(i) for i in input().split())
print((0--N//X)*T)
if __name__ == '__main__':
main()
| n, x, t = map(int, input().split())
print(n//x*t) if n%x==0 else print((n//x+1)*t) | 1 | 4,310,888,915,590 | null | 86 | 86 |
def GCD_calc(A,B):
if(A>=B):
big = A
small = B
else:
big = B
small = A
r=big%small
if r == 0:
return small
else:
return GCD_calc(small,r)
a,b = map(int,input().split())
print(GCD_calc(a,b))
| from itertools import accumulate
from bisect import bisect_left,bisect_right
def main():
n,m,k=map(int,input().split())
a=[0]+list(accumulate(map(int,input().split())))
b=[0]+list(accumulate(map(int,input().split())))
result = 0
for i in range(n+1):
tmp = k - a[i]
if tmp < 0:
continue
tmpNum = i + bisect_right(b, tmp) - 1
if tmpNum > result:
result = tmpNum
print(result)
if __name__ == "__main__":
main() | 0 | null | 5,367,231,921,310 | 11 | 117 |
memo = {}
def fib(n):
key = n
if key in memo:
return memo[key]
if n == 0:
return 1
if n == 1:
return 1
if n > 1:
memo[key] = fib(n-1) + fib(n-2)
return memo[key]
n = int(input())
print(fib(n)) | n = int(input())
pair = [1, 1]
for i in range(n - 1):
pair[i % 2] = sum(pair)
print(pair[n % 2])
| 1 | 1,742,250,430 | null | 7 | 7 |
class COM:
def __init__(self, n: int, mod: int):
self.n = n
self.mod = mod
self.fact = [1, 1]
self.factinv = [1, 1]
self.inv = [0, 1]
for i in range(2, n + 1):
self.fact.append((self.fact[-1] * i) % mod)
self.inv.append((-self.inv[mod % i] * (mod // i)) % mod)
self.factinv.append((self.factinv[-1] * self.inv[-1]) % mod)
def get_cmb(self, n: int, k: int):
if (k < 0) or (n < k):
return 0
k = min(k, n - k)
return self.fact[n] * self.factinv[k] % self.mod * self.factinv[n - k] % self.mod
def solve():
n, k = map(int, input().split())
MOD = 10 ** 9 + 7
com = COM(n, MOD)
ans = 0
for i in range(min(n, k + 1)):
ans += com.get_cmb(n, i) * com.get_cmb(n - 1, i)
ans %= MOD
print(ans)
if __name__ == '__main__':
solve()
| n, k = map(int, input().split())
k = min(k, n - 1)
MOD = 1000000007
fact = [1] * (n + 1)
ifact = [0] * (n + 1)
for i in range(1, n + 1):
fact[i] = fact[i - 1] * i % MOD
ifact[n] = pow(fact[n], MOD - 2, MOD)
for i in range(n, 0, -1):
ifact[i - 1] = ifact[i] * i % MOD
def comb(n, k):
if k < 0 or k > n:
return 0
return fact[n] * ifact[k] * ifact[n - k] % MOD
ans = 0
for i in range(k + 1):
ans += comb(n, i) * comb(n - 1, i)
ans %= MOD
print(ans)
| 1 | 66,931,530,148,570 | null | 215 | 215 |
a, b = map(int, raw_input().split())
if a < b:
print('a < b')
elif b < a:
print('a > b')
else:
print('a == b') | N = int(input())
#1 is dividable by all
#-> sum = 1 + 2 + .. + N = (N+1)*N//2
ans = (N+1)*N//2
for num in range(2, N+1):
for tt in range(N//num+1):
ans += num*tt
print(ans)
| 0 | null | 5,682,883,060,960 | 38 | 118 |
n,m = map(int,input().split())
a = list(map(int,input().split()))
b = [x for x in a if x >= sum(a)/4/m]
if len(b)>=m:
print("Yes")
else:
print("No")
| n, m = map(int, input().split())
L = list(map(int, input().split()))
a = 0
for i in range(len(L)):
a = a + L[i]
a = a / (4*m)
nL = sorted(L, reverse=True)
if a <= nL[m-1]:
print("Yes")
else:
print("No") | 1 | 38,724,391,855,990 | null | 179 | 179 |
import sys
input = sys.stdin.readline
r,c,k = map(int,input().split())
l = [[0]*c for i in range(r)]
for i in range(k):
x,y,v = map(int,input().split())
l[x-1][y-1] = v
dp = [[0]*4 for i in range(c+1)]
for i in range(r):
ndp = [[0]*4 for i in range(c+1)]
for j in range(c):
M = max(dp[j+1])
if l[i][j]>0:
v = l[i][j]
ndp[j+1][0] = max(M,dp[j][0],ndp[j][0])
ndp[j+1][1] = max(M+v,dp[j][0]+v,ndp[j][0]+v,dp[j][1],ndp[j][1])
ndp[j+1][2] = max(dp[j][1]+v,ndp[j][1]+v,dp[j][2],ndp[j][2])
ndp[j+1][3] = max(dp[j][2]+v,ndp[j][2]+v,dp[j][3],ndp[j][3])
else:
ndp[j+1][0] = max(M,dp[j][0],ndp[j][0])
ndp[j+1][1] = max(dp[j][1],ndp[j][1])
ndp[j+1][2] = max(dp[j][2],ndp[j][2])
ndp[j+1][3] = max(dp[j][3],ndp[j][3])
dp = ndp
print(max(dp[-1])) | R,C,K= map(int,input().split(" "))
original=[[0]*(C+1) for i in range(R+1)]
for _ in range(K):
r,c,v= map(int,input().split(" "))
original[r][c]=v
d1=[[0]*(C+1) for i in range(R+1)]
d2=[[0]*(C+1) for i in range(R+1)]
d3=[[0]*(C+1) for i in range(R+1)]
for i in range(1,R+1):
for j in range(1,C+1):
curr= original[i][j]
d1[i][j]=max(d1[i-1][j]+curr,d2[i-1][j]+curr,d3[i-1][j]+curr,d1[i][j-1],curr)
d2[i][j]=max(d2[i][j-1],d1[i][j-1]+curr)
d3[i][j]=max(d3[i][j-1],d2[i][j-1]+curr)
print(max(d1[-1][-1],d2[-1][-1],d3[-1][-1])) | 1 | 5,551,496,766,720 | null | 94 | 94 |
from math import gcd
n=int(input())
l=list(map(int,input().split()))
mal=max(l)
e=[i for i in range(mal+1)]
x=2
while x*x <= mal:
if x == e[x]:
for m in range(x, len(e), x):
if e[m] == m:
e[m] = x
x+=1
#print(e)
s=set()
f=0
for i in l:
st = set()
while i > 1:
st.add(e[i])
i//=e[i]
if not s.isdisjoint(st):
f=1
break
s |= st
if f==0:
print('pairwise coprime')
exit()
p=l[0]
for i in range(1,n):
p=gcd(p,l[i])
if p==1:
print('setwise coprime')
else:
print('not coprime')
| from math import floor
s = input()
k = int(input())
if len(set(s)) == 1:
print(floor(len(s) * k / 2))
exit(0)
x = s[0]
y = 1
ans = 0
for i in s[1:]:
if i == x:
y += 1
else:
ans += floor(y / 2)
x = i
y = 1
ans += floor(y / 2)
if s[0] != s[-1]:
print(ans * k)
else:
x = s[0]
y = 1
for i in s[1:]:
if x == i:
y += 1
else:
a = y
break
y = 0
for i in s[::-1]:
if x == i:
y += 1
else:
b = y
break
print(ans * k - ((floor(a / 2) + floor(b / 2) - floor((a + b) / 2)) * (k - 1))) | 0 | null | 89,787,911,740,524 | 85 | 296 |
a, b = map(str, input().split())
if (len(a) == 1 and len(b) ==1):
print(int(a) * int(b))
else:
print(-1) | a,b=map(int,input().split())
print(a*b if a<10 and b<10 else '-1') | 1 | 158,482,416,291,472 | null | 286 | 286 |
N=int(input())
a,b,c,d=0,0,0,0
for i in range(N):
A=input()
if A=="AC":
a+=1
elif A=="WA":
b+=1
elif A=="TLE":
c+=1
else:
d+=1
print("AC x",a)
print("WA x",b)
print("TLE x",c)
print("RE x",d) | n=int(input())
l=['AC','WA','TLE','RE']
d=[0,0,0,0]
for i in range(n):
s=input()
if(s=='AC'):
d[0]+=1
elif(s=='WA'):
d[1]+=1
elif(s=='TLE'):
d[2]+=1
else:
d[3]+=1
for i in range(4):
print(l[i],'x',d[i])
| 1 | 8,682,311,121,572 | null | 109 | 109 |
import numpy as np
MOD = 998244353
N,S = map(int,input().split())
A = list(map(int,input().split()))
coefs = np.array([0]*(S+1))
coefs[0] = 1
for i in range(N):
tmp = coefs[:]
coefs = coefs*2
coefs[A[i]:] += tmp[:-A[i]]
coefs%=MOD
print(coefs[-1])
| import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 998244353
N, K = MAP()
A = LIST()
dp = list2d(N+1, K+1, 0)
dp[0][0] = 1
for i, a in enumerate(A):
for j in range(K+1):
dp[i+1][j] += dp[i][j] * 2
dp[i+1][j] %= MOD
if j+a <= K:
dp[i+1][j+a] += dp[i][j]
dp[i+1][j+a] %= MOD
ans = dp[N][K]
print(ans)
| 1 | 17,569,167,743,920 | null | 138 | 138 |
for a in range(1,10):
for b in range(1,10):
print("%dx%d=%d" % (a,b,a*b)) | (n, m, l) = [int(i) for i in input().split()]
a = []
b = []
for i in range(n):
a.append([int(i) for i in input().split()])
for j in range(m):
b.append([int(j) for j in input().split()])
for x in range(n):
c = []
for y in range(l):
d = 0
for z in range(m):
d += a[x][z] * b[z][y]
c.append(str(d))
print(' '.join(c)) | 0 | null | 729,486,709,798 | 1 | 60 |
N = int(input())
a = []
typ = ["S ", "H ", "C ", "D "]
for i in range(N):
a.append(input())
for i in range(4):
for j in range(1, 14):
if typ[i] + str(j) not in a:
print(typ[i] + str(j)) | li = []
for i in range(2):
a,b = map(int, input().split())
li.append(a)
if li[1] == li[0]+1:
print(1)
else:
print(0) | 0 | null | 62,436,314,154,060 | 54 | 264 |
N = int(input())
As = list(map(int,input().split()))
array = []
B = 0
for i in range(N):
B ^= As[i]
ans_array = []
for i in range(N):
ans_array.append(B^As[i])
print(*ans_array) | n = int(input())
s = list(input())
if s[:n//2]==s[n//2:]:print("Yes")
else:print("No") | 0 | null | 79,682,292,920,360 | 123 | 279 |
S = raw_input()
areas = []
stack = []
for i,c in enumerate(S):
if c == "\\":
stack.append(i)
elif c == "/":
if len(stack) > 0:
j = stack.pop()
area = i-j
while len(areas) > 0:
p,a = areas.pop()
if j < p:
area += a
else:
areas.append((p, a))
break
areas.append((j, area))
A = map(lambda x:x[1], areas)
print sum(A)
if len(A) == 0:
print "0"
else:
print len(A), " ".join(map(str, A))
| # -*- coding: utf-8 -*-
modelmap = list(input())
S1 = []
S2 = []
A = 0
for i, l in enumerate(modelmap):
if l == "\\":
S1.append(i)
elif l == "/" and len(S1) > 0:
ip = S1.pop()
A += i - ip
L = i - ip
while len(S2) > 0 and S2[-1][0] > ip:
L += S2.pop()[1]
S2.append([ip, L])
print(A)
text2 = "{}".format(len(S2))
for s in S2:
text2 += " " + str(s[1])
print(text2) | 1 | 57,131,939,062 | null | 21 | 21 |
n=int(input())
x=0
for i in range(n):
if i==0:
continue
elif n//i==n/i:
x+=(n//i)-1
else:
x+=n//i
print(x) | N = int(input())
S = input()
ans = ''
Z_s = 'Z'
for i in range(len(S)):
ord_s = ord(S[i]) + N
if ord_s > ord(Z_s):
ord_s -= ord('Z') - ord('A') + 1
ans += chr(ord_s)
print(ans) | 0 | null | 68,437,503,804,932 | 73 | 271 |
def main2():
K = int(input())
rem = set()
n = ans = 0
while True:
n = n * 10 + 7
ans += 1
if n % K == 0:
print(ans)
break
else:
n = n % K
if n in rem:
print(-1)
break
else:
rem.add(n)
if __name__ == "__main__":
main2() | n=int(input())
if n%2:
a=list(map(int,input().split()))
s=[[a[0],0,0],[0,a[1],0],[a[0]+a[2],0,a[2]]]+[[0,0,0]for i in range(3,n)]
for i in range(3,n):
if i%2:
s[i][1]=max(s[i-2][1],s[i-3][0])+a[i]
else:
s[i][0]=s[i-2][0]+a[i]
s[i][2]=max([s[i-2][2],s[i-3][1],s[i-4][0]])+a[i]
print(max([s[-1][2],s[-2][1],s[-3][0]]))
else:
a=list(map(int,input().split()))
s=[a[0],a[1]]+[0 for i in range(2,n)]
for i in range(2,n):
if i%2:
s[i]=max([s[i-2],s[i-3]])+a[i]
else:
s[i]=s[i-2]+a[i]
print(max(s[-2:])) | 0 | null | 21,586,529,707,188 | 97 | 177 |
N = int(input())
A = list(map(int,input().split()))
A.sort(reverse = True)
ans = A[0]
j = 1
for i in range(2,N):
ans += A[j]
if i % 2 == 1:
j += 1
print(ans) | import sys
input = sys.stdin.readline
from itertools import accumulate
N, K = map(int, input().split())
A = map(int, input().split())
B = accumulate(A)
C = [0]+[(b-i)%K for i, b in enumerate(B,start=1)]
cnt = dict()
cnt[C[0]] = 1
res = 0
for i in range(1, N+1):
if i >= K:
cnt[C[i-K]] = cnt.get(C[i-K],0) - 1
res += cnt.get(C[i], 0)
cnt[C[i]] = cnt.get(C[i],0) + 1
print(res)
| 0 | null | 73,272,173,718,500 | 111 | 273 |
A, B, M = map(int,input().split())
A = [a for a in map(int,input().split())]
B = [b for b in map(int,input().split())]
C = []
for m in range(M):
C.append([c for c in map(int,input().split())])
ans = min(A) + min(B)
for c in C:
if (A[c[0]-1]+B[c[1]-1]-c[2])<ans:
ans = A[c[0]-1]+B[c[1]-1]-c[2]
print(ans) | A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
# 割引券を使用しない場合は各品の最低金額合計が解となる
ans = min(a) + min(b)
# 割引券を使用して安くなるケースがないか調べる
for _ in range(M):
x, y, c = map(int, input().split())
tmp = a[x-1] + b[y-1] - c
if tmp < ans:
ans = tmp
print(ans)
| 1 | 53,940,762,905,572 | null | 200 | 200 |
h = int(input())
w = int(input())
n = int(input())
for i in range(min(h,w)):
n = n - max(h,w)
if n <= 0:
print(i + 1)
break | n=int(input())
s='*'+input()
r=s.count('R')
g=s.count('G')
b=s.count('B')
cnt=0
for i in range(1,n+1):
for j in range(i,n+1):
k=2*j-i
if k>n:
continue
if s[i]!=s[j] and s[j]!=s[k] and s[k]!=s[i]:
cnt+=1
print(r*g*b-cnt) | 0 | null | 62,454,314,091,558 | 236 | 175 |
s = input()
q = int(input())
for i in range(q):
inp = input().split()
com = inp[0]
a = int(inp[1])
b = int(inp[2])+1
if com =="print":
print(s[a:b])
elif com =="reverse":
s_rev = s[a:b]
s = s[:a] + s_rev[::-1] + s[b:]
elif com =="replace":
s = s[:a] + inp[3] + s[b:] | # A - Curtain
def main():
a, b = map(int,input().split())
print(a - b*2 if a >= b*2 else 0)
if __name__ == "__main__":
main() | 0 | null | 84,045,499,291,810 | 68 | 291 |
def main():
import sys
input = sys.stdin.readline
N = int(input())
plus = []
minus = []
total = 0
for _ in range(N):
s = input().strip()
h = 0
bottom = 0
for ss in s:
if ss == "(":
h += 1
else:
h -= 1
bottom = min(bottom, h)
total += h
if h > 0:
plus.append((bottom, h))
else:
minus.append((bottom-h, -h))
if total != 0:
print("No")
sys.exit()
plus.sort(reverse=True)
minus.sort(reverse=True)
height = 0
for b, h in plus:
if height + b < 0:
print("No")
sys.exit()
height += h
height = 0
for b, h in minus:
if height + b < 0:
print("No")
sys.exit()
height += h
print("Yes")
if __name__ == '__main__':
main() | import sys
n=int(input())
a=[]
b=[]
for i in range(n):
s=input()
overall=0
minimum=0
current=0
for j in range(len(s)):
if s[j]=='(':
current+=1
else:
current-=1
minimum=min(current,minimum)
overall=current
if overall>=0:
a.append([overall,minimum])
else:
b.append([overall,minimum])
finalsum=0
a=sorted(a, key=lambda t:t[1])
a.reverse()
b=sorted(b, key=lambda t:t[0]-t[1])
b.reverse()
for i in a:
if finalsum+i[1]<0:
print('No')
sys.exit()
finalsum+=i[0]
for i in b:
if finalsum+i[1]<0:
print('No')
sys.exit()
finalsum+=i[0]
if finalsum==0:
print('Yes')
else:
print('No') | 1 | 23,784,404,185,308 | null | 152 | 152 |
import math
pages = int(input())
print(math.ceil(pages/2)) | n, x, m = [int(x) for x in input().split()]
A = [x]
while len(A) < n:
a = (A[-1] * A[-1]) % m
if a not in A:
A.append(a)
else:
i = A.index(a)
loop_len = len(A) - i
print(sum(A[:i]) + sum(A[i:]) * ((n - i) // loop_len) + sum(A[i:i + ((n - i) % loop_len)]))
break
else:
print(sum(A))
| 0 | null | 30,740,876,121,088 | 206 | 75 |
n, k = map(int, input().split())
p = list(map(int, input().split()))
c = list(map(int, input().split()))
p.insert(0, 0)
c.insert(0, 0)
visit = [0] * (n + 1)
cyclelist = []
for i in range(1, n + 1):
if visit[i] == 0:
a = [c[i]]
visit[i] = 1
while visit[p[i]] == 0:
i = p[i]
visit[i] = 1
a.append(c[i])
cyclelist.append(a)
ans = -1145141919810
for cycle in cyclelist:
s = sum(cycle)
l = len(cycle)
a = 0
if l < k and s > 0:
a = s * ((k - 1) // l)
now = 0
x = k % l
if x == 0:
x = l
for i in range(min(k, l)):
now += cycle[i]
for j in range(l):
now += cycle[(i + j + 1) % l] - cycle[j]
if i < x:
ans = max(ans, a + now)
else:
ans = max(ans, now)
print(ans) | #!/usr/bin/env python3
import sys
from collections import defaultdict
sys.setrecursionlimit(10**6)
INF = 10 ** 9 + 1 # sys.maxsize # float("inf")
MOD = 10 ** 9 + 7
def debug(*x):
print(*x, file=sys.stderr)
def solve(N, K, PS, CS):
PS = [x - 1 for x in PS]
CS = [CS[PS[i]] for i in range(N)]
visited = {}
loops = []
loopScore = []
for i in range(N):
loop = []
c = 0
while i not in visited:
visited[i] = True
c += CS[i]
i = PS[i]
loop.append(i)
if loop:
loops.append(loop)
loopScore.append(c)
pos = list(range(N))
ret = -INF
for i, loop in enumerate(loops):
if loopScore[i] > 0:
baseScore = loopScore[i] * (K // len(loop))
r = K % len(loop)
if r == 0:
r = len(loop)
baseScore -= loopScore[i]
maxscore = 0
scores = defaultdict(int)
for i in range(r):
for x in loop:
scores[x] += CS[pos[x]]
pos[x] = PS[pos[x]]
maxscore = max(maxscore, max(scores.values()))
ret = max(maxscore + baseScore, ret)
else:
r = len(loop)
maxscore = -INF
scores = defaultdict(int)
for i in range(r):
for x in loop:
scores[x] += CS[pos[x]]
pos[x] = PS[pos[x]]
maxscore = max(maxscore, max(scores.values()))
ret = max(maxscore, ret)
return ret
def main():
# parse input
N, K = map(int, input().split())
PS = list(map(int, input().split()))
CS = list(map(int, input().split()))
print(solve(N, K, PS, CS))
# tests
T1 = """
5 2
2 4 5 1 3
3 4 -10 -8 8
"""
TEST_T1 = """
>>> as_input(T1)
>>> main()
8
"""
T2 = """
2 3
2 1
10 -7
"""
TEST_T2 = """
>>> as_input(T2)
>>> main()
13
"""
T3 = """
3 3
3 1 2
-1000 -2000 -3000
"""
TEST_T3 = """
>>> as_input(T3)
>>> main()
-1000
"""
T4 = """
10 58
9 1 6 7 8 4 3 2 10 5
695279662 988782657 -119067776 382975538 -151885171 -177220596 -169777795 37619092 389386780 980092719
"""
TEST_T4 = """
>>> as_input(T4)
>>> main()
29507023469
"""
T5 = """
3 1000
2 3 1
1 0 2
"""
TEST_T5 = """
>>> as_input(T5)
>>> main()
1001
"""
T6 = """
3 1000
2 3 1
1 1 -3
"""
TEST_T6 = """
>>> as_input(T6)
>>> main()
2
"""
T7 = """
4 1000
2 1 4 3
1 1 -10000 10000
"""
TEST_T7 = """
>>> as_input(T7)
>>> main()
10000
"""
T8 = """
4 1000
2 1 4 3
1 1 -10000 10001
"""
TEST_T8 = """
>>> as_input(T8)
>>> main()
10500
"""
def _test():
import doctest
doctest.testmod()
g = globals()
for k in sorted(g):
if k.startswith("TEST_"):
doctest.run_docstring_examples(g[k], g, name=k)
def as_input(s):
"use in test, use given string as input file"
import io
f = io.StringIO(s.strip())
g = globals()
g["input"] = lambda: bytes(f.readline(), "ascii")
g["read"] = lambda: bytes(f.read(), "ascii")
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
if sys.argv[-1] == "-t":
print("testing")
_test()
sys.exit()
main()
| 1 | 5,363,963,133,608 | null | 93 | 93 |
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
n, m, k = map(int, input().split())
u = UnionFind(n + 1)
already = [0] * (n + 1)
for i in range(m):
a, b = map(int, input().split())
u.union(a, b)
already[a] += 1
already[b] += 1
for i in range(k):
c, d = map(int, input().split())
if u.same(c, d):
already[c] += 1
already[d] += 1
for i in range(1, n + 1):
print(u.size(i) - already[i] - 1)
| n, m = map(int, input().split())
s = []
c = []
for _ in range(m):
S, C = map(int, input().split())
s.append(S)
c.append(C)
for i in range(m):
if s[i] == 1 and c[i] == 0 and n != 1:
print(-1)
exit()
for i in range(m):
for j in range(m-1):
if s[i] == s[-j-1] and c[i] != c[-j-1]:
print(-1)
exit()
if n == 3:
one_hundred = False
ten = False
one = False
for i in range(m):
if s[i] == 1:
one_hundred = c[i]
elif s[i] == 2:
ten = c[i]
else:
one = c[i]
if one_hundred == False:
one_hundred = 1
if ten == False:
ten = 0
if one == False:
one = 0
print(one_hundred*100 + ten*10 + one)
exit()
elif n == 2:
ten = False
one = False
for i in range(m):
if s[i] == 1:
ten = c[i]
else:
one = c[i]
if ten == False:
ten = 1
if one == False:
one = 0
print(ten*10 + one)
exit()
else:
one = False
for i in range(m):
if s[i] == 1:
one = c[i]
if one == False:
one = 0
print(one)
exit()
print(-1) | 0 | null | 60,999,535,956,888 | 209 | 208 |
from collections import deque
q = deque()
n = int(input())
C = [deque() for _ in range(n+1)]
for i in range(n):
tmp = list(map(int,input().split()))
for j in range(tmp[1]):
C[tmp[0]].append(tmp[2+j])
visited = [False]*(n+1)
d = [0]*(n+1)
f = [0]*(n+1)
t = 0
def stack(i):
global t
if visited[i] == False:
q.append(i)
while q:
#ノードの探索開始
node = q[-1]
if d[node] == 0:
t += 1
d[node] = t
visited[node] = True
for _ in range(len(C[node])):
tmp = C[node].popleft()
if visited[tmp] == False:
next_node = tmp
q.append(next_node) #未探索の接続ノード
break
#未探索接続ノードがなければそのノードは探索終了
else:
t += 1
f[q.pop()] = t
for i in range(1,n+1):
stack(i)
for i in range(1,n+1):
print("{} {} {}".format(i,d[i],f[i]))
| N=int(input())
L=[[10**9]for i in range(N+1)]
for i in range(N):
l=list(map(int,input().split()))
for j in range(l[1]):
L[i+1].append(l[2+j])
#print(L)
for i in range(N+1):
L[i].sort(reverse=True)
#print(L)
ans=[]
for i in range(N+1):
ans.append([0,0])
from collections import deque
Q=deque()
cnt=1
for i in range(N):
Q.append([0,N-i])
for i in range(10**7):
if len(Q)==0:
break
q0,q1=Q.pop()
#print(q0,q1)
if q1!=10**9:
if ans[q1][0]==0:
ans[q1][0]=cnt
cnt+=1
for j in L[q1]:
Q.append([q1,j])
else:
ans[q0][1]=cnt
cnt+=1
#print(ans,Q)
for i in range(1,N+1):
print(i,ans[i][0],ans[i][1])
| 1 | 3,019,266,476 | null | 8 | 8 |
import math
n = int(input())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
def p1(x, y, n):
D = []
for i in range(n):
D.append(abs(x[i] - y[i]))
return sum(D)
def p2(x, y, n):
D = []
for i in range(n):
D.append(abs(x[i] - y[i]))
D[i] *= D[i]
Sum = sum(D)
return math.sqrt(Sum)
def p3(x, y, n):
D = []
for i in range(n):
D.append(abs(x[i] - y[i]))
D[i] = D[i] * D[i] * D[i]
Sum = sum(D)
return math.pow(Sum, 1 / 3)
def pX(x, y, n):
D = []
for i in range(n):
D.append(abs(x[i] - y[i]))
return max(D)
print('{:6f}'.format(p1(x, y, n)))
print('{:6f}'.format(p2(x, y, n)))
print('{:6f}'.format(p3(x, y, n)))
print('{:6f}'.format(pX(x, y, n)))
| import math
n = input()
x = [int(_) for _ in raw_input().split()]
y = [int(_) for _ in raw_input().split()]
for p in range(1,4):
sum = 0
for i in range(n):
sum += math.pow(abs(x[i] - y[i]),p)
print math.pow(sum,1/float(p))
print max([abs(float(i) - float(j)) for i,j in zip(x,y) ]) | 1 | 218,649,675,190 | null | 32 | 32 |
n = int(input())
a = list(map(int,input().split()))
mod = 10**9 + 7
c = [n]*61
for i in range(n):
b = str(bin(a[i]))[2:]
b = b[::-1]
for j, x in enumerate(b):
if x == "1":
c[j] -= 1
ans = 0
for i in range(60):
ans += c[i]*(n-c[i])*pow(2,i,mod)
ans %= mod
print(ans)
| #!/usr/bin/env python3
import sys
from itertools import chain
from bisect import bisect_right
# from collections import Counter
# import numpy as np
def solve(N: int, M: int, K: int, A: "List[int]", B: "List[int]"):
A = [0] + A
for i in range(1, N + 1):
A[i] = A[i] + A[i - 1]
B = [0] + B
for i in range(1, M + 1):
B[i] = B[i] + B[i - 1]
answer = 0
for n in range(N+1):
ka = A[n]
if ka > K:
break
kb = K - ka # ak > K だから kb >= 0 bisect_right > 0
m = bisect_right(B, kb) - 1
if n + m > answer:
answer = n + m
return answer
def main():
tokens = chain(*(line.split() for line in sys.stdin))
# N, M, K, A, B = map(int, line.split())
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
B = [int(next(tokens)) for _ in range(M)] # type: "List[int]"
answer = solve(N, M, K, A, B)
print(answer)
if __name__ == "__main__":
main()
| 0 | null | 66,697,894,517,632 | 263 | 117 |
import math
a,b = map(int,input().split())
print(a*b//math.gcd(a,b)) | from itertools import permutations
n = int(input())
p = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
perm = list(permutations(sorted(p), n)) #; print(perm)
a = perm.index(tuple(p))
b = perm.index(tuple(q))
print(abs(a-b)) | 0 | null | 107,030,877,107,286 | 256 | 246 |
import math
def findNumberOfDigits(n, b):
dig = (math.floor(math.log(n) /math.log(b)) + 1)
return dig
n, k = map(int, input().strip().split())
print(findNumberOfDigits(n, k)) | N,K=map(int,input().split())
ans=0
while N>=K**ans:
ans+=1
print(ans) | 1 | 64,355,055,950,306 | null | 212 | 212 |
from math import ceil, floor
# dp[a_i番まで見た。a_iを含む][a_i（を含む）までにいくつ採用しているか][i - 1を使ったかどうか] bool
memo = {}
def dp(i, j):
if (i, j) in memo:
return memo[(i, j)]
else:
return float("inf")*-1
def main():
n = int(input())
A = [0] + list(map(int, input().split()))
memo[(0, 0)] = 0
memo[(1, 1)] = A[1]
memo[(1, 0)] = 0
for i in range(2, n + 1):
for j in range(max(floor(n/2) - ceil((n-i)/2) - 1, 0), floor(i/2) + 5):
# a_iを採用する場合
if (i, j) in memo:
memo[(i, j)] = max(
[dp(i, j), A[i] + dp(i - 2, j - 1), A[i] + dp(i - 3, j - 1)])
else:
memo[(i, j)] = max(A[i] + dp(i - 2, j - 1),
A[i] + dp(i - 3, j - 1))
# a_iを採用しない場合
if (i - 1, j) in memo:
memo[(i, j)] = max(dp(i - 1, j), dp(i, j))
print(dp(n, floor(n/2)))
return
if __name__ == "__main__":
main()
| a,b,c=map(int,input().split())
d=[i for i in range(a,b+1)]
count=0
for i in d:
if c%i==0:
count+=1
print(count) | 0 | null | 18,857,763,922,140 | 177 | 44 |
#template
from sys import setrecursionlimit
setrecursionlimit(10**6)
from collections import Counter
def inputlist(): return [int(i) for i in input().split()]
#template
li = ['hi','hihi','hihihi','hihihihi','hihihihihi']
S = input()
if S in li:
print("Yes")
else:
print("No") | S=list(input())
while len(S)>1:
if S[0] == 'h' and S[1] == 'i':
S.remove('h')
S.remove('i')
else:
break
if len(S) == 0:
print('Yes')
else:
print('No')
| 1 | 52,876,614,490,478 | null | 199 | 199 |
a, b = map(int, input().split(" "))
print("%d %d %.5f" %(a/b, a%b, a/b))
| N=int(input())
ans = []
for i in range(1,N+1):
if i % 3 == 0 and i % 5 == 0:
continue
elif i % 3 == 0 and i % 5 != 0:
continue
elif i % 5 == 0 and i % 3 != 0:
continue
else:
ans.append(i)
print(sum(ans))
| 0 | null | 17,796,487,050,200 | 45 | 173 |
n = list(raw_input())
for i in xrange(len(n)):
if n[i].isupper(): n[i]=n[i].lower()
elif n[i].islower(): n[i]=n[i].upper()
print ''.join(n) | # C - Subarray Sum
def main():
N, K, S = map(int, input().split())
res = [str(S)] * K + ["1" if S == 10 ** 9 else str(S + 1)] * (N - K)
print(" ".join(res))
if __name__ == "__main__":
main()
| 0 | null | 46,440,120,847,398 | 61 | 238 |
import numpy as np
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
from numba import njit
def getInputs():
D = int(readline())
CS = np.array(read().split(), np.int32)
C = CS[:26]
S = CS[26:].reshape((-1, 26))
return D, C, S
@njit('(i8, i4[:], i4[:, :], i4[:], )', cache=True)
def _compute_score1(D, C, S, out):
score = 0
last = np.zeros((D, 26), np.int32)
for d in range(len(out)):
if d:
last[d, :] = last[d - 1, :]
i = out[d]
score += S[d, i]
last[d, i] = d + 1
score -= np.sum(C * (d + 1 - last[d, :]))
return last, score
def _update_score():
pass
@njit('(i8, i4[:], i4[:, :], i4[:], i8, )', cache=True)
def _random_update(D, C, S, out, score):
d = np.random.randint(0, D)
q = np.random.randint(0, 26)
p = out[d]
out[d] = q
if p == q:
return out, score
last, new_score = _compute_score1(D, C, S, out)
if score < new_score:
score = new_score
else:
out[d] = p
return out, score
def _random_swap():
pass
def step1(D, C, S):
out = []
LAST = 0
for d in range(D):
max_score = -10000000
best_i = 0
for i in range(26):
out.append(i)
last, score = _compute_score1(D, C, S, np.array(out, np.int32))
if max_score < score:
max_score = score
LAST = last
best_i = i
out.pop()
out.append(best_i)
return np.array(out), LAST, max_score
def step2(D, C, S, out, score):
for i in range(10 ** 4):
out = out.astype(np.int32)
out, score = _random_update(D, C, S, out, score)
return out, score
def output(out):
out += 1
print('\n'.join(out.astype(str).tolist()))
D, C, S = getInputs()
out, _, score = step1(D, C, S)
#print(score)
out, score = step2(D, C, S, out, score)
output(out)
#print(score) | import numpy as np
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
from numba import njit
def getInputs():
D = int(readline())
CS = np.array(read().split(), np.int32)
C = CS[:26]
S = CS[26:].reshape((-1, 26))
return D, C, S
def _compute_score(output, i, d, last):
mask = np.ones((26, ), np.int32)
mask[i] = 0
score = S[d][i] - np.sum(C * (d + 1 - last) * mask)
return score
def _evaluate(output, i, d, last, k):
score = _compute_score(output, i, d, last)
score -= np.sum(C * (d + k + 1 - last))
return score
def solve(k):
output = np.array([], np.int32)
last = np.zeros((26, ), np.int32)
SCORE = 0
for d in range(D):
max_score = float('-inf')
best_i = 0
for i in range(26):
output = np.append(output, i)
#score = _compute_score(output, i, d, last)
score = _evaluate(output, i, d, last, k)
if max_score < score:
max_score = score
best_i = i + 1
output = output[:-1]
output = np.append(output, best_i)
last[best_i - 1] = d + 1
SCORE += max_score
return output, SCORE
D, C, S = getInputs()
max_score = float('-inf')
for k in range(7, 14):
ans, score = solve(k)
if max_score < score:
max_score = score
ANS = ans
print('\n'.join(ANS.astype(str).tolist())) | 1 | 9,645,276,194,870 | null | 113 | 113 |
from collections import Counter
n = int(input())
x = list(map(int, input().split()))
a = []
b = []
for i in range(n):
a.append(i+1+x[i])
b.append(i+1-x[i])
ans = 0
a, b = Counter(a), Counter(b)
for i in range(min(a), max(b)+1):
ans += a[i]*b[i]
print(ans) | def main():
x, n = list(map(int, input().split()))
if n > 0:
p_list = list(map(int, input().split()))
else:
return x
ans = 0
diff = abs(p_list[0]-x)
for i in range(n):
diff_new = abs(p_list[i] - x)
if diff_new < diff:
ans =i
diff=diff_new
#print(p_list[ans])
for i in range(200):
if p_list[ans] - i not in p_list:
return p_list[ans] - i
break
elif p_list[ans] + i not in p_list:
return p_list[ans] + i
break
if __name__=='__main__':
print(main()) | 0 | null | 20,000,914,882,844 | 157 | 128 |
import sys
sys.setrecursionlimit(10**6)
def root(x):
if pair[x]<0:
return x
else:
tmp=root(pair[x])
pair[x]=tmp
return tmp
def unite(x,y):
x=root(x)
y=root(y)
if x==y:return False
if pair[x]>pair[y]:
x,y=y,x
pair[x]+=pair[y]
pair[y]=x
return True
def size(x):
return -pair[root(x)]
icase=0
if icase==0:
n,m,k=map(int,input().split())
g=[[] for i in range(n)]
x=[[] for i in range(n)]
a=[0]*m
b=[0]*m
pair=[-1]*n
for i in range(m):
ai,bi=map(int,input().split())
g[ai-1].append(bi-1)
g[bi-1].append(ai-1)
a[i]=ai-1
b[i]=bi-1
unite(a[i],b[i])
for i in range(k):
ci,di=map(int,input().split())
x[ci-1].append(di-1)
x[di-1].append(ci-1)
for i in range(n):
ss=size(i)-1
rooti=root(i)
for gi in g[i]:
if root(gi)==rooti:
ss-=1
for xi in x[i]:
if root(xi)==rooti:
ss-=1
print(ss,end=" ")
print(" ")
| a,b=map(float,input().split())
import decimal
a=decimal.Decimal(a)
b=decimal.Decimal(b)
print(int(a*b)) | 0 | null | 38,872,455,851,190 | 209 | 133 |
n = int(input())
rem = n%1000
if rem!=0:rem = 1000 - rem
print(rem) | A, B = list(map(float,input().split()))
result = int(A * B)
print(result) | 0 | null | 12,085,966,214,962 | 108 | 133 |
S = input()
for c in S:
print(c.swapcase(), end='')
print()
| import sys
import resource
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def union(x, y):
rx = root(x)
ry = root(y)
if rx != ry:
par[rx] = ry
return 0
sys.setrecursionlimit(10 ** 6)
n, m=map(int, input().split(" "))
par = list(range(n + 1))
for i in range(m):
a, b = map(int, input().split(" "))
union(a, b)
#print(par)
maxi = 0
count = 1
#print(par)
countpar = [0 for i in range(n + 1)]
#print(len(countpar), len(par))
for i in range(1, n + 1):
countpar[root(par[i])] += 1
print(max(countpar))
#print(countpar, par)
| 0 | null | 2,781,513,093,360 | 61 | 84 |
def resolve():
a,b = map(int,input().split())
print(0 if a<b*2 else a-b*2)
resolve() | #!/usr/bin/env python3
import sys
YES = "Yes" # type: str
NO = "No" # type: str
def solve(N: int, M: int):
if N==M:
print(YES)
else:
print(NO)
return
# Generated by 1.1.6 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()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
solve(N, M)
if __name__ == '__main__':
main()
| 0 | null | 125,041,623,761,418 | 291 | 231 |
a,b,c=map(int,input().split());print('Yes'if a<b<c else'No')
| #coding:utf-8
data = [int(i) for i in input().split()]
a = data[0]
b = data[1]
c = data[2]
if a<b<c:
print("Yes")
else:
print("No") | 1 | 387,663,697,396 | null | 39 | 39 |
N = int(input())
A = list(map(int,input().split()))
Q = int(input())
S = [list(map(int, input().split())) for l in range(Q)]
l = [0] * 10**6
tot = 0
for i in range(N) :
l[A[i]]+=1
tot += A[i]
for i in range(Q):
s0 = S[i][0]
s1 = S[i][1]
tot += s1 * (l[s0] + l[s1]) - (s0 * l[s0] + s1*l[s1])
l[s1] += l[s0]
l[s0] = 0
print(tot) | N = int(input())
A = list(map(int, input().split()))
Q = int(input())
d = {}
v = 0
ans = []
for a in A:
d[a] = d.get(a, 0) + 1
v += a
for i in range(Q):
B, C = map(int, input().split())
v += d.get(B, 0) * (C - B)
d[C] = d.get(C, 0) + d.get(B, 0)
d[B] = 0
ans.append(v)
for a in ans:
print(a)
| 1 | 12,220,850,365,152 | null | 122 | 122 |
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
class UnionFind(object):
def __init__(self, n, recursion = False):
self._par = list(range(n))
self._size = [1] * n
self._recursion = recursion
def root(self, k):
if self._recursion:
if k == self._par[k]:
return k
self._par[k] = self.root(self._par[k])
return self._par[k]
else:
root = k
while root != self._par[root]: root = self._par[root]
while k != root: k, self._par[k] = self._par[k], root
return root
def unite(self, i, j):
i, j = self.root(i), self.root(j)
if i == j: return False
if self._size[i] < self._size[j]: i, j = j, i
self._par[j] = i
self._size[i] += self._size[j]
return True
def is_connected(self, i, j):
return self.root(i) == self.root(j)
def size(self, k):
return self._size[self.root(k)]
def resolve():
n, m = map(int, input().split())
uf = UnionFind(n)
for _ in range(m):
u, v = map(int, input().split())
u -= 1; v -= 1
uf.unite(u, v)
ans = len(set(uf.root(v) for v in range(n))) - 1
print(ans)
resolve() | def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x]) #経路圧縮
return par[x]
def same(x,y):
return find(x) == find(y)
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return 0
par[x] = y
size[y] = size[x] + size[y]
size[x] = 0
N,M = map(int,input().split())
par = [ i for i in range(N+1)]
size = [1 for _ in range(N+1)]
for _ in range(M):
a,b = map(int,input().split())
unite(a,b)
A = size.count(0)
print(N-A-1) | 1 | 2,251,676,024,222 | null | 70 | 70 |
import sys
input = sys.stdin.readline
def main():
s, w = map(int, input().split())
print("unsafe" if w >= s else "safe")
if __name__ == "__main__":
main() | s = input()
if len(s) % 2 == 1:
print('No')
else:
ans = "Yes"
for i in range(len(s)):
if i % 2 == 0 and s[i] != 'h':
ans = "No"
break
if i % 2 == 1 and s[i] != 'i':
ans = "No"
break
print(ans) | 0 | null | 41,234,520,121,852 | 163 | 199 |
from collections import deque
N = int(input())
c = [chr(ord("a") + i) for i in range(26)]
q = deque("a")
ans = []
while q:
s = q.pop()
if len(s) == N:
ans.append(s)
continue
for x in c[:c.index(max(s)) + 2]:
q.append(s + x)
[print(a) for a in sorted(ans)] | s = input()
N = [int(c) for c in s]
add = 0
for i in range(len(N)):
num = N[i]
add += num
if add % 9 == 0:
print('Yes')
else:
print('No') | 0 | null | 28,286,931,563,184 | 198 | 87 |
N, K = map(int, input().split())
expectation = list(map(lambda x: (x+1) / 2, map(int, input().split())))
cur_expectation = sum(expectation[:K])
max_expectation = cur_expectation
for i in range(N - K):
cur_expectation -= expectation[i]
cur_expectation += expectation[i + K]
if cur_expectation > max_expectation:
max_expectation = cur_expectation
print(max_expectation)
| n,k = map(int,input().split())
p = [int(x) for x in input().split()]
sum1 = sum(p[:k])
num = k-1
max1 = sum1
for i in range(k,n):
sum1 = sum1 - p[i-k] + p[i]
if sum1 >= max1:
max1 = sum1
num = i
#print(max1,sum1,i)
sum2 = sum(p[num-k+1:num+1])
def goukei(j):
return 1/2 * j * (j+1)
print(float((goukei(sum2)-goukei(k-1))/(sum2 -k +1)))
| 1 | 75,106,838,207,400 | null | 223 | 223 |
import math
n=int(input())
xs=list(map(float,input().split()))
ys=list(map(float,input().split()))
ds=[ abs(x - y) for (x,y) in zip(xs,ys) ]
print('{0:.6f}'.format(sum(ds)))
print('{0:.6f}'.format((sum(map(lambda x: x*x,ds)))**0.5))
print('{0:.6f}'.format((sum(map(lambda x: x*x*x,ds)))**(1./3.)))
print('{0:.6f}'.format(max(ds))) | import math
n = int(input())
xlist = list(map(float, input().split()))
ylist = list(map(float, input().split()))
#x, y = [list(map(int, input().split())) for _ in range(2)] 로 한방에 가능
print(sum(abs(xlist[i] - ylist[i]) for i in range(n)))
print(pow(sum(abs(xlist[i] - ylist[i]) ** 2 for i in range(n)),0.5))
print(pow(sum(abs(xlist[i] - ylist[i]) ** 3 for i in range(n)),1/3))
print(max(abs(xlist[i] - ylist[i])for i in range(n)))
| 1 | 211,536,918,530 | null | 32 | 32 |
def main():
n, r = map(int, input().split())
if n < 10:
r += 100 * (10 - n)
print(r)
main()
| N = input()
a=0
for i in range(len(N)):
a+=int(N[i])%9
if a%9==0:
print('Yes')
if a%9!=0:
print('No') | 0 | null | 33,790,750,926,368 | 211 | 87 |
import math
N = int(input())
A = list(map(int, input().split()))
section = [[A[-1], A[-1]]]
for i in range(1, N+1):
min_section = math.ceil(section[i-1][0] / 2) + A[-i-1]
max_section = section[i-1][1] + A[-i-1]
section.append([min_section, max_section])
section = section[::-1]
if section[0][0] > 1:
print(-1)
exit()
node = [1]
for i in range(1, N+1):
node.append(min((node[i-1] - A[i-1]) * 2, section[i][1]))
print(sum(node)) | n, m = map(int, input().split())
a = sorted(map(int, input().split()))[::-1]
i = 0
for j in range(n):
i = i + a[j]
x = i / (4 * m)
print("Yes" if a[m - 1] >= x else "No") | 0 | null | 28,910,905,014,310 | 141 | 179 |
import sys
input = sys.stdin.readline
S=tuple(input().strip())
N=len(S)+1
sets = []
count = 0
for c in S:
d = 1 if c == '<' else -1
if count * d < 0:
sets.append(count)
count = d
else:
count += d
sets.append(count)
sum = 0
for i in range(len(sets)):
k=sets[i]
if k > 0:
sum += (k*(k+1))//2
else:
sum += (k*(k-1))//2
if i > 0:
sum -= min(sets[i-1], -k)
print(sum)
| n = int(input())
a = list(map(int, input().split()))
x = "APPROVED"
for i in range(n):
if a[i] == (2 * int(a[i] / 2)):
if a[i] != (3 * int(a[i] / 3)):
if a[i] != (5 * int(a[i] / 5)):
x = "DENIED"
print(str(x)) | 0 | null | 112,294,648,901,252 | 285 | 217 |
N = int(input())
A_ls = input().split(' ')
rst = set()
for i in A_ls:
rst.add(i)
if len(rst) == N:
print('YES')
else:
print('NO') | n = int( input() )
a = list( map( int, input().split() ) )
cnt = {}
for a_i in a:
try:
cnt[ a_i ]
print( "NO" )
break
except KeyError:
cnt[ a_i ] = 1
else:
print( "YES" ) | 1 | 73,729,487,422,990 | null | 222 | 222 |
N, M, X = list(map(int, input().split()))
C = [list() for _ in range(N)]
for i in range(N):
C[i] = list(map(int, input().split()))
INF = 10**9 + 7
minpr = INF
for i in range(2**N):
buy = list()
for j in range(N):
if i&1==1: buy.append(j)
i >>= 1
skill = [0]*M
price = 0
for k in range(len(buy)):
price += C[buy[k]][0]
for l in range(M):
skill[l] += C[buy[k]][l+1]
for m in range(M):
if skill[m] < X: break
else:
if minpr > price: minpr = price
if minpr==INF:
print(-1)
else:
print(minpr)
| n, m, x = map(int, input().split())
ca = []
for _ in range(n):
ca.append(list(map(int, input().split())))
cost_max = 12 * (10 ** 5)
book_list = []
flag = 0
for i in range(2**n):
book_num = 0
book_list = []
if i == 0:
continue
for j in range(n):
if (i >> j) & 1:
book_list.append(ca[j])
book_num += 1
for j in range(m):
skill_revel = 0
for k in range(book_num):
skill_revel += book_list[k][j+1]
if skill_revel >= x:
if j == (m-1) and k == (book_num-1):
cost = 0
for l in range(book_num):
cost += book_list[l][0]
if cost <= cost_max:
flag = 1
cost_max = cost
continue
else:
break
if flag == 0:
print(-1)
else:
print(cost_max) | 1 | 22,315,555,152,978 | null | 149 | 149 |
n = int(input())
a = list(map(int, input().split()))
menber = [0]*n
for value in a:
menber[value-1] += 1
for i in menber:
print(i) | class Dice():
def __init__(self, spots):
self.spots = [spots[i] for i in range(6)]
def roll(self, direction):
if direction == 0:
self.spots = [self.spots[i] for i in [1, 5, 2, 3, 0, 4]]
elif direction == 1:
self.spots = [self.spots[i] for i in [3, 1, 0, 5, 4, 2]]
elif direction == 2:
self.spots = [self.spots[i] for i in [4, 0, 2, 3, 5, 1]]
elif direction == 3:
self.spots = [self.spots[i] for i in [2, 1, 5, 0, 4, 3]]
spots = list(map(int, input().split()))
moves = input()
my_dice = Dice(spots=spots)
for move in moves:
if move == 'N':
my_dice.roll(0)
elif move == 'E':
my_dice.roll(1)
elif move == 'S':
my_dice.roll(2)
elif move == 'W':
my_dice.roll(3)
print(my_dice.spots[0])
| 0 | null | 16,448,216,519,060 | 169 | 33 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.