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
|
|---|---|---|---|---|---|---|
n = input()
n = int(n)
seq = input().split()
sumNum = 0
minNum = 1000000
maxNum = -1000000
for numT in seq:
num = int(numT)
if(num > maxNum):
maxNum = num
if(num < minNum):
minNum = num
sumNum+=num
print(minNum,maxNum,sumNum)
|
def InsertionSort(A, N, g, cnt):
for i in range(g,N):
v = A[i]
j = i-g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j -= g
cnt += 1
A[j+g] = v
return(cnt, A)
N = int(input())
A = [int(input()) for j in range(N)]
cnt = 0
G=[]
G.append(1)
for i in range(100):
g = 3 * G[i] + 1
if g >= N:
break
else:
G.append(g)
G.reverse()
m = len(G)
print(m)
print(" ".join(map(str, G)))
for i in range(m):
cnt, A = InsertionSort(A, N, G[i], cnt)
print(cnt)
Ap = [print(A[i]) for i in range(N)]
| 0 | null | 373,145,557,818 | 48 | 17 |
R = int(input())
import math
nagasa = R*2 * math.pi
print(nagasa)
|
r = int(input())
print(2*r*3.14159)
| 1 | 31,492,658,470,570 | null | 167 | 167 |
dict = {}
S, T = input().split(' ')
dict[S], dict[T] = map(int, input().split(' '))
U = input()
dict[U] -= 1
print(dict[S], dict[T])
|
#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
As = map(int, readline().split())
if sum(As) >= 22:
print('bust')
else:
print('win')
if __name__ == '__main__':
main()
| 0 | null | 95,582,500,691,428 | 220 | 260 |
N = input()
print('Yes' if "7" in N else 'No')
|
def main():
n = input()
if n[0] == '7':
print("Yes")
return
if n[1] == '7':
print("Yes")
return
if n[2] == '7':
print("Yes")
return
print("No")
if __name__ == "__main__":
main()
| 1 | 34,257,241,344,270 | null | 172 | 172 |
K = int(input())
A, B = map(int, input().split())
for n in range(A, B+1):
if n%K ==0:
print("OK")
exit()
print("NG")
|
# A We Love Golf
K = int(input())
A, B = map(int, input().split())
for i in range(A, B+1):
if i % K == 0:
print("OK")
exit()
else:
print("NG")
| 1 | 26,550,063,736,160 | null | 158 | 158 |
N,M= map(int, input().split())
num = list(range(1,N+1))
ans = []
if M % 2 == 0:
for i in range(M // 2):
ans.append([i+1,M+1-i])
for i in range(M // 2):
ans.append([i+2+M,2*M+1-i])
if M % 2 != 0:
for i in range(M // 2):
ans.append([i+1,M-i])
for i in range(M - M//2):
ans.append([i+1+M,2*M+1-i])
for an in ans:
print(an[0],an[1])
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
s = list(readline().rstrip().decode())
k = int(read())
if len(set(s)) == 1:
print(len(s) * k // 2)
exit()
ans = 0
memo = 0
flag = True
for i, (bf, af) in enumerate(zip(s, s[1:])):
if s[0] == af and flag:
memo += 1
else:
flag = False
if bf == af:
ans += 1
s[i + 1] = '?'
ans *= k
if s[-1] == s[0] and memo % 2 == 0:
ans += k - 1
print(ans)
| 0 | null | 101,859,551,024,790 | 162 | 296 |
s, t = input().split()
print(f"{t}{s}")
|
S,W = map(int,input().split())
print('safe' if S > W else 'unsafe')
| 0 | null | 66,324,588,483,648 | 248 | 163 |
number = int(input())
Total = []
for i in range(1, number + 1):
if number % 3 == 0 and i % 5 ==0:
"FizzBuzz"
elif i % 3 ==0:
"Fizz"
elif i % 5 == 0:
"Buzz"
else:
Total.append(i)
print(sum(Total))
|
from collections import Counter, defaultdict
a = defaultdict(int)
a[0] += 1
s = input()[::-1]
cur = 0
for i, x in enumerate(s):
cur += (int(x)*pow(10, i, 2019))%2019
cur %= 2019
a[cur] += 1
def comb(a):
return a*(a-1)//2
ans = 0
for x in a.values():
if x >= 2:
ans += comb(x)
print(ans)
| 0 | null | 32,622,648,344,968 | 173 | 166 |
import sys, math
for line in sys.stdin.readlines():
line = line.strip()
n = int(line)
value = 100000.0
for week in xrange(n):
value = value * 1.05
value = math.ceil(value / 1000) * 1000
print int(value)
|
import math
cnt = 0
for i in range(int(input())):
x = int(input())
flg = False # なんらかの数で割り切れるかどうか
if x == 1:
continue
if x == 2:
cnt += 1
continue
for k in range(2, math.floor(math.sqrt(x))+1):
if not(x % k):
flg = True
break
if not flg:
cnt += 1
print(cnt)
| 0 | null | 6,045,673,580 | 6 | 12 |
N = int(input())
X = []
for i in range(N):
X.append(input().split())
S = input()
flg = False
ans = 0
for x in X:
if flg:
ans += int(x[1])
if S == x[0]:
flg = True
print(ans)
|
n=int(input())
slist=[]
tlist=[]
ans=0
yn=0
for i in range(n):
s,t=input().split()
slist.append(s)
tlist.append(int(t))
x=input()
for i in range(n):
if yn==1:
ans+=tlist[i]
if x==slist[i]:
yn=1
print(ans)
| 1 | 96,839,258,914,048 | null | 243 | 243 |
from collections import Counter
ans = 0
H, W, M = map(int, input().split())
HW = set()
Hlist, Wlist = [], []
for _ in range(M):
h, w = map(int, input().split())
Hlist.append(h)
Wlist.append(w)
HW.add((h,w))
cntH = Counter(Hlist)
cntW = Counter(Wlist)
maxhk, maxhv = cntH.most_common()[0]
ans = max(ans, maxhv)
for i in range(1,1+W):
tmp = cntW[i]
if (maxhk, i) in HW:
tmp -= 1
ans = max(ans, tmp+maxhv)
maxwk, maxwv = cntW.most_common()[0]
ans = max(ans, maxwv)
for i in range(1,1+H):
tmp = cntH[i]
if (i, maxwk) in HW:
tmp -= 1
ans = max(ans, tmp+maxwv)
print(ans)
|
pd = list(input())
for i in range(len(pd)):
if '?' in pd[i]:
pd[i] = 'D'
print(pd[i], end = '')
| 0 | null | 11,664,663,988,484 | 89 | 140 |
import sys
from builtins import enumerate
from io import StringIO
import unittest
import os
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
# 実装を行う関数
def resolve(test_def_name=""):
# 数値取得サンプル
# 1行1項目 n = int(input())
# 1行2項目 x, y = map(int, input().split())
# 1行N項目 x = list(map(int, input().split()))
# N行1項目 x = [int(input()) for i in range(n)]
# N行N項目 x = [list(map(int, input().split())) for i in range(n)]
# 文字取得サンプル
# 1行1項目 x = input()
# 1行1項目(1文字ずつリストに入れる場合) x = list(input())
n, k = map(int, input().split())
p_s = [0] + list(map(int, input().split()))
avr_s = [0]
cumsum = 0
for i in range(1, 1001):
cumsum += i
avr_s.append(cumsum / i)
ans = 0
val = 0
for i in range(1, len(p_s)):
val += avr_s[p_s[i]]
if i < k:
continue
elif i == k:
ans = val
else:
val -= avr_s[p_s[i - k]]
ans = max(ans, val)
print(ans)
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """5 3
1 2 2 4 5"""
output = """7.000000000000"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """4 1
6 6 6 6"""
output = """3.500000000000"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """10 4
17 13 13 12 15 20 10 13 17 11"""
output = """32.000000000000"""
self.assertIO(test_input, output)
# 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
def tes_t_1original_1(self):
test_input = """データ"""
output = """データ"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
dp=[0]*(n-k+1)
dp[0]=sum(p[:k])
for i in range(n-k):
dp[i+1]=dp[i]+p[k+i]-p[i]
print((max(dp)+k)/2)
| 1 | 74,670,407,385,130 | null | 223 | 223 |
X=int(input())
for A in range(1000):
for B in range(-100, 1000):
if A**5 - B**5 == X:
ans = (A,B)
print(*ans)
|
X,Y,Z=map(int, input().split())
A=[Z,X,Y]
print(*A,end='')
| 0 | null | 32,022,016,465,110 | 156 | 178 |
import math as mt
import sys, string
from collections import Counter, defaultdict
input = sys.stdin.readline
MOD = 1000000007
# input functions
I = lambda : int(input())
M = lambda : map(int, input().split())
Ms = lambda : map(str, input().split())
ARR = lambda: list(map(int, input().split()))
def main():
a, b, c = M()
k = I()
ans = 0
while b <= a:
b *= 2
ans += 1
while c <= b:
c *= 2
ans += 1
if ans <= k:
print("Yes")
else:
print("No")
# testcases
tc = 1
for _ in range(tc):
main()
|
def magic(a,b,c,k):
for i in range(k):
if(a>=b):
b*=2
elif(b>=c):
c*=2
if(a < b and b < c):
print("Yes")
else:
print("No")
d,e,f = map(int,input().split())
j = int(input())
magic(d,e,f,j)
| 1 | 6,840,883,931,908 | null | 101 | 101 |
import numpy as np
mod = 998244353
n, s = map(int, input().split())
A = list(map(int, input().split()))
DP = np.zeros(3005, dtype=np.int64)
for num, a in enumerate(A):
double = DP * 2
shift = np.hstack([np.zeros(a), DP[:-a]]).astype(np.int64)
DP = double + shift
DP[a] += pow(2, num, mod)
DP %= mod
print(DP[s])
|
a, b, c, d, e, f = map(int, input().split())
directions = [x for x in input()]
class Dice():
def __init__(self, a, b, c, d, e, f):
self.a = a
self.b = b
self.c = c
self.d = d
self.e = e
self.f = f
def rotation(self, directions):
for direction in directions:
if direction == 'N':
self.a, self.b, self.f, self.e = self.b, self.f, self.e, self.a
if direction == 'S':
self.a, self.b, self.f, self.e = self.e, self.a, self.b, self.f
if direction == 'E':
self.a, self.c, self.f, self.d = self.d, self.a, self.c, self.f
if direction == 'W':
self.a, self.c, self.f, self.d = self.c, self.f, self.d, self.a
return self
dice = Dice(a, b, c, d, e, f)
print(dice.rotation(directions).a)
| 0 | null | 8,984,534,281,560 | 138 | 33 |
A, B, K = map(int, input().split())
if A >= K:
print(str(A - K) + ' ' + str(B))
else:
print(str(0) + ' ' + str(max((B - (K - A)), 0)))
|
A,B,K = map(int,input().split())
if A <= K:
K -= A
A = 0
else:
A -= K
K = 0
if B <= K:
K -= B
B = 0
else:
B -= K
K = 0
print(A,B)
| 1 | 104,032,682,394,852 | null | 249 | 249 |
#153
def main():
N, K = map(int,input().split())
H = list(map(int,input().split()))
H.sort()
H.reverse()
H = H[K:]
cost = 0
for i in H:
cost+=i
print(cost)
main()
|
from collections import deque
times = int(input())
stack = deque()
for i in range(times):
op = input().split()
if op[0] == "insert":
stack.appendleft(op[1])
if op[0] == "delete":
if op[1] in stack:
stack.remove(op[1])
if op[0] == "deleteFirst":
stack.popleft()
if op[0] == "deleteLast":
stack.pop()
print(*stack)
| 0 | null | 39,569,581,121,408 | 227 | 20 |
from collections import Counter
def solve():
N = int(input())
A = list(map(int, input().split()))
c = Counter(A)
Q = int(input())
ans = [0]*Q
total = sum(A)
for i in range(Q):
x,y = map(int, input().split())
total += c[x]*(y-x)
c[y] += c[x]
c[x] = 0
ans[i] = total
return ans
print(*solve(),sep='\n')
|
S=input()
S+=input()
print(*[a for a in '123' if a not in S])
| 0 | null | 61,822,563,160,170 | 122 | 254 |
# Python 3
if __name__ == "__main__":
input()
str = input()
a = [int(x) for x in str.split()]
print(min(a), max(a), sum(a))
|
h, w = map(int,input().split())
s = [input() for i in range(h)]
def f(i, j):
t = [[-1]*w for j in range(h)]
t[i][j] = 0
q = [(i,j)]
while q:
y, x = q.pop(0)
if y - 1 >= 0 and s[y-1][x] != "#" and t[y-1][x] == -1:
t[y-1][x] = t[y][x] + 1
q.append((y-1,x))
if y + 1 < h and s[y+1][x] != "#" and t[y+1][x] == -1:
t[y+1][x] = t[y][x]+1
q.append((y+1,x))
if x - 1 >= 0 and s[y][x-1] != "#" and t[y][x-1] == -1:
t[y][x-1] = t[y][x] + 1
q.append((y,x-1))
if x + 1 < w and s[y][x+1] != "#" and t[y][x+1] == -1:
t[y][x+1] = t[y][x] + 1
q.append((y,x+1))
return max(max(tt) for tt in t)
result = 0
for i in range(h):
for j in range(w):
if s[i][j] != "#":
result = max(result,f(i,j))
print(result)
| 0 | null | 47,783,290,443,040 | 48 | 241 |
import sys
r, c = map(int, raw_input().split())
table = {}
for i in range(r):
a = map(int, raw_input().split())
for j in range(c):
table[(i,j)] = a[j]
for i in range(r+1):
for j in range(c+1):
if(i != r and j != c):
sys.stdout.write(str(table[(i,j)]))
sys.stdout.write(' ')
elif(i != r and j == c):
print sum(table[(i,l)] for l in range(c))
elif(i == r and j != c):
sys.stdout.write(str(sum(table[(k,j)] for k in range(r))))
sys.stdout.write(' ')
elif(i == r and j == c):
total = 0
for k in range(r):
for l in range(c):
total += table[(k,l)]
print total
|
rc=list(map(int,input().split()))
a=[[0 for x in range(rc[1]+1)]for x in range(rc[0]+1)]
for x in range(rc[0]):
code=list(map(int,input().split()))
result=0
for y in range(rc[1]):
a[x][y]=code[y]
result+=code[y]
a[x][rc[1]]=result
for y in range(rc[1]+1):
result=0
for x in range(rc[0]):
result+=a[x][y]
a[rc[0]][y]=result
for x in range(rc[0]+1):
string=""
for y in range(rc[1]+1):
string+=str(a[x][y])
if (y!=rc[1]):
string+=" "
print(string)
| 1 | 1,372,520,570,798 | null | 59 | 59 |
# local search is all you need
# 「日付 d とコンテストタイプ q をランダムに選び、d 日目に開催するコンテストをタイプ q に変更する」
# このデメリット→変化させる量が小さすぎるとすぐに行き止まり (局所最適解) に陥ってしまい、逆に、変化させる量が 大きすぎると闇雲に探す状態に近くなって、改善できる確率が低くなってしまう。
# 今回ならば、開催日が全体的に遠すぎず近すぎない感じのlocal minimumに収束する∵d日目のコンテストをi→jに変更したとする。iの開催期間はすごく伸びると2乗でスコアが下がるため、iの開催期間が比較的近いところのiしか選ばれない
# →じゃ2点スワップを導入して改善してみよう
# あといっぱい回すためにinitやscoreも若干高速化
from time import time
t0 = time()
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 a_int(): return int(read())
def ints(): return list(map(int, read().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, zip(*ret)))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
from random import randint, random
def score(D, C, S, T):
'''2~3*D回のループでスコアを計算する'''
# last = [-1] * 26
date_by_contest = [[-1] for _ in range(26)]
for d, t in enumerate(T):
date_by_contest[t].append(d)
for i in range(26):
date_by_contest[i].append(D) # 番兵
# print(*date_by_contest, sep='\n')
score = 0
for d in range(D):
score += S[d][T[d]]
for c, dates in enu(date_by_contest):
for i in range(len(dates) - 1):
dd = (dates[i + 1] - dates[i])
# for ddd in range(dd):
# score -= C[c] * (ddd)
score -= C[c] * (dd - 1) * dd // 2
return score
D = a_int()
C = ints()
S = read_tuple(D)
def maximizer(newT, bestT, bestscore):
tmpscore = score(D, C, S, newT)
if tmpscore > bestscore:
return newT, tmpscore
else:
return bestT, bestscore
def ret_init_T():
'''greedyで作ったTを初期値とする。
return
----------
T, score ... 初期のTとそのTで得られるscore
'''
def _make_T(n_days):
# editorialよりd日目の改善は、改善せずにd+n_days経過したときの関数にしたほうが
# 最終的なスコアと相関があるんじゃない？
T = []
last = [-1] * 26
for d in range(D):
ma = -INF
for i in range(26):
tmp = S[d][i]
dd = d - last[i]
tmp += C[i] * (((dd + n_days + dd) * (n_days) // 2))
if tmp > ma:
t = i
ma = tmp
last[t] = d # Tを選んだあとで決める
T.append(t)
return T
T = _make_T(2)
sco = score(D, C, S, T)
for i in range(3, 16):
T, sco = maximizer(_make_T(i), T, sco)
return T, sco
bestT, bestscore = ret_init_T()
def add_noise(T, thre_p, days_near):
'''確率的にどちらかの操作を行う
1.日付dとコンテストqをランダムに選びd日目に開催するコンテストのタイプをqに変更する
2.10日以内の点でコンテストを入れ替える
thre_pはどちらの行動を行うかを調節、days_nearは近さのパラメータ'''
ret = T.copy()
if random() < thre_p:
d = randint(0, D - 1)
q = randint(0, 25)
ret[d] = q
return ret
else:
i = randint(0, D - 2)
j = randint(i - days_near, i + days_near)
j = max(j, 0)
j = min(j, D - 1)
if i == j:
j += 1
ret[i], ret[j] = ret[j], ret[i]
return ret
while time() - t0 < 1.9:
for _ in range(100):
bestT, bestscore = maximizer(
add_noise(bestT, 0.8, 8), bestT, bestscore)
# print(bestscore)
# print(score(D, C, S, T))
print(*mina(*bestT, sub=-1), sep='\n')
|
mod = 10**9+7
s = int(input())
dp = [0]*2500
dp[0] = 1
for i in range(1, s+1):
for j in range(0, i-2):
dp[i]+=dp[j]
dp[i]%=mod
print(dp[s])
| 0 | null | 6,561,065,994,560 | 113 | 79 |
n,k = map(int,input().split())
p = [0 for _ in range(n)]
p = [int(s) for s in input().split()]
p.sort()
sm = 0
for i in range(k):
sm += p[i]
print(sm)
|
n, k = map(int, input().split())
p_lst = list(map(int, input().split()))
p_lst = sorted(p_lst)
print(sum(p_lst[:k]))
| 1 | 11,538,098,476,870 | null | 120 | 120 |
from collections import defaultdict
N = int(input())
if N == 1:
print(0)
exit()
p = defaultdict(int)
while N % 2 == 0:
p[2] += 1
N //= 2
f = 3
while f * f <= N:
if N % f == 0:
p[f] += 1
N //= f
else:
f += 2
if N != 1:
p[N] += 1
ans = 0
for v in p.values():
n = 1
i = 1
while n <= v:
ans += 1
i += 1
n += i
print(ans)
|
cards = [
"{0} {1}".format(s, r)
for s in ('S', 'H', 'C', 'D')
for r in range(1, 13 + 1)
]
count = int(input())
for n in range(count):
card = input()
cards.remove(card)
for n in cards:
print(n)
| 0 | null | 8,890,060,602,760 | 136 | 54 |
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations
def main():
X = int(input())
if X <= 599:
print('8')
elif X <= 799:
print('7')
elif X <= 999:
print('6')
elif X <= 1199:
print('5')
elif X <= 1399:
print('4')
elif X <= 1599:
print('3')
elif X <= 1799:
print('2')
else:
print('1')
if __name__ == '__main__':
main()
|
n,m = list(map(int,input().split()))
A = [[0 for w in range(m)] for h in range(n)]
B = [0 for h in range(m)]
for i in range(n) :
A[i] = list(map(int, input().split()))
for i in range(m) :
B[i] = int(input())
for i in range(n):
c = 0
for j in range(m):
c += A[i][j] * B[j]
print(c)
| 0 | null | 3,877,974,266,308 | 100 | 56 |
#!/usr/bin/env python3
from collections import Counter
def main():
S = input()
N = len(S)
T = [0] * (N+1)
for i in range(N-1,-1,-1):
T[i] = (T[i+1] + int(S[i]) * pow(10,N-i,2019)) % 2019
l = Counter(T)
ans = 0
for v in l.values():
ans += v * (v-1) // 2
print(ans)
if __name__ == "__main__":
main()
|
a,b,k=map(int,input().split())
s=k-a
t=k-a-b
if s>=0:
if t>=0:
print(0,0)
else:
print(0,a+b-k)
else:
print(a-k,b)
| 0 | null | 67,386,835,306,720 | 166 | 249 |
# encoding: utf-8
input = raw_input().split()
stack = []
for n in input:
if(n.isdigit()):
stack.append(int(n))
else:
a = stack.pop()
b = stack.pop()
if n == '+':
stack.append(b + a)
elif n == '-':
stack.append(b - a)
elif n == '*':
stack.append(b * a)
else:
stack.append(b / a)
print stack.pop()
|
S = []
A = raw_input().split()
for i in A:
if i == '+':
S.append(int(S.pop()) + int(S.pop()))
elif i == '-':
S.append(-int(S.pop()) + int(S.pop()))
elif i == '*':
S.append(int(S.pop()) * int(S.pop()))
else:
S.append(i)
print S[0]
| 1 | 37,711,505,730 | null | 18 | 18 |
N = int(input())
D = N % 10
if D in [2, 4, 5, 7, 9]:
print("hon")
if D in [0, 1, 6, 8]:
print("pon")
if D == 3:
print("bon")
|
from math import ceil
N, K = map(int, input().split())
A = list(map(int, input().split()))
def f(x):
cnt = 0
for a in A:
cnt += ceil(a / x) - 1
return True if cnt <= K else False
OK, NG = 10**9, 0
while OK - NG > 1:
mid = (OK + NG) // 2
if f(mid):
OK = mid
else:
NG = mid
print(OK)
| 0 | null | 12,941,316,414,730 | 142 | 99 |
N=int(input())
import numpy as np
h=np.array(list(map(int,input().split())))
print(*(np.argsort(h)+1).tolist(), sep=' ')
|
N=int(input())
A=list(map(int,input().split()))
for i in range(N):
A[i] = [i+1, A[i]]
A.sort(key=lambda x:x[1])
ans=[]
for i in range(N):
ans.append(A[i][0])
ans = map(str, ans)
print(' '.join(ans))
| 1 | 180,614,704,682,340 | null | 299 | 299 |
# !/usr/bin/python3
"""
https://atcoder.jp/contests/abc151/tasks/abc151_c
Welcome at atcoder
"""
if __name__ == "__main__":
n, m = list(map(int, input().split()))
accepted = [False for _ in range(n+5)]
wrong = [0 for _ in range(n+5)]
ac = wa = 0
for _ in range(m):
p, s = input().split()
p = int(p)
if accepted[p]: continue
elif s == "WA": wrong[p] += 1
elif s == "AC":
ac += 1
wa += wrong[p]
accepted[p] = True
print(f"{ac} {wa}")
|
N, M = map(int, input().split(' '))
ac_set = set()
wa_cnt, wa_cnt_ls = 0, [ 0 for i in range(N) ]
for i in range(M):
p, s = input().split(' ')
idx = int(p) - 1
if not idx in ac_set:
if s == 'AC':
ac_set.add(idx)
wa_cnt += wa_cnt_ls[idx]
else:
wa_cnt_ls[idx] += 1
print(len(ac_set), wa_cnt)
| 1 | 93,429,145,925,220 | null | 240 | 240 |
import math
def print_list(a):
out = ''
for ai in a:
out += str(ai) + ' '
else:
out = out[:-1]
print(out)
def insertion_sort(a, n, g):
cnt = 0
for i in range(g, n):
v = a[i]
j = i - g
while j >= 0 and a[j] > v:
a[j + g] = a[j]
j = j - g
cnt += 1
a[j + g] = v
return cnt
def shell_sort(a, n):
cnt = 0
m = 0
g = []
h = 1
while True:
if h > n:
break
m += 1
g.append(h)
h = 3 * h + 1
g.reverse()
for i in range(m):
cnt += insertion_sort(a, n, g[i])
print(m)
print_list(g)
print(cnt)
for i in a:
print(i)
n = int(input())
a = [0] * n
for i in range(n):
a[i] = int(input())
shell_sort(a, n)
|
n, k = map(int, input().split())
r, s, p = map(int, input().split())
t = input()
def score(hand):
if hand == 's':
return r
if hand == 'p':
return s
if hand == 'r':
return p
ans = 0
changed = [0] * n
for i in range(n):
if i >= k and t[i] == t[i - k] and changed[i - k] == 0:
changed[i] = 1
continue
ans += score(t[i])
print(ans)
| 0 | null | 53,712,313,267,200 | 17 | 251 |
a = list(map(int, input().split()))
print('un' * (a[0] <= a[1]) + 'safe')
|
nm = input().split()
n, m = map(int, nm)
A = [[int(i) for i in input().split()] for j in range(n)]
b = [int(input()) for i in range(m)]
for row in A:
s = 0
for i, elm in enumerate(row):
s += (elm*b[i])
print(s)
| 0 | null | 15,132,765,317,822 | 163 | 56 |
N=str(input())
print(N[0]+N[1]+N[2])
|
main=list(map(int,input().split()));count=0
for i in range(main[0],main[1]+1):
if(i%main[2]==0): count=count+1
print(count)
| 0 | null | 11,242,805,228,340 | 130 | 104 |
D=int(input())
c = [int(i) for i in input().split()]
s=[]
for i in range(D):
s.append([int(j) for j in input().split()])
t=[0] * D
for i in range(D):
t[i] = int(input())
tst = [0] * 26
last = [0] * 26
for i,j in enumerate(t):
tst[j-1] += s[i][j-1]
last[j-1] = i+1
for k in range(26):
if k != j-1:
tst[k] -= (i+1 - last[k])*c[k]
print(sum(tst))
|
N = int(input())
G = [[0] * N for _ in range(N)]
time = 0
times = [{'s': 0, 'f': 0} for _ in range(N)]
for _ in range(N):
u, n, *K = map(int, input().split())
for k in K:
G[u - 1][k - 1] = 1
def dfs(u):
global time
time += 1
times[u]['s'] = time
for i in range(N):
if G[u][i] == 1 and times[i]['s'] == 0:
dfs(i)
else:
time += 1
times[u]['f'] = time
for i in range(N):
if times[i]['s'] == 0:
dfs(i)
for i, time in enumerate(times):
print(i + 1, *time.values())
| 0 | null | 4,942,439,306,980 | 114 | 8 |
# your code goes here
N=int(input())
Ci=[i for i in input().split()]
C=[]
for i in range(N):
# print(C)
C.append([])
C[i].append(Ci[i][0])
# print(C)
C[i].append(int(Ci[i][1]))
Cb=C
fl=1
#print(Cb)
while fl==1:
fl=0
for j in range(N-1):
# print(Cb)
if Cb[N-1-j][1]<Cb[N-2-j][1]:
# print(Cb)
t=Cb[N-1-j]
Cb[N-1-j]=Cb[N-2-j]
Cb[N-2-j]=t
fl=1
# print(C)
for i in range(N):
Cb[i][1]=str(Cb[i][1])
# print(Cb)
Cb[i]="".join(Cb[i])
print(" ".join(Cb))
p="Stable"
print(p)
C=[]
for i in range(N):
# print(C)
C.append([])
C[i].append(Ci[i][0])
# print(C)
C[i].append(int(Ci[i][1]))
Co=[]
for i in range(N):
Co.append([])
# print(Co)
Co[i].append(Ci[i][0])
Co[i].append(int(Ci[i][1]))
for i in range(N-1):
minj=i
for j in range(i,N):
# print(C)
if C[j][1]<C[minj][1]:
minj=j
elif C[j][1]==C[minj][1]:
k=0
while k<N and C[minj][1]!=Co[k][1]:
k+=1
# print (j)
if k<N and C[minj][0]!=Co[k][0]:
p="Not stable"
if i!=minj:
t=C[i]
C[i]=C[minj]
C[minj]=t
# print(minj)
for i in range(N):
C[i][1]=str(C[i][1])
C[i]="".join(C[i])
print(" ".join(C))
print(p)
|
import os, sys, re, math
A = [int(n) for n in input().split()]
print('win' if sum(A) <= 21 else 'bust')
| 0 | null | 59,204,438,614,090 | 16 | 260 |
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 7 17:36:58 2020
@author: liang
"""
"""
全探索
"""
N, M = map(int, input().split())
test = list()
for _ in range(M):
s,c = map(int,input().split())
test.append((s,c))
#print(test)
tmp = [0]*3
for i in range(10**N):
tmp[0] = i//100
tmp[1] = i//10%10
tmp[2] = i%10
#print(tmp)
for tup in test:
s, c = tup[0], tup[1]
if tmp[(3-N)+s-1] != c:
break
else:
#最上位の桁が0でないか
if tmp[-N] == 0 and N != 1:
continue
print(i)
break
else:
print(-1)
|
def main():
n, m = map(int, input().split(" "))
s = [0] * m
c = [0] * m
for i in range(m):
s[i], c[i] = map(int, input().split(" "))
ans = [-1] * n
for i in range(m):
if ans[s[i]-1] != -1 and ans[s[i]-1] != c[i]:
print(-1)
return
ans[s[i]-1] = c[i]
if ans[0] == 0:
if n == 1:
print(0)
return
print(-1)
return
for i in range(n):
if ans[i] == -1:
if i == 0:
if n == 1:
print(0)
return
print(1, end="")
else:
print(0, end = "")
else:
print(ans[i], end ="")
print()
if __name__ == "__main__":
main()
| 1 | 60,736,838,260,070 | null | 208 | 208 |
import sys
sys.setrecursionlimit(10 ** 9)
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())
uf = UnionFind(N)
FG = [0] * N
BG = [0] * N
for _ in range(M):
a, b = map(int, input().split())
a, b = a-1, b-1
uf.union(a, b)
FG[a] += 1
FG[b] += 1
for _ in range(K):
c, d = map(int, input().split())
c, d = c-1, d-1
if uf.same(c, d):
BG[c] += 1
BG[d] += 1
ans = []
for i in range(N):
ans.append(uf.size(i) - FG[i] - BG[i] - 1)
print(*ans)
|
N,M,K = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
###Bをi冊目まで読むのにどれだけ時間がかかるか
P = [0]*M
P[0] = B[0]
for i in range(1,M):
P[i] = P[i-1] + B[i]
T = K###残り時間
ans = 0
num = M-1
for i in range(N):
T -= A[i]
if T < 0:
break
while P[num] > T and num >= 0:
num -= 1
ans = max(ans,i+num+2)
#print(i,num,ans)
###Aを1冊も読まない場合
for i in range(M):
if P[i] <= K:
ans = max(ans,i+1)
else:
break
print(ans)
| 0 | null | 36,105,718,658,020 | 209 | 117 |
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
D1 = abs(A-B)
D2 = (V-W)*T
if (D1 - D2) <=0:
print("YES")
else:
print("NO")
|
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,031,599,160,552 | null | 131 | 131 |
from sys import stdin
input = stdin.readline
import math
import heapq
def solve():
n, k = map(int, input().split())
a = list(map(int, input().split()))
left = 1
right = max(a)
def ok(l):
s = sum([(i-1) // l for i in a])
return s <= k
while left < right:
mid = (left + right) // 2
if ok(mid):
right = mid
else:
left = mid + 1
print(left)
if __name__ == '__main__':
solve()
|
n, k = map(int, input().split())
A = list(map(int, input().split()))
l = 1
r = 10**9+1
while l < r:
mid = (l+r)//2
count = 0
for i in range(n):
if A[i] > mid:
count += A[i]//mid
if count <= k:
r = mid
else:
l = mid+1
print(l)
| 1 | 6,506,677,669,760 | null | 99 | 99 |
import numpy as np
def main() -> None:
n, m, x = map(int, input().split())
books = [tuple(map(int, input().split())) for _ in range(n)]
is_able = False
answer = float('inf')
for i in range(2**n):
money = 0
skills = np.zeros(m)
for j in range(n):
if ((i >> j) & 1):
money += books[j][0]
skills += books[j][1:]
if x <= skills.min():
is_able = True
answer = min(answer, money)
print(answer if is_able else -1)
return
if __name__ == '__main__':
main()
|
from itertools import combinations
def python_list_add(in1, in2):
return list(map(sum, zip(in1, in2)))
N, M, X = map(int, input().split())
T = []
C = []
min = 10000000
for n in range(N):
C.append(list(map(int, input().split())))
for bi in range(2**N):
rikai = [0]*(M+1)
low = False
for i in range(N):
b = 2**i
if bi & b != 0:
for j in range(M+1):
rikai[j] = rikai[j] + C[i][j]
#if rikai[0] > min:
#break
#print(rikai)
if rikai[0] < min:
for m in range(1, M+1):
if rikai[m] < X:
low = True
#print('low rikai')
break
if low == False:
min = rikai[0]
if min == 10000000:
print('-1')
else:
print(min)
| 1 | 22,402,275,167,312 | null | 149 | 149 |
n,m = map(int,input().split())
if n % 2 == 1:ans = [[1+i,n-i] for i in range(n//2)]
else:ans = [[1+i,n-i] for i in range(n//4)]+[[n//2+1+i,n//2-1-i] for i in range(n//2-n//4-1)]
for i in range(m):print(ans[i][0],ans[i][1])
|
n, m = map(int, input().split())
if m % 2 ==0:
for i in range(m//2):
print(1+i, m-i)
print(m+1+i, 2*m+1-i)
else:
for i in range((m//2)+1):
print(m+1+i, 2*m+1-i)
for i in range(m//2):
print(1+i, m-i)
| 1 | 28,662,889,495,940 | null | 162 | 162 |
s=input()
l=['SUN','MON','TUE','WED','THU','FRI','SAT']
d=[7,6,5,4,3,2,1]
print(d[l.index(s)])
|
days = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]
S = input()
for i in range(7):
if S == days[i]:
print(7 - i)
exit()
| 1 | 132,904,568,545,668 | null | 270 | 270 |
N = int(input())
A_lis = list(map(int,input().split()))
ls = [0] * N
for i in range(N-1):
ls[A_lis[i]-1] += 1
for a in ls:
print(a)
|
l = [int(i) for i in input().split()]
l.sort()
print(str(l[0])+' '+str(l[1])+' '+str(l[2]))
| 0 | null | 16,592,918,892,988 | 169 | 40 |
import sys
def gcd(a,b):
while a%b :
a,b=b,a%b
return b
def lcm(a,b) :
return a*b/gcd(a,b)
for ab in sys.stdin:
a,b = map(int,ab.split())
a,b = max(a,b),min(a,b)
print "%d" % gcd(a,b),
print "%d" % lcm(a,b)
|
n,x,t = map(int,input().split())
print((-(-(n)//x) * t))
| 0 | null | 2,128,008,986,520 | 5 | 86 |
import sys
if __name__ == "__main__":
n, m = map(lambda x: int(x), input().split())
coins = list(map(lambda x: int(x), input().split()))
table = [sys.maxsize] * (n + 2)
table[0] = 0
for i in range(n + 1):
for coin in coins:
if (i + coin <= n):
table[i + coin] = min(table[i + coin], table[i] + 1)
print(table[n])
|
n, m = map(int, input().split())
c_list = list(map(int, input().split()))
c_list.sort()
dp_list = [0] + [10**9]*(n)
for i in range(1, n+1):
for c in c_list:
if i - c >= 0:
dp_list[i] = min(dp_list[i], dp_list[i-c]+1)
else:
break
print(dp_list[-1])
| 1 | 143,049,987,462 | null | 28 | 28 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
n,m = map(int, input().split())
a = list(map(int, input().split()))
b = sorted(a)
c = [0] + sorted(b)
c = list(accumulate(c))
a.sort(reverse=True)
# mid以上の和をm個作れるならTrue
def check(mid):
total = 0
for i in a:
total += n - bisect_left(b, mid-i)
if total >= m:
return True
return False
l = 0
r = 2*(10**5)+10
# 最終的なlがm個以上作れる最小値
while r - l > 1:
mid = (l+r) // 2
if check(mid):
l = mid
else:
r = mid
res = 0
for i in a:
d = bisect_left(b, r-i)
if d == n:
continue
res += i * (n-d) + c[-1] - c[d]
m -= n - d
print(res + l*m)
if __name__ == '__main__':
main()
|
a=map(int,raw_input().split())
if 0<=a[2]-a[4] and a[2]+a[4]<=a[0] and 0<=a[3]-a[4] and a[3]+a[4]<=a[1]:
print "Yes"
else:
print "No"
| 0 | null | 54,261,498,576,448 | 252 | 41 |
S=[]
T=[]
n=int(input())
s=input().split()
for i in range(n):
S.append(s[i])
q=int(input())
t=input().split()
for j in range(q):
T.append(t[j])
cnt=0
for i in range(q):
for j in range(n):
if T[i]==S[j]:
cnt+=1
break
print(cnt)
|
# coding: utf-8
n = int(input().rstrip())
count = 0
for i in range(1,n//2+1):
m = n - i
if i != m:
count += 1
print(count)
| 0 | null | 76,476,602,600,902 | 22 | 283 |
N, K = map(int, input().split())
S = 0
for p in range(K, N+2):
S += p*(2*N-p+1)//2-p*(p-1)//2+1
S %= 10**9+7
print(S)
|
import bisect
import copy
import heapq
import math
import sys
from collections import *
from itertools import accumulate, combinations, permutations, product
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
n,k=map(int,input().split())
a=list(map(int,input().split()))
# amari=[a[i]%k for i in range(n)]
rui=ruiseki(a)
# print(a)
# print(amari)
# print(rui)
dic=defaultdict(int)
ans=0
for i in range(n+1):
if i>=k:
dic[(rui[i-k]-(i-k))%k]-=1
ans+=dic[(rui[i]-i)%k]
dic[(rui[i]-i)%k]+=1
# print(dic)
print(ans)
| 0 | null | 85,196,639,148,208 | 170 | 273 |
import heapq
n = int(input())
A = list(map(int, input().split()))
A = sorted(A, reverse=True)
ans = 0
q = []
heapq.heappush(q, A[0]*-1)
for i in range(1, n):
tmp = heapq.heappop(q)
ans += tmp
heapq.heappush(q, A[i] * -1)
heapq.heappush(q, A[i] * -1)
print(ans*-1)
|
ans = 0
while True:
num = list(map(str,input().split()))
if(num[1] == "?"): break
a = int(num[0])
b = int(num[2])
op = num[1]
if(op == "+"): ans=a+b
elif(op == "-"): ans=a-b
elif(op == "*"): ans=a*b
elif(op == "/"): ans=a/b
print("%d" %ans)
| 0 | null | 4,914,085,372,492 | 111 | 47 |
from collections import deque
n = int(input())
ki = [[] for i in range(n)]
lis = []
for i in range(n-1):
a,b = map(int, input().split())
a -= 1
b -= 1
ki[a].append(b)
ki[b].append(a)
lis.append([a,b,i])
mx = 0
for i in range(n):
ki[i].sort()
mx = max(mx,len(ki[i]))
lis = sorted(lis, key=lambda x:x[0])
lis = sorted(lis, key=lambda x:x[1])
lis2 = [[] for i in range(n)]
cnt = 0
for i in range(n-1):
lis2[lis[i][0]].append(lis[i])
#print(lis2)
#print(ki)
def bfs(ki,lis2):
d = [True] * n
que = deque([(0,-1)])
d[0] = False
while len(que) != 0:
val = que.popleft()
cnt = 1
cnt2 = 0
for i in range(len(ki[val[0]])):
if d[ki[val[0]][i]] == True:
d[ki[val[0]][i]] = False
#print(cnt,cnt2,val,i)
if val[1] == cnt:
cnt += 1
lis2[val[0]][cnt2].append(cnt)
que.append([ki[val[0]][i],cnt])
cnt += 1
cnt2 += 1
return lis2
lis2 = bfs(ki,lis2)
#print(lis2)
val = 0
for i in range(n):
val = max(len(ki[i]),val)
print(val)
lis = []
for i in range(n):
for j in range(len(lis2[i])):
lis.append(lis2[i][j])
lis = sorted(lis,key=lambda x:x[2])
for i in range(n-1):
print(lis[i][3])
|
# -*- coding:utf-8 -*-
def gcd(a,b):
big,small=max(a,b),min(a,b)
while big%small!=0:
big,small=small,big%small
return small
def lcm(a,b):
return int(a*b/gcd(a,b))
def main():
while True:
try:
IN=input()
val=IN.split()
g=gcd(int(val[0]),int(val[1]))
l=lcm(int(val[0]),int(val[1]))
print(g,l)
except:
break
if __name__ == '__main__':
main()
| 0 | null | 67,842,672,582,400 | 272 | 5 |
N = int(input())
S = [s for s in input()]
ans = S.count("R") * S.count("G") * S.count("B")
for i in range(N - 2):
for j in range(i + 1, N - 1):
k = j + (j - i)
if N - 1 < k:
continue
if S[k] != S[i] and S[k] != S[j] and S[i] != S[j]:
ans -= 1
print(ans)
|
import itertools
n = int(input())
a = [[[0 for _ in range(10)] for _ in range(3)] for _ in range(4)]
for _ in range(n):
b, f, r, v = map(int, input().split())
a[b-1][f-1][r-1] += v
for b in range(4):
for f in range(3):
for r in range(10):
print('', a[b][f][r], end="")
print()
if b < 3:
print("#"*20)
| 0 | null | 18,631,963,442,696 | 175 | 55 |
from collections import deque
N,M = map(int,input().split())
G = {i:[] for i in range(1,N+1)}
for _ in range(M):
a,b = map(int,input().split())
G[a].append(b)
G[b].append(a)
col = [-1 for _ in range(N+1)]
cnt = 0
for i in range(1,N+1):
if col[i]<0:
col[i]=cnt
que = deque([i])
while que:
x = que.popleft()
for y in G[x]:
if col[y]<0:
col[y] = cnt
que.append(y)
cnt += 1
C = {}
for i in range(1,N+1):
a = col[i]
if a not in C:
C[a] = 0
C[a] += 1
cmax = 0
for a in C:
cmax = max(cmax,C[a])
print(cmax)
|
S=input();
if(S=="hi" or S=="hihi" or S=="hihihi" or S=="hihihihi" or S=="hihihihihi"):
print("Yes");
else:
print("No");
| 0 | null | 28,746,101,630,818 | 84 | 199 |
def sample(n):
return n * n * n
n = input()
x = sample(n)
print x
|
#coding: UTF-8
input_number = int(input())
print input_number ** 3
| 1 | 286,195,176,300 | null | 35 | 35 |
n = int(input())
p = []
for i in range(n):
x,y = map(int,input().split())
p.append([x,y])
q = []
r = []
for i in range(n):
q.append(p[i][0]+p[i][1])
r.append(p[i][0]-p[i][1])
q.sort()
r.sort()
ans = max(abs(q[-1]-q[0]),abs(r[-1]-r[0]))
print(ans)
|
def f(input1):
if input1 >= 30:
return 'Yes'
return 'No'
if __name__ == "__main__":
input1 = int(input())
print(f(input1))
| 0 | null | 4,528,392,453,260 | 80 | 95 |
n,k = map(int,input().split())
res = n*500
if res >= k:
print("Yes")
else:
print("No")
|
N = 26
D = int(input())
c_list = list(map(int, input().split()))
s_table = []
for _ in range(D):
s_table.append(list(map(int, input().split())))
data = []
for _ in range(D):
data.append(int(input()) - 1)
def calc(data):
last = [-1] * N
satisfaction = 0
for i in range(D):
j = data[i]
satisfaction += s_table[i][j]
last[j] = i
for k in range(N):
satisfaction -= c_list[k] * (i - last[k])
print(satisfaction)
return satisfaction
calc(data)
| 0 | null | 54,024,647,160,700 | 244 | 114 |
from bisect import bisect_left, bisect_right
n,m = map(int, input().split())
al = list(map(int, input().split()))
al.sort()
ok, ng = 0, 10**18+1
while abs(ok-ng) > 1:
mid = (ok+ng)//2
ok_flag = True
cnt = 0
# print('-----')
# print(ok,ng,mid)
for i,a in enumerate(al):
rem = mid-a
cnt_a = n-bisect_left(al,rem)
# cnt_a = min(n-i-1, cnt_a)
cnt += cnt_a
# print(i,a,cnt_a)
if cnt >= m:
ok = mid
else:
ng = mid
min_sum = ok
cum_sums = [0]
csum = 0
for a in al:
csum += a
cum_sums.append(csum)
# print(min_sum)
ans = 0
cnt = 0
for i,a in enumerate(al):
rem = min_sum - a
ind = bisect_left(al, rem)
# ind = ind if 0 <= ind < n else None
# ind = max(i+1,ind)
csum = cum_sums[n] - cum_sums[ind]
# print(i,a,csum)
ans += csum
ans += a*(n-ind)
cnt += (n-ind)
ans -= (cnt-m)*min_sum
print(ans)
# print(min_sum)
|
a,b,c,d = map(int,input().split())
print('Yes' if (c+b-1)//b <= (a+d-1)//d else 'No')
| 0 | null | 68,866,295,360,996 | 252 | 164 |
N = int(input())
S = ["*"]*(N+1)
S[1:] = list(input())
Q = int(input())
q1,q2,q3 = [0]*Q,[0]*Q,[0]*Q
for i in range(Q):
tmp = input().split()
q1[i],q2[i] = map(int,tmp[:2])
if q1[i] == 2:
q3[i] = int(tmp[2])
else:
q3[i] = tmp[2]
class BIT:
def __init__(self, n, init_list):
self.num = n + 1
self.tree = [0] * self.num
for i, e in enumerate(init_list):
self.update(i, e)
#a_kにxを加算
def update(self, k, x):
k = k + 1
while k < self.num:
self.tree[k] += x
k += (k & (-k))
return
def query1(self, r):
ret = 0
while r > 0:
ret += self.tree[r]
r -= r & (-r)
return ret
#通常のスライスと同じ。lは含み、rは含まない
def query2(self, l, r):
return self.query1(r) - self.query1(l)
s_pos = [BIT(N+1,[0]*(N+1)) for _ in range(26)]
for i in range(1,N+1):
s_pos[ord(S[i]) - ord("a")].update(i,1)
alphabets = [chr(ord("a") + i) for i in range(26)]
for i in range(Q):
if q1[i] == 1:
s_pos[ord(S[q2[i]]) - ord("a")].update(q2[i],-1)
S[q2[i]] = q3[i]
s_pos[ord(q3[i]) - ord("a")].update(q2[i],1)
else:
ans = 0
for c in alphabets:
if s_pos[ord(c) - ord("a")].query2(q2[i],q3[i]+1) > 0:
ans += 1
print(ans)
|
import sys
input = sys.stdin.readline
N = int(input())
S = list(input().rstrip())
ord_a = ord("a")
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
bits = [Bit(N) for _ in range(26)]
for i in range(N):
s = S[i]
bits[ord(s) - ord_a].add(i + 1, 1)
Q = int(input())
for _ in range(Q):
query = input().rstrip().split()
if query[0] == "1":
i, c = int(query[1]), query[2]
bits[ord(S[i - 1]) - ord_a].add(i, -1)
S[i - 1] = c
bits[ord(S[i - 1]) - ord_a].add(i, 1)
else:
l, r = int(query[1]), int(query[2])
res = 0
for bit in bits:
if l != 1:
res += int(bit.sum(r) - bit.sum(l - 1) > 0)
else:
res += int(bit.sum(r) > 0)
print(res)
| 1 | 62,351,476,414,812 | null | 210 | 210 |
N = int(input())
S = [int(x) for x in input().split()]
T = int(input())
Q = [int(x) for x in input().split()]
c = 0
def seach(A, n, key):
i = 0
A = A + [key]
while A[i] != key:
i += 1
return i != n
for q in Q:
if seach(S, N, q):
c += 1
print(c)
|
import fractions
while True:
try:
(a, b) = map(int, raw_input().split())
c = fractions.gcd(a, b)
print c, ((a*b)/c)
except EOFError:
break
| 0 | null | 35,421,165,220 | 22 | 5 |
x, y = map(int,input().split())
ans = 0
for i in range(x+1):
for j in range(x+1):
if 2*i + 4 * j == y and i + j == x:
ans += 1
if ans > 0:
print('Yes')
else:
print('No')
|
from collections import deque
s = input()
q = int(input())
deq = deque([s])
flag = 1
for i in range(q):
query = input().split()
if query[0]==str(1):
flag*=-1
if query[0]==str(2):
x = 1 if query[1]==str(1) else -1
if flag*x==1:
deq.appendleft(query[2])
else:
deq.append(query[2])
if flag==-1:
print(''.join(deq)[::-1])
else:
print(''.join(deq))
| 0 | null | 35,506,568,483,008 | 127 | 204 |
import sys
from io import StringIO
import unittest
import os
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr.append([i, cnt])
if temp != 1:
arr.append([temp, 1])
if not arr:
arr.append([n, 1])
return arr
# 実装を行う関数
def resolve(test_def_name=""):
n = int(input())
target_s = factorization(n)
# 素因数1だけ処理対象外。
if sum([i[1] for i in target_s]) == 1:
if target_s[0][0] == 1:
print(0)
else:
print(1)
return
# 少ない物から使っていく。
cnt = 0
for i in range(1, 1000):
if not any([True if j[1] >= i else False for j in target_s]):
break
for target in target_s:
if target[1] < i:
continue
target[1] -= i
cnt += 1
print(cnt)
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """24"""
output = """3"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """1"""
output = """0"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """64"""
output = """3"""
self.assertIO(test_input, output)
def test_input_4(self):
test_input = """1000000007"""
output = """1"""
self.assertIO(test_input, output)
def test_input_5(self):
test_input = """997764507000"""
output = """7"""
self.assertIO(test_input, output)
def test_1original_1(self):
test_input = """108"""
output = """3"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
|
first_flag = True
while True:
H, W = map(int, input().split())
if H == 0 and W == 0: break
if not first_flag:
print()
first_flag = False
print(("#" * W + "\n") * H)
| 0 | null | 8,865,985,638,150 | 136 | 49 |
N = int(input())
M = []
for _ in range(N):
s, t = input().split()
M.append((s, int(t)))
X = input()
res = sum(map(lambda m: m[1], M))
for m in M:
res -= m[1]
if X == m[0]:
break
print(res)
|
n=int(input())
a=list()
for i in range(n):
s,t=input().split()
a.append([s,int(t)])
x=input()
flag=False
ans=0
for i in a:
if flag:
ans+=i[1]
if i[0]==x:
flag=True
print(ans)
| 1 | 97,102,466,626,948 | null | 243 | 243 |
def main():
a, b, k = map(int, input().split())
if a >= k:
remain_a = a - k
remain_b = b
else:
remain_a = 0
if k - a >= b:
remain_b = 0
else:
remain_b = b - (k - a)
print(remain_a, remain_b)
if __name__ == "__main__":
main()
|
from collections import deque
N = int(input())
# 有向グラフと見る、G[親] = [子1, 子2, ...]
G = [[] for _ in range(N + 1)]
# 子ノードを記録、これで辺の番号を管理
G_order = []
# a<bが保証されている、aを親、bを子とする
for i in range(N - 1):
a, b = map(lambda x: int(x) - 1, input().split())
G[a].append(b)
G_order.append(b)
# どこでも良いが、ここでは0をrootとする
que = deque([0])
# 各頂点と「親」を結ぶ辺の色
# 頂点0をrootとするのでC[0]=0で確定(「無色」), 他を調べる
colors = [0] * N
# BFS
while que:
# prt = 親
# 幅優先探索
prt = que.popleft()
color = 0
# cld = 子
for cld in G[prt]:
color += 1
# 「今考えている頂点とその親を結ぶ辺の色」と同じ色は使えないので次の色にする
if color == colors[prt]:
color += 1
colors[cld] = color
que.append(cld)
# それぞれの頂点とその親を結ぶ辺の色
# print(colors)
# 必要な最小の色数
print(max(colors))
# 辺の番号順に色を出力
for i in G_order:
print(colors[i])
| 0 | null | 120,272,856,642,490 | 249 | 272 |
import bisect
N = int(input())
L = sorted(map(int, input().split(' ')))
ans = 0
for i in range(len(L)):
for j in range(i + 1, len(L)):
a = L[i]
b = L[j]
ans += max(0, bisect.bisect_right(L, a + b - 1) - (j + 1))
print(ans)
|
import bisect
N = int(input())
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(N - 1, 1, -1):
for j in range(i - 1, 0, -1):
x = bisect.bisect(L, L[i] - L[j])
ans += max((j - x), 0)
print(ans)
| 1 | 171,929,384,878,720 | null | 294 | 294 |
nums = [int(i) for i in input().split()]
nums.sort()
print("{} {} {}".format(nums[0], nums[1], nums[2]))
|
num = input().split()
num.sort()
print(num[0], num[1], num[2])
| 1 | 418,600,709,452 | null | 40 | 40 |
n, x, m = map(int, input().split())
P = [] # value of pre & cycle
sum_p = 0 # sum of pre + cycle
X = [-1] * m # for cycle check
for i in range(n):
if X[x] > -1:
cyc_len = len(P) - X[x]
nxt_len = (n - X[x]) % cyc_len
pre = sum(P[:X[x]])
cyc = (sum_p - pre) * ((n - X[x]) // cyc_len)
nxt = sum(P[X[x]: X[x] + nxt_len])
print(pre + cyc + nxt)
exit()
X[x] = i
P.append(x)
sum_p += x
x = x*x % m
print(sum_p)
|
import math
N,X,M = map(int, input().split())
MAP = [-1]*(M+1)
TMAP = [0]*(M+1)
ans = 0
for i in range(N):
if (X%M!=0):
X = X%M
ans += X
if MAP[X]==-1:
MAP[X] = i
TMAP[X] = ans
else:
loopcnt = i-MAP[X]
loopsum = ans-TMAP[X]
ans += (((N-MAP[X])//loopcnt)-1)*loopsum
jmax = N-(MAP[X]+((N-MAP[X])//loopcnt)*loopcnt)
ans -= X
for j in range(jmax):
X = X%M
ans += X
X = X**2
X=M
X = X**2
else:
break
print(ans)
| 1 | 2,812,147,080,772 | null | 75 | 75 |
from itertools import permutations
import math
N = int(input())
l = [list(map(int, input().split())) for i in range(N)]
waru = 1
for i in range(N):
waru*= i+1
a = [i+1 for i in range(N)]
c = 0
su = 0
for i in permutations(a,N):
li = list(i)
for j in range(len(li)-1):
start = l[li[j]-1]
g = l[li[j+1]-1]
su += math.sqrt((start[0]-g[0]) ** 2 + (start[1]-g[1]) ** 2)
print(su/waru)
|
import itertools
N = int(input())
cities = [tuple(map(int, input().split())) for _ in range(N)]
distance = 0
for c in itertools.combinations(range(N), 2):
c1, c2 = c
distance += ((cities[c1][0] - cities[c2][0]) ** 2 + (cities[c1][1] - cities[c2][1]) ** 2) **0.5
answer = 2 * distance / N
print(answer)
| 1 | 148,843,926,280,182 | null | 280 | 280 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N = list(input())
K = int(input())
length = len(N)
dp = [[[0]*2 for _ in range(K+1)] for _ in range(length+1)]
dp[0][0][1] = 1
for i in range(length):
n = int(N[i])
for k in range(K+1):
if k==K:
dp[i+1][k][0]+=dp[i][k][0]
if n==0:
dp[i+1][k][1]+=dp[i][k][1]
else:
dp[i+1][k][0]+=dp[i][k][1]
continue
for j in range(10):
if j==0:
if n==0:
dp[i+1][k][0]+=dp[i][k][0]
dp[i+1][k][1]+=dp[i][k][1]
else:
dp[i+1][k][0]+=dp[i][k][0]+dp[i][k][1]
elif j==n:
dp[i+1][k+1][1]+=dp[i][k][1]
dp[i+1][k+1][0]+=dp[i][k][0]
elif j<n:
dp[i+1][k+1][0]+=dp[i][k][0]+dp[i][k][1]
else:
dp[i+1][k+1][0]+=dp[i][k][0]
print(sum(dp[-1][K]))
|
n,K=input(),int(input())
m=len(n)
DP=[[[0]*(K+2) for _ in range(2)] for _ in range(m+1)]
DP[0][0][0]=1
for i in range(1,m+1):
for flag in range(2):
num=9 if flag else int(n[i-1])
for j in range(K+1):
for k in range(num+1):
if k!=0:DP[i][flag or k<num][j+1] +=DP[i-1][flag][j]
else:DP[i][flag or k<num][j] +=DP[i-1][flag][j]
print(DP[m][0][K]+DP[m][1][K])
| 1 | 75,971,265,174,038 | null | 224 | 224 |
n,m=map(int,input().split())
print("Yes" if n<=m else "No")
|
A, B, C = map(int, input().split())
Z = A + B + C
if Z >= 22:
print("bust")
else:
print("win")
| 0 | null | 100,855,529,876,194 | 231 | 260 |
N = int(input())
A = input().split()
ans = 1
zero_count = A.count("0")
if zero_count != 0:
print(0)
else:
for i in range(N):
ans *= int(A[i])
if ans > 10**18:
ans = -1
break
print(ans)
|
N =int(input())
A = sorted(list(map(int,input().split())))
B = 1
C = 10 ** 18
for i in range(N):
B = B * A[i]
if B == 0:
break
elif B > C:
B = -1
break
print(B)
| 1 | 16,198,930,003,670 | null | 134 | 134 |
import numpy
n, m = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
sup_A = 10 ** 5
B = [0] * (1 << 18)
for a in A:
B[a] += 1
C = numpy.fft.fft(B)
D = numpy.fft.ifft(C * C)
ans = 0
cnt = 0
for i in range(2 * sup_A, -1, -1):
d = int(D[i].real + 0.5)
if cnt + d >= m:
ans += (m - cnt) * i
break
cnt += d
ans += i * d
print(ans)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Shell Sort
?¬????????????°?????????????????\?????????????????¨?????? n ????????´??°???????????°??? A ??????????????´?????????????????°????????§??????
1 insertionSort(A, n, g)
2 for i = g to n-1
3 v = A[i]
4 j = i - g
5 while j >= 0 && A[j] > v
6 A[j+g] = A[j]
7 j = j - g
8 cnt++
9 A[j+g] = v
10
11 shellSort(A, n)
12 cnt = 0
13 m = ?
14 G[] = {?, ?,..., ?}
15 for i = 0 to m-1
16 insertionSort(A, n, G[i])
shellSort(A, n) ????????????????????? g ????????¢??????????´??????????????±???¨???????????\???????????§??????
insertionSort(A, n, g) ?????????????????§??????????????? g ????????????????????°??????????????????
??????????????§??????????????¨?¨?????????????
???????????????????????? ? ??????????????????????????°???????????????????????????????????????
n ??¨??°??? A ???????????????????????§????????????????????????m??? m ????????´??° Gi(i=0,1,...,m???1)???
??\??? A????????????????????????????????????????????°????????????????????????????????????
???????????????????????\???????????¶????????????????????????????????????
1???m???100
0???Gi???n
cnt ????????? [n^1.5] ????¶??????????????????????
"""
import sys
def insertionSort(A, n, g):
""" ?????\????????? """
c = 0
for i in range(g, n):
v = A[i]
j = i - g
while j >=0 and A[j] > v:
A[j+g] = A[j]
j = j - g
c += 1
A[j+g] = v
return c
def shellSort(A, n):
cnt = 0
G = []
i = 1
while i <= n:
G.insert(0,i)
i = i * 3 + 1
m = len(G)
for i in range(0, m):
cnt += insertionSort(A, n, G[i])
# ??????
print(m)
print(" ".join(map(str,G)))
print(cnt)
for i in A:
print(i)
# ?????????
n = int(input().strip())
a = []
for i in range(n):
a.append(int(input().strip()))
shellSort(a,n)
| 0 | null | 54,317,654,193,550 | 252 | 17 |
import itertools
#再帰関数のときのRE予防
import sys
sys.setrecursionlimit(312467)
N = int(input())
List = []
def dfs(S):
List.append(S)
if len(S) < N:
for i in range(ord("a"), ord(max(S))+2):
dfs(S+[chr(i)])
return
dfs(["a"])
for i in List:
if len(i) == N:
print("".join(i))
elif len(i) > N:
break
|
n = int(input())
def dfs(i,s):
if i == n:
print(s)
return
ma = 0
for j in s:
ma = max(ma,ord(j))
for j in range(ma - 95):
dfs(i+1,s+chr(97+j))
return
dfs(1,"a")
| 1 | 52,285,287,140,580 | null | 198 | 198 |
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, K, A, F):
A.sort()
F.sort(reverse=True)
def f(x):
sy = 0
for a, f in zip(A, F):
m = a * f
if m > x:
sy += (m - x + f - 1) // f
return sy
under = -1
hi = 10**12 + 1
while hi - under > 1:
m = (hi + under) // 2
if f(m) <= K: hi = m
else: under = m
print(hi)
if __name__ == '__main__':
input = sys.stdin.readline
N, K = map(int, input().split())
*A, = map(int, input().split())
*F, = map(int, input().split())
main(N, K, A, F)
|
#!/usr/bin/env python3
import sys
input=sys.stdin.readline
mod=998244353
n,k=map(int,input().split())
arr=[list(map(int,input().split())) for i in range(k)]
dp=[0]*(n+1)
dp[1]=1
acum=[0]*(n+1)
for i in range(k):
l,r=arr[i]
if 1+l<=n:
acum[1+l]+=1
if 1+r+1<=n:
acum[1+r+1]-=1
for i in range(2,n+1):
acum[i]+=acum[i-1]
acum[i]%=mod
dp[i]=acum[i]
for j in range(k):
l,r=arr[j]
if i+l<=n:
acum[i+l]+=dp[i]
if i+r+1<=n:
acum[i+r+1]-=dp[i]
print(dp[n]%mod)
| 0 | null | 83,607,777,499,660 | 290 | 74 |
class dise:
def __init__(self, label):
self.label1 = label[0]
self.label2 = label[1]
self.label3 = label[2]
self.label4 = label[3]
self.label5 = label[4]
self.label6 = label[5]
def N_rotation(self):
reg = self.label1
self.label1 = self.label2
self.label2 = self.label6
self.label6 = self.label5
self.label5 = reg
def E_rotation(self):
reg = self.label1
self.label1 = self.label4
self.label4 = self.label6
self.label6 = self.label3
self.label3 = reg
def S_rotation(self):
reg = self.label1
self.label1 = self.label5
self.label5 = self.label6
self.label6 = self.label2
self.label2 = reg
def W_rotation(self):
reg = self.label1
self.label1 = self.label3
self.label3 = self.label6
self.label6 = self.label4
self.label4 = reg
dise1 = dise(input().split())
order = list(input())
for i in order:
if i == 'N':
dise1.N_rotation()
elif i == 'E':
dise1.E_rotation()
elif i == 'S':
dise1.S_rotation()
elif i == 'W':
dise1.W_rotation()
print(dise1.label1)
|
class Dice:
D = {'E':(3,1,0,5,4,2), 'W':(2,1,5,0,4,3), 'S':(4,0,2,3,5,1), 'N':(1,5,2,3,0,4)}
def __init__(self, tp, fwd, rs, ls, bk, bm):
self.nbrs = [tp, fwd, rs, ls, bk, bm]
def rll(self, drctn):
return [self.nbrs[i] for i in self.D[drctn]]
A = input().split()
for i in input():
dice = Dice(A[0], A[1], A[2], A[3], A[4], A[5])
A = dice.rll(i)
print(A[0])
| 1 | 238,411,043,340 | null | 33 | 33 |
N = int(input())
A = list(map(int,input().split()))
if 0 in A:
prod = 0
else:
prod = 1
for i in range(N):
prod *= A[i]
if prod>10**18:
prod = -1
break
print(prod)
|
n = int(input())
plus,minus = [],[]
for i in range(n):
a,b = map(int,input().split())
plus.append(a+b)
minus.append(a-b)
plus.sort()
minus.sort()
print(max(plus[-1]-plus[0],minus[-1]-minus[0]))
| 0 | null | 9,777,816,022,240 | 134 | 80 |
k=int(input())
s=list(input())
num_list=[]
if k<len(s):
for x in range(k):
num_list+=s[x]
x+=1
t=''.join(num_list)+'...'
else:
t=''.join(s)
print(t)
|
# B - ... (Triple Dots)
# K
K = int(input())
# S
S = input()
if K >= len(S):
answer = S
else:
answer = S[0:K] + '...'
print(answer)
| 1 | 19,723,282,940,900 | null | 143 | 143 |
N = int(input())
S,T = map(str,input().split())
slist = list(S)
tlist = list(T)
new = ''
for i in range(N):
new += slist[i]
new += tlist[i]
print(new)
|
N=input()
S,T=input().split()
print(*[s+t for s,t in zip(S,T)],sep="")
| 1 | 112,205,829,576,788 | null | 255 | 255 |
from itertools import accumulate
from bisect import bisect_left
n, m = map(int, input().split())
a = sorted(map(int, input().split()))
cs = [0] + list(accumulate(a))
c = 0
s = 0
def f(x):
global c, s
c = 0
s = 0
for i in range(n):
left = bisect_left(a, x - a[i])
c += n - left
s += cs[n] - cs[left] + (n - left) * a[i]
return c
ok = 0
ng = 2 * 10 ** 5 + 1
while abs(ok - ng) > 1:
x = (ok + ng) // 2
if f(x) >= m:
ok = x
else:
ng = x
print(s - (c - m) * ok)
|
n, m = map(int, input().split())
print(int(n*m) if (n<=9 and m<=9) else -1)
| 0 | null | 133,213,378,479,852 | 252 | 286 |
from sys import stdin
r, c = [int(x) for x in stdin.readline().rstrip().split()]
table = [[int(x) for x in stdin.readline().rstrip().split()] for _ in range(r)]
for row in range(r):
table[row] += [sum(table[row])]
print(*table[row])
col_sum = [sum(x) for x in zip(*table)]
print(*col_sum)
|
n,m=map(int,input().split())
s=input()[::-1]
i=0
ans=[]
while i<n:
for j in range(min(n-i,m),0,-1):
if s[i+j]=="0":
ans.append(j)
i+=j
break
if j==1:print(-1);exit()
print(*ans[::-1])
| 0 | null | 70,430,079,208,720 | 59 | 274 |
from math import sqrt, ceil
def divisors(n):
out = []
nn = ceil(sqrt(n))
for i in range(1, nn):
if n % i == 0:
out.append(i)
out.append(n//i)
if nn ** 2 == n:
out.append(nn)
out.sort()
return out
n = int(input())
a = len(divisors(n-1)[1:])
d = divisors(n)
for dd in d[1:]:
nn = n
while nn % dd == 0:
nn = nn // dd
if nn % dd == 1:
a += 1
print(a)
|
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
n = ni()
ans = len(make_divisors(n-1))-1
ls = make_divisors(n)[1:]
for i in ls:
nn = n
while nn%i == 0:
nn = nn//i
if nn%i == 1:
ans += 1
print(ans)
| 1 | 41,397,117,790,550 | null | 183 | 183 |
# author: Taichicchi
# created: 20.09.2020 11:13:28
import sys
from math import factorial
from scipy.special import comb
MOD = 10 ** 9 + 7
S = int(input())
m = S // 3
cnt = 0
for n in range(1, m + 1):
cnt += int(comb(S - 3 * n + 1, n - 1, exact=True, repetition=True)) % MOD
cnt %= MOD
print(cnt)
|
input()
array = input().split()
array.reverse()
print(' '.join(array))
| 0 | null | 2,146,239,675,040 | 79 | 53 |
A = map(int, input().split())
if sum(A) > 21:
print('bust')
else:
print('win')
|
a1, a2, a3 = map(int, input().split())
x = a1 + a2 + a3
print('win' if x <= 21 else 'bust')
| 1 | 118,291,578,150,592 | null | 260 | 260 |
from collections import defaultdict
H, W, M = map(int, input().split())
row_bom_cnt = defaultdict(int)
col_bom_cnt = defaultdict(int)
row_max = 0
col_max = 0
boms = [list(map(int, input().split())) for _ in range(M)]
for rm, cm in boms:
row_bom_cnt[rm] += 1
col_bom_cnt[cm] += 1
row_max = max(row_max, row_bom_cnt[rm])
col_max = max(col_max, col_bom_cnt[cm])
target_row = set()
for r, val in row_bom_cnt.items():
if val == row_max:
target_row.add(r)
target_col = set()
for c, val in col_bom_cnt.items():
if val == col_max:
target_col.add(c)
cnt = 0
for rm, cm in boms:
if rm in target_row and cm in target_col:
cnt += 1
if len(target_row) * len(target_col) == cnt:
print(row_max + col_max - 1)
else:
print(row_max + col_max)
|
import heapq
INFTY = 10**4
N,X,Y = map(int,input().split())
G = {i:[] for i in range(1,N+1)}
for i in range(1,N):
G[i].append(i+1)
G[i+1].append(i)
G[X].append(Y)
G[Y].append(X)
dist = [[INFTY for _ in range(N+1)] for _ in range(N+1)]
for i in range(N+1):
dist[i][i] = 0
for i in range(1,N+1):
hist = [0 for _ in range(N+1)]
heap = [(0,i)]
hist[i] = 1
while heap:
d,x = heapq.heappop(heap)
if d>dist[i][x]:continue
hist[x] = 1
for y in G[x]:
if hist[y]==0:
if dist[i][y]>d+1:
dist[i][y] = d+1
heapq.heappush(heap,(d+1,y))
C = {k:0 for k in range(1,N)}
for i in range(1,N):
for j in range(i+1,N+1):
C[dist[i][j]] += 1
for k in range(1,N):
print(C[k])
| 0 | null | 24,300,599,814,820 | 89 | 187 |
n,m,l=map(int,input().split())
#print("n:%d, m:%d, l:%d"%(n, m, l))
nmlist=[]
for i in range(n):
nm=list(map(int,input().split()))
nmlist.append(nm)
#print(nmlist)
mllist=[]
for j in range(m):
ml=list(map(int,input().split()))
mllist.append(ml)
#print(mllist)
result = []
for i in range(n):
for j in range(l):
sum = 0
for k in range(m):
sum = sum + nmlist[i][k]*mllist[k][j]
result.append(sum)
#print(result)
for o in range(1,len(result)+1):
if o%l==0:
print(result[o-1])
else:
print(result[o-1],end=' ')
|
n = int(input())
if (n%2 == 1):
n = n + 1
print(int(n/2))
| 0 | null | 30,442,859,808,640 | 60 | 206 |
import math
A, B = [i for i in input().split()]
A = int(A)
tmp = B.split('.')
B = 100 * int(tmp[0]) + int(tmp[1])
print((A*B)//100)
|
from math import floor
A= input().split()
p = int(A[0])
q = round(float(A[1])*100)
t = p*q
t //= 100
print(t)
| 1 | 16,477,581,474,940 | null | 135 | 135 |
from fractions import gcd
n, m = map(int, input().split())
print(n * m // gcd(n, m))
|
n,m=map(int,input().split(" "))
l=max(n,m)
s=min(n,m)
while s!=0:
tmp = s
s = l % s
l = tmp
print(n*m // l)
| 1 | 113,862,220,140,158 | null | 256 | 256 |
import numpy as np
n = int(input())
a = list(map(int,input().split()))
a = np.array(a, dtype='int64')
MOD = 10**9+7
ans = 0
for i in range(60):
ca = a >> i & 1
c1 = int(ca.sum())
c0 = n - c1
c0c1 = (c0 * c1) % MOD
c0c1pow = (c0c1 * 2**i) % MOD
ans = (ans + c0c1pow) % MOD
print(ans)
|
import math
def main():
mod = 1000000007
N = int(input())
A = list(map(int, input().split()))
A_max = sorted(A)[-1]
if A_max == 0:
print(0)
exit()
bit_max = int(math.ceil(math.log2(A_max)))
i = 0
bit = 1
res = 0
while i <= bit_max:
c_zero = 0
c_one = 0
for j in range(N):
if A[j] & bit == 0:
c_zero += 1
else:
c_one += 1
m_bit = bit % mod
res += m_bit*c_zero*c_one
res %= mod
i += 1
bit<<=1
print(res)
if __name__ == "__main__":
main()
| 1 | 122,933,104,107,930 | null | 263 | 263 |
from collections import defaultdict
def main():
n = int(input())
a = list(map(int, input().split()))
d = defaultdict(lambda : 0)
ans = 0
for i, ai in enumerate(a, 1):
num = str(ai+i)
d[num] += 1
ans += d[str(i-ai)]
print(ans)
if __name__ == "__main__":
main()
|
n = int(input())
import math
a = n*100/108
b = (n*100+100)/108
ans = math.ceil(a) if math.ceil(a) < b else ":("
print(ans)
| 0 | null | 76,136,100,883,948 | 157 | 265 |
a, b = map(int, input().split())
def gcd(a, b):
big = max(a, b)
small = min(a, b)
while not big % small == 0:
big, small = small, big%small
return small
print(gcd(a, b))
|
n = input().split()
x = int(n[0])
y = int(n[1])
if x < y:
bf = x
x = y
y = bf
while y > 0:
r = x % y
x = y
y = r
print(str(x))
| 1 | 8,362,910,430 | null | 11 | 11 |
n = int(input())
if n%2 == 0:
t=(n//2)/n
else:
t=(n//2+1)/n
print('{:.10f}'.format(t))
|
import sys
input = sys.stdin.readline
class WarshallFloyd:
def __init__(self,n):
self.v = n
self.d = [[1e100]*n for _ in range(n)]
for i in range(n):
self.d[i][i] = 0
def path(self,x,y,c):
if x == y:
return False
self.d[x][y] = c
self.d[y][x] = c
return True
def build(self):
for k in range(self.v):
for i in range(self.v):
for j in range(self.v):
self.d[i][j] = min(self.d[i][j], self.d[i][k] + self.d[k][j])
n,m,l = map(int,input().split())
wf = WarshallFloyd(n)
for i in range(m):
a,b,c = map(int,input().split())
wf.path(a-1,b-1,c)
wf.build()
d = [[1e100]*n for _ in range(n)]
for i in range(n):
for j in range(n):
if i == j:
d[i][j] = 0
elif wf.d[i][j] <= l:
d[i][j] = 1
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
q = int(input())
for i in range(q):
s,t = map(int,input().split())
ans = d[s-1][t-1]
if ans == 1e100:
print(-1)
else:
print(ans - 1)
| 0 | null | 175,397,705,046,810 | 297 | 295 |
from sys import stdin
import sys, math
n = int(stdin.readline().rstrip())
s = set()
for i in range(n):
s.add(stdin.readline().rstrip())
print(len(s))
|
n,x,y=map(int,input().split())
l=[]
for i in range(n-1):
for j in range(i+1,n):
d1=j-i
d2=abs((x-1)-i)+abs(j-(y-1))+1
d=min(d1,d2)
l.append(d)
import collections
c=collections.Counter(l)
for kk in range(1,n):
print(c[kk])
| 0 | null | 37,125,066,515,580 | 165 | 187 |
x, y = input().split()
x = int(x)
y = int(y)
if y % 2 == 0 and 2 * x <= y <= 4 * x:
print('Yes')
else:
print('No')
|
x, y = map(int,input().split())
ans = 0
for i in range(x+1):
for j in range(x+1):
if 2*i + 4 * j == y and i + j == x:
ans += 1
if ans > 0:
print('Yes')
else:
print('No')
| 1 | 13,728,898,569,540 | null | 127 | 127 |
print(*sorted([int(input()) for _ in [0]*10])[:6:-1], sep="\n")
|
lis = [ ]
for i in range ( 10 ):
lis.append ( int ( input ( ) ) )
lis.sort ( )
for i in range ( 3 ):
print ( lis.pop ( ) )
| 1 | 17,773,090 | null | 2 | 2 |
import sys
sys.setrecursionlimit(10**8)
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 li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
N, M = mi()
C = li()
'''
# 二次元DP
dp = dp2(float('inf'), N+1, M+1)
dp[0][0] = 0
for i in range(1, M+1):
for j in range(N+1):
#if j == 0:
#dp[i][j] = 0
dp[i][j] = min(dp[i-1][j], dp[i][j])
c = C[i-1]
if j+c <= N:
dp[i][j+c] = min(dp[i][j]+1, dp[i-1][j+c])
#print(dp)
print(dp[M][N])
'''
# 1次元DP
dp = [float('inf') for i in range(N+1)]
dp[0] = 0
for i in range(M):
for j in range(N+1):
c = C[i]
if j+c <= N:
dp[j+c] = min(dp[j]+1, dp[j+c])
print(dp[N])
|
n, m = map(int, input().split())
coins = list(map(int, input().split()))
memo = [0] + [10**7] * n
for coin in coins:
for i in range(coin, n+1):
memo[i] = min(memo[i], memo[i-coin]+1)
print(memo[-1])
| 1 | 139,475,138,208 | null | 28 | 28 |
import sys
n = int(input())
for a in range(-200, 201):
for b in range(-200, 201):
if a * a * a * a * a - b * b * b * b * b == n:
print(a, b)
sys.exit(0)
|
X=int(input())
def check():
for a in range(-200,200):
for b in range(-200,200):
if a**5-b**5==X:
print(a,b)
return 0
check()
| 1 | 25,663,714,487,446 | null | 156 | 156 |
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if v<w:
print("NO")
elif v==w:
if a==b:
print("YES")
else:
print("NO")
elif v>w:
t0 = abs((a-b)/(v-w))
if t0<=t:
print("YES")
else:
print("NO")
|
S = input()
S1 = S[:len(S) // 2]
S2 = S[-1:(len(S)-1) // 2:-1]
ans = 0
for s1, s2 in zip(S1, S2):
ans += s1!=s2
print(ans)
| 0 | null | 67,772,927,489,778 | 131 | 261 |
import math
def fact(n):
ans = 1
for i in range(2, n+1):
ans*= i
return ans
def comb(n, c):
return fact(n)//(fact(n-c)*c)
n = int(input())
nums = list(map(int, input().split()))
ans = 0
l = {}
r = []
for i in range(1,n+1):
if(i + nums[i-1] not in l):
l[i+nums[i-1]] =0
l[i+nums[i-1]]+=1
if((-1*nums[i-1])+i in l):
ans+=l[(-1*nums[i-1])+i]
print(ans)
|
import collections
h, w, m = map(int, input().split())
h = [None]*m
w = [None]*m
for i in range(m):
u, v = map(int, input().split())
h[i] = u
w[i] = v
hc = collections.Counter(h)
wc = collections.Counter(w)
hm = hc.most_common()[0][1]
hs = set([])
for hi, ci in hc.most_common():
if ci == hm:
hs.add(hi)
else:
break
wm = wc.most_common()[0][1]
ws = set([])
for wi, ci in wc.most_common():
if ci == wm:
ws.add(wi)
else:
break
cnt = 0
for i in range(m):
if h[i] in hs and w[i] in ws:
cnt += 1
if cnt == len(hs)*len(ws):
print(hm + wm -1)
else:
print(hm + wm)
| 0 | null | 15,552,854,222,464 | 157 | 89 |
from collections import namedtuple
Line = namedtuple('Line', ['lowest', 'end'])
def main():
N = int(input())
up_lines = []
down_lines = []
for i in range(N):
s = input()
now = 0
lowest = 0
for c in s:
if c == "(":
now += 1
else:
now -= 1
lowest = min(lowest, now)
if now > 0:
up_lines.append(Line(lowest, now))
else:
down_lines.append(Line(lowest-now, -now))
up_lines.sort(key=lambda line: -line.lowest)
down_lines.sort(key=lambda line: -line.lowest)
left = 0
for line in up_lines:
if left + line.lowest < 0:
print("No")
return
left += line.end
if left < 0:
print("No")
break
right = 0
for line in down_lines:
if right + line.lowest < 0:
print("No")
return
right += line.end
if right < 0:
print("No")
break
if left == right:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
|
from collections import defaultdict
import math
def P(n, r):
return math.factorial(n)//math.factorial(n-r)
def C(n, r):
return P(n, r)//math.factorial(r)
S = input()[::-1]
N = len(S)
cnt = [0]*N
tmp = 0
d = defaultdict(int)
d[0] += 1
for i in range(N):
tmp += int(S[i])*pow(10,i,2019)
tmp %= 2019
d[tmp] += 1
ans = 0
for v in d.values():
if v >= 2:
ans += C(v,2)
print(ans)
| 0 | null | 27,333,815,910,742 | 152 | 166 |
r, c = map(int, input().split())
args = []
for i in range(r):
args.append(list(map(int, input().split())))
r_sum = 0
for j in args[i]:
r_sum += j
args[i].append(r_sum)
l_row = []
for k in range(c + 1):
c_sum = 0
for l in range(r):
c_sum += args[l][k]
l_row.append(c_sum)
for m in range(r):
print(' '.join(map(str, args[m])))
print(' '.join(map(str, l_row)))
|
import sys
from operator import add
(r, c) = [int(i) for i in sys.stdin.readline().split()]
s = [0] * (c + 1)
for i in range(r):
l = [int(i) for i in sys.stdin.readline().split()]
l.append(sum(l))
print(" ".join([str(i) for i in l]))
s = map(add, s, l)
print(" ".join([str(i) for i in s]))
| 1 | 1,346,515,762,398 | null | 59 | 59 |
def main():
N,K = map(int, input().split())
R,S,P = map(int, input().split())
T = list(input())
score=0
for i in range(N):
if T[i] == 'r':
score+=P
if i+K<N and T[i+K]=='r':
T[i+K]='x'
if T[i]=='s':
score+=R
if i+K<N and T[i+K]=='s':
T[i+K]='x'
if T[i]=='p':
score+=S
if i+K<N and T[i+K]=='p':
T[i+K]='x'
print(score)
if __name__ == '__main__':
main()
|
def main():
n = int(input())
A = []
for _ in range(n):
x, l = map(int, input().split())
A.append([x - l, x + l])
A.sort(key = lambda x: x[1])
ans, lmax = 0, -10 ** 11
for a in A:
if lmax <= a[0]:
ans += 1
lmax = a[1]
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 98,473,111,418,500 | 251 | 237 |
s,t,a,b,u=open(0).read().split()
if s==u:
print(int(a)-1,b)
elif t==u:
print(a,int(b)-1)
|
n = int(input())
print(" " + " ".join([str(i) for i in range(1, n+1) if i % 3 == 0 or '3' in str(i)]))
| 0 | null | 36,427,885,451,858 | 220 | 52 |
n = int(input())
if n % 2 == 0:
ans = n / 2 - 1
else:
ans = n / 2
print(int(ans))
|
# -*- coding: utf-8 -*-
def main():
from math import ceil
n = int(input())
count = 0
for i in range(1, ceil(n / 2)):
j = n - i
if i != j:
count += 1
print(count)
if __name__ == '__main__':
main()
| 1 | 153,910,918,176,310 | null | 283 | 283 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.