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
|
|---|---|---|---|---|---|---|
word, num = input(), 0
while True:
sentence = input()
if sentence=="END_OF_TEXT":
break
word_list = sentence.lower().replace(".", " ").split()
for i in word_list:
if word==i:
num += 1
print(num)
|
import statistics
from collections import Counter
N = int(input())
A = [list(map(int, input().split(" "))) for i in range(N)]
xMIN = []
xMAX = []
for i in range(N):
xMIN.append(A[i][0])
for j in range(N):
xMAX.append(A[j][1])
if N % 2 != 0:
medianMIN = statistics.median(xMIN)
medianMAX = statistics.median(xMAX)
print(int(medianMAX-medianMIN+1))
else:
medianMIN_LOW = statistics.median_low(xMIN)
medianMIN_HIGH = statistics.median_high(xMIN)
medianMAX_LOW = statistics.median_low(xMAX)
medianMAX_HIGH = statistics.median_high(xMAX)
print((medianMAX_LOW+medianMAX_HIGH)-(medianMIN_LOW+medianMIN_HIGH)+1)
| 0 | null | 9,645,317,714,692 | 65 | 137 |
import bisect
X, N=map(int, input().split())
if N==0:print(X);exit()
p=sorted(list(map(int, input().split())))
#print(p)
m=min(p)-1
M=max(p)+1
#for i in range(m,M+1):
# p.append(i)
#p=sorted(p)
m=X;i=0
for i in range(m,min(p)-2,-1):
if i not in p:break
M=X;j=0
for j in range(M,max(p)+2):
if j not in p:break
if abs(i-X)==abs(j-X):print(min(i,j))
elif abs(i-X)<abs(j-X):
print(i)
else:print(j)
|
import bisect
X, N = map(int, input().split())
P = set(map(int, input().split()))
A = {i for i in range(102)}
S = list(A - P)
T = bisect.bisect_left(S, X)
if T == 0:
print(S[0])
elif X - S[T-1] > S[T] - X:
print(S[T])
else:
print(S[T-1])
| 1 | 14,093,944,108,832 | null | 128 | 128 |
from sys import stdin
readline = stdin.readline
payment, _ = map(int, readline().split())
coin = list(map(int, readline().split()))
dp = [float('inf')] * (payment + 1)
dp[0] = 0
for ci in coin:
for pi in range(ci, len(dp)):
if dp[pi] > dp[pi - ci] + 1:
dp[pi] = dp[pi - ci] + 1
print(dp[-1])
|
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
ac = Counter(a)
if len(ac) == n:
print("YES")
else:
print("NO")
| 0 | null | 37,110,011,808,630 | 28 | 222 |
import sys
input = sys.stdin.readline
def read():
S = input().strip()
return S,
def solve(S):
N = len(S)
ans = 0
for i in range(N//2):
if S[i] != S[N-i-1]:
ans += 1
return ans
if __name__ == '__main__':
inputs = read()
print(solve(*inputs))
|
list_s = list(input())
count = 0
for i in range(0, len(list_s) // 2):
if list_s[i] == list_s[0 - (i + 1)]:
continue
else: count += 1
print(count)
| 1 | 120,302,254,614,150 | null | 261 | 261 |
### ----------------
### ここから
### ----------------
import sys
from io import StringIO
import unittest
def resolve():
readline=sys.stdin.readline
mod=10**9+7
n=int(readline())
arr=list(map(int, readline().rstrip().split()))
ans = 0
x = 1
for i in range(60):
c = 0
for j in range(n):
if arr[j]&x != 0:
c += 1
ans += (c * (n-c)) * x
ans %= mod
x = x*2
print(ans)
return
if 'doTest' not in globals():
resolve()
sys.exit()
### ----------------
### ここまで
### ----------------
|
import numpy as np
n = int(input())
a = list(map(int,input().split()))
mod = 10**9+7
ans = 0
a=np.array(a)
for i in range(60):
keta = a>>i & 1
num1 = int(keta.sum())
num0 = n - num1
ans+= ((2**i)%mod)*(num1*num0)
ans%=mod
print(ans)
| 1 | 123,012,592,780,660 | null | 263 | 263 |
h,w,n=map(int,open(0));print(0--n//max(h,w))
|
import math
a = int(input())
b = int(input())
n = int(input())
dum = max(a,b)
ans = n/dum
print(math.ceil(ans))
| 1 | 88,742,711,652,490 | null | 236 | 236 |
X = int(input())
flag = False
for i in range(-120, 120):
for j in range(-120, 120):
if i ** 5 - j ** 5 == X:
print(i, j)
flag = True
break
if flag:
break
|
N = int(input())
A = list(map(int,input().split()))
Q = int(input())
S = [list(map(int, input().split())) for l in range(Q)]
numList = {}
sum = 0
for n in range(N):
if A[n] not in numList:
numList[A[n]] = 0
numList[A[n]] += 1
sum += A[n]
for q in range(Q):
if S[q][0] in numList:
if S[q][1] not in numList:
numList[S[q][1]] = 0
sum += (S[q][1] - S[q][0]) * numList[S[q][0]]
numList[S[q][1]] += numList[S[q][0]]
numList[S[q][0]] = 0
print(sum)
| 0 | null | 18,885,617,251,588 | 156 | 122 |
n , m = map(int,input().split(" "))
if n * 500 >= m:
print("Yes")
elif n * 500 < m:
print("No")
|
def ABC_150_A():
K,X = map(int, input().split())
if 500*K>=X:
print('Yes')
else:
print('No')
if __name__ == '__main__':
ABC_150_A()
| 1 | 97,766,737,106,016 | null | 244 | 244 |
N, K = map(int, input().split())
P = list(map(int, input().split()))
_c = list(map(int, input().split()))
# Cを書き換える
C = [0] * N
for i in range(N):
P[i] -= 1
C[i] = _c[P[i]]
m = 31 # bit数
# ダブリング
vertex = list()
score = list()
vertex.append(P)
score.append(C)
for b in range(1, m+1):
p_bth = [0] * N
c_bth = [0] * N
for i in range(N):
p_bth[i] = vertex[b-1][vertex[b-1][i]]
c_bth[i] = score[b-1][i] + score[b-1][vertex[b-1][i]]
vertex.append(p_bth)
score.append(c_bth)
# 桁DP
MIN = -(1 << 63)
prv = [[MIN, 0] for _ in range(N)]
nxt = [[MIN, MIN] for _ in range(N)]
for b in range(m, -1, -1):
for i in range(N):
if (K >> b) & 1:
nxt[vertex[b][i]][0] = max(nxt[vertex[b][i]][0], prv[i][0] + score[b][i])
nxt[vertex[b][i]][1] = max(nxt[vertex[b][i]][1], prv[i][1] + score[b][i])
nxt[i][0] = max(nxt[i][0], prv[i][0], prv[i][1])
else:
nxt[vertex[b][i]][0] = max(nxt[vertex[b][i]][0], prv[i][0] + score[b][i])
nxt[i][0] = max(nxt[i][0], prv[i][0])
nxt[i][1] = max(nxt[i][1], prv[i][1])
prv, nxt = nxt, prv
ans = max(max(x) for x in prv)
if ans == 0:
ans = max(C)
print(ans)
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
c = list(map(int, input().split()))
max_score = -float('inf')
for i in range(n):
loop_score_array = []
loop_score = 0
loop_len = 0
pos = i
while True:
pos = p[pos] - 1
loop_score += c[pos]
loop_score_array.append(loop_score)
loop_len+=1
if pos == i:
break
for i, score in enumerate(loop_score_array):
if k-i-1 < 0:
continue
loop_num = (k-i-1)//loop_len
score_sum = score + max(0, loop_score)*loop_num
max_score = max(score_sum, max_score)
print(max_score)
| 1 | 5,348,206,428,080 | null | 93 | 93 |
n, x, t = map(int, input().split())
answer = -((-n)//x)*t
print(answer)
|
def inp():
return input()
def iinp():
return int(input())
def inps():
return input().split()
def miinps():
return map(int,input().split())
def linps():
return list(input().split())
def lmiinps():
return list(map(int,input().split()))
def lmiinpsf(n):
return [list(map(int,input().split()))for _ in range(n)]
n,x,t = miinps()
ans = (n + (x - 1)) // x
ans *= t
print(ans)
| 1 | 4,260,113,692,732 | null | 86 | 86 |
x,n = map(int,input().split())
if n == 0:
print(x)
exit()
p = list(map(int,input().split()))
ans = []
num = 0
while ans == []:
if x + num in p and x - num in p:
num+=1
else:
if x + num not in p and x - num not in p:
ans = x - num
elif x + num not in p:
ans = x + num
else:
ans = x - num
print(ans)
|
import numpy as np
X,N = map(int,input().split())
if N ==0:
print(X)
else:
p = list(map(int,input().split()))
length =np.zeros(102)
length =list(length)
for i in range(len(length)):
length[i]= abs(X-i)
for i in range(N):
length[p[i]]=1000
ans = length.index(min(length))
print(ans)
| 1 | 14,117,265,959,990 | null | 128 | 128 |
def main():
n = int(input())
if n == 0:
print("Yes")
return
slup = []
sldown = []
for i in range(n):
height, mi = 0, 0
for si in input():
if si == "(":
height += 1
else:
height -= 1
mi = min(mi, height)
if height >= 0:
slup.append([mi, height])
else:
sldown.append([mi-height, -height])
slup.sort(key = lambda x: -x[0])
sldown.sort(key = lambda x: -x[0])
if sum([si[1] for si in slup]) + sum([-si[1] for si in sldown]):
print("No")
return
h = 0
for si in slup:
if h+si[0] < 0:
print("No")
return
h += si[1]
h = 0
for si in sldown:
if h+si[0] < 0:
print("No")
return
h += si[1]
print("Yes")
if __name__ == "__main__":
main()
|
import collections
n = int(input())
s_ls = []
dic = collections.defaultdict(int)
for i in range(n):
[s,t] = [j for j in input().split()]
s_ls.append(s)
dic[s] = int(t)
x = input()
f = 0
ans = 0
for i in range(n):
if f:
ans += dic[s_ls[i]]
if x == s_ls[i]:
f = 1
print(ans)
| 0 | null | 60,328,911,496,668 | 152 | 243 |
"""
pppppppppppppppppppp
ppppp ppppppppppppppppppp
ppppppp ppppppppppppppppppppp
pppppppp pppppppppppppppppppppp
pppppppppppppppppppppppppppppppp
pppppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppp
pppppppppppppppppppppppppppppppppppppppppppppppp ppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppp
pppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppppppp
pppppppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppp
pppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppp
ppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppppp
pppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppppppp
ppppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppppppp
pppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppppp
ppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppp
pppppppppppppppppppppppp
pppppppppppppppppppppppppppppppp
pppppppppppppppppppppp pppppppp
ppppppppppppppppppppp ppppppp
ppppppppppppppppppp ppppp
pppppppppppppppppppp
"""
import sys
from functools import lru_cache, cmp_to_key
from collections import defaultdict as dd, deque, Counter as C
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(var, end="\n"): sys.stdout.write(str(var)+end)
def outa(*var, end="\n"): sys.stdout.write(' '.join(map(str, var)) + end)
def L(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
l, r, d = sp()
answer = 0
for i in range(l, r + 1):
if i % d == 0:
answer += 1
out(answer)
|
N = int(input())
A = list(map(int,input().split()))
cnt = 0
for i in range(N):
minj = i
for j in range(i+1,N):
if A[j] < A[minj]:
minj = j
if i != minj:
A[i],A[minj] = A[minj],A[i]
cnt += 1
print(*A)
print(cnt)
| 0 | null | 3,773,443,708,188 | 104 | 15 |
import sys
t1, t2 = map(int, input().split())
a1, a2 = map(int, input().split())
b1, b2 = map(int, input().split())
a = a1 * t1 + a2 * t2
b = b1 * t1 + b2 * t2
ha = a1 * t1
hb = b1 * t1
if a == b or ha == hb:
print ("infinity")
sys.exit(0)
if a > b:
a, b = b, a
ha, hb = hb, ha
gap = b - a
hgap = ha - hb
if hgap < 0:
print (0)
sys.exit(0)
ans = 2 * (hgap // gap) + (1 if hgap % gap > 0 else 0)
print (ans)
|
def f(a,b):
if (b == 0): return a
a = a * 1.05
if (a%1000 != 0): a = a - a%1000 + 1000
return f(a,b-1)
print int(f(100000,input()))
| 0 | null | 65,505,039,992,512 | 269 | 6 |
H, W, K = map(int, input().split())
S = []
for _ in range(H):
S.append(input())
hsummation = [[int(S[0][k])]for k in range(W)]
for k in range(W):
for j in range(1, H):
hsummation[k].append(hsummation[k][j-1] + int(S[j][k]))
#print(hsummation)
ans = float('inf')
anskouho = 0
h = 2**(H-1)
for j in range(2**(H-1)):
h -= 1
binh = "0"*(H-len(str(bin(h)))+1)+str(bin(h))[2:]
hlist=[]
for k in range(H-1):
if binh[-k-1] == '1':
hlist.append(k)
hlist.append(-1)
#print(hlist)
anskouho = len(hlist)-1
now = 0
while now < W:
counter = [0 for _ in range(len(hlist))]
while now < W:
for l in range(len(hlist)):
if l == 0:
counter[l] += hsummation[now][int(hlist[l])]
continue
else:
counter[l] += - hsummation[now][hlist[l-1]] + hsummation[now][hlist[l]]
if max(counter) > K:
anskouho += 1
break
else:
now += 1
if anskouho > ans:
break
else:
ans = min(ans, anskouho)
#print(counter)
#print(anskouho)
print(ans)
|
X, Y = map(int, input().split())
ans = "No"
for i in range(101) :
for j in range(101) :
if(i + j != X) :
continue
if(2*i + 4*j != Y) :
continue
ans = "Yes"
break
print(ans)
| 0 | null | 31,030,766,029,088 | 193 | 127 |
from itertools import permutations
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
l=[i+1 for i in range(n)]
perm = permutations(l)
perm=list(perm)
p=[]
for i in perm:
k=(''.join(map(str,i)))
p.append(int(k))
a=''.join(map(str,a))
b=''.join(map(str,b))
idx1=p.index(int(a))
idx2=p.index(int(b))
print(abs(idx1-idx2))
|
n, m, q = map(int, input().split())
candidate = []
def gen(cur):
if len(cur) == n:
candidate.append(cur)
else:
t = cur[-1]
for tv in range(t, m + 1):
nex = cur[:]
nex.append(tv)
gen(nex)
for i in range(1, m + 1):
arr = [i]
gen(arr)
ask = []
for _ in range(q):
ask.append(list(map(int, input().split())))
ans = 0
for cv in candidate:
tmp = 0
for av in ask:
if cv[av[1] - 1] - cv[av[0] - 1] == av[2]:
tmp += av[3]
ans = max(ans, tmp)
print(ans)
| 0 | null | 63,786,461,008,032 | 246 | 160 |
N = int(input())
A = list(map(int, input().split()))
ans = 0
for i in range(60):
cnt1 = 0
for j in range(N):
cnt1 += (A[j]>>i)&1
ans += cnt1 * (N-cnt1) * 2**i
ans %= 10**9+7
print(ans)
|
import numpy as np
N, D = map(int,input().split())
count = 0
for _ in range(N):
x,y = map(int,input().split())
distance = np.sqrt(x**2 + y**2)
if distance <= D:
count += 1
print(count)
| 0 | null | 64,340,896,343,460 | 263 | 96 |
n, k, s = map(int, input().split())
# 1. 全部10**9
# 2. s=10**9の時, 他は1でok
if s == 10 ** 9:
a = [5] * n
else:
a = [10 ** 9] * n
for i in range(k):
a[i] = s
print(*a)
|
str0 = raw_input()
q = int(raw_input())
for i in xrange(q):
# print "###########################"
# print "str0 = " + str0
line = raw_input().split(" ")
temp = str0[int(line[1]):int(line[2])+1]
if line[0] == "print":
print temp
elif line[0] == "reverse":
temp2 = []
# print "temp = " + temp
for j in xrange(len(temp)):
temp2.append(temp[len(temp) - j - 1])
str0 = str0[:int(line[1])] + "".join(temp2) + str0[int(line[2]) + 1:]
# print "str0 = " + str0
elif line[0] == "replace":
str0 = str0[:int(line[1])] + line[3] + str0[int(line[2]) + 1:]
# print "str0 = " + str0
| 0 | null | 46,813,899,884,240 | 238 | 68 |
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
l = [A[0]]
for i in range(1, N):
l.append(A[i])
l.append(A[i])
print(sum(l[:N-1]))
|
n=int(input())
x=100000
for i in range(n):
x=x+x*0.05
x=((x-1)//1000+1)*1000
print(int(x))
| 0 | null | 4,553,296,084,218 | 111 | 6 |
def main():
N = int(input())
S = input()
print(S.count("ABC"))
if __name__ == "__main__":
main()
|
n = int(input())
s = input()
cnt = 0
for p in range(len(s)):
if p <= n - 3:
if s[p] == 'A':
if s[p + 1] == 'B' and s[p + 2] == 'C':
cnt += 1
print(cnt)
| 1 | 98,946,650,733,082 | null | 245 | 245 |
n=input()
s=[[1 for i in range(13)] for j in range(4)]
for i in range(n):
a,b=map(str,raw_input().split())
b=int(b)
if a=='S':s[0][b-1]=0
elif a=='H':s[1][b-1]=0
elif a=='C':s[2][b-1]=0
else:s[3][b-1]=0
for i in range(4):
for j in range(13):
if s[i][j]:
if i==0:print'S',j+1
if i==1:print'H',j+1
if i==2:print'C',j+1
if i==3:print'D',j+1
|
import sys
n = int(input()) # ?????£?????????????????????????????°
pic_list = ['S', 'H', 'C', 'D']
card_dict = {'S':[], 'H':[], 'C':[], 'D':[]} # ?????£?????????????????\?????????????????°
lost_card_dict = {'S':[], 'H':[], 'C':[], 'D':[]} # ?¶??????????????????\?????????????????°
# ?????????????¨??????\???????????????
for i in range(n):
pic, num = input().split()
card_dict[pic].append(int(num))
# ?¶???????????????????????¨??????\????¨????
for pic in card_dict.keys():
for j in range(1, 14):
if not j in card_dict[pic]:
lost_card_dict[pic].append(j)
# ?????????????????????
for pic in card_dict.keys():
lost_card_dict[pic] = sorted(lost_card_dict[pic])
# ?¶????????????????????????????
for pic in pic_list:
for k in range(len(lost_card_dict[pic])):
print(pic, lost_card_dict[pic][k])
| 1 | 1,049,010,353,588 | null | 54 | 54 |
a=input()
cnt=0
for i in a:
if i=='R':
cnt+=1
if cnt==2 and len(a)==3:
if a[0]=='R' and a[2]=='R':
cnt=1
print(cnt)
|
x1,x2,x3,x4,x5 = map(int,input().split())
if x1==0:
print('1')
elif x2==0:
print('2')
elif x3==0:
print('3')
elif x4==0:
print('4')
elif x5==0:
print('5')
| 0 | null | 9,097,222,843,320 | 90 | 126 |
X,Y = list(map(int,input().split()))
MAXN = 2*(10**6)+10
p = 10**9+7
f = [1]
for i in range(MAXN):
f.append(f[-1] * (i+1) % p)
def nCr(n, r, mod=p):
return f[n] * pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod
Z = (X+Y)//3
if Z*3!=X+Y:
print(0)
else:
P,Q = X-Z, Y-Z
if P<0 or Q<0:
print(0)
else:
print(nCr(Z,P))
|
import math
def isprime(x):
if x == 2:
return True
if x < 2 or x % 2 == 0:
return False
i = 3
while(i <= math.sqrt(x)):
if x % i == 0:
return False
i += 2
return True
num = raw_input()
count = 0
for i in range(int(num)):
x = raw_input()
if isprime(int(x)):
count += 1
print count
| 0 | null | 75,161,879,138,522 | 281 | 12 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list( map(int, input().split()))
A.sort()
F.sort(reverse=True)
la = 10**12+1
sm = -1
while sm+1<la:
mi = (sm+la)//2
y=0
for i in range(N):
y += max(0, A[i]-(mi//F[i]))
if y<=K:
la = mi
else:
sm = mi
print(la)
|
import sys
input = sys.stdin.readline
def solve():
N, T = map(int, input().split())
items = [tuple(map(int, input().split())) for _ in range(N)]
items.sort()
capW = T-1
dp = [0] * (capW+1)
ans = 0
for wi, vi in items:
ans = max(ans, dp[-1]+vi)
for w in reversed(range(wi, capW+1)):
v0 = dp[w-wi] + vi
if v0 > dp[w]:
dp[w] = v0
print(ans)
solve()
| 0 | null | 158,261,552,531,860 | 290 | 282 |
N = int(input())
A = list(map(int, input().split()))
x = 0
for a in A:
x ^= a
ans = []
for a in A:
ans.append(a ^ x)
print(" ".join(map(str, ans)))
|
numline=input().split(" ")
a=int(numline[0])
b=int(numline[1])
numline=input().split(" ")
numlis=[]
for i in range(a):
numlis.append(int(numline[i]))
numlis.sort()
result=0
for i in range(b):
result+=numlis[i]
print(result)
| 0 | null | 12,143,770,235,098 | 123 | 120 |
import itertools
n = int(input())
p = list(map(int,input().split()))
q = list(map(int,input().split()))
c_p = 0
c_q = 0
count = 0
for i in itertools.permutations(sorted(p),len(p)):
if p == list(i):
c_p = count
if q == list(i):
c_q = count
count += 1
print(abs(c_p - c_q))
|
def abc150c_count_order():
import bisect, itertools
n = int(input())
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
pattern = list(itertools.permutations(range(1, n+1)))
p_idx = bisect.bisect(pattern, p)
q_idx = bisect.bisect(pattern, q)
print(abs(p_idx-q_idx))
abc150c_count_order()
| 1 | 100,409,294,069,710 | null | 246 | 246 |
def readinput():
n=int(input())
a=list(map(int,input().split()))
return n,a
def main(n,a):
aa=[]
for i in range(n):
aa.append((i+1,a[i]))
aa.sort(key=lambda x:x[1])
b=[]
for i in range(n):
b.append(aa[i][0])
return b
if __name__=='__main__':
n,a=readinput()
ans=main(n,a)
print(' '.join(map(str,ans)))
|
from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from itertools import combinations # (string,3) 3回
from collections import deque
from collections import defaultdict
from fractions import gcd
import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
def readInts():
return list(map(int,input().split()))
def main():
a,b,m = readInts()
A = readInts()
B = readInts()
ans = float('inf')
for i in range(m):
x,y,c = readInts()
x -=1
y -=1
ans = min(ans,A[x] + B[y] - c)
# Aの商品の中で1番最小のやつを買うだけでもいいかもしれない
# Bの商品の中で1番最小のやつを買うだけでもいいかもしれない
ans = min(ans,min(A) + min(B))
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 117,462,144,145,192 | 299 | 200 |
#事前に階乗を計算しておく maximにnの最大値をいれる
maxim = 10**6+1
MOD = 10**9+7
kaijou = [1]*(maxim)
for i in range(1,maxim):
kaijou[i]=(kaijou[i-1]*i)%MOD
#nCr
def nCr(n,r):
if n < r:
return 0
return ((kaijou[n]*pow(kaijou[r],MOD-2,MOD))%MOD*pow(kaijou[n-r],MOD-2,MOD))%MOD
#nHr
def nHr(n,r):
if r == 0:
if n == 0:
return 1
return 0
return ((kaijou[n+r-1]*pow(kaijou[n],MOD-2,MOD))%MOD*pow(kaijou[r-1],MOD-2,MOD))%MOD
N = int(input())
ans = 0
for i in range(1,(N//3)+1):
tmp = nHr(N-3*i,i)
ans = (ans+tmp)%MOD
print(ans)
|
import sys
S = int(sys.stdin.readline())
mod = 10**9 + 7
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, 2*S+1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
def nCr(n, r, mod=10**9+7):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % mod
ans = 0
n = 1
n_max = S // 3
while n <= n_max:
res = S - 3 * n
tmp = nCr(res + n - 1, n - 1)
# print(n, res, tmp)
ans += tmp
ans %= mod
n += 1
print(ans)
| 1 | 3,295,780,609,496 | null | 79 | 79 |
import sys
read = sys.stdin.read
def main():
n = int(input())
if n <= 9 or n % 2 == 1:
print(0)
sys.exit()
n5 = 5
r = 0
while n >= n5 * 2:
r += n // (n5 * 2)
n5 *= 5
print(r)
if __name__ == '__main__':
main()
|
n,ans = int(input()),0
if not n%2:
for i in range(1,30):
ans+=n//(5**i*2)
print(ans)
| 1 | 116,321,989,183,462 | null | 258 | 258 |
ri = raw_input().split()
stack = []
for i in xrange(len(ri)):
if ri[i] == "+":
b = stack.pop()
a = stack.pop()
stack.append(str(int(a)+int(b)))
elif ri[i] == "-":
b = stack.pop()
a = stack.pop()
stack.append(str(int(a)-int(b)))
elif ri[i] == "*":
b = stack.pop()
a = stack.pop()
stack.append(str(int(a)*int(b)))
else:
stack.append(ri[i])
print stack.pop()
|
import sys
str = ""
for line in sys.stdin:
str = line
numbers = str.split()
answer = 0
stackList = []
for number in numbers :
if number == '+' :
answer = int(stackList.pop()) + int(stackList.pop())
stackList.append(answer)
elif number == '-' :
x = int(stackList.pop())
y = int(stackList.pop())
answer = y - x
stackList.append(answer)
elif number == '*' :
answer = int(stackList.pop()) * int(stackList.pop())
stackList.append(answer)
else :
stackList.append(number)
print(answer)
| 1 | 36,372,825,524 | null | 18 | 18 |
from collections import deque
n=int(input())
commands=[input().split() for i in range(n)]
List=deque()
for list_command in commands:
if 'insert' in list_command:
List.appendleft(list_command[1])
elif 'delete' in list_command:
try:
List.remove(list_command[1])
except:
pass
elif 'deleteFirst' in list_command:
List.popleft()
elif 'deleteLast' in list_command:
List.pop()
print(*List)
|
from collections import deque
n = int(input())
dlist = deque()
for i in range(n):
code = input().split()
if code[0] == "insert":
dlist.insert(0,code[1])
if code[0] == "delete":
try:
dlist.remove(code[1])
except:
continue
if code[0] == "deleteFirst":
dlist.popleft()
if code[0] == "deleteLast":
dlist.pop()
print(*dlist,sep=" ")
| 1 | 52,372,940,842 | null | 20 | 20 |
a,b,c=map(int,input().split());print('Yes'if a<b<c else'No')
|
a, b, c = [int(x) for x in input().split(" ")]
if a < b and b < c:
ans ="Yes"
else:
ans ="No"
print(ans)
| 1 | 381,558,227,656 | null | 39 | 39 |
def solve():
n, r = map(int, input().split())
return r + max(0, 100 * (10-n))
print(solve())
|
s = input()
S = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
print(7-S.index(s))
| 0 | null | 98,295,732,181,544 | 211 | 270 |
def abc150c_count_order():
import bisect, itertools
n = int(input())
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
pattern = list(itertools.permutations(range(1, n+1)))
p_idx = bisect.bisect(pattern, p)
q_idx = bisect.bisect(pattern, q)
print(abs(p_idx-q_idx))
abc150c_count_order()
|
def f(x, y):
if x % y == 0:
return y
return f(y, x % y)
a = []
while True:
try:
a.append(list(map(int, input().split())))
except EOFError:
break
for i in a:
g = f(i[0], i[1])
l = (i[0] * i[1]) / g
print(g, int(l))
| 0 | null | 50,276,495,078,510 | 246 | 5 |
def atc_153b(a: str, b: str) -> str:
HN = a.split(" ")
H = int(HN[0])
N = int(HN[1])
A = b.split(" ")
A_int = [int(ai) for ai in A]
damage = sum(A_int)
if (H - damage) <= 0:
return "Yes"
else:
return "No"
a = input()
b = input()
print(atc_153b(a, b))
|
count = 0
W = input().lower()
T = [0]
while True:
try:
if T[0] == "END_OF_TEXT":
break
for t in T:
if W == t:
count += 1
T = [x.lower() for x in input().split()]
except EOFError:
break
except IndexError:
break
print(count)
| 0 | null | 39,855,633,752,220 | 226 | 65 |
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,K = map(int,input().split())
P = list(map(int,input().split()))
C = list(map(int,input().split()))
uf = UnionFind(N)
ans = -10**9
for i in range(N):
uf.union(i,P[i]-1)
for group in uf.all_group_members().values():
size = len(group)
SUM = 0
for i in group:
SUM += C[i]
if SUM < 0:
SUM = 0
for i in group:
cur = i
current_sum = 0
remain = K
for _ in range(size):
cur = P[cur]-1
current_sum += C[cur]
remain -= 1
if remain < 0:
break
ans = max(ans,current_sum+SUM*(remain//size))
print(ans)
|
from collections import defaultdict
N, X, Y = map(int, input().split())
cnt_dict = defaultdict(int)
for i in range(1,N):
for j in range(i+1, N+1):
if j<=X or i>=Y:
path = j-i
else:
path = min(j-i, abs(X-i)+abs(j-Y)+1)
cnt_dict[path] += 1
for i in range(1,N):
print(cnt_dict[i])
| 0 | null | 24,791,470,076,268 | 93 | 187 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
temperature = int(input())
if temperature >= 30:
print('Yes')
else:
print('No')
|
import sys
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
t = int(input())
if t >= 30:
print("Yes")
else:
print("No")
| 1 | 5,761,125,739,798 | null | 95 | 95 |
import sys
N,M = map(int,input().split())
s = []
c = []
for i in range(M):
S,C = map(int,input().split())
s.append(S)
c.append(C)
for i in range(10**(N+1)):
st = str(i)
if len(st) == N and all([st[s[j]-1] == str(c[j]) for j in range(M)]):
print(st)
sys.exit()
print(-1)
|
from itertools import combinations
def is_achievable(M, X, A):
result = [0] * M
for a_row in A:
for i, a in enumerate(a_row):
result[i] += a
for n in result:
if n < X:
return False
return True
def main():
N, M, X = map(int, input().split())
C = [0] * N
A = []
for i in range(N):
query = list(map(int, input().split()))
C[i] = query[0]
A.append(query[1:])
if not is_achievable(M, X, A):
print(-1)
return
index_C = [ i for i in range(N) ]
min_cost = 10 ** 10
for i in range(len(index_C)+1):
for comb in combinations(index_C, i):
cur_A = []
cur_cost = 0
for i in comb:
cur_A.append(A[i])
cur_cost += C[i]
if is_achievable(M, X, cur_A):
min_cost = min(min_cost, cur_cost)
print(min_cost)
main()
| 0 | null | 41,789,006,920,386 | 208 | 149 |
import math
H = int(input())
ans = 0
num = 0
while True:
ans += 2**num
if H == 1:
print(ans)
break
else:
H = math.floor(H/2)
num += 1
|
d, t, s = map(int, input().split())
ans = "Yes" if d / s <= t else "No"
print(ans)
| 0 | null | 41,711,437,107,024 | 228 | 81 |
import sys
a = [0]*26
s = sys.stdin.read().lower()
for i in map(chr, range(ord('a'), ord('z')+1)):
print(i, ':', s.count(i))
|
s1 = ''
try:
while True:
t = input()
if t == '':
break
s1 += t
except EOFError:
pass
n = [0] * 26
s = s1.lower()
for i in range(len(s)):
j = ord(s[i]) - 97
if j >= 0 and j < 26:
n[j] += 1
for i in range(26):
print('%s : %d' %(chr(i + 97),n[i]))
| 1 | 1,680,864,875,588 | null | 63 | 63 |
import numpy as np
# 複数個格納
# A,B = map(int, input().split())
#A = int(input())
# 行列化
# A = np.array(A)
# A=A.reshape(1,-1)
# A=A.T
#行列の比較
#C=((A%2 == vector0).all())
#行列の作成
#A=(np.arange(0,2000,500)).reshape(1,-1)
A,B = map(int, input().split())
print(A*B)
|
from itertools import accumulate
MAX = 2 * 10 ** 5 + 5
N, M, *A = map(int, open(0).read().split())
B = [0] * MAX
for a in A:
B[a] += 1
C = list(accumulate(reversed(B)))[::-1]
ng, ok = 1, MAX
while abs(ok - ng) > 1:
m = (ok + ng) // 2
if sum(C[max(0, m - a)] for a in A) >= M:
ng = m
else:
ok = m
D = list(accumulate(reversed(list(i * b for i, b in enumerate(B)))))[::-1]
print(sum(D[max(0, ng - a)] - (ng - a) * C[max(0, ng - a)] for a in A) + ng * M)
| 0 | null | 61,806,087,490,928 | 133 | 252 |
N, X, T = map(int,input().split())
i = 0
while X * i < N: i += 1
print(T * i)
|
N,X,T=map(int,input().split())
if N%X==0:
print(N//X*T)
else:
print((N//X+1)*T)
| 1 | 4,223,958,700,160 | null | 86 | 86 |
def selection_sort(array):
count_swap = 0
for i in range(len(array)):
minj = i
for j in range(i + 1,len(array)):
if num(array[j]) < num(array[minj]):
minj = j
if num(array[minj]) is not num(array[i]):
tmp = array[minj]
array[minj] = array[i]
array[i] = tmp
count_swap += 1
return count_swap
def bubble_sort(array):
isEnd = False
count_swap = 0
while isEnd is False:
isEnd = True
for j in reversed(range(1,len(array))):
if num(array[j - 1]) > num(array[j]):
tmp = array[j - 1]
array[j - 1] = array[j]
array[j] = tmp
count_swap += 1
isEnd = False
return count_swap
def print_array(array):
print(str(array)[1:-1].replace(', ', ' ').replace('\'', ''))
def num(s):
# print(s[1])
return int(s[1])
def main():
N = int(input())
array = [s for s in input().split(' ')]
array2 = [i for i in array]
# print(array)
bubble_sort(array)
print_array(array)
print('Stable')
selection_sort(array2)
print_array(array2)
if array == array2:
print('Stable')
else:
print('Not stable')
if __name__ == '__main__':
main()
|
def main():
N, K = map(int, input().split())
N = N + 1
A=[n for n in range(N)]
S=[0]*(N+1)
for a in A:
S[a+1]+=S[a]+a
ans=0
for k in range(K, N+1):
maxS, minS=S[-1], S[k]
offset=S[-k-1]
ans+=(maxS - offset) - minS + 1
print(ans%(1000000007))
if __name__=='__main__':
main()
| 0 | null | 16,576,968,729,622 | 16 | 170 |
import sys
i=1
while True:
x=sys.stdin.readline().strip()
if x=="0":
break;
print("Case %d: %s"%(i,x))
i+=1
|
'''
Created on 2020/08/31
@author: harurun
'''
def main():
import sys
pin=sys.stdin.readline
pout=sys.stdout.write
perr=sys.stderr.write
N,M=map(int,pin().split())
ans=[0]*N
for _ in [0]*M:
s,c=map(int,pin().split())
if s==1 and c==0 and N!=1:
print(-1)
return
if ans[s-1]!=0 and ans[s-1]!=c:
print(-1)
return
ans[s-1]=c
if N==3:
if ans[0]==0:
if ans[1]==0:
print(f"{1}{0}{ans[2]}")
else:
print(f"{1}{ans[1]}{ans[2]}")
return
else:
print(f"{ans[0]}{ans[1]}{ans[2]}")
return
elif N==2:
if ans[0]==0:
print(f"{1}{ans[1]}")
else:
print(f"{ans[0]}{ans[1]}")
return
else:
print(ans[0])
return
return
main()
| 0 | null | 30,419,654,287,580 | 42 | 208 |
tmp = 0
while True:
i = raw_input().strip().split()
a = int(i[0])
b = int(i[1])
if a == 0 and b == 0:
break
if a > b:
tmp = a
a = b
b = tmp
print a,b
|
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt
from copy import deepcopy
def main():
d,t,s = map(int, input().split())
if d <= t*s:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| 0 | null | 2,054,178,746,500 | 43 | 81 |
from itertools import combinations
N = int(input())
L = sorted(list(map(int, input().split())))
ans = 0
for a,b,c in combinations(L, 3):
ans += a < b < c < a+b
print(ans)
|
tmp = input()
line = input().split(" ")
for i in range(len(line)):
line[i] = int(line[i])
line.sort()
count = 0
for i in range(0, len(line) - 2):
for j in range(1, len(line) - 1):
if i > j or i == j:
continue
for k in range(2, len(line)):
if j > k or j == k:
continue
if int(line[i]) != int(line[j]) and int(line[j]) != int(line[k]):
if int(line[i]) + int(line[j]) > int(line[k]):
count += 1
print(count)
| 1 | 5,003,248,399,350 | null | 91 | 91 |
N, K = map(int, input().split())
P = [int(i)-1 for i in input().split()]
C = [int(i) for i in input().split()]
ans = -1e18
for si in range(N):
x = si
s = []
tot = 0
while True:
x = P[x]
s.append(C[x])
tot += C[x]
if x == si:
break
l = len(s)
t = 0
for i in range(l):
t += s[i]
if i+1 > K:
break
now = t
if tot > 0:
e = (K-i-1)//l
now += tot*e
ans = max(ans, now)
print(ans)
|
def mod_max(loop, mod):
if mod == 0:
return 0
loop_len = len(loop)
mm = min(loop)
for start in range(loop_len):
current_sum = 0
for i in range(mod):
current_sum += loop[(start + i) % loop_len]
mm = max(current_sum, mm)
return mm
def main():
n, k = map(int, input().split())
p = [int(i) - 1 for i in input().split()]
c = [int(i) for i in input().split()]
seen = set()
loop_list = []
for start in range(n):
v = start
loop = []
while v not in seen:
seen.add(v)
loop.append(c[v])
v = p[v]
seen.add(v)
if loop:
loop_list.append(loop)
ans = min(c)
for loop in loop_list:
loop_len = len(loop)
loop_num = k // loop_len
loop_mod = k % loop_len
loop_sum = sum(loop)
ans = max(mod_max(loop, min(loop_len, k)), ans)
if loop_num > 0:
ans = max(loop_sum * loop_num + mod_max(loop, loop_mod), ans)
ans = max(loop_sum * (loop_num - 1) + mod_max(loop, loop_len), ans)
print(ans)
if __name__ == '__main__':
main()
| 1 | 5,432,929,784,988 | null | 93 | 93 |
def selection(l):
lists = l[:]
N = len(lists)
for i in range(N):
minj = i
for j in range(i, N):
if int(lists[j][1]) < int(lists[minj][1]):
minj = j
if i == minj:
continue
else:
lists[i], lists[minj] = lists[minj], lists[i]
return lists
def bubble(l):
lists = l[:]
N = len(lists)
flag = 1
while flag:
flag = 0
for j in range(N - 1, 1 - 1, -1):
if int(lists[j][1]) < int(lists[j - 1][1]):
lists[j], lists[j - 1] = lists[j - 1], lists[j]
flag = 1
return lists
def output(l):
count = 0
leng = len(l)
for i in l:
count += 1
if count < leng:
print(i, end =' ')
else:
print(i)
if __name__ == '__main__':
n = int(input())
l = input().split()
l_1 = bubble(l)
l_2 = selection(l)
output(l_1)
print("Stable")
output(l_2)
if l_1 == l_2:
print("Stable")
else:
print("Not stable")
|
# coding: utf-8
# Here your code !
n=int(input())
cards=input().split()
def bubble_sort(cards_b,n):
for i in range(n):
for j in range(-1,-n,-1):
a=int(cards_b[j][1])
b=int(cards_b[j-1][1])
if a<b:
cards_b[j],cards_b[j-1]=cards_b[j-1],cards_b[j]
return cards_b
def selection_sort(cards_s,n):
for i in range(n):
minv=i
for j in range(i,n):
a=int(cards_s[minv][1])
b=int(cards_s[j][1])
if a>b:
minv=j
cards_s[minv],cards_s[i]=cards_s[i],cards_s[minv]
return cards_s
dummy=cards.copy()
ans_1=bubble_sort(cards,n)
ans_2=selection_sort(dummy,n)
print(*ans_1)
print("Stable")
print(*ans_2)
if ans_1!=ans_2:
print("Not stable")
else:
print("Stable")
| 1 | 26,669,790,430 | null | 16 | 16 |
K = str(input())
print(K[0:3])
|
import sys
prime = lambda x: True if x==2 else False if x<2 or not x%2 else pow(2,x-1,x)==1
inp = sys.stdin.readlines()
print(len([prime(e) for e in list(map(int, inp[1:])) if prime(e)==1]))
| 0 | null | 7,405,286,931,782 | 130 | 12 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N, X, mod = mapint()
doubling = [[i*i%mod for i in range(mod)]]
accu = [doubling[0][:]]
for i in range(40):
tmp1 = [None]*mod
tmp2 = [None]*mod
for j in range(mod):
tmp1[j] = doubling[-1][doubling[-1][j]]
tmp2[j] = accu[-1][doubling[-1][j]] + accu[-1][j]
doubling.append(tmp1)
accu.append(tmp2)
now = X
ans = X
for i in range(40):
if (N-1)>>i&1:
ans += accu[i][now]
now = doubling[i][now]
print(ans)
|
while int(input()) != 0:
m = list(map(int, input().split()))
mean = sum(m) / len(m)
std = (sum([(i - mean) ** 2 for i in m]) / len(m)) ** 0.5
print("{:4f}".format(std))
| 0 | null | 1,528,312,521,208 | 75 | 31 |
n,m = map(int, input().split())
A = list(map(int,input().split()))
min_limit = sum(A)*(1 / (4*m))
select_ok = 0
for i in A:
if i >= min_limit:
select_ok += 1
if select_ok >= m:
print("Yes")
else:
print("No")
|
import math
n, m = map(int,input().split())
a = list(map(int,input().split()))
sum = sum(a)
x = 0
for i in a:
if i * 4 * m >= sum:
x += 1
if x >= m:
print('Yes')
else:
print('No')
| 1 | 38,945,419,109,818 | null | 179 | 179 |
n, x, m = map(int, input().split())
ans = 0
a = [0]
id = [0]*(m+1)
l = 1
while id[x] == 0:
a.append(x)
id[x] = l
ans += x
l += 1
x = x**2 % m
c = l - id[x]
s=0
for i in range(id[x],l):
s += a[i]
if n <= l-1:
ans = 0
for i in range(1,n+1):
ans += a[i]
else:
n -= l
n += 1
ans += s*(n//c)
n %= c
for i in range(n):
ans += a[id[x] + i]
print(ans)
|
N,X,M = [int(a) for a in input().split()]
amari = [0]*M
i = 1
A = X
amari[A] = i
l = [X]
ichi = i
while i<=M:
i += 1
A = A**2 % M
if amari[A]: i += M
else:
amari[A] = i
l.append(A)
if i==N: i = M+1
else:
if i>M+1: ni = i-M - amari[A]
else: ni = 0
#for j in range(M):
# if amari[j]: print(j, amari[j])
#print(i,len(l))
ichi = len(l) - ni
#print(l)
if ni:
ni_times, san = divmod((N - ichi), ni)
#print(ichi, '%d*%d'%(ni,ni_times), san)
print(sum(l[:ichi]) +
sum(l[ichi:])*ni_times +
sum(l[ichi:ichi+san]))
else:
#print(ichi, '%d*%d'%(ni,ni_times), san)
print(sum(l))
| 1 | 2,817,406,362,980 | null | 75 | 75 |
mod = 998244353
# 貰うDP
def main(N, S):
dp = [0 if n != 0 else 1 for n in range(N)] # dp[i]はマスiに行く通り数． (答えはdp[-1]), dp[0] = 1 (最初にいる場所だから1通り)
A = [0 if n != 0 else 1 for n in range(N)] # dp[i] = A[i] - A[i-1] (i >= 1), A[0] = dp[0] = 1 (i = 0) が成り立つような配列を考える．
for i in range(1, N): # 今いる点 (注目点)
for l, r in S: # 選択行動範囲 (l: 始点, r: 終点)
if i - l < 0: # 注目点が選択行動範囲の始点より手前の場合 → 注目点に来るために使用することはできない．
break
else: # 注目点に来るために使用することができる場合
dp[i] += A[i-l] - A[max(i-r, 0)-1] # lからrの間で，注目点に行くために使用できる点を逆算． そこに行くことができる = 選択行動範囲の値を選択することで注目点に達することができる通り数．
dp[i] %= mod
A[i] = (A[i-1] + dp[i]) % mod
print(dp[-1])
if __name__ == '__main__':
N, K = list(map(int, input().split()))
S = {tuple(map(int, input().split())) for k in range(K)}
S = sorted(list(S), key = lambda x:x[0]) # 始点でsort (範囲の重複がないため)
main(N, S)
|
# coding: utf-8
row, col = map(int, input().split())
spreadsheet = []
for i in range(row):
val = list(map(int, input().split()))
val.append(sum(val))
spreadsheet.append(val)
for r in spreadsheet:
print(' '.join(map(str, r)))
last_row = []
for j in range(len(spreadsheet[0])):
col_sum = 0
for i in range(len(spreadsheet)):
col_sum += spreadsheet[i][j]
last_row.append(col_sum)
print(' '.join(map(str, last_row)))
| 0 | null | 2,054,791,607,200 | 74 | 59 |
#get input
n = input()
S = map(lambda x: int(x), input().split(' '))
q = input()
T = list(map(lambda x: int(x), input().split(' ')))
#create T set
T_set = set(T)
#iterate S and counting
count = 0
for i in S:
if i in T_set:
count += 1
T_set.remove(i)
print(count)
|
N = int(input())
S = [input() for _ in range(N)]
S.sort()
check = [True]*N
item = ""
item_ = ""
dict_item = {}
cnt = 0
for i in range(N):
item_ = S[i]
if item_ != item:
item = item_
cnt += 1
print(cnt)
| 0 | null | 15,099,398,816,348 | 22 | 165 |
import sys
for line in sys.stdin:
a,b = [int(i) for i in line.split()]
print(len(str(a+b)))
|
a,b = input().split()
c = [a*int(b), b*int(a)]
print(sorted(c)[0])
| 0 | null | 41,926,616,723,762 | 3 | 232 |
a,b=map(int,input().split())
s1=str(a)*b
s2=str(b)*a
print(s1 if s2>s1 else s2)
|
import sys
input = lambda: sys.stdin.readline().rstrip()
x=int(input())
a=1
while True:
for b in range(a + 1):
if a**5+b**5==x:
print(a,-b)
sys.exit()
elif a**5-b**5==x:
print(a,b)
sys.exit()
else:
a+=1
| 0 | null | 54,925,334,115,428 | 232 | 156 |
from sys import stdin
input = stdin.buffer.readline
n, k = map(int, input().split())
*a, = map(int, input().split())
for i in range(k, n):
if a[i] > a[i - k]:
print('Yes')
else:
print('No')
|
A,B = map(int, input().split())
tmp_A, tmp_B = max(A,B), min(A,B)
while 1:
if tmp_A % tmp_B != 0:
tmp = tmp_B
tmp_B = tmp_A%tmp_B
tmp_A = tmp
else:
if tmp_B == 1:
result = A*B
break
else:
result = int(A*B/tmp_B)
break
print(result)
| 0 | null | 60,385,289,233,412 | 102 | 256 |
#!/usr/bin/env python
"""AtCoder Beginner Contest 169: A - Multiplication 1
https://atcoder.jp/contests/abc169/tasks/abc169_a
"""
def main():
A, B = list(map(int, input().split()))
print(A * B)
if __name__ == '__main__':
main()
|
n,k=map(int,input().split())
n=list(map(int,input().split()))
a=0
for i in n:
if i>=k:
a+=1
print(a)
| 0 | null | 97,755,396,824,360 | 133 | 298 |
r, c = map(int, input().split())
row_lists = []
column = []
for i in range(r):
rows = list(map(int, input().split()))
row_sum = sum(rows)
rows.append(row_sum)
row_lists.append(rows)
for j in range(c+1):
tmp_list = []
for i in range(r):
tmp = row_lists[i][j]
tmp_list.append(tmp)
sum_tmp_list = sum(tmp_list)
column.append(sum_tmp_list)
# output
for i in range(r):
print(' '.join(map(str, row_lists[i])))
print(" ".join(map(str, column)))
|
N,K=map(int,input().split())
H=list(map(int,input().split()))
H.sort()
for _ in range(min(N,K)): H.pop()
print(sum(H))
| 0 | null | 40,183,490,833,862 | 59 | 227 |
N, M = map(int, input().split())
A = list(set(map(lambda x : int(x)//2, input().split())))
def _gcd(a, b):
return a if b == 0 else _gcd(b, a%b)
def _lcm(a,b):
return (a*b) // _gcd(a,b)
lcm = A[0]
for ai in A[1:]:
lcm = _lcm(lcm, ai)
ret = (M//lcm + 1)//2
for ai in A[1:]:
if (lcm // ai) % 2 == 0:
ret = 0
break
print(ret)
|
a,b,k = map(int, input().split())
m = k if a > k else a
a -= m
b -= min(k-m, b)
print(f'{a} {b}')
| 0 | null | 102,998,198,883,732 | 247 | 249 |
from fractions import gcd
n = int(input())
a = list(map(int, input().split()))
max_a = max(a)
mod = 10**9 + 7
inverse = [1] * (max_a + 1)
for i in range(2, max_a + 1):
inverse[i] = -inverse[mod % i] * (mod // i) % mod
lcm = 1
for i in range(n):
lcm = lcm * a[i] // gcd(lcm, a[i])
lcm %= mod
sum_b = 0
for i in range(n):
sum_b = (sum_b + lcm * inverse[a[i]]) % mod
print(sum_b)
|
# エラトステネスの篩, フェルマーの小定理
def make_prime_table(N):
sieve = list(range(N + 1))
sieve[0] = -1
sieve[1] = -1
for i in range(2, int(N ** 0.5) + 1):
if sieve[i] != i:
continue
for j in range(i * i, N + 1, i):
if sieve[j] == j:
sieve[j] = i
return sieve
N = int(input())
A = list(map(int, input().split()))
m = 1000000007
prime_table = make_prime_table(1000000)
lcm_factors = {}
for i in range(N):
t = []
a = A[i]
while a != 1:
if len(t) != 0 and t[-1][0] == prime_table[a]:
t[-1][1] += 1
else:
t.append([prime_table[a], 1])
a //= prime_table[a]
for k, v in t:
if k not in lcm_factors or lcm_factors[k] < v:
lcm_factors[k] = v
lcm = 1
for k in lcm_factors:
for i in range(lcm_factors[k]):
lcm *= k
lcm %= m
result = 0
for i in range(N):
result += lcm * pow(A[i], m - 2, m)
result %= m
print(result)
| 1 | 87,936,709,021,590 | null | 235 | 235 |
a,b = map(int,input().split())
x = ''
if a < b:
x = ' < '
elif a > b:
x = ' > '
else:
x = ' == '
print('a'+x+'b')
|
data = [int(i) for i in input().split()]
if data[0] < data[1]:
print('a < b')
elif data[0] > data[1]:
print('a > b')
else:
print('a == b')
| 1 | 348,796,432,348 | null | 38 | 38 |
H,W = map(int,input().split())
s = [input() for _ in range(H)]
DP = [[1000]+[0]*W for _ in range(H+1)]
re = [[0]*(W+1) for _ in range(H+1)]
DP[0] = [1000]*(W+1)
DP[0][1] = DP[1][0] = 0
for i in range(1,H+1):
for j in range(1,W+1):
if s[i-1][j-1] == ".":
DP[i][j] = min(DP[i-1][j],DP[i][j-1])
else:
u = DP[i-1][j]+1-re[i-1][j]
l = DP[i][j-1]+1-re[i][j-1]
DP[i][j] = min(u, l)
re[i][j] = 1
print(DP[H][W])
|
H,W = map(int,input().split())
s = []
for i in range(H):
S = list(input())
s.append(S)
dis = [[float("inf")] * W for i in range(H)]
if s[0][0] == "#":
dis[0][0] = 1
else:
dis[0][0] = 0
for i in range(H):
for j in range(W):
if i != H-1:
if s[i][j] == "." and s[i+1][j] == "#":
dis[i+1][j] = min(dis[i][j] + 1,dis[i+1][j])
else:
dis[i+1][j] = min(dis[i][j],dis[i+1][j])
if j != W-1:
if s[i][j] == "." and s[i][j+1] == "#":
dis[i][j+1] = min(dis[i][j] + 1,dis[i][j+1])
else:
dis[i][j+1] = min(dis[i][j],dis[i][j+1])
print (dis[-1][-1])
| 1 | 49,353,161,529,750 | null | 194 | 194 |
S = input()
i = 0
print(S[i]+S[i+1]+S[i+2])
|
def main():
import sys
input = sys.stdin.readline
S = input().rstrip()
print(S[:3])
if __name__ == '__main__':
main()
| 1 | 14,785,733,084,382 | null | 130 | 130 |
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
#mod = 998244353
from sys import stdin
readline = stdin.readline
def readInts():
return list(map(int,readline().split()))
def readTuples():
return tuple(map(int,readline().split()))
def I():
return int(readline())
a,b = map(decimal.Decimal,input().split())
print(int(a*b))
|
n, k = map(int, input().split())
d = [0] * k
a = []
for i in range(k):
d[i] = int(input())
a_in = list(map(int, input().split()))
a.extend(a_in)
num = len(set(a))
print(n-num)
| 0 | null | 20,419,529,071,204 | 135 | 154 |
#
import sys
input=sys.stdin.readline
from collections import deque
def main():
N,M,K=map(int,input().split())
ABadj=[[] for i in range(N)]
CDadj=[set() for i in range(N)]
for i in range(M):
a,b=map(int,input().split())
ABadj[a-1].append(b-1)
ABadj[b-1].append(a-1)
for i in range(K):
c,d=map(int,input().split())
CDadj[c-1].add(d-1)
CDadj[d-1].add(c-1)
w=[-1]*N
sets=[]
j=-1
done=[-1]*N
for i in range(N):
if done[i]==-1:
sets.append(set())
j+=1
qu=deque([i])
done[i]=1
sets[j].add(i)
w[i]=j
while(len(qu)>0):
v=qu.popleft()
for nv in ABadj[v]:
if done[nv]==-1:
done[nv]=1
qu.append(nv)
sets[j].add(nv)
w[nv]=j
for i in range(N):
ans=len(sets[w[i]])-1-len(ABadj[i])
for bl in CDadj[i]:
if bl in sets[w[i]]:
ans-=1
print(ans,end=" ")
if __name__=="__main__":
main()
|
from collections import defaultdict
from collections import deque
n,m,k = map(int,input().split())
f_set = {tuple(map(int,input().split())) for _ in range(m)}
b_set = {tuple(map(int,input().split())) for _ in range(k)}
friends_counts = {key:[] for key in range(1,n+1)}
blocks_counts = {key:[] for key in range(1,n+1)}
for f in f_set:
friends_counts[f[0]].append(f[1])
friends_counts[f[1]].append(f[0])
for b in b_set:
blocks_counts[b[0]].append(b[1])
blocks_counts[b[1]].append(b[0])
friends_groups_list = [set() for _ in range(n+1)]
#dfs
que = deque()
groups_count = 0
checked_dict = {key:0 for key in range(1,n+1)}
#que.appendleft(1)
for i in range(1,n+1):
if checked_dict[i] == 1:
continue
que.appendleft(i)
checked_dict[i] = 1
while que:
x = que.popleft()
friends_groups_list[groups_count].add(x)
for i in range(len(friends_counts[x])):
if checked_dict[friends_counts[x][i]] == 0:
que.appendleft(friends_counts[x][i])
checked_dict[friends_counts[x][i]] = 1
groups_count += 1
result_list=[0]*n
#print(blocks_counts)
#print(friends_groups_list)
for i in range(len(friends_groups_list)):
mini_set = friends_groups_list[i]
for ms in mini_set:
result_list[ms-1] = len(mini_set) - 1 - len(friends_counts[ms])
block_counter_in_minilist = 0
for k in blocks_counts[ms]:
if k in mini_set:
block_counter_in_minilist += 1
result_list[ms-1] -= block_counter_in_minilist
print(" ".join(map(str,result_list)))
#cの配列の解釈が違ったらしい。。。
#f_set = {tuple(map(int,input().split())) for _ in range(m)}
#
#b_set = {tuple(map(int,input().split())) for _ in range(k)}
#
#c_list = [0] * (n-1)
#
#result_dict = {key:0 for key in range(1,n+1)}
#
#for f in f_set:
# if abs(f[0]-f[1]) == 1:
# c_list[min(f[0],f[1]) - 1] = 1
# #ここでelseで飛び石での友達のsetを作ってもよいが、そもそもsetなのでinでの探索にそんなに時間かからないし、いったんこのままやってみる。
#
#for start in range(0,n-2):
# if c_list[start] == 0:
# #c[start]が1になるまで飛ばす
# continue
#
# for end in range(start+1,n-1):
# if c_list[end] == 0:
# #友人同士ではないペアまできたらstartをインクリメント
# break
#
# #もし「友人候補」の候補者が、「友人関係でない」かつ「ブロック関係でない」ことをチェックしている。
# if not (start+1,end+2) in f_set and not (end+2,start+1) in f_set and not (start+1,end+2) in b_set and not (end+2,start+1) in b_set:
# result_dict[start+1] += 1
# result_dict[end+2] += 1
#
#for i in range(1,n+1):
# print(result_dict[i])
#
#print(c_list)
| 1 | 61,644,092,145,098 | null | 209 | 209 |
x = list(map(int,input().split()))
result = x[0]*x[1]
print(result)
|
n = input().split(" ")
print(int(n[0]) * int(n[1]))
| 1 | 15,827,835,841,088 | null | 133 | 133 |
d, t, s = map(int, input().split())
if s * t >= d:
print("Yes")
else:
print("No")
|
d, t, s = map(int, input().split())
if t * s >= d:
print('Yes')
quit()
print('No')
| 1 | 3,515,117,512,928 | null | 81 | 81 |
N = int(input())
A = list(map(int,input().split()))
sum_height = 0
max_height = A[0]
for i in range(1,len(A)):
if A[i] < max_height:
sum_height += max_height - A[i]
else:
max_height = A[i]
print(sum_height)
|
N=int(input())
A=str(input())
def ans176(N:int, A:str):
A=list(map(int,A.split()))
step_count=0
max=A[0]
for i in range(1,N):
if A[i]<max:
step_count=step_count+max-A[i]
else:
max=A[i]
return(step_count)
print(ans176(N,A))
| 1 | 4,545,278,864,430 | null | 88 | 88 |
N = int(input())
L = list(map(int, input().split()))
L.sort(reverse=True)
ans = 0
for i in range(N-2):
for j in range(i+1, N-1):
ok = i
ng = N
while ng - ok > 1:
mid = (ok + ng) // 2
if L[mid] > L[i] - L[j]:
ok = mid
else:
ng = mid
if ok > j:
ans += ok - j
print(ans)
|
import sys
import math
from collections import defaultdict
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 998244353
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def main():
N, K = NMI()
LR = [NLI() for _ in range(K)]
dp = [0] * (N*2+10)
dp[1] = 1
now = 0
for i in range(1, N+1):
now = (now + dp[i]) % MOD
for l, r in LR:
dp[i+l] = (dp[i+l] + now) % MOD
dp[i+r+1] = (dp[i+r+1] - now) % MOD
print(dp[N])
if __name__ == "__main__":
main()
| 0 | null | 87,216,389,461,468 | 294 | 74 |
x, k, d = [int(s) for s in input().split()]
x = abs(x)
q, m = divmod(x, d)
if q >= k:
x -= k * d
else:
x = m
if (k - q) & 1:
x = d - x
print(x)
|
# coding:UTF-8
import sys
from math import factorial
MOD = 10 ** 9 + 7
INF = 10000000000
# 素数列挙
def primeNumList(n):
d = [d for d in range(0, n+1)]
if n < 2:
return [[],d]
is_prime = [True] * (n + 1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n ** 0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, n + 1, i):
is_prime[j] = False
d[j] = i
return [[i for i in range(n + 1) if is_prime[i]], d]
def main():
# ------ 入力 ------#
n = int(input()) # 数字
aList = list(map(int, input().split())) # スペース区切り連続数字
# ------ 処理 ------#
amax = max(aList)
pl = primeNumList(amax)
countList = [0] * (amax+1)
if pl[0] != []:
for a in aList:
at = a
sl = []
while at != 1:
s = pl[1][at]
sl.append(s)
at = int(at / s)
sl2 = list(set(sl))
for s in sl2:
countList[s] += 1
m = max(countList)
else:
m = 0
# ------ 出力 ------#
if m == len(aList):
print("not coprime")
elif m >= 2:
print("setwise coprime")
else:
print("pairwise coprime")
if __name__ == '__main__':
main()
| 0 | null | 4,643,012,927,222 | 92 | 85 |
inputted = list(map(int, input().split()))
K = inputted[0]
X = inputted[1]
total = 500 * K;
answer = 'Yes' if total >= X else 'No';
print(answer);
|
while True:
try:
print len(list(str(sum(map(int,raw_input().split())))))
except:
break
| 0 | null | 49,027,926,701,210 | 244 | 3 |
import sys
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
n, k = inm()
H = inl()
H.sort()
def solve():
if k >= n:
return 0
return sum(H[: n - k])
print(solve())
|
r = input()
if len(r) & 1:
print("No")
else:
for i in range(0, len(r), 2):
if not (r[i] == 'h' and r[i + 1]=='i'):
print("No")
exit()
print("Yes")
| 0 | null | 66,497,081,051,828 | 227 | 199 |
x = int(input())
hap = x // 500
hap2 = (x - hap*500)//5
ans = hap*1000 + hap2*5
print(ans)
|
X=int(input())
number1=X//500
number2=(X-(X//500)*500)//5
print(number1*1000+number2*5)
| 1 | 42,718,139,330,640 | null | 185 | 185 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
for i, j in zip(a[:n-k], a[k:]):
if i < j:
print('Yes')
else:
print('No')
|
N, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
#%%
for i in range(K, N):
if A[i - K] < A[i]:
print("Yes")
else:
print("No")
| 1 | 7,082,877,217,780 | null | 102 | 102 |
r, c = [int(_) for _ in input().split()]
sum_row = [0 for _ in range(c + 1)]
for i in range(r):
row = [int(_) for _ in input().split()]
row.append(sum(row))
print(*row)
for j in range(c + 1):
sum_row[j] += row[j]
print(*sum_row)
|
r,c = map(int,input().split())
a = [list(map(int,input().split(" "))) for i in range(r)]
for i in range(r):
r_total = sum(a[i])
a[i].append(r_total)
c_total = []
for j in range(c+1):
s = 0
for k in range(r):
s += a[k][j]
c_total.append(s)
a.append(c_total)
for z in range(r+1):
for w in range(c+1):
print(a[z][w],end="")
if w != c:
print(" ",end="")
print()
| 1 | 1,350,688,115,868 | null | 59 | 59 |
def ok(a,b,c):
return (a*a+b*b==c*c)
n=input()
for i in range(n):
a,b,c=map(int,raw_input().split())
if(ok(a,b,c) or ok(b,c,a) or ok(c,a,b)):
print "YES"
else:
print "NO"
|
import sys
for e in sys.stdin.readlines():
print(len(str(eval('+'.join(e.split())))))
| 0 | null | 158,438,460 | 4 | 3 |
n=int(input())
a=list(map(int,input().split()))
b=[]
for i in range(n):
tmp=[i+1,a[i]]
b.append(tmp)
b=sorted(b,key=lambda x:x[1])
ans=[]
for j in b:
ans.append(j[0])
print(*ans)
|
n = int(input())
a = [int(x) for x in input().split()]
ans = [0] * n
for i in range(n):
ans[a[i]-1] = i+1
ans = [str(x) for x in ans]
print(" ".join(ans))
| 1 | 180,875,536,334,540 | null | 299 | 299 |
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())
v=V-W
l=abs(A-B)
if l<=v*T:
print("YES")
else:
print("NO")
| 1 | 14,968,222,420,532 | null | 131 | 131 |
n= int(raw_input())
print float((n/2) + 1)/n if n % 2 else 0.5
|
N = int(input())
A = input()
if len(A) <= N:
print(A)
else:
print(A[:N] + '...')
| 0 | null | 98,423,276,905,380 | 297 | 143 |
import sys
# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
# import heapq
import decimal
# import statistics
import queue
# import numpy as np
sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
# 約数を列挙 n=10^12までいける
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)
# divisors.sort()
divisors.remove(1)
return divisors
def main():
n = ni()
ans = set()
ans.add(n)
for i in range(2, int(n ** (0.5)) + 1):
tmp = n
while tmp % i == 0:
tmp //= i
if (tmp - 1) % i == 0:
ans.add(i)
yaku = set(make_divisors(n - 1))
ans = ans | yaku
print(len(ans))
if __name__ == '__main__':
main()
|
import numpy as np
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
if V <= W:
print("NO")
elif np.abs(A - B) / (V - W) <= T: print("YES")
else:
print("NO")
| 0 | null | 28,267,366,457,210 | 183 | 131 |
while True:
mid, term, add = map(int, input().split())
if mid == -1 and term == -1 and add == -1:
break
if mid == -1 or term == -1:
rank = 'F'
elif mid + term >= 80:
rank = 'A'
elif mid + term >= 65:
rank = 'B'
elif mid + term >= 50:
rank = 'C'
elif mid + term >= 30:
if add >= 50:
rank = 'C'
else:
rank = 'D'
else:
rank = 'F'
print(rank)
|
while(True):
m, f, r = map(int, input().split(" "))
if (m == -1) and (f == -1) and (r == -1):
exit()
if (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):
if (r >= 50):
print("C")
else:
print("D")
else:
print("F")
| 1 | 1,251,155,282,740 | null | 57 | 57 |
# 解説放送の方針
# ダメージが消える右端をキューで管理
# 右端を超えた分は、累積ダメージから引いていく
from collections import deque
N,D,A=map(int,input().split())
XH = [tuple(map(int,input().split())) for _ in range(N)]
XH = sorted(XH)
que=deque()
cum = 0
ans = 0
for i in range(N):
x,h = XH[i]
if i == 0:
r,n = x+2*D,(h+A-1)//A
d = n*A
cum += d
que.append((r,d))
ans += n
continue
while que and que[0][0]<x:
r,d = que.popleft()
cum -= d
h -= cum
if h<0:
continue
r,n = x+2*D,(h+A-1)//A
d = n*A
cum += d
que.append((r,d))
ans += n
print(ans)
|
from bisect import bisect_left
def main():
n, dis, dam = map(int, input().split())
mon = [list(map(int, input().split())) for _ in range(n)]
mon.sort(key=lambda x: x[0])
p = [v[0] for v in mon]
imos = [0]*(n+1)
dis = 2*dis + 1
ans = 0
for i in range(n):
if 0 < i:
imos[i] += imos[i-1]
if imos[i] < mon[i][1]:
tmp = (mon[i][1] - imos[i] + dam - 1) // dam
ans += tmp
tmp *= dam
imos[i] += tmp
idx = bisect_left(p, p[i]+dis)
imos[idx] -= tmp
print(ans)
if __name__ == "__main__":
main()
| 1 | 82,231,274,068,738 | null | 230 | 230 |
from collections import Counter
N=int(input())
S=input()
c=Counter(S+'RGB')
ans = (c['R']-1)*(c['G']-1)*(c['B']-1)
max_d = (N-3)//2+1
for d in range(1,max_d+1):
for i in range(N-2):
j = i+d
k = j+d
if k > N-1:break
if len(set([S[i],S[j],S[k]]))==3:
ans -= 1
print(ans)
|
n=int(input())
s=input()
r=s.count('R')
g=s.count('G')
b=s.count('B')
cnt=0
for i in range(n-1):
for j in range(1, min(i+1, n-i)):
if (s[i] != s[i-j]) and (s[i] != s[i+j]) and (s[i-j] != s[i+j]):
cnt += 1
print(r*g*b-cnt)
| 1 | 36,198,528,319,762 | null | 175 | 175 |
import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq as hpq
import itertools
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
h,w,k = map(int,ipt().split())
s = [list(map(int,list(input()))) for _ in [0]*h]
'''
sms = [[0]*w for _ in [0]*h]
for i in range(w):
for j in range(h):
sms[j][i] = sms[j-1][i]+s[j][i]
print(i)
'''
cmi = 10**18
for i in range(2**(h-1)):
pos = [0]*h
for j in range(h-1):
if (i >> j) & 1:
pos[j+1] = pos[j]+1
else:
pos[j+1] = pos[j]
cmii = pos[-1]
si = [0]*h
for jj in range(h):
si[pos[jj]] += s[jj][0]
if max(si) > k:
continue
f = True
for j in range(1,w):
if f:
for ii in range(h):
if si[pos[ii]]+s[ii][j] > k:
cmii += 1
si = [0]*h
for jj in range(h):
si[pos[jj]] += s[jj][j]
if max(si) > k:
f = False
break
else:
si[pos[ii]]+=s[ii][j]
if f and cmii < cmi:
cmi = cmii
print(cmi)
return
if __name__ == '__main__':
main()
|
H, W, K = map(int, input().split())
S = [list(map(int, input())) for _ in range(H)]
ans = 100000
for i in range(2**H):
cnt = 0
temp = i
group = [0]*H
for j in range(H):
group[j] = cnt
if temp & 1:
cnt += 1
temp >>= 1
div = [0]*H
for j in range(W):
for k in range(H):
if div[group[k]] + S[k][j] > K:
cnt += 1
div = [0]*H
for l in range(H):
div[group[l]] += S[l][j]
if div[group[l]] > K:
cnt = 100000
break
else:
div[group[k]] += S[k][j]
ans = min(ans, cnt)
print(ans)
| 1 | 48,220,079,550,020 | null | 193 | 193 |
x,y=map(int,input().split())
print(('No','Yes')[2*x<=y<=4*x and -~y%2])
|
x,y=map(int,input().split())
print(['No','Yes'][y%2==0 and 2*x <= y <= 4*x])
| 1 | 13,848,503,070,280 | null | 127 | 127 |
from math import ceil
h,w=map(int,input().split())
ans=0
if h==1 or w==1:
ans=1
elif (h*w)%2==0:
ans=int(h*w//2)
else:
ans=ceil(h*w/2)
print(ans)
|
S = input()
import re
print('Yes' if re.match(r'^(hi)+$', S) else 'No')
| 0 | null | 51,849,232,529,600 | 196 | 199 |
import math
def sieve_of_erastosthenes(num):
is_prime = [True for i in range(num+1)]
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(num**0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, num + 1, i):
is_prime[j] = False
return [i for i in range(num + 1) if is_prime[i]]
N = int(input())
A = [int(i) for i in input().split()]
ans = math.gcd(A[0], A[1])
tmp = math.gcd(A[0], A[1])
for i in range(2, N):
ans = math.gcd(ans, A[i])
if ans > 1:
print('not coprime')
exit()
maxA = max(A)
l = sieve_of_erastosthenes(maxA)
B = [False for i in range(maxA+1)]
for i in range(N):
B[A[i]] = True
flag = False
for each in l:
tmp = each
counter = 0
while True:
if B[tmp]:
counter += 1
tmp += each
if tmp > maxA:
break
if counter > 1:
flag = True
break
if flag:
print('setwise coprime')
else:
print('pairwise coprime')
|
N = int(input())
X = int(N/1.08)
for i in [-1, 0, 1]:
X_ = int((X+i)*1.08)
if(X_ == N):
print(X+i)
exit()
print(':(')
| 0 | null | 64,878,910,106,368 | 85 | 265 |
s = int(input())
maxv = -100000000000000000
minv = 10000000000000000
for i in range(s):
x = int(input())
maxv = max(maxv,x-minv)
minv = min(minv,x)
if x >= 0:
print(maxv)
else:
print("-1")
|
import sys
s_max = -float('inf')
s = 0
n = int(input())
r = list(map(int, sys.stdin.read().split()))
for i in range(1, n):
s = max(s, 0) + r[i] - r[i-1]
s_max = max(s, s_max)
print(s_max)
| 1 | 13,027,037,308 | null | 13 | 13 |
n = int(input())
stack = [["",0] for i in range(10**6*4)]
stack[0] = ["a",1]
pos = 0
while(pos>=0):
if(len(stack[pos][0]) == n):
print(stack[pos][0])
pos-=1
else:
nowstr = stack[pos][0]
nowlen = stack[pos][1]
#print(nowlen)
pos-=1
for ii in range(nowlen+1):
i = nowlen-ii
pos+=1
stack[pos][0] = nowstr+chr(ord('a')+i)
if(i == nowlen):
stack[pos][1] = nowlen+1
else:
stack[pos][1] = nowlen
|
n = int(input())
w = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
s = {}
s["a"] = 0
ans = [s]
for i in range(2, n+1):
new_s = {}
for t in s.items():
for j in range(1, i):
if t[0][-1] == w[j-1]:
for k in range(t[1] + 2):
new_s[t[0] + w[k]] = max(t[1], k)
ans.append(new_s)
s = new_s
answer = sorted(ans[n-1].keys())
for x in answer:
print(x)
| 1 | 52,393,806,733,732 | null | 198 | 198 |
import sys
input = lambda: sys.stdin.readline().rstrip()
n, m = map(int, input().split())
s = input()
ans = []
s = s[::-1]
now = 0
while True:
for i in range(m, -1, -1):
if i == 0:
print(-1)
sys.exit()
if now + i <= n and s[now + i] == "0":
now += i
ans.append(i)
if now == n:
print(*ans[::-1])
sys.exit()
else:
break
|
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
x,k,d = map(int, input().split())
x = abs(x)
if x == 0:
if k % 2 == 0:
print(0)
exit()
else:
print(abs(d))
exit()
bai = x//d
if bai >= k:
print(x-k*d)
exit()
else:
x -= bai*d
if (k-bai)%2==0:
print(x)
exit()
else:
print(abs(x-d))
| 0 | null | 72,278,722,794,948 | 274 | 92 |
def II(): return int(input())
N=II()
d=2
ans=0
while d*d<=N:
if N%d!=0:
d+=1
continue
z=d
while N%z==0:
ans+=1
N//=z
z*=d
while N%d==0:
N//=d
if N!=1:
ans+=1
print(ans)
|
# -*- coding: utf-8 -*-
N, K = map(int, input().split())
H = list(map(int, input().split()))
H = sorted(H, reverse=True)
total = 0
for i in range(K, N):
total += H[i]
print(total)
| 0 | null | 48,044,574,095,840 | 136 | 227 |
import math
import collections
import fractions
import itertools
import functools
import operator
import bisect
N = int(input())
def solve():
cnt = 0
for i in range(1, N):
cnt += (N-1)//i
print(cnt)
return 0
if __name__ == "__main__":
solve()
|
def fib(n):
if n ==0 or n == 1:
return 1
l = [0] * (n+1)
l[0] = 1
l[1] = 1
for i in range(2,n+1):
l[i] = l[i-2] + l[i-1]
return l[i]
print(fib(int(input())))
| 0 | null | 1,283,895,119,912 | 73 | 7 |
n = int(input())
total = 0
for i in range(1, n + 1):
j = n // i
if n % i == 0:
j -= 1
total += j
print(total)
|
#!/usr/bin/env python3
import sys
from collections import Counter
input = sys.stdin.readline
INF = 10**9
n, k = [int(item) for item in input().split()]
a = [int(item) - 1 for item in input().split()]
cumsum = [0] * (n + 1)
for i in range(n):
cumsum[i+1] = cumsum[i] + a[i]
cumsum[i+1] %= k
ls = list(set(cumsum))
dic = dict()
for i, item in enumerate(ls):
dic[item] = i
cnt = [0] * (n + 10)
num = 0
ans = 0
for i, item in enumerate(cumsum):
index = dic[item]
ans += cnt[index]
cnt[index] += 1
num += 1
if num >= k:
left = cumsum[i - k + 1]
index = dic[left]
if cnt[index] > 0:
cnt[index] -= 1
num -= 1
print(ans)
| 0 | null | 69,943,675,078,980 | 73 | 273 |
N, K = map(int, input().split())
x = 10
y = 10 + N
ans = 0
a = x
b = y
for i in range(1, N + 2):
if i >= K:
ans += b - a + 1
a += (x + i)
b += (y - i)
print(ans % (10 ** 9 + 7))
|
import sys
input=sys.stdin.readline #文字列入力はするな！！
sys.setrecursionlimit(10**9) #再帰の上限をあげる
n=int(input())
a=list(map(int,input().split()))
z=[0]*(10**6+1)
for i in a:
z[i]+=1
x=[-1]*(10**6+1) #2以上の自然数に対して最小の素因数を表す
x[0]=0
x[1]=1
i=2
prime=[]
while i<=10**6:
if x[i]==-1:
x[i]=i
prime.append(i)
for j in prime:
if i*j>10**6 or j>x[i]:break
x[j*i]=j
i+=1
ans=0
for i in a:
f=0
u=i
if z[u]>=2:
f=1
w=[[1,0]]
p=x[u]
cnt=1
while u>1:
if p==x[u//p]:
cnt+=1
u=u//p
else:
w.append([p,cnt])
cnt=1
u=u//p
p=x[u]
m=len(w)
def s(d,y):
global m
global i
global f
if d==m-1:
p=y
if p!=i and z[p]>=1:
f=1
else:
for j in range(w[d+1][1]+1):
s(d+1,y*(w[d+1][0]**j))
s(0,1)
if f==0:
ans+=1
print(ans)
| 0 | null | 23,743,194,335,600 | 170 | 129 |
N, K, S = map(int, input().split())
S2 = S-1 if S == 1000000000 else S+1
As = [S]*K+[S2]*(N-K)
print(" ".join(map(str, As)))
|
N, K, S = map(int,input().split())
if S != 10**9:
A = [S]*K + [S+1]*(N-K)
else:
A = [S]*K + [1]*(N-K)
print(*A)
| 1 | 90,891,818,407,180 | null | 238 | 238 |
N = int(input())
A = list(map(int,input().split()))
X = 0
for i in range(N):
X = X^A[i]
ans = []
for i in range(N):
temp = X^A[i]
ans.append(temp)
print(*ans)
|
from collections import deque
T = input()
A = deque()
d = 0
s = 0
for i, token in enumerate(T):
if token == "\\":
s += d + 0.5
if not d:
l = i
d += 1
elif token == "/":
if not d:
continue
d -= 1
s += d + 0.5
if not d:
A.append((l, s))
s = 0
else:
s += d
B = deque()
d = 0
s = 0
for i in range(len(T) - 1, -1, -1):
token = T[i]
if token == "/":
s += d + 0.5
d += 1
elif token == "\\":
if not d:
continue
d -= 1
s += d + 0.5
if not d:
B.appendleft((i, s))
s = 0
else:
s += d
S = set(A) | set(B)
S = list(S)
S.sort()
S = [round(s[1]) for s in S]
print(sum(S))
print(len(S), *S)
| 0 | null | 6,256,389,233,568 | 123 | 21 |
N = input()
K = int(input())
if len(N) < K:
print(0)
exit()
ans = [1, int(N[-1]), 0, 0];
def combination(N,K):
if N < K:
return 0
else:
p = 1
for k in range(K):
p *= N
N -= 1
for k in range(1, K+1):
p //= k
return p
for k in range(1, len(N)):
if int(N[-k-1]) > 0:
a = [1, 0, 0, 0]
for j in range(1, K+1):
a[j] += (9**(j))*combination(k, j)
a[j] += (int(N[-k-1])-1)*combination(k, j-1)*(9**(j-1)) + ans[j-1]
ans = a
print(ans[K])
|
n = input()
k = int(input())
dp0 = [[0]*(k+1) for _ in range(len(n)+1)]
dp1 = [[0]*(k+1) for _ in range(len(n)+1)]
dp0[0][0] = 1
for i in range(len(n)):
for j in range(k+1):
if int(n[i]) == 0:
dp0[i+1][j] += dp0[i][j]
if int(n[i]) > 0:
dp1[i+1][j] += dp0[i][j]
if j < k:
dp0[i+1][j+1] += dp0[i][j]
dp1[i+1][j+1] += dp0[i][j]*(int(n[i])-1)
if j < k:
dp1[i+1][j+1] += dp1[i][j]*9
dp1[i+1][j] += dp1[i][j]
print(dp0[len(n)][k]+dp1[len(n)][k])
| 1 | 75,958,012,103,838 | null | 224 | 224 |
from collections import deque
N, M, K = map(int, input().split())
friend = [list(map(int, input().split())) for _ in range(M)]
block = [list(map(int, input().split())) for _ in range(K)]
f = [set() for _ in range(N + 1)]
b = [set() for _ in range(N + 1)]
for i, j in friend:
f[i].add(j)
f[j].add(i)
for i, j in block:
b[i].add(j)
b[j].add(i)
stack = deque()
ans = [0] * (N + 1)
visited = [0] * (N + 1)
for i in range(1, N + 1):
if visited[i]:
continue
# setは{}で書く
link = {i}
stack.append(i)
visited[i] = 1
while stack:
n = stack.pop()
# nのフレンド全員について
for j in f[n]:
if visited[j] == 0:
stack.append(j)
visited[j] = 1
# link(set)に追加
link.add(j)
for i in link:
# 全体-既にフレンドの人数-ブロックした人数-自分自身
# set同士で積集合をとる
ans[i] = len(link) - len(link & f[i]) - len(link & b[i]) - 1
print(*ans[1:])
|
A, B, K = map(int, input().split())
a = max(0, A - K)
b = B
if K - A > 0:
b = max(0, B - K + A)
print(a, b)
| 0 | null | 83,169,511,465,600 | 209 | 249 |
class Dice:
def __init__(self):
self.top = 1
self.front = 2
self.left = 4
@property
def bottom(self):
return 7 - self.top
@property
def back(self):
return 7 - self.front
@property
def right(self):
return 7 - self.left
def move(self, direction):
if direction == 'N':
bottom = self.bottom
self.top = self.front
self.front = bottom
elif direction == 'W':
right = self.right
self.left = self.top
self.top = right
elif direction == 'E':
bottom = self.bottom
self.top = self.left
self.left = bottom
elif direction == 'S':
back = self.back
self.front = self.top
self.top = back
def __repr__(self):
print(self.__dict__)
dice = Dice()
numbers = input().split()
for cmd in input():
dice.move(cmd)
print(numbers[dice.top - 1])
|
class Dice1():
def move(self,direction,n):
if direction == "S":
top = n[0]
n[0] = n[4]
n[4] = n[5]
n[5] = n[1]
n[1] = top
elif direction == "N":
top = n[0]
n[0] = n[1]
n[1] = n[5]
n[5] = n[4]
n[4] = top
elif direction == "E":
top = n[0]
n[0] = n[3]
n[3] = n[5]
n[5] = n[2]
n[2] = top
elif direction == "W":
top = n[0]
n[0] = n[2]
n[2] = n[5]
n[5] = n[3]
n[3] = top
return n
n = [int(i) for i in input().split()]
di = list(input())
dc = Dice1()
for i in di:
n = dc.move(i,n)
print(n[0])
| 1 | 230,095,005,830 | null | 33 | 33 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.