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
|
|---|---|---|---|---|---|---|
import numpy as np
N = int(input())
mod = 10**9 + 7
A = np.array(input().split(), int)
ans = 0
for i in range(60):
b = np.count_nonzero(A >> i & 1)
ans += 2**i*(b*(N-b))
ans %= mod
c = np.count_nonzero(A >> i & 1)
print(ans)
|
# -*- coding: utf-8 -*-
import sys
point = '.'
sharp = '#'
while True:
H, W = map(int, raw_input().split())
if H == W == 0:
break
for h in xrange(H):
for w in xrange(W):
if h % 2 == 0:
if w % 2 == 0:
sys.stdout.write(sharp),
else:
sys.stdout.write(point),
else:
if w % 2 == 0:
sys.stdout.write(point)
else:
sys.stdout.write(sharp)
print
print
| 0 | null | 61,635,199,624,580 | 263 | 51 |
import array
K = int(input())
s = 0
cache = [1] * K
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
for i in range(1, K+1):
cache[i-1] = [1] * K
for j in range(i, K+1):
cache[i-1][j-1] = array.array('i', [1] * K)
for k in range(j, K+1):
cache[i-1][j-1][k-1] = gcd(k, gcd(j, i))
for i in range(1, K+1):
for j in range(1, K+1):
for k in range(1, K+1):
a, b, c = sorted([i, j, k])
s += cache[a-1][b-1][c-1]
print(s)
|
import math
n = int(input())
s = 0
for a in range(n):
for b in range(n):
d = math.gcd(a + 1, b + 1)
for c in range(n):
s += math.gcd(c + 1, d)
print(s)
| 1 | 35,398,061,169,052 | null | 174 | 174 |
n = int(input())
print('{:.10f}'.format(1-(n//2 / n)))
|
from random import choice
from time import time
start_time = time()
d = int(input())
*C, = map(int, input().split())
S = [list(map(int, input().split())) for i in range(d)]
X = []
L = [-1 for j in range(26)]
for i in range(d):
max_diff = -10**10
best_j = 0
for j in range(26):
memo = L[j]
L[j] = i
diff = S[i][j] - sum([C[jj] * (i - L[jj]) for jj in range(26)])
if diff > max_diff:
max_diff = diff
best_j = j
L[j] = memo
L[best_j] = i
X.append(best_j)
def f(X):
score = 0
L = [-1 for j in range(26)]
A = [0 for j in range(26)]
for i in range(d):
score += S[i][X[i]]
A[X[i]] += (i - L[X[i]]) * (i - L[X[i]] - 1) // 2
L[X[i]] = i
for j in range(26):
A[j] += (d - L[j]) * (d - L[j] - 1) // 2
score -= C[j] * A[j]
return score
max_score = f(X)
while time() - start_time < 1.8:
i = choice(range(d))
j = choice(range(26))
memo = X[i]
X[i] = j
score = f(X)
if score > max_score:
max_score = score
else:
X[i] = memo
a = choice(range(7))
i0 = choice(range(d - a))
i1 = i0 + a
memo = X[i0], X[i1]
X[i0], X[i1] = X[i1], X[i0]
score = f(X)
if score > max_score:
max_score = score
else:
X[i0], X[i1] = memo
for x in X:
print(x + 1)
| 0 | null | 93,320,897,644,558 | 297 | 113 |
def bubblesort(N, A):
"""Do BubbleSort"""
m = 0
flag = True
while(flag):
flag = False
for i in range(N-1, 0, -1):
if (A[i-1] > A[i]):
tmp = A[i-1]
A[i-1] = A[i]
m += 1
A[i] = tmp
flag = True
b = list(map(str, A))
print(" ".join(b))
print(m)
A = []
N = int(input())
s = input()
A = list(map(int, s.split()))
bubblesort(N, A)
|
### ----------------
### ここから
### ----------------
import sys
from io import StringIO
import unittest
def resolve():
readline=sys.stdin.readline
mod=10**9+7
n=int(readline())
arr=list(map(int, readline().rstrip().split()))
ans = 0
x = 1
for i in range(60):
c = 0
for j in range(n):
if arr[j]&x != 0:
c += 1
ans += (c * (n-c)) * x
ans %= mod
x = x*2
print(ans)
return
if 'doTest' not in globals():
resolve()
sys.exit()
### ----------------
### ここまで
### ----------------
| 0 | null | 61,251,476,051,440 | 14 | 263 |
n, q = map(int , input().split())
queue = []
for _ in range(n):
line = input().split()
queue.append([line[0], int(line[1])])
class my_queue:
def __init__(self, queue):
self.queue = queue
def enqueue(self, item):
self.queue = self.queue + [item]
self.queue.append(item)
def dequeue(self):
if len(self.queue) != 0:
item = self.queue[0]
self.queue = self.queue[1:]
else :
item = None
return item
time = 0
finish_task = []
while(len(queue) != 0):
item = queue.pop(0)
if item == None:
break
elif item[1] <= q:
time += item[1]
finish_task.append([item[0], time])
else :
time += q
queue.append([item[0], item[1] - q])
for item in finish_task:
print(item[0], item[1])
|
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
if A < B:
if A + (V*T) >= B + (W*T):
print("YES")
else:
print("NO")
else:
if A - (V*T) <= B - (W*T):
print("YES")
else:
print("NO")
| 0 | null | 7,517,414,120,498 | 19 | 131 |
def n_cand(x):
return int(x*1.08)
n = int(input())
x = round(n / 1.08)
n_dash = n_cand(x)
n_dash_m = n_cand(x-1)
n_dash_p = n_cand(x+1)
if n_dash == n:
print(x)
elif n_dash_m == n:
print(x-1)
elif n_dash_p == n:
print(x+1)
else:
print(':(')
|
n = int(input())
dic = {}
for i in range(1,50000):
dic[int(i * 1.08)] = i
if n in dic:
print(dic[n])
else:
print(':(')
| 1 | 125,529,742,028,028 | null | 265 | 265 |
import math
a, b, n = map(int, input().split())
x = min(b - 1, n)
ans = math.floor(a * x / b) - a * math.floor(x / b)
print(ans)
|
a,b,n=map(int,input().split())
def f(x):
return (a*x)//b - a*(x//b)
print(f(min(b-1,n)))
| 1 | 28,106,819,221,128 | null | 161 | 161 |
s = raw_input().split()
stack = []
for op in s:
if op.isdigit():
stack.append(op)
else:
b = int(stack.pop())
a = int(stack.pop())
ret = 0
if op == "+":
ret = a + b
elif op == "-":
ret = a - b
elif op == "*":
ret = a * b
stack.append(str(ret))
print stack.pop()
|
data = raw_input().split()
#figure = [chr(i) for i in range(ord('0'), ord('9')+1)]
stack = []
for i in range(len(data)):
if data[i] == "+":
stack[-2] = stack[-2] + stack[-1]
del stack[-1]
#print stack
elif data[i] == "-":
stack[-2] = stack[-2] - stack[-1]
del stack[-1]
#print stack
elif data[i] == "*":
stack[-2] = stack[-2] * stack[-1]
del stack[-1]
#print stack
else:
stack.append(int(data[i]))
#print stack
print stack[0]
| 1 | 34,967,593,860 | null | 18 | 18 |
import copy
class Dice2:
def __init__(self, nums):
self.nums = nums
self.dic = \
{(1,2):3, (1,3):5, (1,4):2, (1,5):4, (2,3):1, (2,4):6, (2,6):3, (3,5):1, (3,6):5, (4,5):6, (4,6):2, (5,6):4}
def output_right(self, x):
x[0] = self.nums.index(x[0]) + 1
x[1] = self.nums.index(x[1]) + 1
nums = self.nums
y = copy.deepcopy(x)
x.sort()
key = tuple(x)
if tuple(y)==key:
return nums[self.dic[key]-1]
else:
return nums[6-self.dic[key]]
dice = Dice2(list(map(int, input().split())))
q = int(input())
for i in range(q):
print(dice.output_right(list(map(int, input().split()))))
|
input();a=1
for i in input().split():a*=int(i);a=[-1,a][0<=a<=10**18]
print(a)
| 0 | null | 8,301,977,629,338 | 34 | 134 |
a = [x + 1 for x in range(9)]
for i in a:
for j in a:
print('{}x{}={}'.format(i, j, i * j))
|
MOD = 10 ** 9 + 7
N = int(input())
Sall = pow(10, N, MOD)
S0 = S9 = pow(9, N, MOD)
S09 = pow(8, N, MOD)
ans = (Sall - (S0 + S9 - S09)) % MOD
print(ans)
| 0 | null | 1,556,459,777,028 | 1 | 78 |
n = int(input())
a = [int(i) for i in input().split()]
if n // 2 == 1:
print(max(a))
exit()
if n < 20:
d = a.copy()
for i in range(1, n // 2):
b = [0] * n
c = -10 ** 24
ans = -10 ** 24
for j in range(i * 2, n):
c = max(c, a[j - 2])
b[j] = c + d[j]
ans = max(ans, c + d[j])
a = b.copy()
print(ans)
exit()
b = a[:10]
e = [True]*10
for i in range(1, n // 2):
c = [0] * 10
f = [False]*10
d = -10**24
for j in range(10):
if 2 * i + j >= n:
continue
if not e[j]:
continue
d = max(d, b[j])
c[j] = d + a[2 * i + j]
f[j] = True
e = f.copy()
b = c.copy()
ans = -10 ** 24
for i in range(10):
if e[i]:
ans = max(ans, b[i])
print(ans)
|
#from collections import deque
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**6)
#def mypopleft(que, index):
# if len(que) > index:
# return que.pop(index)
# else:
# return []
def main():
# input
n = int(input())
graph = []
for i in range(n):
u, k, *tmp = [int(i) for i in readline().split()]
graph.append(tmp)
#print(graph)
d = [-1]*n
#que = deque([1])
que = [1]
#count = 0
d[0] = 0
check = []
while True:
v = que.pop(0)
#print(v)
#count += 1
#print(d)
for u in graph[v-1]:
#print(u)
if d[u-1] == -1:
d[u-1] = d[v-1] + 1
que.append(u)
if len(que) == 0:
break
for i in range(n):
print("{} {}".format(i+1, d[i]))
if __name__ == "__main__":
main()
| 0 | null | 18,664,159,328,870 | 177 | 9 |
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = LI()
memo = [0] * (10**6 + 1)
f = defaultdict(int)
for i in a:
if f[i] > 1:
continue
f[i] += 1
for j in range(i, 10**6+1, i):
memo[j] += 1
ans = 0
for i in a:
if memo[i] == 1:
ans += 1
print(ans)
|
n, k, s = map(int,input().split())
if s == 10**9:
ans = [1 for i in range(n)]
for i in range(k):
ans[i] = 10**9
else:
ans = [10**9 for i in range(n)]
for i in range(k):
ans[i] = s
print(" ".join(map(str,ans)))
| 0 | null | 52,423,158,716,540 | 129 | 238 |
# coding: utf-8
import sys
from collections import deque
n, q = map(int, input().split())
total_time = 0
tasks = deque(map(lambda x: x.split(), sys.stdin.readlines()))
try:
while True:
t = tasks.popleft()
if int(t[1]) - q <= 0:
total_time += int(t[1])
print(t[0], total_time)
else:
t[1] = str(int(t[1]) - q)
total_time += q
tasks.append(t)
except Exception:
pass
|
n,q = map(int,input().split())
process = []
for i in range(n):
name,time = input().split()
process.append([name,int(time)])
elap = 0
out = []
while len(process) > 0:
name,time = process.pop(0)
temp_q = q
while True:
if time <= 0:
out.append([name,elap])
break
if temp_q <= 0:
process.append([name,time])
break
time -= 1
temp_q -= 1
elap += 1
for name,time in out:
print(name,time)
| 1 | 42,527,791,722 | null | 19 | 19 |
N = int(input())
print((N //2 + N % 2) / N)
|
n,m = map(int, input().split())
AC = [False]*n
WA = [0]*n
for i in range(m):
p,s = input().split()
p = int(p)-1
if AC[p] == False:
if s == 'WA':
WA[p] += 1
else:
AC[p] = True
wa = 0
for i in range(n):
if AC[i]:
wa += WA[i]
print(AC.count(True),wa)
| 0 | null | 135,288,240,741,318 | 297 | 240 |
def is_good(mid, key):
ret = 0
for i in range(N):
ret += max(0, A[i] - mid // F[i])
return ret <= key
def binary_search(key):
bad, good = -1, 10 ** 18
while good - bad > 1:
mid = (bad + good) // 2
if is_good(mid, key):
good = mid
else:
bad = mid
return good
N, K = map(int, input().split())
A = sorted(map(int, input().split()))
F = sorted(map(int, input().split()), reverse=True)
print(binary_search(K))
|
# -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
class Bisect:
def __init__(self, func):
self.__func = func
def bisect_left(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if self.__func(mid) < x:
lo = mid+1
else:
hi = mid
return lo
def bisect_right(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if x < self.__func(mid):
hi = mid
else:
lo = mid+1
return lo
def f(n):
r = 1
for i in range(1, n+1):
r *= i
return r
@mt
def slv(N, K, A, F):
A.sort()
F.sort(reverse=True)
def f(x):
y = 0
for a, f in zip(A, F):
b = a - x//f
if b > 0:
y += b
if y <= K:
return 1
return 0
return Bisect(f).bisect_left(1, 0, 10**18)
def main():
N, K = read_int_n()
A = read_int_n()
F = read_int_n()
print(slv(N, K, A, F))
if __name__ == '__main__':
main()
| 1 | 164,677,029,428,652 | null | 290 | 290 |
def resolve():
n,k = map(int,input().split())
ans = 0
while n!=0:
n = n//k
ans += 1
print(ans)
resolve()
|
def solve(x):
return sum([int(i) for i in str(x)])
if __name__ == '__main__':
while True:
x = int(input())
if x == 0: break
print(solve(x))
| 0 | null | 32,900,767,591,102 | 212 | 62 |
S = str(input())
T = str(input())
count=0
for i in range(len(S)):
if(S[i]==T[i]):
continue
else:
count += 1
print(count)
|
#!/usr/bin/env python3
S = input()
T = input()
count = 0
for s, t in zip(S, T):
if s != t:
count += 1
ans = count
print(ans)
| 1 | 10,507,160,407,952 | null | 116 | 116 |
S = input()
T = input()
len_s = len(S)
len_t = len(T)
result = len_t
i = 0
while (i <= len_s - len_t):
diff = 0
for j, c in enumerate(T):
if (c != S[i + j]):
diff += 1
result = min(result, diff)
i += 1
print(result)
|
S =input()
T =input()
min = 1000
for i in range(len(S)-len(T)+1):
count = 0
for j in range(len(T)):
if S[i+j] != T[j]:
count += 1
if count > min:
break
if count < min:
min = count
print(min)
| 1 | 3,681,043,884,390 | null | 82 | 82 |
a,v,b,w,t=map(int,open(0).read().split());print('YNEOS'[w>=v or t<-(-abs(a-b)//(v-w))::2])
|
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
print("YES" if A+T*V>= B+T*W and A-T*V <= B-T*W else "NO")
| 1 | 15,044,218,941,044 | null | 131 | 131 |
class Combination():
def __init__(self, N:int, P:int):
self.N = N
self.P = P
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) % P)
self.inv.append((-self.inv[P % i] * (P // i)) % P)
self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)
def getComb(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.P * self.factinv[n-k] % self.P
def main():
n,k = map(int,input().split())
MOD = 10**9 +7
COMB = Combination(n,MOD)
ans = 0
for i in range(min(n, k+1)):
ans += COMB.getComb(n,i) * COMB.getComb(n-1,i)
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
|
import math
N = int(input())
if N % 2 == 0:
ans = 0.5
else :
ans = math.ceil(N / 2) / N
print(ans)
| 0 | null | 121,874,060,673,690 | 215 | 297 |
import sys
readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
n, s = nm()
a = nl()
mod = 998244353
dp = [0]*(s+1)
dp[0] = 1
for i in range(n):
v = a[i]
for j in range(s, -1, -1):
if j >= v:
dp[j] = (dp[j] * 2 + dp[j-v]) % mod
else:
dp[j] = dp[j] * 2 % mod
print(dp[s])
|
N, S = map(int, input().split())
MOD = 998244353
A = list(map(int, input().split()))
dp = [0]*(S+1)
dp[0] = 1
for a in A:
for s in reversed(range(S+1)):
if s+a<=S: dp[s+a] += dp[s]
dp[s] *= 2
dp[s] %= MOD
print(dp[S]%MOD)
| 1 | 17,824,507,294,818 | null | 138 | 138 |
def combination_mod(n, r, mod):
x = 1
y = 1
for i in range(r):
x *= n - i
y *= r - i
x %= mod
y %= mod
return (x * pow(y, mod - 2, mod)) % mod
n, a, b = map(int, input().split())
mod = 10 ** 9 + 7
ans = pow(2, n, mod) - 1
ans %= mod
ans -= combination_mod(n, a, mod)
ans %= mod
ans -= combination_mod(n, b, mod)
ans %= mod
print(ans)
|
a, b, c = map(int, input().split())
x = c - b - a
if x > 0 and a * b * 4 < x * x:
print("Yes")
else:
print("No")
| 0 | null | 59,027,787,816,930 | 214 | 197 |
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))
n=int(input())
a=lmp()
ans=0
for i in range(n-1):
for j in range(i+1,n):
ans+=a[i]*a[j]
print(ans)
|
k = int(input())
a,b = map(int, input().split())
def judge(a,b):
for i in range(a,b+1):
if i%k == 0: return 'OK'
return 'NG'
print(judge(a,b))
| 0 | null | 97,370,700,969,032 | 292 | 158 |
A, B, N = map(int, input().split())
if N >= B - 1:
x = B - 1
c = (A * x) // B - A * (x // B)
else:
x = N
c = (A * x) // B - A * (x // B)
print(c)
|
# floor(a/b)=(a-(a%b))/b
# ax%b=a(x%b)%b
a,b,n=map(int,input().split())
if(n>=b-1):
print(a*(b-1)//b)
else:
print(a*n//b)
| 1 | 28,136,450,989,822 | null | 161 | 161 |
# 140 B
n = int(input())
s = input()
num = 0
for i in range(len(s)):
if s[i] == 'A':
try:
if s[i + 1] == 'B' and s[i + 2] == 'C':
num += 1
except:
pass
print(num)
|
# coding: utf-8
import sys
import math
import collections
import itertools
import bisect
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def lcm(x, y) : return (x * y) // math.gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")
def YesNo(B) : print("Yes" if B else "No")
def YESNO(B) : print("YES" if B else "NO")
def check(j):
global cur
for i in range(g):
cur[i] += c[i][j]
flag = True
for curr in cur:
if curr > K:
flag = False
return flag
H, W, K = LI()
S = RS(H)
ans = INF
N = H-1
for bit in range(1 << N):
g = 0
id = [0] * H
for i in range(H):
id[i] = g
if (bit >> i) & 1:
g += 1
g += 1
c = [[0] * W for _ in range(g)]
for i in range(H):
for j in range(W):
c[id[i]][j] += int(S[i][j])
num = g-1
cur = [0] * g
for i in range(W):
if not check(i):
num += 1
cur = [0] * g
if not check(i):
num = INF
break
ans = min(ans, num)
print(ans)
| 0 | null | 73,961,570,527,258 | 245 | 193 |
def cut(S,H,W,K):
cnt,h = 0,0
OP = [[0 for _ in range(W)] for _ in range(H)]
while "#" not in S[h]:
h += 1
burst = False
for i in range(h,H):
if "#" not in S[i]:
OP[i] = [OP[i-1][j] for j in range(W)]
burst = False
else:
cnt += 1
cnt_h = 1
for j in range(W):
OP[i][j] = cnt
if S[i][j] == "#" and cnt_h < S[i].count("#"):
cnt += 1
cnt_h += 1
for i in reversed(range(h)):
for j in range(W):
OP[i][j] = OP[i+1][j]
for i in range(H):
OP[i] = " ".join(map(str,OP[i]))
return OP
def main():
H,W,K = map(int,input().split())
S = [input() for _ in range(H)]
ans = cut(S,H,W,K)
for i in range(H):
print(ans[i])
if __name__ == "__main__":
main()
|
import math
a,b,c=map(float,input().split())
C=math.radians(c)
D=math.sin(C)*a*b
S=D/2
E=a**2+b**2-2*a*b*math.cos(C)
F=math.sqrt(E)
L=a+b+F
if C<90:
h=b*math.sin(C)
elif C==90:
h=b
else:
h=b*math.sin(180-C)
print(S,L,h)
| 0 | null | 71,777,301,258,832 | 277 | 30 |
import sys
def main():
N = int(input())
P = list(map(int, input().split()))
min_so_far = sys.maxsize
ans = 0
for p in P:
if p <= min_so_far:
ans += 1
min_so_far = p
print(ans)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools
import itertools
import math
import sys
INF = float('inf')
def solve(N: int, S: str):
return "".join(chr((ord(c) - ord('A') + N) % 26 + ord('A')) for c in S)
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
S = next(tokens) # type: str
print(f'{solve(N, S)}')
if __name__ == '__main__':
main()
| 0 | null | 110,111,911,121,500 | 233 | 271 |
ns = list(map(int, input().split()))
x = 0
for i in ns:
for j in range(3):
if ns[j] == i:
x += 1
o = 'Yes' if x == 5 else 'No'
print(o)
|
n = int(input())
ans = 0
for i in range(1, n+1):
g = n // i
ans += i * (g*(g+1))//2
print(ans)
| 0 | null | 39,424,414,962,240 | 216 | 118 |
def solve():
h, a = map(int, input().split())
print(-(-h//a))
if __name__ == '__main__':
solve()
|
N, K = (int(x) for x in input().split())
listN = [1] * N
# N is population / K is candy
for i in range(K):
d = int(input())
tmp = map(int, input().split())
for j in tmp:
listN[j-1] = 0
print(sum(listN))
| 0 | null | 50,810,553,684,152 | 225 | 154 |
MOD = 10**9 + 7
dp = {0: 1}
S = int(input())
for s in range(3, S+1):
for term in range(3, s+1):
if s - term < 0:
break
else:
dp[s] = dp.get(s-term, 0) + dp.get(s, 0) % MOD
print(dp.get(S, 0))
|
import sys
S = int(sys.stdin.readline())
mod = 10**9 + 7
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, 2*S+1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
def nCr(n, r, mod=10**9+7):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % mod
ans = 0
n = 1
n_max = S // 3
while n <= n_max:
res = S - 3 * n
tmp = nCr(res + n - 1, n - 1)
# print(n, res, tmp)
ans += tmp
ans %= mod
n += 1
print(ans)
| 1 | 3,281,681,440,638 | null | 79 | 79 |
import sys
sys.setrecursionlimit(10**9)
INF = 110110110
H, W, K = list(map(int, input().split()))
S = [''] * H
for i in range(H):
S[i] = input()
ans = H * W
for bit in range(2**(H-1)):
cnt = bin(bit).count('1')
id = [0] * H
for i in range(H-1):
if bit>>i & 1:
id[i+1] = id[i] + 1
else:
id[i+1] = id[i]
num = [[0] * W for i in range(id[H-1]+1)]
for i in range(H):
for j in range(W):
if S[i][j] == '1':
num[id[i]][j] += 1
for i in range(id[H-1]+1):
for j in range(W):
if num[i][j] > K:
cnt = INF
sum = [0] * (id[H-1]+1)
for j in range(W):
need = False
for i in range(id[H-1]+1):
if sum[i] + num[i][j] > K:
need = True
if need:
cnt += 1
for i in range(id[H-1]+1):
sum[i] = num[i][j]
else:
for i in range(id[H-1]+1):
sum[i] += num[i][j]
ans = min(ans, cnt)
print(ans)
|
#!/usr/bin/env python3
h,w,k = map(int,input().split())
b =[]
for i in range(h):
s = input()
b.append(s)
# 縦の切り方を固定すれば、左から見て貪欲に考えることができる。
# どれかの切り方でK+1 以上1 のマスがあれば、そこで切る
if h == 1:
print(math.ceil(s//k))
exit()
# リストで現在のそれぞれのブロックの1の数を持つ
# 列の切断が入ったときに全て0に初期化
# bit 全探索は 2 ** h-1 存在する
ans = h*w #INF
for i in range(2**(h-1)):
cnt_white = [0]
# ループの中で宣言する
ans_i = 0
#前処理として、どこに切れ込みがあるかを見て、リストの構成
for bit in range(h-1):
if i >> bit & 1:
cnt_white.append(0)
ans_i += 1
#print("i = ",i,cnt_white)
c = 0
last_div = 0
while c < w:# 左から貪欲
r_idx = 0
for r in range(h):
if b[r][c] == "1":#対応するブロックのcnt+=1
cnt_white[r_idx] += 1
#print("col = ",c,cnt_white,r_idx,ans_i)
if i >> r & 1:#次にブロックが変わるのでidxを増やす
r_idx += 1
# 1行だけでmax(cnt_white) >= k+1になるときはその切り方では不可能
if max(cnt_white) >= k+1:
# 戻らないといけない
ans_i += 1
if c == last_div:
ans_i = h*w #INF
break
last_div = c
c -= 1
cnt_white = [0]*len(cnt_white)#初期化
#print("initialize",last_div)
c += 1
ans = min(ans,ans_i)
print(ans)
| 1 | 48,357,886,723,252 | null | 193 | 193 |
def resolve():
N = int(input())
S = str(input())
print(S.count('ABC'))
return
resolve()
|
N = int(input())
*A, = list(map(int, input().split()))
count = 0
def merge(a, left, mid, right):
global count
la = a[left:mid] + [float("inf")]
ra = a[mid:right] + [float("inf")]
i, j = 0, 0
for k in range(left, right):
count += 1
if la[i] <= ra[j]:
a[k] = la[i]
i += 1
else:
a[k] = ra[j]
j += 1
def merge_sort(a, left, right):
if left + 1 < right:
mid = int((left + right) / 2)
merge_sort(a, left, mid)
merge_sort(a, mid, right)
merge(a, left, mid, right)
merge_sort(A, 0, N)
print(*A)
print(count)
| 0 | null | 49,851,246,447,860 | 245 | 26 |
x = int(input())
def judge(n):
for i in range(1, n // 2 + 1):
if i == 1: continue
if n % i == 0:
return False
return True
i = x
while True:
if judge(i):
print(i)
break
i += 1
|
a,b=map(int,input().split())
print((a//b)+1 if a%b!=0 else a//b)
| 0 | null | 90,875,683,799,072 | 250 | 225 |
import heapq
def main():
_ = int(input())
A = sorted(list(map(int, input().split())), reverse=True)
q = []
heapq.heapify(q)
ans = A[0]
tmp_score = min(A[0], A[1])
heapq.heappush(q, (-tmp_score, A[0], A[1]))
heapq.heappush(q, (-tmp_score, A[1], A[0]))
for a in A[2:]:
g = heapq.heappop(q)
ans += -g[0]
tmp_score1 = min(a, g[1])
tmp_push1 = (-tmp_score1, a, g[1])
tmp_score2 = min(a, g[2])
tmp_push2 = (-tmp_score2, a, g[2])
heapq.heappush(q, tmp_push1)
heapq.heappush(q, tmp_push2)
print(ans)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
h, w, k = map(int, input().split())
s = [input() for _ in range(h)]
ans = []
c = 1
for i in s:
if i == "." * w:
if ans:
ans.append(ans[-1])
else:
ans.append([0]*w)
else:
f = i.index("#")
ans.append([c] * (f + 1))
for j in i[f + 1:]:
if j == "#":
c += 1
ans[-1].append(c)
c += 1
for i in range(h):
if ans[i] != [0]*w:
for j in range(i):
ans[j] = ans[i]
break
for i in ans:
print(*i)
| 0 | null | 76,500,768,196,758 | 111 | 277 |
N,M = map(int,input().split())
f = [[] for i in range(N)]
for i in range(M):
A,B = map(int,input().split())
f[A-1].append(B-1)
f[B-1].append(A-1)
from collections import deque
d = deque()
x = [-1]*N
for i in range(N):
if x[i] == -1:
x[i] = i
d.append(f[i])
while len(d) > 0:
z = d.popleft()
for j in z:
if x[j] == -1:
x[j] = i
d.append(f[j])
import collections
ans = collections.Counter(x)
print(ans.most_common()[0][1])
|
input()
a=1
d=1000000000000000000
for i in input().split():
a=min(a*int(i),d+1)
print([a,-1][a>d])
| 0 | null | 10,102,380,786,746 | 84 | 134 |
import math
def prime_array(n=1000):
List = [2]
i = 3
while i <= n:
judge = True
for k in List :
if math.sqrt(i) < k :
break
if i%k == 0:
judge = False
break
if judge :
List.append(i)
i += 2
return List
def main():
cnt=0
prime_List=prime_array(10**4)
n=input()
for i in range(n):
a=input()
if a<=10**4:
for j in prime_List:
if a==j:
cnt+=1
break
else:
judge=True
for j in prime_List:
if a%j==0:
judge=False
break
if judge:
cnt+=1
print('%d' % cnt)
if __name__=='__main__':
main()
|
n = int(input())
ans = 0
for x in (int(input()) for _ in range(n)):
flg = True
for y in range(2, int(x**0.5+1)):
if x % y == 0:
flg = False
break
if flg:
ans += 1
print(ans)
| 1 | 10,533,757,948 | null | 12 | 12 |
str = input() *2
pattern = input()
if pattern in str:
print("Yes")
else:
print("No")
|
s = input()
p = input()
s += s
if s.count(p):
print("Yes")
else:
print("No")
| 1 | 1,740,526,038,382 | null | 64 | 64 |
K = int(input())
numbers = set([])
q = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
# print(f'{q=}')
while len(numbers) <= 100000: # 10**8:
# print('test')
qq = set([])
for i in q:
# print(f'{i=}')
if i % 10 != 0:
n = i * 10 + (i % 10) - 1
qq.add(n)
if i % 10 != 9:
n = i * 10 + (i % 10) + 1
qq.add(n)
n = i * 10 + (i % 10)
qq.add(n)
numbers |= q
# print(f'{numbers=}')
# print(f'{len(numbers)=}')
q = qq
numbers = sorted(map(int, numbers))
# print(f'{numbers[:30]=}')
ans = numbers[K - 1]
print(ans)
|
import sys
s = sys.stdin.readlines
A, V = [int(x) for x in input().split()]
B, W= [int(x) for x in input().split()]
T = int(input())
d = abs(A - B)
d2 = (V - W) * T
s = 'YES' if d <= d2 else 'NO'
print(s)
| 0 | null | 27,719,738,312,770 | 181 | 131 |
import sys, math
from functools import lru_cache
from collections import deque
sys.setrecursionlimit(500000)
MOD = 10**9+7
def input():
return sys.stdin.readline()[:-1]
def mi():
return map(int, input().split())
def ii():
return int(input())
def i2(n):
tmp = [list(mi()) for i in range(n)]
return [list(i) for i in zip(*tmp)]
def main():
S = input()
for i in range(1, 6):
if S == 'hi'*i:
print('Yes')
return
print('No')
if __name__ == '__main__':
main()
|
# coding: utf-8
s = list(input().rstrip())
ht = []
ponds=[]
for i, ch in enumerate(s):
if ch == "\\":
ht.append(i)
elif ch == "/":
if ht:
b = ht.pop()
ap = i - b
if not ponds:
ponds.append([b, ap])
else:
while ponds:
p = ponds.pop()
if p[0] > b:
ap += p[1]
else:
ponds.append([p[0],p[1]])
break
ponds.append([b,ap])
else:
pass
ans = ""
area = 0
for point, ar in ponds:
area += ar
ans += " "
ans += str(ar)
print(area)
print(str(len(ponds)) + ans)
| 0 | null | 26,439,251,562,358 | 199 | 21 |
X = int(input())
item_num = X // 100
if item_num * 5 >= X - item_num * 100:
print('1')
else:
print('0')
|
def resolve():
x = int(input())
dp = [0] * (x+1+105)
dp[0] = 1
for i in range(x):
if dp[i] == 1:
for j in range(100, 106):
dp[i+j] = 1
print(dp[x])
resolve()
| 1 | 127,205,864,192,210 | null | 266 | 266 |
N = int(input())
sum_num = 0
for i in range(1, N+1):
if (i%3) and (i%5):
sum_num += i
print(sum_num)
|
l = input().split(' ')
print('Yes' if len(set(l)) == 2 else 'No')
| 0 | null | 51,637,333,217,260 | 173 | 216 |
N = int(input())
l = list(map(int,input().split()))
def is_ok(n, su):
return l[n] > su
def binary_search(left, right, su):
while (abs(right - left) > 1):
mid = (left + right) // 2
if is_ok(mid, su): right = mid
else: left = mid
return right
l = sorted(l)
ans = 0
for i in range(2, N):
for j in range(1, i):
left = j
right = -1
ret = binary_search(right, left, l[i] - l[j])
if ret != right: ans += j - ret
print(ans)
|
def gcd(m, n):
x = max(m, n)
y = min(m, n)
if x % y == 0:
return y
else:
while x % y != 0:
z = x % y
x = y
y = z
return z
def lcm(m, n):
return (m * n) // gcd(m, n)
# input
A, B = map(int, input().split())
# lcm
snack = lcm(A, B)
print(snack)
| 0 | null | 142,005,787,510,322 | 294 | 256 |
"""
AtCoder :: Beginner Contest 175 :: C - Walking Takahashi
https://atcoder.jp/contests/abc175/tasks/abc175_c
"""
import sys
def solve(X, K, D):
"""Solve puzzle."""
# print('solve X', X, 'K', K, 'D', D)
if D == 0:
return X
X = abs(X)
soln = abs(X - (K * D))
steps_to_zero = abs(X) // D
# print('steps to zero', steps_to_zero, K - steps_to_zero)
# print('to zero', abs(X - (steps_to_zero * D)))
# Undershoot or get directly on to zero.
if steps_to_zero <= K and ((K - steps_to_zero) % 2 == 0):
soln = min(soln, abs(X - (steps_to_zero * D)))
# Overshoot by one step
steps_past_zero = steps_to_zero + 1
# print('steps past zero', steps_past_zero, K - steps_past_zero)
# print('past zero', abs(X - (steps_past_zero * D)))
if steps_past_zero <= K and ((K - steps_past_zero) % 2 == 0):
soln = min(soln, abs(X - (steps_past_zero * D)))
# Overshoot and return by one
steps_back_zero = steps_past_zero + 1
# print('steps back zero', steps_back_zero, K - steps_back_zero)
# print('back zero', abs(X - (steps_back_zero * D)))
if steps_back_zero <= K and ((K - steps_back_zero) % 2 == 0):
soln = min(soln, abs(X - (steps_back_zero * D)))
return soln
def main():
"""Main program."""
X, K, D = (int(i) for i in sys.stdin.readline().split())
print(solve(X, K, D))
if __name__ == '__main__':
main()
|
from collections import deque
n = int(input())
edges=[[]for i in range(n)]
nodes=[None]*n
for i in range(1,n):
a , b = map(int, input().split())
edges[a-1].append(i)
edges[b-1].append(i)
nodes[i]=(a-1,b-1)
ma =0
for i in range(n):
ma=max(ma,len(edges[i]))
col=[None]*n
d = deque([(0,0)])
while d:
t=1
v , ex_col = d.pop()
for i in edges[v]:
if col[i] is None:
if t==ex_col:
t+=1
col[i]=t
a1,b1=nodes[i]
if a1==v:
d.append((b1,t))
else:
d.append((a1,t))
t+=1
print(ma)
for i in range(1,n):
print(col[i])
| 0 | null | 70,778,724,363,270 | 92 | 272 |
N = int(input())
A = list(map(int, input().split()))
A.sort()
result = 1
for i in range(N):
result *= A[i]
if result > 10**18:
result = -1
break
print(result)
|
n, k = map(int, input().split())
A = list(map(lambda x: int(x) - 1, input().split()))
prev = 0
count = 0
used = {prev: count}
for _ in range(min(k, n)):
prev = A[prev]
count += 1
if prev in used:
for _ in range((k - used[prev]) % (count - used[prev])):
prev = A[prev]
break
used[prev] = count
print(prev + 1)
| 0 | null | 19,428,180,491,158 | 134 | 150 |
d,t,s = map(float,input().split())
if t >= d/s:
print("Yes")
else:
print("No")
|
d, t, s = list(map(int, input().split()))
ans = 'Yes' if d / s <= t else 'No'
print(ans)
| 1 | 3,556,141,017,068 | null | 81 | 81 |
n,k=map(int, input().split())
a = list(map(int, input().split()))
k = min(k,50)
for i in range(k):
aa = [0]*n
for j in range(n):
aa[max(0,j-a[j])] += 1
if j+a[j]+1 < n: aa[j+a[j]+1] -= 1
for j in range(n-1):aa[j+1] = aa[j]+aa[j+1]
a = aa[:]
print(*a)
|
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N,K = MI()
A = LI()
from itertools import accumulate
for _ in range(min(K,100)):
B = [0]*(N+1)
for i in range(N):
a = A[i]
B[max(i-a,0)] += 1
B[min(N,i+a+1)] -= 1
C = list(accumulate(B))
A = C
print(*[A[i] for i in range(N)])
| 1 | 15,395,804,114,570 | null | 132 | 132 |
import numpy as np
# 解説みた
N, K = map(int, input().split())
A = list(map(int, input().split()))
for i in range(K, N):
if A[i] / A[i - K] > 1:
print("Yes")
else:
print("No")
"""
・書き始める前に式変形等考える
・判定分を吟味する。（実際の数、今回でいうと積、で比較しない）
"""
|
n = int(input())
a = int(n//1.08)
for x in range(a, a+2):
if x < (n + 1)/1.08 and x >= n/1.08:
print(x)
exit()
print(':(')
| 0 | null | 66,352,737,479,420 | 102 | 265 |
import bisect
n = int(input())
arr = list(map(int,input().split()))
arr.sort()
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
x = arr[i]+arr[j]
ind = bisect.bisect_left(arr,x)
ans+=(ind-j-1)
print(ans)
|
INF = 10 ** 10
def merge(A, left, mid, right):
c = 0
n1 = mid - left
n2 = right - mid
Left = [A[left+i] for i in range(n1)]
Right = [A[mid+i] for i in range(n2)]
Left.append(INF)
Right.append(INF)
i=0
j=0
for k in range(left, right):
c += 1
if Left[i] <= Right[j]:
A[k] = Left[i]
i += 1
else:
A[k] = Right[j]
j += 1
return c
def mergeSort(hoge, left, right):
c = 0
if left+1 < right:
mid = (left + right) // 2
c += mergeSort(hoge, left, mid)
c += mergeSort(hoge, mid, right)
c += merge(hoge, left, mid, right)
return c
if __name__ == '__main__':
_ = input()
hoge = [int(x) for x in input().split()]
c = mergeSort(hoge, 0, len(hoge))
print (' '.join([str(x) for x in hoge]))
print (c)
| 0 | null | 85,540,254,774,870 | 294 | 26 |
while True:
s = raw_input()
if s == "-":
break
m = int(raw_input())
for i in range(m):
n = int(raw_input())
s = s[n:]+s[:n]
print s
|
# ?????????????±±???????????????????????????????????¨ h ????????????????????????????????????????????????????????????????????????????????°??????
# ?????????????±±???????????¶?????????????????????????????????
cardList = []
while 1:
temp = input()
if temp == "-":
cardList += temp
break
if temp.isalpha:
temp = "".join(temp).split()
cardList += temp
# print(cardList)
for i in range(len(cardList)):
if cardList[i] == "-":
break
if cardList[i].isalpha():
editCard = cardList[i]
for j in range(i + 2, int(cardList[i + 1]) + i + 2):
if cardList[j].isalpha() or cardList[j] == "-":
break
editCard = editCard + editCard
editCard = editCard[int(cardList[j]):len(cardList[i]) + int(cardList[j])]
print("{0}".format(editCard))
| 1 | 1,888,180,789,860 | null | 66 | 66 |
n= int(input())
ans=(n+1)//2
print(ans)
|
K = int(input())
S = str(input())
if K >= len(S):
answer = S
else:
answer = (S[:K]+'{}'.format('...'))
print(answer)
| 0 | null | 39,251,069,895,582 | 206 | 143 |
x = raw_input().split()
if float(x[0]) < float(x[1]):
print "a < b"
elif float(x[0]) > float(x[1]):
print "a > b"
else:
print "a == b"
|
t = input().split()
a = int(t[0])
b = int(t[1])
if a < b :
print("a < b")
if a == b:
print("a == b")
if a > b :
print("a > b")
| 1 | 360,248,693,760 | null | 38 | 38 |
danmen = input()
down = []
edge = []
pool = []
for (i, line) in enumerate(danmen):
if line == "\\":
down.append(i)
elif down and line == "/":
left = down.pop()
area = i - left
while edge:
if edge[-1] > left:
edge.pop()
area += pool.pop()
else:
break
edge.append(left)
pool.append(area)
print(sum(pool))
print(len(pool), *pool)
|
n = int(input())
table = list(map(int,input().split()))
table.sort()
print(table[0],table[-1],sum(table))
| 0 | null | 389,967,503,360 | 21 | 48 |
def solve():
N, K = map(int, input().split())
R, S, P = map(int, input().split())
dic = {'r':P,'s':R,'p':S}
T = input()
point = [0]*N
for i in range(N):
if i<K:
point[i] = dic[T[i]]
else:
if T[i]!=T[i-K] or point[i-K]==0:
point[i]=dic[T[i]]
ans = sum(point)
return ans
print(solve())
|
N, K = map(int, input().split())
ls1 = list(map(int, input().split()))
d = dict()
ls2 = ['r', 's', 'p']
for x, y in zip(ls1, ls2):
d[y] = x
T = input()
S = T.translate(str.maketrans({'r': 'p', 's': 'r', 'p': 's'}))
ans = 0
for i in range(K):
cur = ''
for j in range(i, N, K):
if cur != S[j]:
ans += d[S[j]]
cur = S[j]
else:
cur = ''
print(ans)
| 1 | 107,165,497,704,200 | null | 251 | 251 |
def main():
x, k, d = map(int, input().split())
x = abs(x)
if k % 2 == 1:
x = abs(x-d)
k -= 1
if x > d*k:
print(x-d*k)
else:
print(min(x % (2*d), abs(x % (2*d)-2*d)))
main()
|
#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
A, B = map(int, readline().split())
if (A <= 9) & (B <= 9):
print(A * B)
else:
print(-1)
if __name__ == '__main__':
main()
| 0 | null | 81,533,952,539,662 | 92 | 286 |
sm=0
for i in range(1,int(input())+1):
if (i%3)*(i%5)>0:
sm+=i
print(sm)
|
a=int(input())
b=a//100
b*=5
c=a%100
print("1" if b>=c else "0")
| 0 | null | 80,932,462,495,628 | 173 | 266 |
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 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
a,b = I()
for i in range(1,2000):
if int(i*0.08)==a and int(i*0.1)==b:
print(i)
sys.exit()
print(-1)
|
import sys
sys.setrecursionlimit(10**9)
def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))
INF=10**20
def main():
N=ii()
S=list(input())
if N%2==1:
print("No")
exit()
if S[:N//2] == S[N//2:]:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| 0 | null | 101,563,223,340,318 | 203 | 279 |
N = int(input())
P = list(map(int, input().split()))
temp = P[0]
res = 1
for i in range(1,N):
if P[i] <= temp:
temp = P[i]
res += 1
print(res)
|
import sys
import math
from collections import defaultdict, deque, Counter
from copy import deepcopy
from bisect import bisect, bisect_right, bisect_left
from heapq import heapify, heappop, heappush
input = sys.stdin.readline
def RD(): return input().rstrip()
def F(): return float(input().rstrip())
def I(): return int(input().rstrip())
def MI(): return map(int, input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int, input().split()))
def TI(): return tuple(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def Init(H, W, num): return [[num for i in range(W)] for j in range(H)]
def main():
N = I()
res = 0
for i in range(N):
a,b = MI()
if a==b:
res+=1
if res==3:
print("Yes")
exit()
else:
res=0
print("No")
if __name__ == "__main__":
main()
| 0 | null | 44,120,072,485,270 | 233 | 72 |
r = int(input())
print(int(r**2))
|
A, B = list(map(int, input().split()))
ans = -1
for i in range(1, 1009):
if int(i*0.08) == A and int(i*0.10) == B:
ans = i
break
print(ans)
| 0 | null | 100,774,617,672,540 | 278 | 203 |
def resolve():
N = int(input())
A = list(map(int, input().split()))
import collections
counter = collections.Counter(A)
total = 0
for k, v in counter.items():
total += v*(v-1)//2
for a in A:
cnt = counter[a]
cntm1 = cnt - 1
print(total - cnt*(cnt-1)//2 + cntm1*(cntm1-1)//2)
if '__main__' == __name__:
resolve()
|
while True:
n = input()
if n == 0: break
print sum(map(int, list(str(n))))
| 0 | null | 24,742,966,053,960 | 192 | 62 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
d, t, s = map(int, input().split())
if t * s >= d:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
|
n, m = list(map(int, input().split()))
s = []
c = []
for _ in range(m):
s_i, c_i = list(input().split())
s.append(int(s_i))
c.append(c_i)
for i in range(10 ** n):
num = str(i)
if len(num) == n and all([num[s[j] - 1] == c[j] for j in range(m)]):
print(num)
exit()
print(-1)
| 0 | null | 32,175,032,151,360 | 81 | 208 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
h, w, k = map(int, input().split())
a = [list(map(int, list(input()))) for _ in range(h)]
ret = 100000
for i in range(2 ** (h-1)):
hi = [0] * h
for j in range(h-1):
hi[j+1] += hi[j] + (i >> j & 1)
cnt = max(hi)
pj = 0
x = []
while pj < w:
s = [0] * 10
fg = False
for j in range(pj, w):
for t in range(h):
s[hi[t]] += a[t][j]
if max(s)>k:
if j == pj:
cnt = 100000
fg = True
break
else:
x.append(j)
cnt += 1
pj = j
break
if j == w-1:
pj = w
break
if fg:
break
ret = min(ret, cnt)
print(ret)
|
r=range;_,*s=open(0);m=9e9
h,w,k=map(int,_.split())
for i in r(1<<h-1):
t=[j+1for j in r(h)if i>>j&1]+[h];l=len(t);v=-1;c=[0]*l
for i in r(w):
b=f=g=0;u=[]
for j in r(l):d,b=sum(s[j][i]>"0"for j in r(b,t[j])),t[j];u+=d,;g|=d>k;c[j]+=d;f|=c[j]>k
v+=f
if f:c=u
if not g:m=min(m,v+l)
print(m)
| 1 | 48,322,932,791,592 | null | 193 | 193 |
# https://atcoder.jp/contests/abc167/tasks/abc167_d
# コンテスト中は周期性を用いたが、今回はdoublingで解いてみる
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def ints(): return list(map(int, read().split()))
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
N, K = ints()
A = mina(*ints())
# 10^18のは60bitで表せるのでnxt tableをつくるのに最大1.2 * 10^7 ぐらい。ギリ間に合いそう
nxt = [[-1] * N for _ in ra(K.bit_length())] # [k][v]...vから2^k回移動したノード
# 初期化
for v, nx in enu(A):
nxt[0][v] = nx
# テーブル埋め
for k in ra(K.bit_length() - 1):
for v in ra(N):
nxt[k + 1][v] = nxt[k][nxt[k][v]]
# 答えの取得
now = 0 # はじめは0地点にいる
for k in ra(K.bit_length()):
if (K >> k) & 1:
# kbit目が立ってたらこの回数分だけ移動
now = nxt[k][now]
print(now + 1)
|
N,K=[int(s) for s in input().split()]
ls=[int(s) for s in input().split()]
town=set()
town.add(1)
town_ls=[1]
now=1
for i in range(min([K,N])):
now=ls[now-1]
if now in town:
break
town.add(now)
town_ls.append(now)
if i+1==K:
print(now)
else:
L=i+1
S=town_ls.index(now)
loop=L-S
#print(loop,S)
x=(K-S)%loop+S
print(town_ls[x])
| 1 | 22,836,012,571,692 | null | 150 | 150 |
def gcd(a,b):
while a%b :
a,b=b,a%b
return b
def lcm(a,b):
return a*b/gcd(a,b)
while True :
try:
a,b = map(int,raw_input().split())
a,b = max(a,b), min(a,b)
print "%d" % gcd(a,b),
print "%d" % lcm(a,b)
except EOFError:
break
|
import sys
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
def lcm(a, b):
return a * b // gcd(a, b)
def main():
for i in sys.stdin.readlines():
a, b = [int(x) for x in i.split()]
print(gcd(a, b), lcm(a, b))
if __name__ == '__main__':
main()
| 1 | 670,177,756 | null | 5 | 5 |
X, K, D = map(int, input().split())
X = abs(X)
if X // D <= K:
print(min(abs(X % D - (K - (X // D))%2*D), abs(X % D + (K - (X // D))%2*D)))
else:
print(min(abs(X - K*D), abs(X + K*D)))
|
first_place, K, Distance = map(int, input().split())
first_place = abs(first_place)
test = first_place
if first_place - Distance*K > 0:
print(first_place -Distance*K)
else:
for i in range(1,K+1):
test -= Distance
if test <= 0:
a = i
#print(a)
break
if (K-a)%2 == 0 or K-a == 0:
print(abs(first_place - Distance*a))
else:
print(abs(first_place - Distance*(a-1)))
| 1 | 5,178,402,957,380 | null | 92 | 92 |
N = int(input())
r = N
while r >= 1000:
r = r-1000
if r == 0:
print(0)
else:
print(1000-r)
|
n = int(input())
rem = n%1000
if rem!=0:rem = 1000 - rem
print(rem)
| 1 | 8,455,907,751,060 | null | 108 | 108 |
import sys
def merge(A, left, mid, right):
L = A[left: mid] + [sys.maxsize]
R = A[mid: right] + [sys.maxsize]
i = j = count = 0
k = left
while k < right:
count += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
k += 1
return count
def merge_sort(A, left, right):
if right - left > 1:
mid = (left + right) // 2
lcost = merge_sort(A, left, mid)
rcost = merge_sort(A, mid, right)
tot = merge(A, left, mid, right)
return tot + lcost + rcost
else:
return 0
if __name__ == '__main__':
n = int(input())
A = [int(i) for i in input().split()]
count = merge_sort(A, 0, n)
print(str(A).replace(',', '').replace('[', '').replace(']', ''))
print(count)
|
cnt = 0
SENTINEL = 2000000000
def merge(arr, length, left, mid, right):
# n1 = mid - left
# n2 = right - mid
L = arr[left : mid]
R = arr[mid : right]
L.append(SENTINEL)
R.append(SENTINEL)
i, j = 0, 0
for k in range(left, right):
global cnt
cnt += 1
if (L[i] <= R[j]):
arr[k] = L[i]
i += 1
else:
arr[k] = R[j]
j += 1
def merge_sort(arr, length, left, right):
if (left + 1 < right):
mid = (left + right)//2
merge_sort(arr, length, left, mid)
merge_sort(arr, length, mid, right)
merge(arr, n, left, mid, right)
if __name__ == '__main__':
n = int(input())
S = list(map(int, input().split()))
merge_sort(S, n, 0, n)
print(' '.join(map(str, S)))
print(cnt)
| 1 | 116,419,787,470 | null | 26 | 26 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
N, M, K = map(int, input().split())
md = 998244353
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % md )
inverse.append( ( -inverse[md % i] * (md//i) ) % md )
g2.append( (g2[-1] * inverse[-1]) % md )
def cmb(n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % md
def cnt(k):
ret = pow(M-1, N-1-k, md)
ret *= cmb(N-1,k)
ret %= md
ret *= M
ret %= md
return ret
def main():
rt = 0
for k in range(K+1):
rt += cnt(k)
rt %= md
print(rt)
if __name__ == '__main__':
main()
|
x,k,d = map(int, input().split())
lists = []
x = abs(x)
step = int(x/d)
if step >= k:
answer = x - k * d
elif step < k:
k_left = k - int(step)
if k_left % 2 == 0:
answer = x % d
if k_left % 2 == 1:
answer = min(abs(x % d - d), abs(x % d + d))
print(answer)
| 0 | null | 14,104,177,185,138 | 151 | 92 |
import sys
import bisect
import math
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
from operator import itemgetter
n,s=map(int,readline().split())
a=list(map(int,readline().split()))
mod=998244353
dp=[[0 for j in range(s+1)] for i in range(n+1)]
dp[0][0]=1
for i in range(n):
for j in range(s+1):
dp[i+1][j]+=2*dp[i][j]
dp[i+1][j]%=mod
if j+a[i]<=s:
dp[i+1][j+a[i]]+=dp[i][j]
dp[i+1][j+a[i]]%=mod
print(dp[n][s])
|
digits = [int(i) for i in list(input())]
Sum = 0
for i in digits:
Sum += i
if Sum%9 == 0:
print("Yes")
else:
print("No")
| 0 | null | 11,048,216,957,152 | 138 | 87 |
n = int(input())
a = list(map(int, input().split()))
count = 0
flag = True
while flag:
flag = False
for j in range(n - 1, 0, -1):
if a[j] < a[j - 1]:
a[j], a[j - 1] = a[j - 1], a[j]
count += 1
flag = True
print(' '.join(list(map(str, a))))
print(count)
|
N = int(input())
A = list(map(int, input().split()))
nSwap = 0
for i in range(N):
for j in range(N-1, i, -1):
if A[j] < A[j-1]:
A[j-1], A[j] = A[j], A[j-1]
nSwap += 1
print(' '.join(map(str, A)))
print(nSwap)
| 1 | 15,432,073,904 | null | 14 | 14 |
def nCk(n, k, mod):
nu = 1
de = 1
for i in range(1, k+1):
nu *= (n-i+1)
de *= i
nu = nu % mod
de = de % mod
ans = nu * pow(de, mod-2, mod) % mod
return ans
n, a, b = map(int, input().split())
mod = 10**9+7
ans = (pow(2, n, mod) - 1 - nCk(n, a, mod) - nCk(n, b, mod)) % mod
print(ans)
|
H, W = map(int, input().split())
S = [list(input()) for h in range(H)]
table = [[0 for w in range(W)] for h in range(H)]
table[0][0] = int(S[0][0]=='#')
for i in range(1, H):
table[i][0] = table[i-1][0] + int(S[i-1][0]=='.' and S[i][0]=='#')
for j in range(1, W):
table[0][j] = table[0][j-1] + int(S[0][j-1]=='.' and S[0][j]=='#')
for i in range(1, H):
for j in range(1, W):
table[i][j] = min(table[i-1][j] + int(S[i-1][j]=='.' and S[i][j]=='#'),
table[i][j-1] + int(S[i][j-1]=='.' and S[i][j]=='#'))
print(table[-1][-1])
| 0 | null | 57,600,799,076,398 | 214 | 194 |
import math
n = int(input())
x = []
x.extend(list(map(int, input().split())))
y = []
y.extend(list(map(int, input().split())))
i = 0
sum = 0
for i in range(n):
sum += abs(x[i] - y[i])
print(sum)
sum = 0
for i in range(n):
sum += (x[i] - y[i]) ** 2
print(math.sqrt(sum))
sum = 0
for i in range(n):
sum += abs(x[i] - y[i]) ** 3
print(sum ** (1/3))
check = 0
for i in range(n):
if check < abs(x[i] - y[i]):
check = abs(x[i] - y[i])
print(check)
|
#10_D
import math
n=int(input())
x_v=list(map(int,input().split()))
y_v=list(map(int,input().split()))
p=1
while(p<5):
d=0
if(p==4):
my_list=[]
for i in range(n):
my_list.append(abs(x_v[i]-y_v[i]))
d=max(my_list)
print(d)
else:
for i in range(n):
d+=abs(x_v[i]-y_v[i])**p
d=pow(d,1/p)
print(d)
p+=1
| 1 | 210,812,015,598 | null | 32 | 32 |
l,r,d = map(int,input().split())
#print(l,r,d)
ans = 0
for i in range(101):
if d * i > r:
break
elif d * i >= l:
ans += 1
continue
else:
continue
print(ans)
|
L = input().split()
n = len(L)
A = []
top = -1
for i in range(n):
if L[i] not in {"+","-","*"}:
A.append(int(L[i]))
top += 1
else:
if(L[i] == "+"):
A[top - 1] = A[top - 1] + A[top]
elif(L[i] == "-"):
A[top - 1] = A[top -1] - A[top]
elif(L[i] == "*"):
A[top - 1] = A[top - 1] * A[top]
del A[top]
top -= 1
print(A[top])
| 0 | null | 3,789,898,622,510 | 104 | 18 |
x, n = map(int, input().split())
p = list(map(int, input().split()))
def calc(a):
return abs(a - x)
if not n:
print(x)
exit()
l = [i for i in range(102) if i not in set(p)]
print(min(l, key=calc))
|
def merge(A, n ,left, mid, right):
cnt = 0
L = A[left:mid] + [float("inf")]
R = A[mid:right] + [float("inf")]
i, j = 0, 0
for k in range(left, right):
cnt += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
return cnt
def mergeSort(A, n, left, right):
if left+1 < right:
mid = (left + right)//2
return mergeSort(A, n, left, mid) + mergeSort(A, n, mid, right)\
+ merge(A, n, left, mid, right)
return 0
n = int(input())
A = list(map(int, input().split()))
cnt = mergeSort(A, n, 0, n)
print(*A)
print(cnt)
| 0 | null | 7,060,988,450,880 | 128 | 26 |
import statistics
while True:
n = int(input())
if n == 0:
break
s = map(int, input().split())
print('{:.5f}'.format(statistics.pstdev(s)))
|
def solve():
N,M = [int(i) for i in input().split()]
solved = set([])
penalty = {}
for i in range(M):
problem_id,result = input().split()
if result == 'AC':
solved.add(problem_id)
elif result == 'WA' and problem_id not in solved:
penalty[problem_id] = penalty.get(problem_id, 0) + 1
num_penalties = 0
for problem_id in solved:
num_penalties += penalty.get(problem_id, 0)
print(len(solved), num_penalties)
if __name__ == "__main__":
solve()
| 0 | null | 46,945,831,506,208 | 31 | 240 |
n,m = input().split()
print(((int(n) * (int(n) - 1)) + (int(m) * (int(m) - 1))) // 2)
|
N, M = map(int, input().split())
Ev = M * (M - 1) // 2
Od = N * (N - 1) // 2
print(Ev + Od)
| 1 | 45,484,604,633,952 | null | 189 | 189 |
n,k,*l=map(int,open(0).read().split())
for _ in range(k):
s=[0]*(n+1)
for i in range(n):
s[max(i-l[i],0)]+=1
s[min(i+l[i]+1,n)]-=1
s[0]=min(s[0],n)
for i in range(1,n):
s[i]=min(s[i-1]+s[i],n)
s.pop()
if s==l: break
l=s
print(*l)
|
def update(A,N):
B=[0 for i in range(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
x = A[0] == B[0]
A[0]=B[0]
for i in range(1,N):
B[i]+=B[i-1]
x = x and A[i] == B[i]
A[i]=B[i]
return x
def resolve():
N,M = map(int,input().split())
A = list(map(int,input().split()))
for i in range(M):
x=update(A,N)
if x:
break
print(" ".join(map(str,A)))
resolve()
| 1 | 15,329,212,180,832 | null | 132 | 132 |
N, A, B = map(int, input().split(' '))
if N - N // (A + B) * (A + B) > A:
tail = A
else:
tail = N - N // (A + B) * (A + B)
print(N // (A + B) * A + tail)
|
#B
N, A, B=map(int, input().split())
quotient=N//(A+B)
remainder=N%(A+B)
quo_bball=quotient*A
if remainder <=A:
rem_bball=remainder
else:
rem_bball=A
print(quo_bball+rem_bball)
| 1 | 55,906,609,439,890 | null | 202 | 202 |
def solve(N, S):
ans = 0
R, G, B = 0, 0, 0
for i in range(N):
if S[i] == "R":
R += 1
elif S[i] == "G":
G += 1
else:
B += 1
# print(R, G, B, R*G*B)
ans = R * G * B
dif = 1
while dif <= N//2+1:
idx = 0
while idx + dif + dif < N:
if S[idx] != S[idx + dif] and S[idx+dif] != S[idx+2*dif] and S[idx+2*dif] != S[idx]:
ans -= 1
idx += 1
dif += 1
print(ans)
if __name__ == '__main__':
# N = 4000
# S = 'RGBR' * 1000
N = int(input())
S = input()
solve(N, S)
|
N = int(input())
A = list(map(int, input().split()))
count = 0
for a in A[0::2]:
if a % 2 == 1:
count = count + 1
print(count)
| 0 | null | 21,914,080,593,980 | 175 | 105 |
import sys
s = input()
if len(s)%2 == 1:
print('No')
sys.exit()
for i in range(len(s)//2):
if s[2*i:2*i+2] != 'hi':
print('No')
sys.exit()
print('Yes')
|
import sys
s = input()
def match(a):
if a[0:2] == 'hi':
return a[2:]
else:
print('No')
sys.exit()
if len(s)%2 == 1:
print('No')
sys.exit()
else:
while len(s) > 1:
s = match(s)
print('Yes')
| 1 | 52,943,196,138,652 | null | 199 | 199 |
n,k = map(int, input().split())
r,s,p = map(int, input().split())
t = input()
def add(x):
if x == 'r':
return p
elif x == 's':
return r
else:
return s
nk =[0]*k
for i in range(n):
key = i%k
if nk[key]==0:
nk[key] = [t[i]]
else:
nk[key].append(t[i])
ans = 0
for j in nk:
if j ==0:
continue
ans += add(j[0])
for k in range(1, len(j)):
if j[k]== j[k-1]:
j[k]='q'
else:
ans += add(j[k])
print(ans)
|
N = int(input())
A = input().split()
num_list = [0] * N
def combination(n):
C = [0]
for i in range(2,n+1):
C.append(int(i*(i-1)/2))
return C
com = combination(N)
sum_com = 0
for i in range(N):
num_list[int(A[i])-1] += 1
for i in range(N):
if num_list[i] == 0:
continue
else:
sum_com += com[num_list[i]-1]
for i in range(N):
print(sum_com - num_list[int(A[i])-1] + 1)
| 0 | null | 77,447,065,471,880 | 251 | 192 |
R,C,K = map(int,input().split()) #行、列、個数
G = [[0]*C for _ in range(R)] #G[i][j]でi行目のj番目にある価値
for i in range(K):
a,b,v = map(int,input().split())
a-=1;b-=1 #0index
G[a][b] = v
#print(G)
dp = [[0]*4 for _ in range(C+1)]
#dp[j][k]ある行において、j個目まで見て、その行でk個拾っている
for i in range(R):
p = [[0]*4 for _ in range(C+1)] #pが前の行、dpが今の行
p,dp = dp,p
for j in range(C):
#print(j+1,dp)
for k in range(4):
if k == 0: #その行で一個も取っていなければ上の行から来るだけ
dp[j+1][k] = max(p[j+1])
elif k == 1: #一個目をとるということは横からきて取るか、上から来て取るか
if G[i][j] == 0: #そこにない場合は横から
dp[j+1][k] = dp[j][k]
else: #ある場合は横からくるか上から来て一個取るか
dp[j+1][k] = max(dp[j][k],max(p[j+1])+G[i][j])
else: #二個以上の場合には上からは来れない。
if G[i][j] == 0: #そこになければ横からくるだけ
dp[j+1][k] = dp[j][k]
else: #あればとったほうがよいか比較
dp[j+1][k] = max(dp[j][k],dp[j][k-1]+G[i][j])
#print(p,dp)
ans = max(dp[C])
print(ans)
|
R,C,K = map(int, input().split())
a = [[0] * (C+1) for i in range(R+1)]
dp = [[[0] * (C+1) for i in range(R+1)] for j in range(4)]
for i in range(K):
r,c,v = map(int, input().split())
r -= 1
c -= 1
a[r][c] = v
for i in range(R):
for j in range(C):
for k in range(2,-1,-1):
dp[k+1][i][j] = max(dp[k+1][i][j], dp[k][i][j] + a[i][j])
for k in range(4):
dp[k][i][j+1] = max(dp[k][i][j+1], dp[k][i][j])
dp[0][i+1][j] = max(dp[0][i+1][j], dp[k][i][j])
ans = 0
for k in range(4):
ans = max(ans, dp[k][R-1][C-1])
print(ans)
| 1 | 5,562,883,978,148 | null | 94 | 94 |
n, m = list(map(int, input().split()))
c = list(map(int, input().split()))
DP = [i for i in range(n + 1)]
for cost in c:
for i in range(cost, n + 1):
DP[i] = min(DP[i], DP[i - cost] + 1)
print(DP[n])
|
n, m = map(int, input().split())
if n > m:
print("safe")
else:
print("unsafe")
| 0 | null | 14,645,219,436,238 | 28 | 163 |
from collections import deque
from sys import stdin
n = int(input())
line = stdin.readlines()
ddl = deque()
for i in range(n):
inp = line[i].split()
if len(inp) == 2:
op, data = inp
data = int(data)
else: op, data = inp[0], None
if op == 'insert':
ddl.appendleft(data,)
elif op == 'delete':
try:
ddl.remove(data)
except ValueError:
pass
elif op == 'deleteFirst':
ddl.popleft()
elif op == 'deleteLast':
ddl.pop()
print(' '.join([str(item) for item in ddl]))
|
from collections import deque
import sys
n = int(sys.stdin.readline())
q = deque()
for i in range(n):
command = sys.stdin.readline()[:-1]
if command[0] == 'i':
q.appendleft(command[7:])
elif command[6] == ' ':
try:
q.remove(command[7:])
except Exception as e:
pass
elif command[6] == 'F':
q.popleft()
else:
q.pop()
print(' '.join(q))
| 1 | 51,830,045,212 | null | 20 | 20 |
n,k=input().split();print(sum(sorted(list(map(int,input().split())))[:int(k)]))
|
n,k = map(int, input().split())
price = list(map(int, input().split()))
count = 0
sum = 0
while count < k:
abc = min(price)
sum += abc
price.pop(price.index(abc))
count += 1
print(sum)
| 1 | 11,576,745,448,380 | null | 120 | 120 |
import math
a,b = map(int,input().split())
c = a*b//math.gcd(a,b)
print(c)
|
import numpy as np
A, B = map(int, input().split())
print(np.lcm(A, B))
| 1 | 113,587,373,768,038 | null | 256 | 256 |
k = int(input())
s = list(input())
an_lis = []
if len(s) <= k:
ans = "".join(s)
print(ans)
else:
for i in range(k):
an_lis.append(s[i])
an_lis.append("...")
ans = "".join(an_lis)
print(ans)
|
input_int = input()
input_str = input()
K = int(input_int)
S = str(input_str)
if len(S)<=K:
print(S)
elif len(S)>K:
print(S[:K]+'...')
| 1 | 19,630,947,440,988 | null | 143 | 143 |
import sys
from collections import deque
import numpy as np
import math
sys.setrecursionlimit(10**6)
def S(): return sys.stdin.readline().rstrip()
def SL(): return map(str,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return map(int,sys.stdin.readline().rstrip().split())
def solve():
f = math.ceil(n/1.08)
if math.floor(f*1.08)==n:
print(f)
else:
print(':(')
return
if __name__=='__main__':
n = I()
solve()
|
import math
def main():
n = int(input())
tax = 1.08
ans = math.ceil(n / tax)
ans_check = ans * tax
if math.floor(ans * tax) == n:
print(ans)
else:
print(":(")
if __name__ == "__main__":
main()
| 1 | 125,947,082,796,380 | null | 265 | 265 |
# -*- coding: utf-8 -*-
def main():
input_string = raw_input().strip()
down_positions = []
ponds = []
for index, value in enumerate(input_string):
if value == '\\':
down_positions.append(index)
elif value == '/' and down_positions:
right = index
left = down_positions.pop()
area = right - left
candidate_pond = []
while ponds and left < ponds[-1][0]:
candidate_pond.append(ponds.pop(-1))
new_pond = (left, area + sum([x[1] for x in candidate_pond]))
ponds.append(new_pond)
print sum(x[1] for x in ponds)
print len(ponds),
for pond in ponds:
print pond[1],
if __name__ == '__main__':
main()
|
print(input()*0 + str(input().count("ABC")))
| 0 | null | 49,745,357,046,540 | 21 | 245 |
n,m=map(int,input().split())
num=[-1]*(n)
total=""
ans=-1
if n==1 and m==0:
print(0)
exit()
for i in range(m):
a,c=map(int,input().split())
if num[a-1]==-1 or num[a-1]==c:
num[a-1]=c
elif num[a-1]!=-1 and num[a-1]!=c:
print(ans)
exit()
for i in range(n):
if num[i]==-1:
if i==0:
num[i]=1
else:
num[i]=0
for i in range(n):
total+=str(num[i])
total=int(total)
total=str(total)
if len(total)==n:
ans=int(total)
print(ans)
|
A, B, K = map(int,input().split())
A1 = max(A-K,0)
K1 = max(K-A,0)
if K1 == 0:
B1 = B
else:
B1 = max(B-K1,0)
print(A1,B1)
| 0 | null | 82,674,865,713,540 | 208 | 249 |
from fractions import gcd
a,b=map(int,input().split())
print(a*b//gcd(a,b))
|
def GCD(a, b):
b %= a
return b if a%b == 0 else GCD(b, a)
while True:
try:
a, b = list(map(float, input().split()))
except EOFError:
break
if a >= b:
a, b = b, a
gcd = GCD(a, b) if b%a != 0 else a
print("{0} {1}".format(int(gcd), int(a*b/gcd)))
| 0 | null | 56,526,105,915,158 | 256 | 5 |
n = int(input())
s = input()
t = ''
for c in s:
t += chr((ord(c) + n - 65) % 26 + 65 )
print(t)
|
N = int(input())
S = input()
for s in S:
print(chr(65+(ord(s)+N-65)%26),end="")
| 1 | 134,287,585,340,948 | null | 271 | 271 |
while True:
L = map(int,raw_input().split())
H = (L[0])
W = (L[1])
if H == 0 and W == 0:break
for x in range(0,H):
if x % 2 == 0:
if W % 2 == 1:
print "{}#".format("#."* (W / 2))
else:
print "#." * (W / 2)
else:
if W % 2 == 1:
print "{}.".format(".#"* (W / 2))
else:
print ".#" * (W / 2)
print ""
|
array = []
while True:
n = input()
if n == "0 0":
break
array.append(n.split())
for i in range(len(array)):
for i2 in range(int(array[i][0])):
for i3 in range(int(array[i][1])):
if i2%2 == 0:
if i3%2 == 0:
if i3 == int(array[i][1])-1:
print("#")
else:
print("#",end="")
else:
if i3 == int(array[i][1])-1:
print(".")
else:
print(".",end="")
else:
if i3%2 == 0:
if i3 == int(array[i][1])-1:
print(".")
else:
print(".",end="")
else:
if i3 == int(array[i][1])-1:
print("#")
else:
print("#",end="")
if i2 ==int(array[i][0])-1:
print("")
| 1 | 860,589,700,530 | null | 51 | 51 |
ans = -1
a = 0
K = int(input())
if K % 2 == 0:
ans = -1
elif K % 5 == 0:
ans = -1
else:
for i in range(0, K):
a = (10 * a + 7) % K
if a == 0:
ans = i + 1
break
print(ans)
|
while True:
a, op, b = map(str, raw_input().split())
if op in "+":
print int(a)+int(b)
elif op in "-":
print int(a)-int(b)
elif op in "*":
print int(a)*int(b)
elif op in "/":
print int(a)/int(b)
else :
break;
| 0 | null | 3,383,897,907,504 | 97 | 47 |
N = int(input())
C = list(input())
r = C.count("R")
cnt = 0
for i in range(r):
if C[i] == "W":
cnt += 1
print(cnt)
|
N, K = [int(_) for _ in input().split()]
A = [int(_) - 1 for _ in input().split()]
X = [-1 for _ in range(N)]
X[0] = 0
k = 0
p = 0
while k < K:
p = A[p]
k += 1
if X[p] != -1:
v = (K - k) % (k - X[p]) + X[p]
print(X.index(v) + 1)
exit(0)
X[p] = k
print(p + 1)
| 0 | null | 14,499,599,336,032 | 98 | 150 |
import math
a,b,c = map(float,input().split())
H = b * math.sin(math.radians(c))
S = (a*(b*math.sin(math.radians(c))))/2
L = a + b + ((a**2) + (b**2) -(((2*a)*b)*math.cos(math.radians(c))))**0.5
print(float(S))
print(float(L))
print(float(H))
|
N, K = map(int, input().split())
ans = 1
while N >= K:
N = N // K
ans += 1
print(ans)
| 0 | null | 32,356,745,258,014 | 30 | 212 |
n = int(input())
S = input()
ans = 0
def ok(i):
pin = '{:0=3}'.format(i)
j = 0
for s in S:
if s == pin[j]:
j += 1
if j == 3:
return True
else:
return False
for i in range(1000):
ans += ok(i)
print(ans)
|
def input_li():
return list(map(int, input().split()))
def input_int():
return int(input())
N = input_int()
S = input()
ans = 0
for i in range(1000):
str_i = str(i)
s = '0' * (3 - len(str_i)) + str_i
idx = 0
for j in range(N):
if S[j] == s[idx]:
idx += 1
if idx == 3:
ans += 1
break
print(ans)
| 1 | 128,731,218,276,320 | null | 267 | 267 |
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)
|
nums=[]
nums=input().split()
a=int(nums[0])
b=int(nums[1])
c=int(nums[2])
ans=0
for i in range(a,b+1):
if c%i==0:
ans+=1
print(ans)
| 1 | 565,593,886,354 | null | 44 | 44 |
n=int(input())
Ns=list(map(int, input().split() ) )
ans=0
for i in range(n):
for j in range(i,n):
for k in range(j,n):
a , b , c = sorted([Ns[i] , Ns[j] , Ns[k]])
if a+b>c and a!=b and b!=c:
ans+=1
print(ans)
|
# coding=utf-8
from math import floor, ceil, sqrt, factorial, log, gcd
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heappushpop
import copy
import numpy as np
import sys
INF = float('inf')
mod = 10**9+7
sys.setrecursionlimit(10 ** 6)
def lcm(a, b): return a * b / gcd(a, b)
# 1 2 3
# a, b, c = LI()
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
# a = I()
def I(): return int(sys.stdin.buffer.readline())
# abc def
# a, b = LS()
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
# a = S()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
# 2
# 1
# 2
# [1, 2]
def IR(n): return [I() for i in range(n)]
# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]]
def LIR(n): return [LI() for i in range(n)]
# 2
# abc
# def
# [abc, def]
def SR(n): return [S() for i in range(n)]
# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]]
def LSR(n): return [LS() for i in range(n)]
# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]]
def SRL(n): return [list(S()) for i in range(n)]
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
fact = [1, 1] # n! mod p
factinv = [1, 1] # (n!)^(-1) mod p
tmp = [0, 1] # factinv 計算用
def main():
x, y = LI()
ans = 0
if x > 2 * y or x < 0.5 * y or (x + y) % 3 != 0:
print(0)
return
n, m = map(int, [(2 * y - x) / 3, (2 * x - y) / 3])
for i in range(2, n + m + 1):
fact.append((fact[-1] * i) % mod)
tmp.append((-tmp[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * tmp[-1]) % mod)
print(cmb(n+m, n, mod))
if __name__ == "__main__":
main()
| 0 | null | 77,391,246,226,370 | 91 | 281 |
from collections import defaultdict
n = int(input())
a = list(map(int, input().split()))
memo = defaultdict(int)
ans = 0
for i, x in enumerate(a, 1):
ans += memo[i - x]
memo[x + i] += 1
print(ans)
|
N = int(input())
A = list(map(int, input().split()))
L = {}
R = {}
ans = 0
for i in range(N):
t = i + 1 + A[i]
if t in L:
L[t] += 1
else:
L[t] = 1
t = i + 1 - A[i]
if t > 0:
if t in R:
R[t] += 1
else:
R[t] = 1
for i in R:
if i in L:
ans += R[i] * L[i]
print(ans)
| 1 | 26,115,286,461,208 | null | 157 | 157 |
### ----------------
### ここから
### ----------------
import sys
from io import StringIO
import unittest
def yn(b):
print("Yes" if b==1 else "No")
return
def resolve():
readline=sys.stdin.readline
n,x,y=map(int, readline().rstrip().split())
ans = [0] * (n-1)
for i in range(1,n+1):
for j in range(i+1,n+1):
d1 = abs(i-x) + abs(j-x)
d2 = abs(i-y) + abs(j-y)
d3 = abs(i-x) + abs(j-y) + 1
d4 = abs(i-y) + abs(j-x) + 1
d5 = abs(i-j)
d=min(d1,d2,d3,d4,d5)
ans[d-1]+=1
for a in ans:
print(a)
#arr=list(map(int, readline().rstrip().split()))
#n=int(readline())
#ss=readline().rstrip()
#yn(1)
return
if 'doTest' not in globals():
resolve()
sys.exit()
### ----------------
### ここまで
### ----------------
|
from collections import Counter
N, X, Y = map(int, input().split())
ans = []
for i in range(1, N + 1):
for j in range(i + 1, N + 1):
min_dis = min(abs(j - i),
abs(X - i) + 1 + abs(j - Y),
abs(Y - i) + 1 + abs(j - X))
ans.append(min_dis)
c = Counter(ans)
for i in range(1, N):
print(c[i])
| 1 | 44,305,103,783,810 | null | 187 | 187 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.