code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
N=int(input())
#people
li = list(map(int, input().split()))
Ave1=sum(li)//N
Ave2=sum(li)//N+1
S1=0
S2=0
for i in range(N):
S1=S1+(Ave1-li[i])**2
for i in range(N):
S2=S2+(Ave2-li[i])**2
if S1>S2:
print(S2)
else:
print(S1)
|
import bisect, copy, heapq, math, sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
def celi(a,b):
return -(-a//b)
sys.setrecursionlimit(5000000)
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=int(input())
x=list(map(int,input().split()))
ans=float('inf')
for i in range(100):
tmp=0
for j in range(n):
tmp+=(x[j]-i-1)**2
ans=min(ans,tmp)
print(ans)
| 1 | 65,437,821,969,376 | null | 213 | 213 |
#!/usr/bin/python
ar = []
while True:
tmp = [int(i) for i in input().split()]
if tmp == [0,0]:
break
else:
ar.append(tmp)
for i in range(len(ar)):
for j in range(ar[i][0]):
for k in range(ar[i][1]):
if j == 0 or j == ar[i][0] - 1 or k == 0 or k == ar[i][1] - 1:
print('#' , end='' if k !=ar[i][1]-1 else '\n' if j != ar[i][0]-1 else '\n\n')
else:
print('.' , end='' if k !=ar[i][1]-1 else '\n' if j != ar[i][0]-1 else '\n\n')
|
#n = int(input())
from collections import deque
n, m = map(int, input().split())
# n=200000
# m=200000
#al = list(map(int, input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
adjl = [[] for _ in range(n+1)]
NIL = -1
appear = {}
isalone = {}
for i in range(m):
a, b = map(int, input().split())
if appear.get((a, b), False) or appear.get((a, b), False):
continue
appear[(a, b)] = True
appear[(b, a)] = True
isalone[a] = False
isalone[b] = False
adjl[a].append(b)
adjl[b].append(a)
NIL = -1 # 未発見を示す値
d = [-1 for i in range(n+1)] # 頂点1からの距離を格納するリスト
color = [NIL for i in range(n+1)] # 未到達かを示すリスト
def bfs(start_node, color_id): # uは探索の開始点
global color, d
q = deque([start_node])
d[start_node] = 0
color[start_node] = color_id
while len(q) != 0:
u = q.popleft()
for v in adjl[u]:
if color[v] == NIL:
d[v] = d[u]+1
color[v] = color_id
q.append(v)
color_id = 0
for u in range(1, n+1):
if color[u] == NIL:
color_id += 1
bfs(u, color_id)
group = {}
for i in range(1, n+1):
if isalone.get(i, True):
continue
group[color[i]] = group.get(color[i], 0)+1
mx = 1
for k, v in group.items():
mx = max(mx, v)
print(mx)
| 0 | null | 2,357,436,147,200 | 50 | 84 |
N=int(input())
A=list()
B=list()
for i in range(N):
a,b=map(int,input().split())
A.append(a)
B.append(b)
A.sort()
B.sort()
if N%2==1:
print(B[int((N-1)/2+0.5)]-A[int((N-1)/2+0.5)]+1)
else:
print((B[int(N/2+0.5)-1]+B[int(N/2+0.5)])-(A[int(N/2+0.5)-1]+A[int(N/2+0.5)])+1)
|
M = 1046527
POW = [pow(4, i) for i in range(13)]
def insert(dic, string):
# i = 0
# while dic[(hash1(string) + i*hash2(string)) % M]:
# i += 1
# dic[(hash1(string) + i*hash2(string)) % M] = string
dic[get_key(string)] = string
def find(dic, string):
# i = 0
# while dic[(hash1(string) + i*hash2(string)) % M] and dic[(hash1(string) + i*hash2(string)) % M] != string:
# i += 1
# return True if dic[(hash1(string) + i*hash2(string)) % M] == string else False
# print(dic[get_key(string)], string)
return True if dic[get_key(string)] == string else False
def get_num(char):
if char == "A":
return 1
elif char == "C":
return 2
elif char == "G":
return 3
else:
return 4
def get_key(string):
num = 0
for i in range(len(string)):
num += POW[i] * get_num(string[i])
return num
def main():
n = int(input())
dic = [None] * POW[12]
# print(dic)
for i in range(n):
order, string = input().split()
if order == "insert":
insert(dic, string)
else:
if find(dic, string):
print('yes')
else:
print('no')
if __name__ == "__main__":
main()
| 0 | null | 8,729,515,082,796 | 137 | 23 |
while(1):
m,f,r=map(int,input().split())
if m==-1 and f==-1 and r==-1:
break
elif m==-1 or f==-1:
print("F")
elif m+f>=80:
print("A")
elif m+f>=65 and m+f<80:
print("B")
elif m+f>=50 and m+f<65:
print("C")
elif m+f>=30 and m+f<50 and r>=50:
print("C")
elif m+f>=30 and m+f<50:
print("D")
elif m+f<30:
print("F")
|
m,f,r = 0,0,0
table = []
i = 0
while m != -1 or f != -1 or r != -1:
m,f,r = (int(x) for x in input().split())
table.append([m,f,r])
for p in table:
m,f,r = p[0],p[1],p[2]
if m == -1 and f == -1 and r == -1:
break
if m == -1 or f == -1:
print('F')
elif m + f >= 80:
print('A')
elif m + f >= 65:
print('B')
elif m + f >= 50:
print('C')
elif m + f >= 30:
if r >= 50:
print('C')
else:
print('D')
else:
print('F')
| 1 | 1,218,754,160,892 | null | 57 | 57 |
n, d, a = map(int, input().split())
xh = []
for _ in range(n):
x, h = map(int, input().split())
xh.append((x, h))
xh.sort(key=lambda x:x[0])
def bisect(x):
ok = n
ng = -1
while abs(ok-ng)>1:
mid = (ok+ng)//2
if xh[mid][0]>x:
ok = mid
else:
ng = mid
return ok
out = [0]*(n+1)
ans = 0
accu = 0
for ind, (x, h) in enumerate(xh):
accu -= out[ind]
h -= accu
if h<=0:
continue
ans += (h+a-1)//a
accu += ((h+a-1)//a)*a
out[bisect(x+2*d)] += ((h+a-1)//a)*a
print(ans)
|
A, B = map(int, input().split())
ans = -1
for i in range(10000):
if int((i/100)*8) == A and int((i/100)*10) == B:
ans = i
break
print(ans)
| 0 | null | 69,132,285,020,020 | 230 | 203 |
N = int(input()) #入力する整数
A = list(map(int,input().split())) #入力する数列A
SUMA = sum(A) #数列の和
MOD = 10**9 + 7 # mod
C = [0] * (N-1) #累積和数列
for i in range(N-1): #\sum_{j = i+1}^{N}を求めて数列に代入する
SUMA -= A[i]
C[i] = SUMA
ans = 0 #求める答え
for i in range(N-1):
ans += A[i]*C[i]
ans %= MOD #その都度modで割った余りにする
print(ans) #答えを出力する
|
n = int(input())
num_list = input().split()
mod_value = 10**9 + 7
sum_all = 0
sum_int = 0
for index in range(len(num_list) - 1):
sum_int += int(num_list[index])
sum_all += sum_int * int(num_list[index + 1])
if sum_all > mod_value:
sum_all %= mod_value
print(sum_all)
| 1 | 3,871,222,038,050 | null | 83 | 83 |
import sys
(a, b ,c) = [int(i) for i in input().split(' ')]
x = a
cnt = 0
while x <= b:
if (c % x == 0) : cnt+=1
x += 1
else:
print(cnt)
|
N = int(input())
p = [list(map(int,input().split())) for _ in range(N)]
z = []
w = []
for i in range(N):
z.append(p[i][0] + p[i][1])
w.append(p[i][0] - p[i][1])
print(max(max(z)-min(z),max(w)-min(w)))
| 0 | null | 2,018,032,741,908 | 44 | 80 |
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mat = lambda x, y, v: [[v]*y for _ in range(x)]
ten = lambda x, y, z, v: [mat(y, z, v) for _ in range(x)]
mod = 1000000007
sys.setrecursionlimit(1000000)
N, X, M = rl()
Xs = [None] * M
ans = 0
dif_i = 0
dif_v = 0
cur_i = 0
for i in range(1, N+1):
ans += X
if Xs[X] != None:
cur_i = i
dif_v = ans - Xs[X][1]
dif_i = i - Xs[X][0]
cur_x = X
break
Xs[X] = (i, ans)
X = (X**2) % M
if cur_i > 0 and cur_i < N:
remain = N - cur_i
ans += (remain // dif_i) * dif_v
X = cur_x
for i in range(remain % dif_i):
X = (X**2) % M
ans += X
print(ans)
|
from copy import deepcopy
n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
mod = 10 ** 9 + 7
ans = 1
i, j = 0, n - 1
k2 = deepcopy(k)
while k2 > 1:
if a[i] * a[i + 1] > a[j] * a[j - 1]:
ans *= a[i] * a[i + 1]
ans %= mod
i += 2
k2 -= 2
else:
ans *= a[j]
j -= 1
ans %= mod
k2 -= 1
if k2 == 1:
ans *= a[j]
ans %= mod
if a[-1] < 0 and k % 2:
ans = 1
for i in range(n - k, n):
ans *= a[i]
ans %= mod
print(ans)
| 0 | null | 6,141,575,182,260 | 75 | 112 |
mod = 10 ** 9 + 7
n, k = map(int, input().split())
binomial = [1]
cum = 1
for i in range(1, n + 2):
cum *= i
cum = cum % mod
binomial.append(cum)
inv = []
tmp = pow(cum, mod - 2, mod)
inv.append(tmp)
for j in range(n + 1, 0, -1):
tmp = j * tmp % mod
inv.append(tmp)
inv.reverse()
def comb(n, k):
return binomial[n] * inv[n - k] % mod * inv[k] % mod if n >= k else 0
k = min(k, n - 1)
ans = 0
for m in range(k + 1):
tmp = comb(n, m) * binomial[n - 1] * inv[n - 1 - m] * inv[m]
ans += tmp % mod
ans %= mod
print(ans)
|
# -*- coding: utf-8 -*-
import sys
index = int(input())
array = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print(int(array[index-1]))
| 0 | null | 58,775,153,765,038 | 215 | 195 |
n,a,b = map(int,input().split())
num1 = n%(a+b)
num2 = n//(a+b)
print(num2*a+min(num1,a))
|
N,A,B = map(int, input().split())
C = A + B
print(min(A, N%C) + N//C * A)
| 1 | 55,757,531,590,528 | null | 202 | 202 |
A, B, C, D = map(int, input().split())
while True:
C -= B
if C < 1:
print('Yes')
quit()
A -= D
if A < 1:
print('No')
quit()
|
card = []
suit = ["S","H","C","D"]
for s in suit:
for i in range(1,14):
card.append(s + " " + str(i))
n = int(input())
for i in range(n):
card.remove(input())
for c in card:
print(c)
| 0 | null | 15,390,812,583,700 | 164 | 54 |
# ABC155E
s = input()
d0 = [0,1,2,3,4,5,6,7,8,9]
d1 = [0,1,2,3,4,5,5,4,3,2] # 通常時
a0 = d1[int(s[0])]
a1 = d1[int(s[0]) + 1] if int(s[0])<=8 else 1
for c in s[1:]:
c = int(c)
b0 = min(a0 + c, a1 + (10 - c))
b1 = min(a0 + c + 1, a1 + (9 - c)) if c <=8 else a1
a0, a1 = b0, b1
print(a0)
|
p, q = 0, 1
for x in map(int, input()):
p, q = min(p + x, q + 10 - x), min(p + x + 1, q + 9 - x)
print(p)
| 1 | 70,714,096,622,952 | null | 219 | 219 |
t_HP, t_A, a_HP, a_A = map(int,input().split())
ans = False
while True:
a_HP -= t_A
if a_HP <= 0:
ans = True
break
t_HP -= a_A
if t_HP <= 0:
break
if ans == True:
print("Yes")
else:
print("No")
|
k = int(input())
s = input()
len_s = len(s)
MOD = 1000000007
x_i = pow(26, k, MOD)
r = (25 * pow(26, -1, MOD)) % MOD
comb_i = 1
a = 0
for i in range(k + 1):
a += (comb_i * x_i ) % MOD
a %= MOD
x_i = (x_i * r) % MOD
comb_i = (comb_i * (len_s + i) * pow(i + 1, -1, MOD)) % MOD
print(a)
| 0 | null | 21,457,479,365,010 | 164 | 124 |
S=list(str(input()))
a=[]
b=[]
count = 1
direction=S[0]
for i in range(1,len(S)):
if S[i]== direction:
count += 1
else:
a.append(S[i-1])
b.append(count)
direction=S[i]
count=1
a.append(S[-1])
b.append(count)
m=max(b)+1
dp=[0]*m
for i in range(1,m):
dp[i] += dp[i-1]+i
ans=0
for i in range(1,len(a)):
if a[i-1]=='<' and a[i]=='>':
ans+=dp[max(b[i-1],b[i])] + dp[min(b[i-1],b[i])-1]
if a[0]=='>':
ans+=dp[b[0]]
if a[-1]=='<':
ans+=dp[b[-1]]
print(ans)
|
n=input()
hon="24579"
pon="0168"
x=n[len(n)-1]
if x in hon:
print("hon")
elif x in pon:
print("pon")
else:
print("bon")
| 0 | null | 88,204,921,491,302 | 285 | 142 |
s = raw_input()
s = s.split(' ')
a, b = int(s[0]), int(s[1])
if 1 <= a <= 9 and 1 <= b <= 9:
print a*b
else:
print -1
|
S = input()
list_S = list(S)
T = input()
list_T = list(T)
count = 0
for i in range(len(list_S)):
if S[i] != T[i]:
count +=1
print(count)
| 0 | null | 84,569,336,662,384 | 286 | 116 |
import fractions
a,b=map(int,input().split())
c = fractions.gcd(a,b)
print(int((a*b)/c))
|
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b,a%b)
a,b = map(int, input().split())
print(a*b//gcd(a,b))
| 1 | 113,432,143,220,658 | null | 256 | 256 |
import networkx as nx
N, M = map(int, input().split())
G = nx.Graph()
G.add_edges_from(tuple(map(int, input().split())) for _ in range(M))
dist = nx.shortest_path_length(G, target=1)
print('Yes')
for i in range(2, N+1):
print(min((dist[j], j) for j in nx.all_neighbors(G, i))[1])
|
#D
from collections import deque
n, m = map(int, input().split())
ans = [0] * (n+1)
g = [[] for _ in range(n + 1)]
for i in range(m):
a, b = map(int, input().split())
g[a].append(b)
g[b].append(a)
#BPS幅優先探索を行う -> 前の座標を記入
nque = deque([1])
while nque:
now_cave = nque.popleft()
for next_cave in g[now_cave]:
if ans[next_cave] == 0:
ans[next_cave] = now_cave
nque.append(next_cave)
# print(nque)
# print(ans)
print("Yes")
for i in range(2, n + 1):
print(ans[i])
| 1 | 20,486,415,887,840 | null | 145 | 145 |
A = str(input())
B = str(input())
c = 0
lenA = len(A)
for i in range(lenA):
if A[i] != B[i]:
c += 1
print(c)
|
# Minor Change
S = input()
T = input()
ans = 0
for e in zip(S,T):
ans += [0,1][e[0]!=e[1]]
print(ans)
| 1 | 10,464,459,832,492 | null | 116 | 116 |
A = input()
B = input()
print('Yes' if A == B[:-1] else 'No')
|
s = input()
t = input()
ans = 'No'
if len(s) + 1 == len(t):
for i in range(len(s)):
if s[i] != t[i]:
break
if i == len(s) - 1:
ans = 'Yes'
print(ans)
| 1 | 21,267,091,987,980 | null | 147 | 147 |
from sys import stdin
def ip():
return stdin.readline().rstrip()
d,t,s=map(int,ip().split())
if d<=t*s:
print('Yes')
else:
print('No')
|
a,b=map(int,input().split())
c=0
for i in range (0,a+1):
for j in range (0,a+1):
if (i+j)==a and (i*2 + j *4) == b:
c+=1
if c== 0:
print('No')
else:
print('Yes')
| 0 | null | 8,629,058,211,538 | 81 | 127 |
from collections import Counter
N = int(input())
A = list(map(int, input().split()))
counter = Counter(A)
B = [1] * (max(A) + 1)
for a in A:
for k in range(a * 2,len(B),a):
B[k] = 0
print(sum(B[a] == 1 and counter[a] == 1 for a in A))
|
N = int(input())
A = list(map(int, input().split()))
max_a = max(A) + 1
counter = [0 for _ in range(max_a)]
for i in A:
for j in range(i, max_a, i):
counter[j] += 1
res = 0
for a in A:
if counter[a] == 1:
res += 1
#print(counter)
print(res)
| 1 | 14,291,134,787,908 | null | 129 | 129 |
#(身長)ー（番号）＝ー（身長）ー（番号）はありえない、身長=0にならないから
N = int(input())
A = list(map(int,input().split()))
from collections import defaultdict
AB = defaultdict(int)
_AB = defaultdict(int)
for i,a in enumerate(A):
AB[i+1+A[i]]+=1
_AB[-A[i]+i+1]+=1
ans = 0
for key,val in AB.items():
ans += val*_AB[key]
print(ans)
|
n=int(input())
a=list(map(int,input().split()))
f={}
f2={}
for i in range(n):
z=i+a[i]
z1=i-a[i]
#print(z,z1)
try:
f[z]+=1
except:
f[z]=1
try:
f2[z1]+=1
except:
f2[z1]=1
s=0
for i in f.keys():
if(i in f2):
s+=f[i]*f2[i]
print(s)
| 1 | 25,879,634,395,748 | null | 157 | 157 |
s = input()
t = input()
ans = len(t)
for i in range(len(s) - len(t) +1):
curr = len(t)
for j in range(len(t)):
if s[i+j] == t[j]:
curr -= 1
if curr < ans:
ans = curr
print(ans)
|
S = list(str(input()))
T = list(str(input()))
s = 0
t = 0
len_s = len(S)
len_t = len(T)
i = 0
ans = []
while i < len_s-len_t+1:
cnt = 0
#print(S[i:i+len_t])
for ss, tt in zip(S[i:i+len_t], T):
#print(ss,tt)
if ss != tt:
cnt +=1
ans.append(cnt)
i += 1
#print(ans)
print(min(ans))
| 1 | 3,644,678,108,028 | null | 82 | 82 |
import sys
def LI():
return list(map(int, input().split()))
N, A, B = LI()
if (B-A) % 2 == 0:
print((B-A)//2)
sys.exit()
a = 1
b = B-A
L = A+(b-a)//2
b = N
R = N-B+1
a = A+R
R += (b-a)//2
print(min(R, L))
|
n, t = map(int, input().split())
ab = sorted(list(map(int, input().split())) for _ in range(n))
dp = [-1] * (t - 1) + [0]
ret = 0
for i in range(n):
a, b = ab[i]
newdp = dp[:]
for j in range(t):
if dp[j] >= 0:
ret = max(ret, dp[j] + b)
if j - a >= 0:
newdp[j - a] = max(newdp[j - a], dp[j] + b)
dp = newdp
print(ret)
| 0 | null | 130,273,564,529,182 | 253 | 282 |
import random
S = input()
x = random.randrange(len(S)-2)
print(S[x] + S[x + 1] + S[x + 2])
|
import sys
import numpy as np
N = input()
print(N[0:3])
| 1 | 14,763,853,583,908 | null | 130 | 130 |
str_num = input()
num_list = str_num.split()
answer = int(num_list[0]) * int(num_list[1])
print(answer)
|
a, b = map(int, raw_input().split())
print a*b
| 1 | 15,904,192,031,680 | null | 133 | 133 |
fact = [1 for _ in range(200000)]
inv = [1 for _ in range(200000)]
fact_inv = [1 for _ in range(200000)]
mod = 998244353
for i in range(2, 200000):
fact[i] = (fact[i-1]*i) % mod
inv[i] = mod - (inv[mod % i] * (mod // i)) % mod
fact_inv[i] = (fact_inv[i-1] * inv[i]) % mod
N, M, K = map(int, input().split())
ans = 0
a = pow(M-1, N-1-K, mod)
for i in range(K, -1, -1):
ans += (fact[N-1] * fact_inv[i] * fact_inv[N-1-i]) * M * a
ans = ans % mod
a *= M-1
a = a % mod
print(ans)
|
def main():
n, m, k = map(int, input().split())
mod = 998244353
if m == 1:
if k == n-1 or n == 1:
print(1)
else:
print(0)
return
ans = 0
m1 = [None]*n
kai = [None]*n
mi = 1
ki = 1
for i in range(n):
m1[i] = mi
mi *= m-1
mi %= mod
kai[i] = ki
ki *= (i+1)
ki %= mod
def comb(a, b):
return kai[a]*fermat(kai[a-b]*kai[b], mod)
def fermat(x, p):
"""
1/x (mod p) を返す
x**(p-1) ≡ 1 [if gcd(x, p) == 1]
x**(p-2) ≡ 1/x
繰返し二乗法
ex: x**50 = (x**25)**2
x**25 = (x**12)**2 * x
x**12 = (x**6)**2
x**6 = (x**3)**2
"""
times = []
mod = p
p -= 2
while p > 1:
times.append(p%2)
p //= 2
x %= mod
out = x
for i in times[::-1]:
if i:
out = (x*pow(out, 2, mod))%mod
else:
out = pow(out, 2, mod)
return out
for i in range(k+1):
ans += m*comb(n-1, i)*m1[n-i-1]
ans %= mod
print(ans)
if __name__ == "__main__":
main()
| 1 | 23,355,569,193,000 | null | 151 | 151 |
m, n = map(int, input().split())
print((m + n - 1)//n)
|
N=int(input())
ans=[]
for i in range(1,99):
if N>26**i:
N-=26**i
else:
N-=1
for l in range(i):
key=(chr(ord("a")+(N%26)))
N=int(N/26)
ans.append(key)
break
ans.reverse()
for i in range(len(ans)):
print(ans[i],end="")
| 0 | null | 44,563,934,831,900 | 225 | 121 |
N = int(input())
S = [input() for _ in range(N)]
S.sort()
res = 0
cnt = 1
for i in range(N-1):
if S[i] == S[i+1]:
cnt+=1
else:
res = max(res,cnt)
cnt = 1
res = max(res,cnt)
cnt = 1
ans = []
for i in range(N-1):
if S[i] == S[i+1]:
cnt+=1
else:
if res == cnt:
ans.append(S[i])
cnt = 1
if cnt == res:
ans.append(S[i+1])
for i in range(len(ans)):
print(ans[i])
|
N = int(input())
S = sorted([input() for x in range(N)])
word = [S[0]]+[""]*(N-1) #単語のリスト
kaisuu = [0]*N #単語の出た回数のリスト
k = 0 #今wordリストのどこを使っているか
for p in range(N): #wordとkaisuuのリスト作成
if word[k] != S[p]:
k += 1
word[k] = S[p]
kaisuu[k] += 1
else:
kaisuu[k] += 1
m = max(kaisuu) #m:出た回数が最大のもの
ansnum = [] #出た回数が最大のもののwordリストでの位置
for q in range(N):
if kaisuu[q] == m:
ansnum += [q]
for r in range(len(ansnum)):
print(word[ansnum[r]])
| 1 | 70,281,809,389,772 | null | 218 | 218 |
n = list(input())
inf = 10**9
dp = [[inf for i in range(2)] for j in range(len(n) + 2)]
#dp[i][j] := 下からi桁目まで決めたときの、繰り下がりがjである。(true, false)
#ときの、最小紙幣数
n.reverse()
n += ['0']
#繰り下がりがない
dp[0][0] = 0
#配るDP
for i in range(len(n)):
for j in range(2):
x = int(n[i])
#さっきの桁に繰り下がりをしている場合は、今回の数字が一つ減る。
#んだけど、実際に払う数字は後で決めるから、今回は、引く側の数字を1大きく
#することで、同じ操作を実現している
x += j
for a in range(10):
#今回払う数字を決める
if a >= x:
#繰り下がりなし
dp[i+1][0] = min(dp[i+1][0], dp[i][j] + 2 * a - x)
else:
#繰り下がりあり
dp[i+1][1] = min(dp[i+1][1], dp[i][j] + 2 * a - x + 10)
print(min(dp[len(n)][0], dp[len(n)][1]))
|
def main():
s = input()
dp = [0, 1]
for c in s:
x = int(c)
a = dp[0] + x
if a > dp[1] + 10 - x:
a = dp[1] + 10 - x
b = dp[0] + x + 1
if b > dp[1] + 10 - x - 1:
b = dp[1] + 10 - x - 1
dp[0] = a
dp[1] = b
dp[1] += 1
print(min(dp))
if __name__ == "__main__":
main()
| 1 | 70,940,483,869,712 | null | 219 | 219 |
n=int(input())
if n%2==0:
print('0.5000000000')
elif n==1:
print('1.000000000')
else:
print((n//2 + 1)/n)
|
n = int(input())
ans = 0
for i in range(1, n + 1):
if i % 2 == 0:
continue
else:
ans += 1
print(ans / n)
| 1 | 176,938,304,766,580 | null | 297 | 297 |
from decimal import Decimal
a, b = [Decimal(i) for i in input().split()]
print(int(a * b))
|
class COM:
def __init__(self, n: int, mod: int):
self.n = n
self.mod = mod
self.fact = [0] * (n + 1)
self.factinv = [0] * (n + 1)
self.inv = [0] * (n + 1)
self.fact[0] = self.fact[1] = 1
self.factinv[0] = self.factinv[1] = 1
self.inv[1] = 1
for i in range(2, n + 1):
self.fact[i] = (self.fact[i - 1] * i) % mod
self.inv[i] = (-self.inv[mod % i] * (mod // i)) % mod
self.factinv[i] = (self.factinv[i - 1] * self.inv[i]) % mod
def get_cmb(self, n: int, k: int):
if (k < 0) or (n < k):
return 0
k = min(k, n - k)
return self.fact[n] * self.factinv[k] % self.mod * self.factinv[n - k] % self.mod
def solve():
n, k = map(int, input().split())
MOD = 10 ** 9 + 7
com = COM(n, MOD)
ans = 0
for i in range(min(n, k + 1)):
ans += com.get_cmb(n, i) * com.get_cmb(n - 1, i)
ans %= MOD
print(ans)
if __name__ == '__main__':
solve()
| 0 | null | 41,841,259,392,608 | 135 | 215 |
N, A, B = map(int, input().split())
# 周期
# 青 A個, 赤 B個
ans = N // (A + B) * A
n = N % (A + B)
if A <= n:
ans += A
else:
ans += n
print(ans)
|
x = int(input())
hap = x // 500
hap2 = (x - hap*500)//5
ans = hap*1000 + hap2*5
print(ans)
| 0 | null | 48,981,651,995,940 | 202 | 185 |
money=100000
n=int(input())
for day in range(n):
money+=money*0.05
money=-(-money//1000)*1000
print(int(money))
|
s_l = list(input())
t_l = list(input())
count_difference = 0
for s, t in zip(s_l, t_l):
if s != t:
count_difference += 1
print(count_difference)
| 0 | null | 5,197,154,661,530 | 6 | 116 |
import sys
from collections import deque
n = int(input())
q = deque()
for i in range(n):
c = sys.stdin.readline()[:-1]
if c[0] == 'i':
q.appendleft(c[7:])
elif c[6] == ' ':
try:
q.remove(c[7:])
except:
pass
elif c[6] == 'F':
q.popleft()
else:
q.pop()
print(*q)
|
class UnionFind:
def __init__(self, numV):
self.pars = list(range(numV))
self.ranks = [0] * numV
self.sizes = [1] * numV
def getRoot(self, x):
par = self.pars[x]
if par != x:
self.pars[x] = par = self.getRoot(par)
return par
def merge(self, x, y):
x, y = self.getRoot(x), self.getRoot(y)
sx, sy = self.sizes[x], self.sizes[y]
if x == y: return (0, 0)
if self.ranks[x] < self.ranks[y]:
self.pars[x] = y
self.sizes[y] += sx
else:
self.pars[y] = x
self.sizes[x] += sy
if self.ranks[x] == self.ranks[y]:
self.ranks[x] += 1
return (sx, sy)
def isSame(self, x, y):
return self.getRoot(x) == self.getRoot(y)
def updatePars(self):
for v in range(len(self.pars)):
self.getRoot(v)
def getSize(self, x):
return self.sizes[self.getRoot(x)]
n, m, k = map(int, input().split())
uf = UnionFind(n)
ex = [[] for i in range(n)]
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
uf.merge(a,b)
ex[a].append(b)
ex[b].append(a)
for i in range(k):
c, d = map(int, input().split())
c -= 1
d -= 1
if uf.getRoot(c) == uf.getRoot(d):
ex[c].append(d)
ex[d].append(c)
ans = []
for i in range(n):
r = uf.getRoot(i)
ans.append(uf.sizes[r] - len(list(set(ex[i]))) - 1)
ans = [str(i) for i in ans]
print(' '.join(ans))
| 0 | null | 30,809,548,216,382 | 20 | 209 |
n=int(input())
a=list(map(int,input().split()))
b=[0]*n
for i in range(n):
x=a[i]
b[x-1]=i+1
print(*b)
|
import math
r=float(input())
print("%.6f"%(r**2*math.pi),"%.6f"%(r*2*math.pi))
| 0 | null | 90,385,495,049,366 | 299 | 46 |
import numpy as np
def check_bingo(A):
for i in range(3):
if np.all(A[i] == -1) or np.all(A[:, i] == -1):
return 'Yes'
if np.all(A[list(range(3)), list(range(3))] == -1) \
or np.all(A[list(range(3)), list(range(3))[::-1]] == -1):
return 'Yes'
return 'No'
def main():
A = np.array([list(map(int, input().split())) for _ in range(3)])
n = int(input())
for i in range(n):
b = int(input())
A = np.where(A == b, -1, A)
ans = check_bingo(A)
print(ans)
if __name__ == '__main__':
main()
|
s=input()
tex=[]
while 1:
a=input()
if a=="END_OF_TEXT":
break
else:
tex.extend([x.lower() for x in a.split()])
c=0
tex
for i in tex:
if i==s:
c+=1
print(c)
| 0 | null | 30,926,002,663,492 | 207 | 65 |
H,W=map(int,input().split())
w1=0--W//2
w2=W//2
if H==1 or W==1:
print(1)
else:
print(w1*(0--H//2)+w2*(H//2))
|
H, W = map(int, input().split())
if (H==1 or W==1):
print(1)
elif (H%2==0):
H /=2
print(int(H*W))
else:
H //= 2
if(W%2==0):
print(int(H*W+(W/2)))
else:
print(int(H*W+(W//2+1)))
| 1 | 50,583,635,151,588 | null | 196 | 196 |
N = int(input())
s = set([input() for _ in range(N)])
print(len(s))
|
Row = int(input())
List = []
for i in range (Row):
List.append(input())
s_l = set(List)
print(len(s_l))
| 1 | 30,281,492,013,916 | null | 165 | 165 |
s = input()
ans = 'Yes'
for i in range(len(s)//2):
if s[i] != s[-i-1]:
ans = 'No'
break
s_s = s[:(len(s)-1)//2]
for i in range(len(s_s)//2):
if s_s[i] != s_s[-i-1]:
ans = 'No'
break
s_e = s[(len(s)+3)//2 - 1:]
for i in range(len(s_e)//2):
if s_e[i] != s_e[-i-1]:
ans = 'No'
break
print(ans)
|
def main():
N,K=map(int,input().split())
res=0
MOD=10**9+7
for i in range(K,N+2):
MAX=(N+(N-i+1))*i//2
MIN=(i-1)*i//2
res+=MAX-MIN+1
res%=MOD
print(res%MOD)
if __name__=="__main__":
main()
| 0 | null | 39,809,524,266,122 | 190 | 170 |
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
s=input()
n=len(s)
K=int(input())
dp_0=[[0]*(K+1) for _ in range(n+1)]
dp_1=[[0]*(K+1) for _ in range(n+1)]
dp_0[0][0]=1
for i in range(n):
for j in range(K+1):
for k in range(2):
nd=int(s[i])-0
for d in range(10):
ni=i+1
nj=j
if d!=0:nj+=1
if nj>K:continue
if k==0:
if d>nd:continue
if d<nd:dp_1[ni][nj]+=dp_0[i][j]
else:dp_0[ni][nj]+=dp_0[i][j]
else:dp_1[ni][nj]+=dp_1[i][j]
print(dp_0[n][K]+dp_1[n][K])
if __name__=='__main__':
main()
|
# coding: utf-8
#import math
#import numpy
#N = int(input())
def main():
import sys
input = sys.stdin.readline
N, K = map(int,input().split())
A = list(map(int,input().split()))
#K =int(input())
ANS = []
#ANS.append(a)
for i in range(K,N):
if A[i-K] < A[i]:
print("Yes")
else:
print("No")
#ANS.append(a)
#print(ANS)
if __name__ == '__main__':
main()
| 0 | null | 41,747,401,585,020 | 224 | 102 |
a, a1, a2 = map(int,input().split())
if a + a1 + a2 >= 22:
print('bust')
else:
print('win')
|
import sys
a,b,c = map(int,input().split())
d = a+b+c
if(d > 21):
print("bust")
else:
print("win")
| 1 | 118,839,905,234,332 | null | 260 | 260 |
#MLE注意！0や1のケースに注意
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
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
s,w = map(int, input().split())
if s<=w:
print('unsafe')
else:
print('safe')
if __name__ == '__main__':
main()
|
val = input().split()
sheep = int(val[0])
wolf = int(val[1])
if (wolf - sheep) >= 0:
print("unsafe")
else:
print("safe")
| 1 | 29,245,159,608,068 | null | 163 | 163 |
N = int(input())
S = input()
ans = S.count("R")*S.count("G")*S.count("B")
for i in range(N):
for j in range(i+1,N):
k = 2*j-i
if k<N and S[i]!=S[j]!=S[k]!=S[i]:
ans-=1
print(ans)
|
n = int(input())
s = input()
r, g, b = s.count("R"), s.count("G"), s.count("B")
cnt = 0
for i in range(n):
for j in range(i + 1, n):
try:
k = j + (j - i)
if s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
cnt += 1
except:
pass
print(r * g * b - cnt)
| 1 | 36,124,593,812,050 | null | 175 | 175 |
import sys
from collections import defaultdict, deque, Counter
import math
# import copy
from bisect import bisect_left, bisect_right
import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def nck(n, k, kaijyo):
return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD
def npk(n, k, kaijyo):
if k == 0 or k == n:
return n % MOD
return (kaijyo[n] * divide(kaijyo[n-k])) % MOD
def kaijyo(n):
ret = [1]
for i in range(1, n + 1):
ret.append((ret[-1] * i)% MOD)
return ret
def cut(pt, grid, k, h, w):
pat = []
for i in range(h-1):
if pt % 2 == 1:
pat.append("1")
else:
pat.append("0")
pt //= 2
# print("pat", pat)
slice = Counter(pat)["1"]
pat = pat + ["0"]
white = [0] * (slice + 1)
ret = 0
for i in range(w):
tw = [0] * (slice + 1)
dan = 0
for j in range(h):
if grid[j][i] == "1":
tw[dan] += 1
if pat[j] == "1":
dan += 1
if max(tw) > k:
return INF
reset = False
for w1, w2 in zip(white, tw):
if w1 + w2 > k:
ret += 1
reset = True
break
if reset:
white = tw
else:
for up in range(slice + 1):
white[up] += tw[up]
return ret + slice
def solve():
h, w, k = getList()
grid = []
for i in range(h):
grid.append(getS())
ans = INF
for i in range(2 ** (h-1)):
tmp = cut(i, grid, k, h, w)
# print(tmp)
ans = min(ans, tmp)
print(ans)
def main():
n = getN()
for _ in range(n):
solve()
if __name__ == "__main__":
# main()
solve()
|
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
h,w,k = inpl()
s = [list(input()) for _ in range(h)]
res = INF
for yoko in itertools.product([0,1], repeat=(h-1)):
# 0:uncut 1:cut
ln = sum(yoko)
gr = [[] for _ in range(ln+1)]
gr[0].append(0)
ind = 0
for i in range(1,h):
if yoko[i-1]: ind += 1
gr[ind].append(i)
possible = True
for x in range(w):
for ind in range(ln+1):
cnt = 0
for y in gr[ind]:
if s[y][x] == '1':
cnt += 1
if cnt > k:
possible = False
break
if not possible:
break
else:
cutcnt = 0
now = [0] * (ln+1)
for x in range(w):
for ind in range(ln+1):
for y in gr[ind]:
if s[y][x] == '1':
now[ind] += 1
if max(now) > k:
now = [0] * (ln+1)
cutcnt += 1
for ind in range(ln+1):
for y in gr[ind]:
if s[y][x] == '1':
now[ind] += 1
res = min(res, cutcnt + ln)
print(res)
| 1 | 48,390,497,294,142 | null | 193 | 193 |
x,n = map(int,input().split())
l = list(map(int,input().split()))
l.sort()
result = x
for i in range(100):
if x in l:
pass
else:
result = x
break
if x - i in l:
pass
else:
if x - i >= 0:
result = x - i
break
if x + i in l:
pass
else:
if x + i <= 101:
result = x + i
break
print(result)
|
X,N = map(int,input().split())
N_List = list(map(int,input().split()))
ct = 0
pos = 0
while True:
if pos == 0:
if X not in N_List:
ans = X
break
else:
pos += 1
elif pos > 0:
if X-pos not in N_List:
ans = X - pos
break
elif X + pos not in N_List:
ans = X + pos
break
else:
pos += 1
print(ans)
| 1 | 14,181,233,920,546 | null | 128 | 128 |
from collections import defaultdict
n = int(input())
A = list(map(int, input().split()))
dd = defaultdict(int)
ans = 0
for i in range(n):
diff = i - A[i]
ans += dd[diff]
summ = A[i] + i
dd[summ] += 1
print(ans)
|
N = int(input())
A = list(map(int,input().split()))
d = {}
ans = 0
for i in range(N):
sa = i-A[i]
if sa in d:
ans += d[sa]
wa = i+A[i]
if wa in d:
d[wa] += 1
else:
d[wa] = 1
print(ans)
| 1 | 26,255,120,069,920 | null | 157 | 157 |
K=int(input())
if K==32:
print(51)
elif K==24:
print(15)
elif K==16:
print(14)
elif K==8 or K==12 or K==18 or K==20 or K==27:
print(5)
elif K==28 or K==30:
print(4)
elif K==4 or K==6 or K==9 or K==10 or K==14 or K==21 or K==22 or K==25 or K==26:
print(2)
else:
print(1)
|
c = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
N = n=int(input())
print(c[N-1])
| 1 | 50,084,580,461,006 | null | 195 | 195 |
X, Y = map(int, input().split())
ans = ''
for i in range(X+1):
if (i*2 + (X-i)*4) == Y:
ans = 'Yes'
break
else:
ans = 'No'
print(ans)
|
H,N = map(int,input().split())
Q = []
for _ in range(N):
a,b = map(int,input().split())
Q.append((a,b))
INF = float("inf")
dp = [INF]*(H+1)
dp[0] = 0
for i in range(H+1):
for a,b in Q:
if i+a>=H:
dp[H] = min(dp[H],dp[i]+b)
else:
dp[i+a] = min(dp[i+a],dp[i]+b)
print(dp[-1])
| 0 | null | 47,731,252,640,240 | 127 | 229 |
n,a,b = map(int, input().split())
if n % (a+b) >= a:
print((n // (a+b))*a + a)
else:
print((n // (a+b))*a + (n % (a+b)))
|
N, A, B = map(int, input().split())
M = N % (A+B)
cnt = (N // (A+B))*A
if M < A:
print(cnt+M)
else:
print(cnt+A)
| 1 | 55,452,040,005,142 | null | 202 | 202 |
a,b=input().split()
a=int(a)
b=int(b)
if a-b*2>=0:
print(int(a-b*2))
else:
print("0")
|
a, b = map(int, input().split())
ans = a - b*2
print(ans if ans > 0 else 0)
| 1 | 166,660,732,359,858 | null | 291 | 291 |
print "\n".join(['{0}x{1}={2}'.format(x,y,x*y) for x in range(1,10) for y in range(1,10)])
|
i=[1,2,3,4,5,6,7,8,9]
j=[1,2,3,4,5,6,7,8,9]
for i1 in i:
for j1 in j:
answer=i1*j1
print(str(i1)+"x"+str(j1)+"="+str(answer))
| 1 | 234,158 | null | 1 | 1 |
def main():
a, b = map(int, input().split(" "))
print(a*b)
if __name__ == "__main__":
main()
|
a,b=map(int,input().split());print(a*b)
| 1 | 15,775,485,571,744 | null | 133 | 133 |
n=int(input())
a,b,c,d=-10**9,10**9,-10**9,10**9
for _ in range(n):
x,y=map(int,input().split())
a=max(a,x+y)
b=min(b,x+y)
c=max(c,x-y)
d=min(d,x-y)
print(max(a-b,c-d))
|
n=int(input())
a= [list(map(int, input().split())) for i in range(n)]
a1=float('inf')
a2=-float('inf')
a3=float('inf')
a4=-float('inf')
for i in range(n):
cnt=a[i][0]+a[i][1]
cnt1=a[i][0]-a[i][1]
a1=min(a1,cnt)
a2=max(a2,cnt)
a3=min(cnt1,a3)
a4=max(cnt1,a4)
print(max(a2-a1,a4-a3))
| 1 | 3,449,546,109,360 | null | 80 | 80 |
N = int(input())
A = list(map(int, input().split()))
dp = [0]*(N)
dp[0] = 1000
for i in range(1,N):
dp[i] = dp[i-1]
for j in range(i):
dp[i] = max(dp[i], (dp[j]//A[j])*A[i]+dp[j]%A[j])
ans = 0
for i in range(N):
ans = max(ans, dp[i])
print(ans)
|
n = int(input())
# 連続する場合は無視できるので圧縮
tmp = list(map(int, input().split()))
arr = [tmp[0]]
for i in range(1, n):
if arr[-1] != tmp[i]:
arr.append(tmp[i])
# 株価が上がる前に全力で買って、上がったら全力で売る。を貪欲にやる
money, stock = 1000, 0
for i in range(1, len(arr)):
if arr[i - 1] < arr[i]:
# 全力買い
buy, money = divmod(money, arr[i - 1])
stock += buy
# 全力売り
money += stock * arr[i]
stock = 0
print(money)
| 1 | 7,379,492,315,020 | null | 103 | 103 |
A,B,C = map(int,input().split())
K = int(input())
for i in range(K):
if A >= B:
B = B*2
else:
C = C*2
print("Yes" if A < B and B < C else "No")
|
def main():
a, b, c = [int(x) for x in input().split()]
count = int(input())
while a >= b:
b *= 2
count -= 1
while b >= c:
c *= 2
count -= 1
print('Yes' if count >= 0 else 'No')
if __name__ == '__main__':
main()
| 1 | 6,959,364,890,720 | null | 101 | 101 |
import numpy as np
S = list(map(str, input().rstrip()))
ans = np.zeros(len(S) + 1, dtype=np.int64)
# 左から、右から流す
for i, s in enumerate(S):
if s == "<":
ans[i+1] = max(ans[i+1], ans[i]+1)
ans = ans[::-1]
for i, s in enumerate(S[::-1]):
if s == ">":
ans[i+1] = max(ans[i+1], ans[i]+1)
print(ans.sum())
|
a = int(input())
if a == 0:
print(1)
elif a == 1:
print(0)
| 0 | null | 79,828,270,751,772 | 285 | 76 |
import sys
num = []
for i in sys.stdin:
H, W = i.split()
if H == W == '0':
break
num.append((int(H), int(W)))
for cnt in range(len(num)):
for h in range(num[cnt][0]):
for w in range(num[cnt][1]):
print('#',end='')
print()
print()
|
def check(r):
if r == r[::-1]:
return True
def main():
s = input()
n = len(s)
print("Yes" if check(s) and check(s[:(n-1)//2])
and check(s[((n-1)//2) + 1:]) else "No")
if __name__ == "__main__":
main()
| 0 | null | 23,658,388,019,466 | 49 | 190 |
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)
|
from collections import Counter
import math
def combinations_count(n):
return (n * (n - 1)) // 2
N = int(input())
A = list(map(int, input().split()))
combs = {}
dic = Counter(A)
for k, v in dic.items():
combs[k] = combinations_count(v)
ans = sum(combs.values())
for i in range(N):
a = A[i]
ans_i = ans
if combs[a] < 2:
ans_i -= combs[a]
print(ans_i)
else:
ans_i -= dic[a] - 1
print(ans_i)
| 1 | 47,711,081,254,430 | null | 192 | 192 |
n = int(input())
fives = [0]
if n % 2 == 1:
print(0)
else:
i = 0
while 1:
temp5 = (n // (5** (i +1))) //2
if temp5 != 0:
fives.append(temp5)
i += 1
else:
break
print(sum(fives))
|
def solve(n):
if n % 2 == 1:
return 0
div_2 = 0
cur = 2
while cur <= n:
div_2 += (n // cur)
cur = cur * 2
div_5 = 0
cur = 5
while cur <= n:
div_5 += (n // cur) // 2
cur = cur * 5
return min(div_2, div_5)
n = int(input())
print(solve(n))
| 1 | 115,459,048,490,434 | null | 258 | 258 |
import itertools
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
count = 1
for p in itertools.permutations(range(1, N+1)):
if p == P:
count_P = count
if p == Q:
count_Q = count
count += 1
ans = abs(count_P - count_Q)
print(ans)
|
import sys
import math
import string
import fractions
import random
from operator import itemgetter
import itertools
from collections import deque
import copy
import heapq
import bisect
MOD = 10 ** 9 + 7
INF = float('inf')
input = lambda: sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 8)
n = int(input())
dis = [-1] * n
info = [list(map(int, input().split())) for _ in range(n)]
stack = [[0, 0]]
ans = 0
while len(stack) > 0:
num = stack.pop(0)
if dis[num[0]] == -1:
dis[num[0]] = num[1]
for i in info[num[0]][2:]:
if dis[i-1] == -1:
stack.append([i - 1, num[1] + 1])
for i in range(n):
print(str(i+1) + " " + str(dis[i]))
| 0 | null | 50,351,906,811,470 | 246 | 9 |
n,x,m=map(int,input().split())
id=[-1 for i in range(m+1)]
s=[]
c=0
while id[x]==-1:
id[x]=c
c+=1
s.append(x)
x=x*x%m
d=c-id[x]
ans=0
if n<=d:
for i in range(n):
ans+=s[i]
else:
for i in range(id[x]):
ans+=s[i]
n-=id[x]
sum=0
for i in range(d):
sum+=s[id[x]+i]
ans+=(n//d)*sum
n=n%d
for i in range(n):
ans+=s[id[x]+i]
print(ans)
|
for i in range(1, 10):
for ii in range(1, 10):
print('{}x{}={}'.format(i, ii, i*ii))
| 0 | null | 1,394,792,234,980 | 75 | 1 |
n,k = map(int,input().split())
A=list(map(int,input().split()) )
kyori = [-1] *len(A)
junban =[]
x=0
d=0
while kyori[x] == -1:
junban.append(x)
kyori[x]=d
d+=1
x=A[x]-1
roop_x = x
roop_d = d - kyori[x]
# for k in range(100):
if k<d:
print(junban[k]+1)
else:
k0 = kyori[x]
k1 = (k-k0)%roop_d
print(junban[k0+k1]+1)
|
from collections import deque
n = int(input())
M = [[0]*n for _ in range(n)]
d = [-1]*n
st = [0]*n
for _ in range(n):
i = [int(i) for i in input().split()]
u = i[0]
k = i[1]
V = i[2:]
for v in V: M[u-1][v-1] = 1
def bfs(s):
Q = deque()
Q.append(s)
st[s] = 1
d[s] = 0
while Q:
u = Q.popleft()
for v in range(n):
if M[u][v] and st[v] == 0:
st[v] = 1
Q.append(v)
d[v] = d[u]+1
st[u] = 2
return
bfs(0)
for i in range(n): print(i+1,d[i])
| 0 | null | 11,355,142,454,620 | 150 | 9 |
# coding:UTF-8
import sys
from math import factorial
MOD = 10 ** 9 + 7
INF = float('inf')
N = int(input()) # 数字
A = list(map(int, input().split())) # スペース区切り連続数字
m = max(A)
num = [0] * (m + 1)
for a in A:
num[a] += 1
for a in A:
if num[a] > 1:
num[a] = 0
i = 2
while a * i <= m:
num[a * i] = 0
i += 1
res = 0
for n in num:
if n != 0:
res += 1
print("{}".format(res))
|
N = int(input())
As = sorted(list(map(int, input().split())))
sieve = [True] * 1000001
prev = 0
for i in range(N):
if As[i] == prev:
sieve[As[i]] = False
continue
else:
prev = As[i]
try:
for j in range(2, 1000000 // prev + 1):
sieve[prev * j] = False
except:
continue
count = 0
As = list(set(As))
for i in range(len(As)):
if sieve[As[i]] is True:
count += 1
print(count)
| 1 | 14,313,417,658,358 | null | 129 | 129 |
from functools import lru_cache
@lru_cache(maxsize=None)
def solve(n):
if n == 1:
return 1
else:
return solve(n//2) * 2 + 1
H = int(input())
print(solve(H))
|
N=int(input())
f=[0]*10000
for i in range(100):
for j in range(100):
for k in range(100):
n=(i+1)**2+(j+1)**2+(k+1)**2+(i+1)*(j+1)+(j+1)*(k+1)+(k+1)*(i+1)
if n<=10000:
f[n-1]+=1
for i in range(N):
print(f[i])
| 0 | null | 44,250,082,031,750 | 228 | 106 |
from subprocess import run
with open("./tmp215378912379.cpp", mode='w') as f:
f.write("""
#include <bits/stdc++.h>
template <class T>
concept Integral = std::is_integral_v<T>;
int main() {
auto f = []<Integral T>(T a, T b) { return a * b; };
int a, b;
std::cin >> a >> b;
std::cout << f(a, b) << std::endl;
}
""")
run("g++ -o ./tmp215378912379 -std=gnu++2a -fconcepts ./tmp215378912379.cpp && ./tmp215378912379", shell=True)
|
a,b=input().split(' ')
if int(a)<=100 and int(b)<=100:
print(int(a)*int(b))
else:
pass
| 1 | 15,826,638,666,270 | null | 133 | 133 |
input()
ls = input().split()
ls.reverse()
print(' '.join(ls))
|
"""
AtCoder Beginner Contest 144 E - Gluttony
愚直解
・修行の順序は結果に影響しないから、修行を誰に割り振るか：N^K
・メンバーN人をどの問題に当てるか（N人の並べ方）：N!
-> N^K * N!
間に合わない。
完食にかかる時間のうち最大値がチーム全体の成績なので、
・消化コストAiを修行で下げる
・消化コストAiの大きい人に、食べにくさFiの小さい食べ物を割り当てる
のが良さそう
最大値の最小化、なので、二分探索が使えそうな気もする。
A,F <= 10^6
かかる時間を X 以下にできるか、を考える。
・消化コストが大きい人に、食べにくさが小さい問題を当てるようにする
・Ai * Fi > Xであれば、(Ai - m) * Fi <= X となるような最小のmをカウントする
全メンバーに対しこれを数え上げた時に、
mの合計 > K
であれば、X以下になるように修行することができない（K回までしか修行できず、回数が足りない）ので、最大値の最小はXより上
mの合計 <= K
であれば、X以下になるように修行できるので、最大値の最小はX以下
A*F <= 10^12 までなので、40~50程度繰り返せば行けそう
"""
import math
N,K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
if K >= sum(A):
print(0)
exit()
A.sort(reverse=True)
F.sort()
def is_ok(mid):
cnt = 0
for i in range(N):
if A[i] * F[i] <= mid:
continue
else:
cnt += math.ceil((A[i] * F[i] - mid) / F[i]) # A[i]が1減少するごとにF[i]減るのでF[i]で割る
return cnt <= K
# okは全員がX以下になる最小値に着地するので、A*F<=10**12 なので＋１して最大のケースにも対応する
ok = 10**12 + 1
# 0ではないことが上で保証されてるので、条件を満たさない最大値の0にしておく
ng = 0
while ok - ng > 1:
mid = (ok + ng) // 2
#print(ok,ng,mid)
if is_ok(mid):
ok = mid
else:
ng = mid
#print(ok,ng,mid)
print(ok)
| 0 | null | 83,058,193,959,168 | 53 | 290 |
n=int(input())
a=list(map(int,input().split()))
a.sort()
# 小さい側から処理する。a[i]について、10**6 以下のすべての倍数をset()として持つ。
# ただし、set内に存在しない==初出の約数のみ倍数計算をしてカウントする。
# 例えば、2,6,... となった場合、(6の倍数セットは2の倍数セットの下位集合となるため計算不要)
s=set()
cnt=0
for i,aa in enumerate(a):
if aa not in s:
# 同値が複数ある場合、カウントしない。sortしているため、同値は並ぶ
if i+1 == len(a) or aa != a[i+1]:
cnt+=1
for i in range(1,10**6+1):
ma=aa*i
if ma > 10**6:
break
s.add(ma)
print(cnt)
|
n = int(input())
a = list(map(int, input().split()))
l = (2 * 10 ** 5) + 1
b = [0] * l
def nC2(n):
return n * (n - 1) // 2
for i in range(n):
b[a[i]] += 1
ttl = 0
for j in range(l):
ttl += b[j] * (b[j] - 1) // 2
for k in range(n):
print(ttl - nC2(b[a[k]]) + nC2(b[a[k]] - 1))
| 0 | null | 30,911,397,655,768 | 129 | 192 |
import sys
input = sys.stdin.readline
(n, k), s, res, sm = map(int, input().split()), list(map(lambda x: (int(x) + 1) / 2, input().split())), 0, 0
for i in range(n):
if i < k: sm += s[i]
else: sm += s[i]; sm -= s[i-k]
res = max(res, sm)
print(f'{res:.10f}')
# print(f'{max([sum(s[i:i+k]) for i in range(n - k + 1)]):.10f}')
|
from math import gcd
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
return(int(input().rstrip()))
def inlt():
return(list(map(int,input().rstrip().split())))
def insr():
s = input().rstrip()
return(s[:len(s) - 1])
def invr():
return(map(int,input().rstrip().split()))
################################################################
n = inp()
nums = [0] + inlt()
dp = [0 for i in range(n + 1)]
s = [0 for i in range(n + 1)]
s[1] = nums[1]
for i in range(3,n,2):
s[i] = s[i - 2] + nums[i]
if n == 1:
print(nums[0])
elif n == 2:
print(max(nums[1],nums[2]))
elif n == 3:
print(max(nums[3],nums[1],nums[2]))
elif n == 4:
print(max(nums[1] + nums[3],nums[1] + nums[4],nums[2] + nums[4]))
else:
dp[1] = nums[1]
dp[2] = max(nums[1],nums[2])
dp[3] = max(nums[3],nums[1],nums[2])
dp[4] = max(nums[1] + nums[3],nums[1] + nums[4],nums[2] + nums[4])
for i in range(5,n + 1):
if i % 2 == 0:
dp[i] = max(dp[i - 2] + nums[i], s[i - 1]) #if n % 2 == 0 take sum else dp[i - 1]
else:
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
print(dp[n])
#print('No')
#print()
| 0 | null | 56,120,713,993,080 | 223 | 177 |
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))
|
# -*- coding: utf-8 -*-
while True:
n = int(input())
if n == 0:
break
l = [int(x) for x in list(str(n))]
print(sum(l))
| 1 | 1,567,300,580,702 | null | 62 | 62 |
N, M = input().split()
N = int(N)
M = int(M)
A = list(map(int, input().split()))
LA = len(A)
i = 0
SUM = 0
for i in range(LA):
SUM = SUM + A[i]
if SUM > N:
print('-1')
else:
print(N - SUM)
|
N, M = map(int, input().split())
A = list(map(int, input().split()))
def answer(N: int, M: int, A: list) -> int:
homework_days = 0
for i in range(0, M):
homework_days += int(A[i])
i += 1
if homework_days <= N:
return N - homework_days
else:
return -1
print(answer(N, M, A))
| 1 | 32,179,698,248,012 | null | 168 | 168 |
if __name__ == '__main__':
from sys import stdin
from itertools import combinations
while True:
n, x = (int(n) for n in stdin.readline().rstrip().split())
if n == x == 0:
break
a = range(1, n + 1)
l = tuple(filter(lambda _: sum(_) == x, combinations(a, 3)))
print(len(l))
|
S = input()
if 'RRR' in S: ANS = 3
elif 'RR' in S: ANS = 2
elif 'RS' in S: ANS = 1
elif 'SR' in S: ANS = 1
elif 'SSS' in S: ANS = 0
print(ANS)
| 0 | null | 3,119,559,467,130 | 58 | 90 |
l = [i for i in range(1,10)]
for i in l:
for j in l:
print(str(i)+ 'x' + str(j) + '=' + str(i*j))
|
from collections import Counter as C
n=int(input())
S=list(input())
a=1
L=C(S).most_common(3)
for l in L:
a*=l[1]
for i in range(1,n):
for j in range(n-2*i):
if len(set((S[j],S[j+i],S[j+2*i])))==3:
a-=1
print(a if len(L)>2 else 0)
| 0 | null | 17,927,129,024,602 | 1 | 175 |
# https://atcoder.jp/contests/sumitrust2019/tasks/sumitb2019_e
import sys
input=sys.stdin.readline
MOD=10**9+7
def main():
N=int(input())
A=list(map(int,input().split()))
cnt=[0]*N
ans=1
for i in range(N):
if A[i]==0:
ans*=3-cnt[0]
ans%=MOD
cnt[A[i]]+=1
else:
ans*=cnt[A[i]-1]-cnt[A[i]]
ans%=MOD
cnt[A[i]]+=1
print(ans)
if __name__=="__main__":
main()
|
MOD = 10**9+7
n = int(input())
A = list(map(int, input().split()))
colors = [0]*3
dp = [0]*n
for i in range(n):
c = colors.count(A[i])
dp[i] = c
if c == 0:
break
colors[colors.index(A[i])] += 1
ans = 1
for x in dp:
ans = ans*x % MOD
print(ans % MOD)
| 1 | 130,240,421,863,952 | null | 268 | 268 |
while True:
a=map(int,raw_input().split())
if a==[0,0]:
break
if a[0]>a[1]:print(str(a[1])+" "+str(a[0]))
else: print(str(a[0])+" "+str(a[1]))
|
def main():
n, m = (int(i) for i in input().split())
graph = { i: [] for i in range(1, n+1) }
for i in range(m):
src, dst = (int(i) for i in input().split())
graph[src].append(dst)
graph[dst].append(src)
def bfs():
st = [1]
pptr = { 1: 0 }
while st:
room = st.pop(0)
for dest_room in graph[room]:
if dest_room in pptr:
continue
st.append(dest_room)
pptr[dest_room] = room
return pptr
pptr = bfs()
if len(pptr) != n:
print('No')
else:
print('Yes')
for i in sorted(pptr.keys()):
if i == 1:
continue
print(pptr[i])
main()
| 0 | null | 10,614,008,409,148 | 43 | 145 |
import numpy
a,b,x=map(int,input().split())
V=a*a*b
if x<=V/2:
y=2*x/b/a
theta=numpy.arctan(b/y)
print(theta*360/2/numpy.pi)
else:
x=V-x
y=2*x/a/a
theta=numpy.arctan(y/a)
print(theta*360/2/numpy.pi)
|
import math
a, b, x = map(float, input().split())
if a * a * b <= x * 2:
h = 2 * (b - x / a / a)
ret = math.degrees(math.atan2(h, a))
else:
h = 2 * x / a / b
ret = 90 - math.degrees(math.atan2(h, b))
print(ret)
| 1 | 163,211,140,649,500 | null | 289 | 289 |
n = int(input())
a = list(map(int, input().split()))
num = [0]*(10**6+1)
for x in a:
if num[x] != 0:
num[x] = 2
continue
for i in range(x, 10**6+1, x):
num[i] += 1
ans = 0
for x in a:
if num[x] == 1:
ans += 1
print(ans)
|
from collections import Counter
n = int(input())
a = sorted(map(int, input().split()))
c = Counter(a)
s = set()
for i in range(n):
if a[i] in s:
continue
elif c[a[i]] >= 2:
s.add(a[i])
for j in range(2,10**6//a[i]+1):
s.add(a[i]*j)
print(sum(not (ai in s) for ai in a))
| 1 | 14,300,058,915,530 | null | 129 | 129 |
n,a,b=map(int,input().split())
def fact(n,p):
a=1
for i in range(1,n+1):
a=(a*i)%p
return a
def bfact(n,x,p):
a=1
for i in range(n-x+1,n+1):
a=(a*i)%p
return a
p=10**9+7
na=bfact(n,a,p)%p
nb=bfact(n,b,p)%p
aa=fact(a,p)%p
bb=fact(b,p)%p
aaa=pow(aa,-1,p)
bbb=pow(bb,-1,p)
ans=pow(2,n,p)-1
ans-=(na*aaa+nb*bbb)
print(ans%p)
|
# https://atcoder.jp/contests/abc146/submissions/8617148
def solve(N, M, S):
from collections import namedtuple
from heapq import heappop, heappush
INF = N * 2
V = namedtuple('V', 'cnt index')
cnt_from_N = [INF] * (N + 1)
cnt_from_N[N] = 0
parent = [0] * (N + 1)
h = [V(cnt=0, index=N)]
for j in range(N - 1, -1, -1):
# S[j]に到達する最小回数とその経路を求める
if S[j]:
continue
while h:
cnt, par = h[0]
if par > j + M:
# jまで移動できない(距離>M)
heappop(h)
continue
break
# jまで最小回数で到達できる頂点par
# parまでの回数cnt
if not h:
return -1,
# jまで到達できる頂点がない
cnt_from_N[j] = cnt + 1
parent[j] = par
heappush(h, V(cnt=cnt + 1, index=j))
ret = []
curr = 0
while curr < N:
par = parent[curr]
ret.append(par - curr)
curr = par
return ret
def main():
N, M = map(int, input().split())
*S, = map(int, input())
print(*solve(N, M, S))
if __name__ == '__main__':
main()
| 0 | null | 102,515,737,297,820 | 214 | 274 |
import math
def calc_debt(week=0):
debt = 100000
for i in range(week):
debt = int(math.ceil(debt * 1.05 / 1000))*1000
return debt
print(calc_debt(int(input())))
|
import sys
input = sys.stdin.readline
from scipy.sparse.csgraph import floyd_warshall
n,m,l = map(int,input().split())
edge = [[0]*n for _ in range(n)]
for i in range(m):
a,b,c = map(int,input().split())
edge[a-1][b-1] = c
edge[b-1][a-1] = c
edge = floyd_warshall(edge)
for i in range(n):
for j in range(n):
if edge[i][j]<=l:
edge[i][j] = 1
else:
edge[i][j] = 0
edge = floyd_warshall(edge)
q = int(input())
for i in range(q):
s,t = map(int,input().split())
if edge[s-1][t-1] == float("inf"):
print(-1)
else:
print(int(edge[s-1][t-1] - 1))
| 0 | null | 86,791,894,149,138 | 6 | 295 |
if __name__ == '__main__':
try:
n = int(raw_input())
except:
print 'the first input must be integer value!'
exit()
genoms = set([])
answers = []
for _ in range(n):
values = raw_input().split()
order = values[0]
genom = values[1]
if order == "insert":
genoms.add(genom)
else:
# TODO: fasten here!
answers.append('yes' if genom in genoms else 'no' )
# print(genoms)
# print(answers)
for answer in answers:
print answer
|
import sys
input = sys.stdin.readline
def main():
X, Y = map(int, input().split())
ans = 0
for i in [X, Y]:
if i == 1:
ans += 300000
elif i == 2:
ans += 200000
elif i == 3:
ans += 100000
if X == Y == 1:
ans += 400000
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 70,099,072,703,940 | 23 | 275 |
def main():
import sys
asa = sys.stdin.readline
n = int(input())
s = list(map(int, asa().split()))
q = int(input())
t = list(map(int, asa().split()))
c = 0
s.append(0)
for i in t: # tの中のiを探索
j = 0
s[n] = i
while s[j] != i:
j += 1
if j < n:
c += 1
print(c)
if __name__ == '__main__':
main()
|
N = int(input())
S = list(map(int, input().split()))
Q = int(input())
T = list(map(int, input().split()))
match_count = 0
for i in T:
if i in S:
match_count += 1
print(str(match_count))
| 1 | 68,285,291,680 | null | 22 | 22 |
def fib(n,memo={}):
if n==0 or n==1:
return 1
elif n in memo:
return memo[n]
else:
memo[n]= fib(n-1,memo)+fib(n-2,memo)
return memo[n]
n=int(input())
print(fib(n))
|
numbers = []
while True:
x=int(input())
if x==0:
break
numbers.append(x)
for i in range(len(numbers)):
print("Case ",i+1,": ",numbers[i],sep="")
| 0 | null | 236,344,120,192 | 7 | 42 |
n = int(raw_input())
dp = [1, 1]
for i in range(50):
dp += [dp[-1] + dp[-2]]
print dp[n]
|
HP, n = map(int,input().split())
a = list(map(int,input().split()))
count = 0
for i in a:
count += i
if count >= HP:
print("Yes")
else:
print("No")
| 0 | null | 39,062,772,856,272 | 7 | 226 |
a = int(input())
f1 = int(2)
f2 = int(1)
f = int(1)
if a == 1:
print("1")
elif a == 2:
print("2")
else:
for b in range(2,a):
f= f1+f2
f2 = f1
f1 = f
print(f)
|
n = int(input())
s = list(map(int,input().split()))
count = 0
def merge(a, left, mid, right):
global count
l = a[left:mid] + [float("inf")]
r = a[mid:right] + [float("inf")]
i = j = 0
for k in range(left, right):
if l[i] <= r[j]:
a[k] = l[i]
i += 1
else:
a[k] = r[j]
j += 1
count += right - left
def mergeSort(a, left, right):
if left + 1 < right:
mid = right + (left - right)//2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
mergeSort(s, 0, n)
print(*s)
print(count)
| 0 | null | 57,353,524,580 | 7 | 26 |
x = 1
y = 1
for x in range(9):
for y in range(9):
print((x+1),"x",(y+1),"=",(x+1)*(y+1),sep="")
y = y + 1
x = x + 1
|
import itertools
for i,j in itertools.product(xrange(1,10),repeat=2):
print '{0}x{1}={2}'.format(i,j,i*j)
| 1 | 532,456 | null | 1 | 1 |
n, m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [int(input()) for _ in range(m)]
for i in a:
c = 0
for j, k in zip(i, b):
c += j * k
print(c)
|
n=int(input())
a=list(map(int,input().split()))
ans=[]
p=0
for i in range(n):
p=p^a[i]
for i in range(n):
k=p^a[i]
ans.append(k)
print(*ans)
| 0 | null | 6,743,080,195,500 | 56 | 123 |
a = [int(i) for i in input().split()]
a[0],a[1] = a[1],a[0]
a[0],a[2] = a[2],a[0]
print(" ".join(map(str,a)))
|
X,Y,Z = map(int,input().split())
X,Y = Y,X
X,Z = Z,X
print(X,Y,Z,sep=" ")
| 1 | 38,064,212,912,252 | null | 178 | 178 |
while(True):
H, W = map(int, input().strip().split())
if(H == W == 0):
break
for x in range(H):
print(''.join('#.'[(x + y) % 2] for y in range(W)))
print()
|
while True:
H,W = map(int,input().split())
if H == W == 0:
break
a = '#.'
b = '#'
c = '.#'
d = '.'
def bw(n):
if n % 2 == 0:
print((n//2)*a)
else:
print((n//2)*a + b)
def wb(n):
if n % 2 == 0:
print((n//2)*c)
else:
print((n//2)*c + d)
for i in range(1,H + 1):
if i % 2 == 0:
wb(W)
else:
bw(W)
print()
| 1 | 872,651,909,822 | null | 51 | 51 |
a,b = map(int, input().split())
def gcd(x, y):
if y < x:
x,y = y,x
while x%y != 0:
x,y = y,x%y
return y
def lcm(x, y):
return (x*y)//gcd(x,y)
print(lcm(a,b))
|
import math
def lcm(x, y):
return (x * y) // math.gcd(x, y)
def main():
a, b = map(int, input().split())
print(lcm(a, b))
if __name__ == '__main__':
main()
| 1 | 113,574,226,691,842 | null | 256 | 256 |
n=list(map(int,input().strip().split()))
m=list(map(int,input().strip().split()))
for i in range(n[0]-n[1]):
if(m[i+n[1]]>m[i]):
print("Yes")
else:
print("No")
|
n,k,*a=map(int,open(0).read().split())
for i in range(n-k):print("Yes" if a[i]<a[i+k] else "No")
| 1 | 7,052,100,262,140 | null | 102 | 102 |
k,n = map(int, input().split())
A = list(map(int, input().split()))
ans = 10**6
for i in range(n-1):
if ans > k - (A[i+1] - A[i]):
ans = k - (A[i+1] - A[i])
if ans > A[-1] - A[0]:
ans = A[-1] - A[0]
print(ans)
|
k, n = map(int, input().split())
a = sorted(map(int, input().split()))
ans = a[-1]-a[0]
for i in range(1, n-1):
path = k- a[-i] + a[-i-1]
ans = min(ans, path)
print(ans)
| 1 | 43,473,006,770,408 | null | 186 | 186 |
x,y = map(int,input().split())
def solve(x,y):
legs = x * 2
while(legs <= x * 4):
if legs == y:
print('Yes')
return
legs += 2
print('No')
return
solve(x,y)
|
h0, w0, k0 = [ int(x) for x in input().split() ]
found, buf = 0, {}
for i in range(h0): buf[1 << i] = { 1 << j for j,x in enumerate(input()) if x == '#' }
for i in range(1, 1 << h0):
idx = {}
for k,vs in buf.items():
if k & i == 0: continue
for v in vs: idx[v] = idx.get(v, 0) + 1
for j in range(1, 1 << w0):
n = sum([ v for k,v in idx.items() if k & j ])
if n == k0: found += 1
print(found)
| 0 | null | 11,320,203,490,320 | 127 | 110 |
N = input()
print(chr(ord(N)+1))
|
x = 'abcdefghijklmnopqrstuvwxyz'
c = str(input())
for i,data in enumerate(x):
if data == c:
print(x[i+1])
break
| 1 | 92,695,176,605,262 | null | 239 | 239 |
H = int(input())
ans,attack = 1,0
while(H > 1):
attack += 1
H //= 2
for i in range(1,attack+1):
ans += 2**i
print(ans)
|
import math
h = int(input())
x = math.floor(math.log2(h)) + 1
y = (2 ** x) - 1
print(y)
| 1 | 80,007,765,411,872 | null | 228 | 228 |
n = int(input())
k = int((n/1000)+1)*1000
print(0 if n%1000 == 0 else (k-n))
|
from collections import Counter
n = int(input())
s = Counter([input() for _ in range(n)])
before = 0
ans = []
s = s.most_common()
for i in range(len(s)):
if before == 0: before = s[i][1]
elif before != s[i][1]: break
ans.append(s[i][0])
for i in sorted(ans): print(i)
| 0 | null | 39,079,504,662,940 | 108 | 218 |
N = int(input())
count = 0
for i in range(1, N):
if i < N - i:
count += 1
print (count)
|
a = int(input())
print(a//2-(a%2==0))
| 1 | 153,206,501,307,260 | null | 283 | 283 |
l = [int (x) for x in input().split()]
for i in range (5):
if l[i] == 0:
print (i+1)
break
|
x1, x2, x3, x4, x5 = map(int, input().split())
l = [x1, x2, x3, x4, x5]
print(l.index(0)+1)
| 1 | 13,438,344,055,260 | null | 126 | 126 |
def cmb(a,b,c):
b = min(b,a-b)
num = 1
for i in range(b):
num = num*(a-i) % c
den = 1
for i in range(b):
den = den*(i+1) % c
return num * pow(den,c-2,c) % c
mod = 10**9 + 7
n,k = map(int,input().split())
inv = [0,1]
for i in range(2,n):
inv += [inv[mod % i]*(mod - mod//i) % mod]
a = list(map(int,input().split()))
a.sort()
ans = 0
c = 1
x = 1
if k == 1:
print(0)
exit()
for i in range(n-k+1):
ans -= a[n-k-i] * c
ans += a[k+i-n-1] * c
ans %= mod
c = c*(i+k)*inv[i+1] % mod
if ans < 0:
ans += mod
print(ans)
|
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue
import numpy as np
# sympy as syp(素因数分解とか)
Mod = 1000000007
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, 10**5 + 1):
fact.append((fact[-1] * i) % Mod)
inv.append((-inv[Mod % i] * (Mod // i)) % Mod)
factinv.append((factinv[-1] * inv[-1]) % Mod)
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
def sieve_of_eratosthenes(n):
if not isinstance(n,int):
raise TypeError("n is not int")
if n<2:
raise ValueError("n is not effective")
prime = [1]*(n+1)
for i in range(2,int(math.sqrt(n))+1):
if prime[i] == 1:
for j in range(2*i,n+1):
if j%i == 0:
prime[j] = 0
res = []
for i in range(2,n+1):
if prime[i] == 1:
res.append(i)
return res
class UnionFind:
def __init__(self,n):
self.parent = [i for i in range(n+1)]
self.rank = [0 for i in range(n+1)]
def findroot(self,x):
if x == self.parent[x]:
return x
else:
y = self.parent[x]
y = self.findroot(self.parent[x])
return y
def union(self,x,y):
px = self.findroot(x)
py = self.findroot(y)
if px < py:
self.parent[y] = px
else:
self.parent[px] = py
def same_group_or_no(self,x,y):
return self.findroot(x) == self.findroot(y)
def main(): #startline-------------------------------------------
n, k = map(int, input().split())
a=list(map(int, input().split()))
a.sort()
ans = 0
for i in range(n - k + 1):
t = cmb(n - i - 1, k - 1, Mod)
ans += (a[n - i - 1] * t % Mod - (a[i] * t % Mod)) % Mod
print(ans%Mod)
if __name__ == "__main__":
main() #endline===============================================
| 1 | 95,431,468,368,068 | null | 242 | 242 |
#coding: UTF-8
word = input().upper()
cnt = 0
while True:
sentence = list(map(str, input().split()))
if 'END_OF_TEXT' in sentence:
break
for i in range(len(sentence)):
if word == sentence[i].upper():
cnt += 1
print(cnt)
|
W = input()
num = 0
while True:
line = input()
if line == 'END_OF_TEXT':
break
for word in line.split():
if word.lower() == W.lower():
num += 1
print(num)
| 1 | 1,835,810,305,494 | null | 65 | 65 |
A,B=map(int,input().split())
if A>9 or B>9:
print(-1)
else:
print(A*B)
|
a, b=map(int, input().split())
print(-1 if a>9 or b>9 else a*b)
| 1 | 157,774,819,109,568 | null | 286 | 286 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.