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
|
|---|---|---|---|---|---|---|
import sys; input = sys.stdin.readline
from math import ceil
d, t, s = map(int, input().split())
u, l = ceil(d/t), d//t
if u == l:
if u <= s: print("Yes")
else: print("No")
else:
if d/t <= s: print("Yes")
else:print("No")
|
d,t,s = map(int, input().split())
if(d-t*s>0):
print("No")
else:
print("Yes")
| 1 | 3,553,584,928,052 | null | 81 | 81 |
S = input()
S_len = len(S)
print("x" * S_len)
|
t = input()
leng = len(t)
print('x' * leng)
| 1 | 72,944,356,159,870 | null | 221 | 221 |
def main():
k = int(input())
s = input()
n = len(s)
def cmb1(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7
N = 2*10**6
fac = [1]*(N+1)
finv = [1]*(N+1)
for i in range(N):
fac[i+1] = fac[i] * (i+1) % mod
finv[-1] = pow(fac[-1], mod-2, mod)
for i in reversed(range(N)):
finv[i] = finv[i+1] * (i+1) % mod
def cmb1(n, r, mod):
if r <0 or r > n:
return 0
r = min(r, n-r)
return fac[n] * finv[r] * finv[n-r] % mod
def power(a, n, mod):
bi=str(format(n,"b")) #2進数
res=1
for i in range(len(bi)):
res=(res*res) %mod
if bi[i]=="1":
res=(res*a) %mod
return res
ans = 0
for i in range(k+1):
temp = power(25, i, mod)
temp *= cmb1(i+n-1, n-1, mod)
temp %= mod
temp *= power(26, k-i, mod)
temp %= mod
ans += temp
print(ans%mod)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
from math import ceil
import heapq
def main():
n, d, a = map(int, input().split())
q = []
for i in range(n):
x, h = map(int, input().split())
heapq.heappush(q, (x, -ceil(h / a)))
bomb = 0
res = 0
while q:
x, h = heapq.heappop(q)
if h < 0:
h *= -1
if h > bomb:
heapq.heappush(q, (x + 2 * d, h - bomb))
res += h - bomb
bomb = h
else:
bomb -= h
print(res)
if __name__ == "__main__":
main()
| 0 | null | 47,250,299,547,890 | 124 | 230 |
def mod_pow(a, n, mod):
"""
二分累乗法による a^n (mod m)の実装
:param a: 累乗の底
:param n: 累乗の指数
:param mod: 法
:return: a^n (mod m)
"""
result = 1
a_n = a
while n > 0:
if n & 1:
result = result * a_n % mod
a_n = a_n * a_n % mod
n >>= 1
return result
def mod_inverse(a, mod):
"""
フェルマーの小定理による a^-1 ≡ 1 (mod m)の実装
aの逆元を計算する
a^-1 ≡ 1 (mod m)
a * a^-2 ≡ 1 (mod m)
a^-2 ≡ a^-1 (mod m)
:param a: 逆元を計算したい数
:param mod: 法
:return: a^-1 ≡ 1 (mod m)
"""
return mod_pow(a=a, n=mod - 2, mod=mod)
def mod_combination(n, k, mod):
fact_n = 1
fact_k = 1
for i in range(k):
fact_n *= (n - i)
fact_n %= mod
fact_k *= (i + 1)
fact_k %= mod
fact_n *= mod_inverse(fact_k, mod)
return fact_n % mod
N, A, B = map(int, input().split(' '))
MOD = 10 ** 9 + 7
print((mod_pow(2, N, MOD) - 1 - mod_combination(N, A, MOD) - mod_combination(N, B, MOD)) % MOD)
|
def main():
N, M = map(int, input().split()) # N must be an odd number
is_odd = (N-1) & 1
bias = 0
for i, distance in enumerate(range(N-1, 0, -2)):
if is_odd and distance <= -distance % N:
bias = 1
left = i + 1
right = left + distance - bias
print(left, right)
if i == M-1:
return
if __name__ == "__main__":
main()
| 0 | null | 47,493,195,286,052 | 214 | 162 |
n=input()
data=input().split()
data.reverse()
print(' '.join(data))
|
import numpy as np
#n = int(input())
a = list(map(int, input().rstrip().split()))
out=0
for i in a:
if i > 1:
out += i*(i-1)//2
print(out)
| 0 | null | 23,155,067,075,740 | 53 | 189 |
import sys
input = sys.stdin.readline
N, M, L = map(int, input().split())
INF = float('inf')
VD = [[INF] * N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
VD[a][b] = c
VD[b][a] = c
for i in range(N):
VD[i][i] = 0
for k in range(N):
for i in range(N):
for j in range(N):
if VD[i][j] > VD[i][k] + VD[k][j]:
VD[i][j] = VD[i][k] + VD[k][j]
WD = [[INF] * N for _ in range(N)]
for i in range(N):
WD[i][i] = 0
for j in range(i+1,N):
d = VD[i][j]
if d <= L:
WD[i][j] = 1
WD[j][i] = 1
for k in range(N):
for i in range(N):
for j in range(N):
if WD[i][j] > WD[i][k] + WD[k][j]:
WD[i][j] = WD[i][k] + WD[k][j]
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
print(WD[s-1][t-1]-1 if WD[s-1][t-1] < INF else -1)
|
n, m, l = map(int, input().split())
a = []
b = []
for i in range(n):
a.append(list(map(int, input().split())))
for k in range(m):
b.append(list(map(int, input().split())))
for i in range(n):
for s in range(l):
c = 0
for k in range(m):
c = c + a[i][k] * b[k][s]
if (s == l-1):
print('{}'.format(c), end = '')
else:
print('{}'.format(c), end = ' ')
print()
| 0 | null | 87,301,537,023,900 | 295 | 60 |
n,k=map(int,input().split())
a=list(map(int,input().split()))
b=[0]*n
c=[0]*n
cnt=0
while cnt<min(k,101):
cnt+=1
for i in range(n):
b[max(0,i-a[i])]+=1
if i+a[i]<n-1:
b[i+a[i]+1]-=1
c[0]=b[0]
for j in range(n-1):
c[j+1]=c[j]+b[j+1]
a=c
b=[0]*n
c=[0]*n
print(*a)
|
def main():
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n, k = map(int, readline().split())
a = list(map(int, readline().split()))
memo = [0] * (n + 1)
for _ in range(k):
flag = True
for i, aa in enumerate(a):
bf = (i - aa if i - aa >= 0 else 0)
af = (i + aa + 1 if i + aa < n else n)
memo[bf] += 1
memo[af] -= 1
for i in range(n):
memo[i + 1] += memo[i]
a[i] = memo[i]
if a[i] != n:
flag = False
memo[i] = 0
if flag:
break
print(*a)
if __name__ == '__main__':
main()
| 1 | 15,547,151,769,878 | null | 132 | 132 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
from bisect import bisect_left, bisect_right
n, d, a = map(int, input().split())
x = []
xh = dict()
for _ in range(n):
xi, hi = map(int, input().split())
x.append(xi)
xh[xi] = hi
x.sort()
l = 0
ret = 0
ai = [0] * (n+1)
anow = 0
while l < n:
xl = x[l]
hl = xh[xl]
anow += ai[l]
hl -= a * anow
if hl > 0:
r = bisect_right(x, xl+2*d)
k = (hl+(a-1))//a
ret += k
anow += k
ai[r] -= k
l += 1
print(ret)
|
n = int(raw_input())
tp = 0; hp = 0
for i in range(n):
tw,hw = raw_input().split()
if tw == hw:
tp += 1
hp += 1
elif tw > hw:
tp += 3
elif tw < hw:
hp += 3
print '%s %s' % (tp,hp)
| 0 | null | 42,213,629,427,280 | 230 | 67 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N, K = mapint()
As = list(mapint())
mod = 10**9+7
pos = []
neg = []
for a in As:
if a>=0:
pos.append(a)
else:
neg.append(a)
pos.sort(reverse=True)
neg.sort()
ans = 1
lenp, lenn = len(pos), len(neg)
if (lenp+lenn)==K:
for a in As:
ans *= a
ans %= mod
print(ans)
elif lenn==0:
for i in range(K):
ans *= pos[i]
ans %= mod
print(ans)
elif lenp==0:
if K%2==0:
for i in range(K):
ans *= neg[i]
ans %= mod
print(ans)
else:
neg = neg[::-1]
for i in range(K):
ans *= neg[i]
ans %= mod
print(ans)
else:
p, n = 0, 0
while p+n+1<K:
if p+2<=lenp and n+2<=lenn:
if pos[p]*pos[p+1]>=neg[n]*neg[n+1]:
ans *= pos[p]
p += 1
else:
ans *= neg[n]*neg[n+1]
n += 2
elif n+2<=lenn:
ans *= neg[n]*neg[n+1]
n += 2
else:
ans *= pos[p]
p += 1
ans %= mod
if p+n<K:
ans *= pos[p]
ans %= mod
print(ans)
|
# Template 1.0
import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx): return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
toret = {}
for tup in temp:
toret[tup[0]] = tup[1]
return toret
def sortDictWithKey(passedDic):
return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
n, k = MAP()
a = LIST()
pos = []
neg = []
zero = []
for el in a:
if(el<0):
neg.append(el)
elif(el>0):
pos.append(el)
else:
zero.append(el)
pos = sorted(pos)[::-1]
neg = sorted(neg)[::-1]
ans = 1
if(k==n or k>len(pos)+len(neg)):
for el in a:
ans = (ans%mod*el%mod)%mod
elif(len(pos)+len(neg)==k):
if(len(neg)%2!=0):
ans = 0
else:
for el in pos:
ans = (ans%mod*el%mod)%mod
for el in neg:
ans = (ans%mod*el%mod)%mod
else:
if(len(pos)==0):
if(k%2==0):
temp = 0
for i in range(len(neg)-1, -1, -1):
if(temp==k):
break
ans = (ans%mod*neg[i]%mod)%mod
temp+=1
if(temp<k):
ans = 0
else:
temp = 0
if(0 in a):
ans = 0
else:
for i in range(len(neg) - 1):
if (temp == k):
break
ans = (ans%mod * neg[i]%mod) % mod
temp += 1
if (temp < k):
ans = 0
else:
left = k
i,j = 0, len(neg)-1
while(left>1):
temp, temp1 = 0, 0
if(i<len(pos)-1):
temp = pos[i]*pos[i+1]
# i+=2
if(j>=1):
temp1 = neg[j]*neg[j-1]
# j-=2
if(temp==0 and temp1==0):
break
if(temp1>temp):
ans = (ans*(temp1%mod))%mod
j-=2
else:
ans = (ans*(temp%mod))%mod
i+=2
left -= 2
# print(ans,i,j)
if(left>1):
ans = 0
elif(left==1):
if(i<len(pos)):
ans = ((ans%mod)*pos[i])%mod
else:
ans1 = 1
for b in range(i-1):
ans1 = (ans1%mod*(pos[b]))%mod
for c in range(len(neg)-1, j-2,-1):
ans1 = (ans1%mod*neg[c])%mod
ans = max(ans, ans1)
if(k%2!=0):
ans1 = 1
if(i-2>=0 and j-2>=-1 and i-2<=len(pos)-1 and j-2<=len(neg)-1):
for b in range(i-1):
ans1 = (ans1%mod*(pos[b]))%mod
for c in range(len(neg)-1, j-2,-1):
ans1 = (ans1%mod*neg[c])%mod
# print(ans, ans1)
ans = max(ans, ans1)
print(ans)
| 1 | 9,319,112,039,040 | null | 112 | 112 |
n = int(input())
arm = []
for i in range(n):
x , l = map(int,input().split())
arm.append([x,l])
arm.sort()
dp = [[0,0] for i in range(n)]
dp[0][1] = arm[0][0] + arm[0][1]
for i in range(1,n):
if dp[i-1][1] <= arm[i][0] -arm[i][1]:
dp[i][0] = dp[i-1][0]
dp[i][1] = arm[i][0] + arm[i][1]
else:
dp[i][0] = dp[i-1][0] + 1
dp[i][1] = min(arm[i][0] + arm[i][1],dp[i-1][1])
print(n-dp[n-1][0])
|
n = int(input())
robot = [0]*n
for i in range(n):
x,l = map(int,input().split())
robot[i] = (x+l, x-l)
robot.sort()
#print(robot)
ans = 1
right = robot[0][0]
for i in range(1,n):
if right <= robot[i][1]:
right = robot[i][0]
ans += 1
print(ans)
| 1 | 89,720,212,545,432 | null | 237 | 237 |
from sys import stdin
input = stdin.readline
def main():
N = int(input())
A = sorted(list(map(int, input().split())))
not_divisible = [False]*(10**6+1)
for i in range(N):
not_divisible[A[i]] = True
prev = 0
for i in range(N):
if not_divisible[A[i]]:
j = A[i] + A[i]
while j <= A[-1]:
not_divisible[j] = False
j += A[i]
if prev == A[i]:
not_divisible[A[i]] = False
prev = A[i]
cnt = 0
for i in range(N):
if not_divisible[A[i]]:
cnt += 1
print(cnt)
if(__name__ == '__main__'):
main()
|
import numpy as np
n = int(input())
a = np.array(list(map(int,input().split())))
amax=max(a)+1
ah=[0]*amax
for i in a:
for j in range(i,amax,i):
ah[j]+=1
an=0
for i in a:
if ah[i]==1:
an+=1
print(an)
| 1 | 14,381,466,738,112 | null | 129 | 129 |
k, n = map(int, input().split())
A = list(map(int, input().split()))
diff = []
for i in range(n-1):
diff.append(A[i+1] - A[i])
diff.append(A[0]+k-A[-1])
print(sum(diff)-max(diff))
|
k, n = list(map(int, input().split()))
a = list(map(int, input().split()))
d = []
for i in range(n):
if i == n - 1:
d.append(a[0] + (k - a[i]))
else:
d.append(a[i + 1] - a[i])
d.sort()
print(sum(d[:-1]))
| 1 | 43,758,337,612,170 | null | 186 | 186 |
M,D=map(int,input().split())
MM,DD=map(int,input().split())
if D>DD:
print(1)
else:
print(0)
|
a,b=input().split()
c,d=input().split()
b=int(b)
d=int(d)
if d-b==1:
print("0")
else:
print("1")
| 1 | 124,405,570,600,828 | null | 264 | 264 |
N,X,Y =map(int,input().split())
count = [0] * (N-1)
for i in range(1,N):
for j in range(i+1,N+1):
dist = min(j-i, abs(X-i)+1+abs(Y-j))
count[dist-1] +=1
print("\n".join(map(str,count)))
|
while True:
(n, x) = input().rstrip('\r\n').split(' ')
n = int(n)
x = int(x)
if n == 0 and x == 0:
break
a = []
for ii in range(n):
a.append(ii + 1)
c = 0
for ii in range(len(a)):
for jj in range(ii + 1, len(a)):
for kk in range(jj + 1, len(a)):
if a[ii] + a[jj] + a[kk] == x:
c += 1
print(c)
| 0 | null | 22,689,119,246,338 | 187 | 58 |
h, w = map(int, input().split())
if h==1 or w == 1:
print(1)
else:
ans = h * w //2 + (h*w)%2
print(ans)
|
h,w=map(int,input().split())
if h!=1 and w!=1:
print((h*w+2-1)//2)
else:
print(1)
| 1 | 50,700,046,919,040 | null | 196 | 196 |
a,b = map(int,input().split())
for i in range(1,1100):
if int(i*0.08) == a:
if int(i*0.1) == b:
print(i)
exit()
print("-1")
|
import math
A, B = map(int, input().split())
answer = -1
for x in range(10000):
if math.floor(x * 0.08) == A and math.floor(x * 0.10) == B:
answer = x
break
print(answer)
| 1 | 56,564,492,453,980 | null | 203 | 203 |
N = int(input())
A = input().split()
num_list = [0] * 10**5
ans = 0
for i in range(N):
num_list[int(A[i])-1] += 1
for i in range(10**5):
ans += (i+1) * num_list[i]
Q = int(input())
for i in range(Q):
B, C = map(int, input().split())
ans = ans + C * num_list[B-1] - B * num_list[B-1]
num_list[C-1] += num_list[B-1]
num_list[B-1] = 0
print(ans)
|
# -*- coding:utf-8 -*-
def solve():
"""しゃくとり法で解く"""
N = int(input())
As = list(map(int, input().split()))
# 数列Aの要素aが何個あるかを保持する辞書dic
dic = {}
for a in As:
if not a in dic:
dic[a] = 0
dic[a] += 1
S = sum(As) # 総和
# 各クエリでしゃくとりする
Q = int(input())
for q in range(Q):
b, c = list(map(int, input().split()))
if b in dic:
if not c in dic:
dic[c] = 0
S -= b*dic[b]
S += c*dic[b]
dic[c] += dic[b]
dic[b] = 0
print(S)
if __name__ == "__main__":
solve()
| 1 | 12,124,842,312,132 | null | 122 | 122 |
n, k = map(int, input().split())
okashi = []
for _ in range(2 * k):
okashi.append(list(map(int, input().split())))
flag = [0] * n
for i in range(int(len(okashi) / 2)):
i = 2 * i + 1
for j in okashi[i]:
flag[j-1] = 1
count = 0
for i in flag:
if i == 0:
count += 1
print(count)
|
w=input()
ll=list()
while True:
T=input()
if T=="END_OF_TEXT":
break
T=T.lower()
t=T.split()
for i in t:
ll.append(i)
ans=ll.count(w)
print(ans)
| 0 | null | 13,232,485,862,550 | 154 | 65 |
print((int(input())+1)%2)
|
h,n=map(int,input().split())
A=[]
B=[]
for i in range(n):
a,b=map(int,input().split())
A.append(a)
B.append(b)
dp=[10**10 for i in range(h+1)]
dp[h]=0
for i in reversed(range(1,h+1)):
for j in range(n):
if i-A[j]>=0:
dp[i-A[j]]=min(dp[i-A[j]],dp[i]+B[j])
else:
dp[0]=min(dp[0],dp[i]+B[j])
print(dp[0])
| 0 | null | 42,185,992,166,710 | 76 | 229 |
word = input()
num = int(input())
for index in range(num):
code = input().split()
instruction = code[0]
start, end = int(code[1]), int(code[2])
if instruction == "replace":
word = word[:start] + code[3] + word[end+1:]
elif instruction == "reverse":
reversed_ch = "".join(reversed(word[start:end+1]))
word = word[:start] + reversed_ch + word[end+1:]
else:
print(word[start:end+1])
|
#coding: utf-8
s = input()
q = int(input())
for i in range(q):
order = input().split(" ")
if order[0] == "print":
print(s[int(order[1]) : int(order[2])+1])
elif order[0] == "reverse":
r = s[int(order[1]) : int(order[2])+1]
r = r[::-1]
s = s[:int(order[1])] + r + s[int(order[2])+1:]
elif order[0] == "replace":
s = s[:int(order[1])] + order[3] + s[int(order[2])+1:]
| 1 | 2,067,990,417,152 | null | 68 | 68 |
n = int(input())
def gcd(a,b):
if b == 0:
return a
return gcd(b, a%b)
print((360 * n // gcd(360, n)) // n)
|
# -*- coding: utf-8 -*-
loop = 1
while(loop):
l = input().strip().split()
H = int(l[0])
W = int(l[1])
if(H == 0 and W == 0):
break
else:
for y in (range(H)):
for x in (range(W)):
if(x == 0 or y == 0 or x == (W-1) or y == (H-1)):
print("#",end="")
else:
print(".",end="")
print()
print()
| 0 | null | 6,943,203,904,664 | 125 | 50 |
list = []
while True:
line = raw_input()
list.append(line)
if line == "0":
break
i = 0
for x in list[:-1]:
i += 1
print "Case %d: %s" % (i, x)
|
l=list(map(int,input().split()))
if sum(l)%9==0:
print('Yes')
else:
print('No')
| 0 | null | 2,475,645,983,360 | 42 | 87 |
a = int(input())
i = 1
while a!=0:
print("Case "+str(i)+":",a)
a = int(input())
i = i+1
|
a=1
while True:
i = input()
if i==0:
break
else :
print "Case %d: %d"%(a,i)
a+=1
| 1 | 479,452,347,680 | null | 42 | 42 |
import math
a, b, h, m = list(map(int, input().split()))
deg_m = (m / 60) * 360
deg_h = ((60 * h + m) / 720) * 360
deg = abs(deg_h - deg_m)
deg = math.radians(min(360 - deg, deg))
x2 = b ** 2 + a ** 2 - 2 * b * a * math.cos(deg)
print(x2**0.5)
|
n, m = map(int,input().split())
a = [[0]*m for i in range(n)]
b = [0]*m
for i in range(n):
a[i] = list(map(int,input().split()))
for j in range(m):
b[j] = int(input())
c = [0]*n
for i in range(n):
for j in range(m):
c[i] += a[i][j] * b[j]
for i in c:
print(i)
| 0 | null | 10,508,145,143,300 | 144 | 56 |
def solve(n):
return (n+1)//2
n = int(input())
print(solve(n))
|
def sep():
return map(int,input().strip().split(" "))
def lis():
return list(sep())
n=int(input())
print((n+1)//2)
| 1 | 59,073,483,898,000 | null | 206 | 206 |
#!/usr/bin/env python3
import sys
from math import gcd
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
A, B = map(int, input().split())
gc = gcd(A, B)
LCM = A * B // gc
print(LCM)
|
from collections import deque
n = int(input())
Q= deque()
for _ in range(n):
str = input()
if str == "deleteFirst":
Q.popleft()
elif str == "deleteLast":
Q.pop()
else:
cmd,key = str.split()
if cmd == "insert":
Q.appendleft(key)
elif cmd == "delete":
try:
Q.remove(key)
except:
pass
print(" ".join(list(Q)))
| 0 | null | 56,846,615,828,420 | 256 | 20 |
N = int(input())
A_list = [int(i) for i in input().split()]
monney = 1000
stock = 0
def max_day(index):
if index == N-1 or (A_list[index] > A_list[index+1]):
return index
return max_day(index+1)
def min_day(index):
if index == N-1:
return -1
if A_list[index] < A_list[index+1]:
return index
return min_day(index+1)
def main(day=0, flag="buy"):
global monney, stock
if flag == "buy":
buy_day = min_day(day)
if buy_day == -1:
return monney
stock, monney = divmod(monney, A_list[buy_day])
return main(buy_day+1, "sell")
elif flag == "sell":
sell_day = max_day(day)
monney += stock * A_list[sell_day]
stock = 0
if sell_day == N-1:
return monney
return main(sell_day+1, "buy")
print(main())
|
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
n = inp()
a = inpl()
sign = [-1]*n
pre = -1
for i in range(1,n):
if a[i] > a[i - 1]:
sign[i] = 1
pre = 1
elif a[i] < a[i - 1]:
sign[i] = -1
pre = -1
else:
sign[i] = pre
money = 1000
stock = 0
for i in range(n):
if sign[i] == 0 or (i != n-1 and sign[i] == sign[i + 1]):
continue
if sign[i] == 1:
#売る
money += a[i] * stock
stock = 0
elif sign[i] == -1:
flg = False
if [j for j in sign[i:] if j == 1]:
flg = True
#買う
if flg == True:
buy = money // a[i]
stock += buy
money -= a[i] * buy
print(money)
| 1 | 7,275,396,372,252 | null | 103 | 103 |
from collections import deque
n=int(input())
que=deque()
for i in range(n):
command=input()
if command=="deleteFirst":
que.popleft()
elif command=="deleteLast":
que.pop()
else:
command,num=command.split()
num=int(num)
if command=="insert":
que.appendleft(num)
else:
if num in que:
que.remove(num)
print(*que,sep=" ")
|
from collections import deque
def process_command(dll, commands):
# line_count = 1
for cmd in commands:
# print('processing line: {0}'.format(line_count))
# line_count += 1
# print(cmd)
try:
cmd, num_str = cmd.split()
except ValueError:
pass
# if cmd.startswith('insert') or cmd.startswith('delete '):
# t = cmd.split(' ')
# cmd = t[0]
# num_str = t[1]
if cmd == 'insert':
dll.appendleft(int(num_str))
elif cmd == 'delete':
# deque.index() ????????¨??§???????????? python3.5??\???????????§???????????§??¢???
if int(num_str) in dll: # ?????????????????????????????¨???????????´?????????????????????????????????
temp = []
result = dll.popleft()
while result != int(num_str):
temp.append(result)
result = dll.popleft()
temp = temp[::-1]
dll.extendleft(temp)
elif cmd == 'deleteFirst':
dll.popleft()
elif cmd == 'deleteLast':
dll.pop()
# print(dll)
# print('=' * 64)
if __name__ == '__main__':
# ??????????????\???
commands = []
num = int(input())
commands = [input() for i in range(num)]
# ??????
dll = deque()
process_command(dll, commands)
# ???????????????
print('{0}'.format(' '.join(map(str, dll))))
| 1 | 48,984,832,360 | null | 20 | 20 |
while True:
h, w = map(int, input().split())
if not h and not w:
break
result = []
w2 = w >> 1
if w % 2:
for i in range(h):
if i % 2:
result.append(".#" * w2 + ".")
else:
result.append("#." * w2 + "#")
else:
for i in range(h):
if i % 2:
result.append(".#" * w2)
else:
result.append("#." * w2)
print("\n".join(result) + "\n")
|
# coding : utf-8
lst = []
while True:
h, w = map(int, input().split())
lst.append([h, w])
if h == 0 and w == 0:
break
for l in lst:
H = l[0]
W = l[1]
for i in range(H):
for j in range(W):
if (i + j) % 2 == 0:
print ('#', end = '')
else:
print ('.', end = '')
print ('')
if i == H-1:
print ('')
| 1 | 866,062,246,648 | null | 51 | 51 |
X, Y = tuple(map(int, input().split()))
# Calculate prize for "Coding Contest"
prize_code = 0;
if X == 1:
prize_code = 300000;
elif X == 2:
prize_code = 200000;
elif X == 3:
prize_code = 100000;
# Calculate prize for "Robot Maneuver"
prize_device = 0;
if Y == 1:
prize_device = 300000;
elif Y == 2:
prize_device = 200000;
elif Y == 3:
prize_device = 100000;
# Calculate prize for "two victories"
prize_both = 0
if X == 1 and Y == 1:
prize_both = 400000
# Calculate the sum and print the answer
prize_total = prize_code + prize_device + prize_both
print(prize_total)
|
X,Y = map(int,input().split())
price = [3*10**5, 2*10**5, 1*10**5]
ans = 0
if X == 1 and Y == 1:
ans += 4*10**5
X -= 1
Y -= 1
if X < 3:
ans += price[X]
if Y < 3:
ans += price[Y]
print(ans)
| 1 | 140,573,167,948,132 | null | 275 | 275 |
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
N, K = LI()
# 逆に考える
"""
X = gcd(A_1, A_2,...A_K)
となるようなXを考えると溶ける
X = 3の時その個数は
[K/3]**N
"""
x_cnt = [0] * (K + 1)
for x in range(K, 0, -1):
# print(x)
tmp = pow(K // x, N, mod)
for j in range(x + x, K+1, x):
tmp -= x_cnt[j]
x_cnt[x] = tmp
ans = 0
for i in range(1,K+1):
ans += i * x_cnt[i]
ans %= mod
print(ans)
|
n, k = map(int, input().split())
prime_mod = 10**9+7
countgcd = [0]*k
for idx in range(k, 0, -1):
num_multiples = k//idx
num_sequences = pow(num_multiples, n, prime_mod)
overcount = sum(countgcd[j*idx-1] for j in range(2, num_multiples+1))
overcount = overcount%prime_mod
countgcd[idx-1] = (num_sequences-overcount)%prime_mod
# print(idx, num_multiples, num_sequences, overcount, num_sequences-overcount)
final_sum = 0
for idx in range(1, k+1):
final_sum = (final_sum + idx*countgcd[idx-1])%prime_mod
print(final_sum)
| 1 | 36,722,615,976,556 | null | 176 | 176 |
W,H,x,y,r = [int(s) for s in input().split()]
if 0 <= (x-r) <= (x+r) <= W:
if 0 <= (y-r) <= (y+r) <= H:
print("Yes")
else:
print("No")
else:
print("No")
|
i = input().split(' ')
W = int(i[0])
H = int(i[1])
x = int(i[2])
y = int(i[3])
r = int(i[4])
if x - r >= 0 and y - r >= 0 and x + r <= W and y + r <= H:
print('Yes')
else:
print('No')
| 1 | 452,433,887,100 | null | 41 | 41 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
N = int(readline())
odd = 0
for i in range(1, N + 1):
if i % 2 == 1:
odd += 1
print(odd / N)
if __name__ == '__main__':
main()
|
n=int(input())
print((n//2+n%2)/n)
| 1 | 177,707,859,387,382 | null | 297 | 297 |
from collections import OrderedDict
n, x, y = map(int, input().split())
x = x-1
y = y-1
dist_hist = OrderedDict({i: 0 for i in range(1, n)})
for i in range(n-1):
for j in range(i+1, n):
if i<=x and j>=y:
dist = j-i + 1 - (y-x)
elif i<=x and x<j<y:
dist = min(j-i, x-i + 1 + y-j)
elif x<i<y and y<=j:
dist = min(i-x + 1 + j-y, j-i)
elif x<i<y and x<j<y:
dist = min(j-i, i-x + 1 + y-j)
else:
dist = j - i
dist_hist[dist] += 1
[print(value) for value in dist_hist.values()]
|
def main():
A, B, C, K = map(int, input().split())
if K <= A + B:
print(min([A, K]))
else:
print(A - (K - A - B))
if __name__ == '__main__':
main()
| 0 | null | 32,784,879,220,702 | 187 | 148 |
s = input ()
S = s.upper ()
if s == S:
print ('A')
else:
print ('a')
|
from bisect import bisect_left, bisect_right, insort_left
import sys
readlines = sys.stdin.readline
def main():
n = int(input())
s = list(input())
q = int(input())
d = {}
flag = {}
for i in list('abcdefghijklmnopqrstuvwxyz'):
d.setdefault(i, []).append(-1)
flag.setdefault(i, []).append(-1)
for i in range(n):
d.setdefault(s[i], []).append(i)
for i in range(q):
q1,q2,q3 = map(str,input().split())
if q1 == '1':
q2 = int(q2) - 1
if s[q2] != q3:
insort_left(flag[s[q2]],q2)
insort_left(d[q3],q2)
s[q2] = q3
else:
ans = 0
q2 = int(q2) - 1
q3 = int(q3) - 1
if q2 == q3:
print(1)
continue
for string,l in d.items():
res = 0
if d[string] != [-1]:
left = bisect_left(l,q2)
right = bisect_right(l,q3)
else:
left = 0
right = 0
if string in flag:
left2 = bisect_left(flag[string],q2)
right2 = bisect_right(flag[string],q3)
else:
left2 = 0
right2 = 0
if left != right:
if right - left > right2 - left2:
res = 1
ans += res
#print(string,l,res)
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 37,115,478,289,312 | 119 | 210 |
import sys
sys.setrecursionlimit(200001)
N, M = [int(n) for n in input().split()]
S = input()
p1 = False
x1 = 0
m1 = N
c1 = 0
for n in S:
if n == "1":
if p1:
c1 += 1
else:
c1 = 1
p1 = True
else:
p1 = False
if c1 > 0:
if c1 > x1:
x1 = c1
if c1 < m1:
m1 = c1
def rest(l, ans):
s = M
while s > 0:
if s >= l:
ans.append(l)
return ans
if S[l-s] == "1":
if s == 1:
return -1
s -= 1
continue
l -= s
if rest(l, ans) == -1:
s -= 1
else:
ans.append(s)
return ans
return -1
if x1 > M - 1:
ans = -1
else:
ans = rest(N, [])
if ans == -1:
print(-1)
else:
print(" ".join([str(n) for n in ans]))
|
import bisect
N, M = map(int, input().split())
S = input()
ok = True
cnt = 0
for c in S:
if c == "1":
cnt += 1
if cnt == M:
ok = False
break
else:
cnt = 0
# 後ろから見て、各マスからもっとも近い右側の0の位置を格納(S[i]=0ならi)
ngo_pos = [0 for _ in range(N+1)]
most_neighbor_zero_pos = N
for i in range(N, -1, -1):
if S[i] == "0":
ngo_pos[i] = i
most_neighbor_zero_pos = i
else:
ngo_pos[i] = most_neighbor_zero_pos
if not ok:
print(-1)
else:
ans = []
pos = N
while pos > 0:
npos = ngo_pos[max(0, pos-M)]
ans.append(pos-npos)
pos = npos
print(" ".join(map(str, ans[::-1])))
| 1 | 138,645,397,859,738 | null | 274 | 274 |
#python2.7
N,M = raw_input().split()
time=0
flag=1
A=[]
for i in range(int(N)):
A.append(raw_input().split())
while len(A)!=0:
if(int(A[0][1])>int(M)):
A[0][1]=str(int(A[0][1])-int(M))
A.append(A[0])
del A[0]
time+=int(M)
else:
time+=int(A[0][1])
print A[0][0]+" "+str(time)
del A[0]
|
process_num, qms = map(int, input().split())
raw_procs = [input() for i in range(process_num)]
if __name__ == '__main__':
procs = []
for row in raw_procs:
name, time = row.split()
procs.append({
"name": name,
"time": int(time),
})
total_time = 0
current_proc = 0
while len(procs) > 0:
if procs[current_proc]["time"] > qms:
procs[current_proc]["time"] = procs[current_proc]["time"] - qms
total_time += qms
if current_proc == len(procs)-1:
current_proc = 0
else:
current_proc += 1
else:
total_time += procs[current_proc]["time"]
print("{} {}".format(procs[current_proc]["name"], total_time))
del procs[current_proc]
if current_proc == len(procs):
current_proc = 0
| 1 | 45,697,562,950 | null | 19 | 19 |
string = list(input())
times = int(input())
for i in range(times):
order = input().split()
if order[0] == "print":
print("".join(string[int(order[1]):int(order[2]) + 1]))
elif order[0] == "replace":
string[int(order[1]):int(order[2]) + 1] = order[3]
else:
string[int(order[1]):int(order[2]) + 1] = list(reversed(string[int(order[1]):int(order[2]) + 1]))
|
word = input()
n = int(input())
for _ in range(n):
meirei = input().split()
if meirei[0] == "print":
print(word[int(meirei[1]):int(meirei[2])+1])
elif meirei[0] == "reverse":
word = word[:int(meirei[1])] + word[int(meirei[1]):int(meirei[2])+1][::-1] + word[int(meirei[2])+1:]
elif meirei[0] == "replace":
word = word[:int(meirei[1])] + meirei[3] + word[int(meirei[2])+1:]
| 1 | 2,084,605,775,300 | null | 68 | 68 |
h,n = map(int, input().split())
magics = [tuple(map(int, input().split())) for _ in range(n)]
max_a = sorted(magics, key=lambda x: x[0], reverse=True)[0][0]
dp = [0]*(h+max_a)
for i in range(1, h+max_a):
dp[i] = min(dp[i-a]+b for a,b in magics)
print(min(dp[h:]))
|
# coding: utf-8
import sys
ans = []
while ( 1 ):
strings = input()
if (len(strings) == 1 and int(strings[0]) == 0):
break
ans = 0
for s in strings:
ans += int(s)
print(ans)
| 0 | null | 41,474,720,307,008 | 229 | 62 |
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import decimal
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [Scanner.string() for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [Scanner.int() for i in range(n)]
def solve():
H, W, K = Scanner.map_int()
S = Scanner.string_list(H)
ans = int(1e15)
for i in range(1 << (H - 1)):
cut = 0
pc = 1
whites = [[0 for _ in range(W)] for _ in range(H)]
for j in range(H - 1):
for w in range(W):
whites[cut][w] += S[j][w] == '1'
if i >> j & 1:
cut += 1
pc += 1
for w in range(W):
whites[cut][w] += S[-1][w] == '1'
flag = True
for line in whites:
for cnt in line:
if cnt > K:
flag = False
if not flag:
continue
cnt = [0 for _ in range(pc)]
for w in range(W):
flag = True
for j in range(pc):
if cnt[j] + whites[j][w] > K:
flag = False
if not flag:
cnt = [0 for _ in range(pc)]
cut += 1
for j in range(pc):
cnt[j] += whites[j][w]
ans = min(ans, cut)
print(ans)
def main():
# sys.setrecursionlimit(1000000)
# sys.stdin = open("sample.txt")
# T = Scanner.int()
# for _ in range(T):
# solve()
# print('YNeos'[not solve()::2])
solve()
if __name__ == "__main__":
main()
|
from itertools import product
H, W, K = map(int, input().split())
G = [list(map(int, list(input()))) for _ in range(H)]
ans = float("inf")
for pattern in product([0, 1], repeat = H - 1):
div = [0] + [i for i, p in enumerate(pattern, 1) if p == 1] + [H]
rows = []
for i in range(len(div) - 1):
row = []
for j in range(W):
tmp = 0
for k in range(div[i], div[i + 1]):
tmp += G[k][j]
row.append(tmp)
rows.append(row)
flag = True
for row in rows:
if [r for r in row if r > K]:
flag = False
break
if not flag:
continue
tmp_ans = 0
cnt = [0] * len(rows)
w = 0
while w < W:
for r in range(len(rows)):
cnt[r] += rows[r][w]
if [c for c in cnt if c > K]:
cnt = [0] * len(rows)
tmp_ans += 1
w -= 1
w += 1
tmp_ans += pattern.count(1)
ans = min(ans, tmp_ans)
print(ans)
| 1 | 48,441,034,628,068 | null | 193 | 193 |
import sys
input = lambda: sys.stdin.readline().rstrip()
def resolve():
class BinaryIndexedTree():
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
def add(self, item, pos):
index = pos
while index < self.n+1:
self.bit[index] += item
index += index & (-index)
def sum(self, pos):
ret = 0
index = pos
while index > 0:
ret += self.bit[index]
index -= index & -index
return ret
N = int(input())
S = list(input())
Q = int(input())
Query = [input().split() for _ in range(Q)]
pos_bit_list = [BinaryIndexedTree(len(S)) for _ in range(26)]
for i, c in enumerate(S):
pos_bit_list[ord(c)-ord('a')].add(1, i+1)
for q in Query:
if q[0] == '1':
pos_bit_list[ord(S[int(q[1])-1])-ord('a')].add(-1, int(q[1]))
pos_bit_list[ord(q[2])-ord('a')].add(1, int(q[1]))
S[int(q[1])-1] = q[2]
else:
print(len([p for p in pos_bit_list if p.sum(int(q[2])) - p.sum(int(q[1])-1) > 0]))
if __name__ == '__main__':
resolve()
|
import bisect
n = int(input().strip())
S = list(input().strip())
L=[[] for _ in range(26)]
for i,s in enumerate(S):
L[ord(s)-ord("a")].append(i)
q = int(input().strip())
for _ in range(q):
query=input().strip().split()
if query[0]=="1":
i=int(query[1])
i-=1
c=query[2]
if S[i]!=c:
delInd=bisect.bisect_left(L[ord(S[i])-ord("a")],i)
del L[ord(S[i])-ord("a")][delInd]
bisect.insort(L[ord(c)-ord("a")], i)
S[i]=c
else:
l,r=map(int,[query[1],query[2]])
l-=1; r-=1
ans=0
for j in range(26):
ind=bisect.bisect_left(L[j],l)
if ind<len(L[j]) and L[j][ind]<=r:
ans+=1
print(ans)
| 1 | 62,652,071,952,778 | null | 210 | 210 |
import itertools
import math
#print(3 & (1 << 0))
def main():
N = int(input())
items = [i+1 for i in range(N)]
locations=[]
for i in range(N):
locations.append(list(map(int, input().split())))
paths =list(itertools.permutations(items))
sum = 0
for path in paths: # path = [1,2,3,4,5]
for i in range(len(path)-1):
from_idx = path[i] -1
to_idx = path[i+1] -1
xdiff= locations[from_idx][0] - locations[to_idx][0]
ydiff= locations[from_idx][1] - locations[to_idx][1]
sum = sum + math.sqrt(xdiff**2 + ydiff**2)
print( sum / len(paths))
main()
|
import math
N = int(input())
town = []
for i in range(N):
x, y = map(int, input().split())
town.append((x, y))
def dfs(current, dist, already):
if len(already) == N:
return dist
d = 0
for i in range(N):
if i in already:
continue
d += dfs(i, dist + math.sqrt((town[current][0] - town[i][0]) ** 2 + (town[current][1] - town[i][1]) ** 2), already | set([i]))
return d
answer = 0
for i in range(N):
answer += dfs(i, 0, set([i]))
print(answer / math.factorial(N))
| 1 | 148,520,437,050,190 | null | 280 | 280 |
n = int(input())
a = list(map(int, input().split()))
dp = [0]*(n+1)
dp[0] = 1000
for i in range(1, n):
dp[i] = dp[i-1]
for j in range(i):
stock = dp[j]//a[j]
cost = dp[j]+(a[i]-a[j])*stock
dp[i] = max(dp[i], cost)
print(dp[n-1])
|
n = int(input())
data = list(map(int, input().split()))
ans = 0
money = 1000
for idx in range(n-1):
today = data[idx]
tmr = data[idx+1]
if tmr > today:
money += (tmr-today) * (money//today)
print(money)
| 1 | 7,343,827,121,730 | null | 103 | 103 |
r = float(input())
print("{0:.6f} {1:.6f}".format(r**2 * 3.141592653589, 2 * r * 3.141592653589))
|
from collections import defaultdict
N,p = map(int,input().split())
S = input()
S = S[::-1]
d = defaultdict(lambda:0)
r = 0
for i in range(N):
r += int(S[i])*pow(10,i,p)
r %= p
d[r] += 1
ans = 0
for r in d:
ans += d[r]*(d[r]-1)//2
ans += d[0]
if p==2 or p==5:
S = S[::-1]
ans = 0
for i in range(N):
if int(S[i])%p==0:
ans += i+1
print(ans)
| 0 | null | 29,270,896,587,262 | 46 | 205 |
c = input()
a = "abcdefghigklmnopqrstuvwxyz"
print(a[a.index(c) + 1])
|
S = input()
import re
print('Yes' if re.match(r'^(hi)+$', S) else 'No')
| 0 | null | 72,520,020,969,980 | 239 | 199 |
from collections import deque
import sys
input = sys.stdin.readline
n = int(input())
doubly_linked_list = deque()
for _ in range(n):
command = input().split()
if command[0] == "insert":
doubly_linked_list.appendleft(command[1])
elif command[0] == "delete":
try:
doubly_linked_list.remove(command[1])
except:
pass
elif command[0] == "deleteFirst":
doubly_linked_list.popleft()
elif command[0] == "deleteLast":
doubly_linked_list.pop()
print(" ".join(doubly_linked_list))
|
import sys
S = sys.stdin.readline().strip()
N = 2019
L = len(S)
curr = 0
seen = {}
INV = 210
seen[curr] = 1
for i in range(L):
curr = (curr * 10 + int(S[i])) % N
t = (curr * pow(10, L-i, N)) %N
if t not in seen: seen[t] = 0
seen[t] += 1
res = 0
for i in range(N):
if i not in seen: continue
t = seen[i]
res += t * (t-1)//2
print(res)
| 0 | null | 15,413,628,086,218 | 20 | 166 |
def numba_compile(numba_config):
import os, sys
if sys.argv[-1] == "ONLINE_JUDGE":
from numba import njit
from numba.pycc import CC
cc = CC("my_module")
for func, signature in numba_config:
globals()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
exit()
elif os.name == "posix":
exec(f"from my_module import {','.join(func.__name__ for func, _ in numba_config)}")
for func, _ in numba_config:
globals()[func.__name__] = vars()[func.__name__]
else:
from numba import njit
for func, signature in numba_config:
globals()[func.__name__] = njit(signature, cache=True)(func)
print("compiled!", file=sys.stderr)
import numpy as np
def solve(N, A):
# dp[n][k] := n 人目まで見て左に k 人送ったときの最大値
A_order = np.argsort(-A)
dp = np.zeros((N+2, N+2), dtype=np.int64)
for n in range(1, N+1):
idx_A = A_order[n-1]
a = A[idx_A]
for k in range(n+1):
dp[n, k] = max(
dp[n-1, k-1] + a * abs(idx_A-(k-1)) if k>0 else 0, # 左に送る
dp[n-1, k] + a * abs(idx_A-(N-n+k)) if k<n else 0, # 右に送る
)
return dp[N].max()
numba_compile([
[solve, "i8(i8,i8[:])"],
])
N = int(input())
A = np.array(input().split(), dtype=np.int64)
ans = solve(N, A)
print(ans)
|
#import numpy as np
#import math
#from decimal import *
#from numba import njit
#@njit
def main():
N = int(input())
A = list(map(int, input().split()))
A = sorted(enumerate(A), key = lambda x: x[1])[::-1]
#dp = np.zeros((N+1,N+1), dtype='int64')
dp = [[0]*(N+1-i) for i in range(N+1)]
m = 0
for i in range(1,len(A)+1):
index,a = A[i-1]
for j in range(i+1):
if (i-j,j) == (0,0):
dp[i-j][j] = 0
elif i-j == 0:
dp[i-j][j] = dp[i-j][j-1] + (N-j-index)*a
elif j == 0:
dp[i-j][j] = dp[i-j-1][j] + (abs(index-(i-j-1)))*a
else:
dp[i-j][j] = max(dp[i-j][j-1] + (N-j-index)*a, dp[i-j-1][j] + (abs(index-(i-j-1)))*a)
if i == len(A):
m = max(m, dp[i-j][j])
#print(dp)
#print(np.max(dp))
print(m)
main()
| 1 | 33,779,310,895,300 | null | 171 | 171 |
k, n = map(int, input().split())
a = [int(i) for i in input().split()]
a += [a[0] + k]
sum = 0
max = 0
# 最も長い辺を求める
for i in range(n):
d = abs(a[i] - a[i + 1])
sum += d
if max < d:
max = d
# 最も長い辺を通らずに1周回るのが最小
print(sum - max)
|
A, B, M=map(int, input().split())
a=list(map(int, input().split()))
b=list(map(int, input().split()))
c = [list(map(int, input().split())) for i in range(M)]
# とりあえず最小
minc=min(a)+min(b)
for v in c:
minc = min(minc, (a[v[0]-1]+b[v[1]-1]-v[2]))
print(minc)
| 0 | null | 48,732,661,750,258 | 186 | 200 |
from decimal import *
from math import *
n,m=map(str,input().split())
p=Decimal(n)*Decimal(m)
print(floor(p))
|
from decimal import *
import math
a, b = map(str, input().split())
print(math.floor(Decimal(a)*Decimal(b)))
| 1 | 16,624,813,469,722 | null | 135 | 135 |
A,B = map(int,input().split())
x = A
y = B
while y>0:
x,y = y,x%y
print((A//x)*B)
|
a,b=map(int,input().split())
#a,bの最大公約数
def gcd(a,b):
if(b==0):
return a
else:
return gcd(b, a%b)
#a,bの最小公倍数
def lcm(a,b):
return a*b//gcd(a,b)
print(lcm(a,b))
| 1 | 113,157,868,999,340 | null | 256 | 256 |
import sys
import numpy as np
sys.setrecursionlimit(10 ** 7)
N, K = map(int, input().split())
MOD = 10 ** 9 + 7
# 階乗、Combinationコンビネーション(numpyを使う)
def cumprod(arr, MOD):
L = len(arr)
Lsq = int(L**.5+1)
arr = np.resize(arr, Lsq**2).reshape(Lsq, Lsq)
for n in range(1, Lsq):
arr[:, n] *= arr[:, n-1]
arr[:, n] %= MOD
for n in range(1, Lsq):
arr[n] *= arr[n-1, -1]
arr[n] %= MOD
return arr.ravel()[:L]
def make_fact(U, MOD):
x = np.arange(U, dtype=np.int64)
x[0] = 1
fact = cumprod(x, MOD)
x = np.arange(U, 0, -1, dtype=np.int64)
x[0] = pow(int(fact[-1]), MOD-2, MOD)
fact_inv = cumprod(x, MOD)[::-1]
return fact, fact_inv
U = 10**6
fact, fact_inv = make_fact(N * 2 + 10, MOD)
fact, fact_inv = fact.tolist(), fact_inv.tolist()
def mod_comb_k(n, k, mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n - k] % mod
ans = 0
for i in range(N):
if K < i:
continue
if N - 1 <= K:
ans = mod_comb_k(N + N - 1, N - 1, MOD)
break
if i == 0:
ans += 1
continue
a = int(mod_comb_k(N - 1, i, MOD)) * int(mod_comb_k(N, i, MOD))
a %= MOD
ans += a
ans %= MOD
'''
a = int(fact[N]) * int(fact_inv[i]) % MOD * int(fact_inv[N - 1])
a = a * int(fact[N-1]) % MOD * int(fact_inv[i]) % MOD * \
int(fact_inv[N-i-1]) % MOD
ans = (a + ans) % MOD
'''
print(ans)
|
import sys
input = sys.stdin.readline
class SegmentTree():
def __init__(self, S, n):
self.size = n
self.array = [set()] * (2**(self.size + 1) - 1)
for i, c in enumerate(S):
self.array[i + 2**self.size - 1] = {c}
for i in range(2**self.size - 1)[::-1]:
self.array[i] = self.array[2 * i + 1] | self.array[2 * i + 2]
def subquery(self, l, r, k, i, j):
if j <= l or r <= i:
return set()
elif l <= i and j <= r:
return self.array[k]
else:
l_set = self.subquery(l, r, 2 * k + 1, i, (i + j) // 2)
r_set = self.subquery(l, r, 2 * k + 2, (i + j) // 2, j)
return l_set | r_set
def query(self, l, r):
return len(self.subquery(l, r, 0, 0, 2**self.size))
def update(self, i, c):
tmp = i + 2**self.size - 1
self.array[tmp] = {c}
while tmp > 0:
tmp = (tmp - 1) // 2
self.array[tmp] = self.array[2 * tmp + 1] | self.array[2 * tmp + 2]
n = int(input())
S = [ord(c) for c in list(input())]
segtree = SegmentTree(S, 19)
for _ in range(int(input())):
t, i, c = input().split()
if t == '1':
segtree.update(int(i)-1, ord(c))
if t == '2':
print(segtree.query(int(i)-1, int(c)))
| 0 | null | 64,885,099,991,754 | 215 | 210 |
import math
N = int(input())
S = input()
lst0 = [0]*N
lst1 = [0]*N
lst0[0] = 1
lst1[0] = 1
c = S.count('1')
m0 = int(S[-1])
m1 = int(S[-1])
for i in range(1, N):
lst0[i] += (lst0[i-1]*2)%(c+1)
if c == 1:lst1[i] = 0
else: lst1[i] += (lst1[i-1]*2)%(c-1)
m0 += lst0[i] * int(S[N - 1- i])
m0 %= c+1
m1 += (lst1[i] * int(S[N - 1 - i]))
if c == 1: m1 = 0
else: m1 %= c-1
memo = [0]*(N+1)
def calc(a):
global ans, memo
if a == 0: return ans
ans += 1
if memo[a] != 0:
b = memo[a]
else:
b = bin(a).count('1')
memo[a] = b
return calc(a%b)
for i in range(N):
if S[i] == '1':
b = c - 1
if b == 0: a = 0
else: a = max((m1 - lst1[N - 1 - i])%b, (m1 - lst1[N - 1 - i]+ b)%b)
else:
b = c + 1
a = (m0 + lst0[N - 1 - i])%b
if b == 0: print(0)
elif a == 0:print(1)
else:
ans = 1
print(calc(a))
|
n = int(input())
l = sorted(list(enumerate(map(int,input().split()),start = 1)), key = lambda x:x[1])
print(*(l[i][0] for i in range(n)))
| 0 | null | 94,788,561,144,638 | 107 | 299 |
def input_data():
num = raw_input()
array = []
array = num.strip().split(" ")
array = map(int, array)
return array
def main():
n = raw_input()
count = 0
array = input_data()
flag = True
i = 0
while flag:
flag = False
for j in reversed(xrange(i + 1, int(n))):
if array[j] < array[j - 1]:
v = array[j]
array[j] = array[j - 1]
array[j - 1] = v
flag = True
count += 1
i += 1
array = map(str, array)
print " ".join(array)
print str(count)
if __name__ == '__main__':
main()
|
n = int(input())
s = [int(x) for x in input().split()]
cnt = 0
for i in range(n) :
for j in range(n - 1, i, -1) :
if s[j - 1] > s[j] :
s[j - 1], s[j] = s[j], s[j - 1]
cnt += 1
print(" ".join(map(str, s)))
print(cnt)
| 1 | 16,684,972,512 | null | 14 | 14 |
L, R, d = map(int, input().split())
print(R // d - L // d + (L % d == 0))
|
n = int(input())
a = 0
for i in range(n+1):
if i%3== 0: continue
elif i%5 == 0:continue
elif i%3 ==0 and i %5 ==0:continue
else: a+=i
print(a)
| 0 | null | 21,272,394,290,982 | 104 | 173 |
k,n = map(int, input().split())
a = list(map(int, input().split()))
l = [a[n-1]-a[0]]
for i in range(n-1):
l.append(k-a[i+1]+a[i])
print(min(l))
|
K, N = map(int, input().split())
A = list(map(int, input().split()))
A3 = A + [K+a for a in A]
dist = [A3[i+N-1] - A[i] for i in range(N)]
print(min(dist))
| 1 | 43,446,958,642,240 | null | 186 | 186 |
#D
A,B,N = map(int,input().split())
if N >= B:
print((A*(B-1))//B)
else:
print((A*N)//B-A*(N//B))
|
a = raw_input().split()
area=int(a[0])*int(a[1])
length=2*(int(a[0])+int(a[1]))
print area,length
| 0 | null | 14,288,969,696,260 | 161 | 36 |
N = int(input())
A = list(map(int, input().split()))
money = 1000
stock = 0
for day in range(N-1):
today_price = A[day]
tommorow_price = A[day+1]
if today_price < tommorow_price:
div,mod = divmod(money, today_price)
stock += div
money = mod
elif today_price > tommorow_price:
money += today_price * stock
stock = 0
money += A[N-1] * stock
print(money)
|
n = int(input())
a_nums = list(map(int, input().split()))
money = 1000
stock = 0
for i in range(n):
if i != n - 1 and a_nums[i] < a_nums[i + 1]:
times = money // a_nums[i]
stock += times
money -= a_nums[i] * times
elif i == n - 1 or a_nums[i] > a_nums[i + 1]:
money += stock * a_nums[i]
stock = 0
print(money)
| 1 | 7,370,320,864,160 | null | 103 | 103 |
a,b,c,k = map(int, input().split())
goukei = 0
if k>=a:
k -= a
goukei += a
else:
goukei += k
k = 0
if k>=b:
k -= b
else:
k = 0
if k>0:
goukei -= k
print(goukei)
|
a,b,c,k = map(int,input().split())
if k < a:
print(k)
elif a + b > k:
print(a)
else:
print(a - (k - a - b))
| 1 | 21,899,853,872,160 | null | 148 | 148 |
from decimal import (Decimal, ROUND_DOWN)
x=Decimal(input())
year = 0
money = 100
while money < x:
money += Decimal(money / 100).quantize(Decimal('0'), rounding=ROUND_DOWN)
year += 1
print(year)
|
X = int(input())
c = 0
i = 100
while True:
c += 1
i = i + i//100
if X <= i:
break
print(c)
| 1 | 27,204,585,388,710 | null | 159 | 159 |
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readlines
infty = 2 ** 20
lines = input()
n, m = list(map(int, lines[0].split()))
coin = list(map(int, lines[1].split()))
T = [[0] * (n+1) for i in range(m+1)]
#0行目の初期化
for i in range(1, n+1):
T[0][i] = infty
#0列目の初期化
for i in range(m+1):
T[i][0] = 0
#1行目の初期化
for i in range(1, n+1):
T[1][i] = i
cnt = 0
for i in range(1, m+1):
if coin[i-1] > n:
continue
else:
cnt += 1
for j in range(1, n+1):
if j < coin[i-1]:
T[i][j] = T[i-1][j]
else:
a = T[i-1][j] ; b = T[i][j-coin[i-1]]+1
if a < b:
T[i][j] = a
else:
T[i][j] = b
print(T[cnt][n])
|
def solve(n,m,c):
INF=50001
dp=[INF]*(n+1)
dp[0]=0
for i in range(m):
v=c[i]
for j in range(v,n+1):
if dp[j-v]!=INF:
dp[j]=min(dp[j-v]+1,dp[j])
return dp[n]
n,m=map(int,input().split())
c=tuple(map(int,input().split()))
print(solve(n,m,c))
| 1 | 138,003,695,492 | null | 28 | 28 |
from collections import deque
n, m = map(int,input().split())
graph = [[] for _ in range(n+1)]
for i in range(m):
a,b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
# dist = [-1]*(n+1)
# dist[0] = 0
# dist[1] = 0
mark = [-1]*(n+1)
mark[0] - 0
mark[1] = 0
d = deque()
d.append(1)
while d:
v = d.popleft()
for i in graph[v]:
if mark[i] != -1:
# if dist[i] != -1:
continue
mark[i] = v
# dist[i] = dist[v] + 1
d.append(i)
if '-1' in mark:
print('No')
else:
print('Yes')
print(*mark[2:], sep='\n')
|
def resolve():
N, M = list(map(int, input().split()))
AB = {}
for _ in range(M):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
if a not in AB:
AB[a] = []
if b not in AB:
AB[b] = []
AB[a].append(b)
AB[b].append(a)
import collections
q = collections.deque([0])
passed = [-1 for i in range(N)]
passed[0] = 0
while q:
node = q.pop()
for nxt in AB[node]:
if passed[nxt] == -1:
passed[nxt] = node
q.appendleft(nxt)
#print(metrics)
for m in passed:
if m == -1:
print("No")
return
print("Yes")
for i in range(1, N):
print(passed[i]+1)
if '__main__' == __name__:
resolve()
| 1 | 20,530,121,481,340 | null | 145 | 145 |
#!/usr/bin/env python3
def _f(H, W, S):
'''
>>> f = _f(3, 3, [[1, 0, 0], [1, 0, 1], [0, 1, 1]])
>>> f(0, 0, 1, 1)
1
>>> f(0, 0, 3, 0)
0
>>> f(0, 0, 3, 1)
2
>>> f(1, 1, 3, 3)
3
>>> f(0, 0, 3, 3)
5
>>> f(2, 0, 3, 3)
2
'''
acc = [[0] * (W + 1) for _ in range(H+1)]
for h in range(1, H+1):
for w in range(1, W+1):
acc[h][w] = acc[h][w-1] + acc[h-1][w] - acc[h-1][w-1] + S[h-1][w-1]
def f(sh, sw, eh, ew):
return acc[eh][ew] + acc[sh][sw] - acc[sh][ew] - acc[eh][sw]
return f
def _solve(H, W, K, S, c, f):
#print(H, W, K, S, c, f)
sw = 0
cut = 0
for ew in range(1, W+1):
#print([(((sh, sw), (eh, ew)), f(sh, sw, eh, ew)) for sh, eh in c])
if any(f(sh, ew-1, eh, ew) > K for sh, eh in c):
return float('inf')
if any(f(sh, sw, eh, ew) > K for sh, eh in c):
cut += 1
sw = ew - 1
return cut
def solve(H, W, K, S):
from itertools import product, compress
f = _f(H, W, S)
ans = float('inf')
for flag in product(range(2), repeat=H-1):
t = (0,) + tuple(compress(range(1,H), flag)) + (H,)
c = tuple(zip(t, t[1:]))
ans = min(ans, _solve(H, W, K, S, c, f)+sum(flag))
return ans
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
def main():
H, W, K = list(map(int, input().split()))
S = [list(map(int, input())) for _ in range(H)]
print(solve(H, W, K, S))
def test():
import doctest
doctest.testmod()
if __name__ == '__main__':
#test()
main()
|
print('win' if sum(list(map(int, input().split(' ')))) <= 21 else 'bust')
| 0 | null | 83,459,792,280,946 | 193 | 260 |
N=int(input())
count=0
for A in range(1,N):
count+=(N-1)//A
print(count)
|
N = int(input())
C = {(i,j):0 for i in range(1,10) for j in range(1,10)}
num = list(range(1,10))
for k in range(1,N+1):
k = str(k)
i = int(k[0])
j = int(k[-1])
if i in num and j in num:
C[(i,j)] += 1
cnt = 0
for i in range(1,10):
for j in range(1,10):
cnt += C[(i,j)]*C[(j,i)]
print(cnt)
| 0 | null | 44,573,149,057,800 | 73 | 234 |
import sys
input=lambda: sys.stdin.readline().rstrip()
n,m,k=map(int,input().split())
mod=998244353
n_max=2*(10**5+1)
F,FI=[0]*(n_max+1),[0]*(n_max+1)
F[0],FI[0]=1,1
for i in range(n_max):
F[i+1]=(F[i]*(i+1))%mod
FI[n_max-1]=pow(F[n_max-1],mod-2,mod)
for i in reversed(range(n_max-1)):
FI[i]=(FI[i+1]*(i+1))%mod
def comb(x,y):
return (F[x]*FI[x-y]*FI[y])%mod
P=[1]
for i in range(n):
P.append((P[-1]*(m-1))%mod)
ans=0
for i in range(k+1):
ans+=m*P[n-1-i]*comb(n-1,i)
if ans>mod:
ans%=mod
print(ans)
|
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()
class ComMod():
def __init__(self,n_max,mod):
self.mod=mod
self.fact=[0]*(n_max+1)
self.ifact=[0]*(n_max+1)
self.fact[0]=1
for i in range(1,n_max+1):
self.fact[i]=self.fact[i-1]*i
self.fact[i]%=mod
self.ifact[n_max]=pow(self.fact[n_max],mod-2,mod)
for i in range(n_max,0,-1):
self.ifact[i-1]=self.ifact[i]*i
self.ifact[i-1]%=mod
def com(self,n,k):
if n<0 or k<0 or n<k:
return 0
return self.fact[n]*(self.ifact[k]*self.ifact[n-k]%self.mod)%self.mod
def main():
n,m,k=LI()
res=0
mod=998244353
tmp=m*pow(m-1,n-k-1,mod)
c=ComMod(200005,mod)
for r in range(n-k-1,n):
res=(res+tmp*c.com(n-1,r)%mod)%mod
tmp=tmp*(m-1)%mod
return res
# main()
print(main())
| 1 | 23,212,286,994,810 | null | 151 | 151 |
# coding: utf-8
x = int(input())
ans = x // 500
x = x - ans * 500
ans = ans * 1000
ans += (x // 5 * 5)
print(ans)
|
import sys
def lcm(a, b):
a, b = max(a, b), min(a, b)
c = a * b
while a % b > 0:
a, b = b, a % b
return c // b
def solve():
input = sys.stdin.readline
X = int(input())
L = lcm(360, X)
print(L // X)
return 0
if __name__ == "__main__":
solve()
| 0 | null | 27,990,628,396,378 | 185 | 125 |
N=int(input())
import math
X=math.ceil(N/1.08)
if int(X*1.08)==N:
print(X)
else:
print(':(')
|
import math
def taxminus(X):
return X/1.08,(X+1)/1.08
N=int(input())
min,max=taxminus(N)
min=math.ceil(min)
if min>=max:
print(":(")
else:
print(min)
| 1 | 126,308,327,303,158 | null | 265 | 265 |
def main():
N, M = map(int, input().split())
H = list(map(int, input().split()))
connected = dict()
for _ in range(M):
A, B = map(int, input().split())
if A not in connected:
connected[A] = H[B-1]
else:
connected[A] = max(connected[A], H[B-1])
if B not in connected:
connected[B] = H[A-1]
else:
connected[B] = max(connected[B], H[A-1])
ans = 0
for i in range(1, N+1):
if i not in connected:
ans += 1
elif H[i-1] > connected[i]:
ans += 1
return ans
if __name__ == '__main__':
print(main())
|
N, M = map(int, input().split())
H = list(map(int, input().split()))
OK = [True] * N
for _ in range(M):
A, B = map(lambda x: int(x)-1, input().split())
if H[A] < H[B]:
OK[A] = False
elif H[A] > H[B]:
OK[B] = False
else:
OK[A] = False
OK[B] = False
ans = sum(OK)
print(ans)
| 1 | 25,066,829,691,748 | null | 155 | 155 |
f = list(map(str, [1, 2, 3]))
f.remove(input())
f.remove(input())
print(f[0])
|
a, b = map(int, input().split())
print(str(a * b) + " " + str(2 * a + 2 * b))
| 0 | null | 55,806,793,701,798 | 254 | 36 |
N = int(input())
AB = [[int(_) for _ in input().split()] for _ in range(N)]
A = sorted([a for a, b in AB])
B = sorted([b for a, b in AB])
ans = B[N // 2] + B[(N - 1) // 2] - (A[N // 2] + A[(N - 1) // 2])
if N % 2:
ans //= 2
ans += 1
print(ans)
|
n ,q = map(int, input().split())
ntlist = []
for i in range(n):
nt = list(map(str, input().split()))
ntlist.append(nt)
tp = 0
while (len(ntlist)):
nt = ntlist.pop(0)
if (int(nt[1])> q):
nt[1] = int(nt[1]) - q
tp += q
ntlist.append(nt)
else:
tp += int(nt[1])
nt[1] = 0
print(nt[0], tp)
| 0 | null | 8,662,402,099,780 | 137 | 19 |
N, M, L = map(int, input().split())
INF = 10**12
dp = [[INF]*N for i in range(N)]
fp = [[INF]*N for i in range(N)]
for i in range(N):
dp[i][i]=0
fp[i][i]=0
k = [[0]*N for i in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
dp[a-1][b-1] = c
dp[b-1][a-1] = c
for i in range(N):
for j in range(N):
for h in range(N):
dp[j][h] = min(dp[j][h], dp[j][i]+dp[i][h])
for j in range(N):
for h in range(N):
if dp[j][h]<=L:
fp[j][h] = 1
for i in range(N):
for j in range(N):
for h in range(N):
fp[j][h] = min(fp[j][h], fp[j][i]+fp[i][h])
Q = int(input())
for i in range(Q):
s, t = map(int, input().split())
s = s-1
t = t-1
if fp[s][t]==INF:
print(-1)
else:
print(fp[s][t]-1)
|
import sys
input = sys.stdin.readline
n,m,l = map(int,input().split())
town = [list(map(int,input().split())) for _ in range(m)]
q = int(input())
query = [list(map(int,input().split())) for _ in range(q)]
inf = (l+1)*n
d = [[inf]*n for _ in range(n)]
for i in range(n):
d[i][i] = 0
for a,b,c in town:
a -= 1
b -= 1
d[a][b] = c
d[b][a] = c
def warshall_floyd(d,n):
for k in range(n):
for j in range(n):
for i in range(n):
d[i][j] = min(d[i][j],d[i][k]+d[k][j])
warshall_floyd(d,n)
d2 = [None]*n
for i,row in enumerate(d):
d2[i] = [1 if val<=l else inf for val in row]
d2[i][i] = 0
warshall_floyd(d2,n)
for s,t in query:
s -= 1
t -= 1
count = (d2[s][t]%inf)-1
print(count)
| 1 | 173,741,248,654,720 | null | 295 | 295 |
import math
n = int(input())
m = n
answer = 0
i = 2
while i ** 2 <= m:
t = 0
while n % i == 0:
n //= i
t += 1
answer += int((-1+math.sqrt(1+8*t)) / 2)
i += 1
if n > 1000000:
answer += 1
print(answer)
|
a,b,c,k=map(int,open(0).read().split())
#while k:k-=1;t=a<b;b*=2-t;c*=1+t
while k:k-=1;exec(f'{"bc"[a<b]}*=2')
#while k:k-=1;exec('%c*=2'%'bc'[a<b])
#while k:k-=1;vars()['bc'[a<b]]*=2
print('NYoe s'[b<c::2])
| 0 | null | 11,891,980,147,330 | 136 | 101 |
H, W = [int(x) for x in input().split(" ")]
if H > W:
H, W = W, H
if H == 1:
print(1)
elif H % 2 == 0:
print(W * (H // 2))
else:
if W % 2 == 0:
print(W * H // 2)
else:
print(((W - 1) * H // 2) + H // 2 + 1)
|
def main():
H, W = map(int, input().split())
if H == 1 or W == 1:
print(1)
return
B = W // 2
A = W - B
D = H // 2
C = H - D
print(C * A + D * B)
main()
| 1 | 50,630,258,734,650 | null | 196 | 196 |
if __name__ == "__main__":
A,B = map(int,input().split())
for i in range(1,1251):
A_tmp,B_tmp = int(i*0.08),int(i*0.10)
if A is A_tmp and B is B_tmp:
print(i)
exit()
print(-1)
|
import math
A,B = map(int,input().split())
ans = 0
AT = 0.08
BT = 0.1
a = A/AT
b = B/BT
aPlus = (A+1)/AT
bPlus = (B+1)/BT
if a == b :
ans = a
elif a < b :
if aPlus <= b :
ans = -1
else :
ans = b
elif b < a :
if bPlus <= a :
ans = -1
else :
ans = a
# print(a,b)
# print(aPlus,bPlus)
print(math.ceil(ans))
| 1 | 56,275,028,311,302 | null | 203 | 203 |
#ALDS1_3-C Elementary data structures - Doubly Linked List
import collections
q = collections.deque()
cmds={"insert":lambda cmd: q.appendleft(cmd[1]),
"delete":lambda cmd: q.remove(cmd[1]) if (q.count(cmd[1]) > 0) else "none",
"deleteFirst":lambda cmd: q.popleft(),
"deleteLast": lambda cmd: q.pop()
}
n=int(input())
for i in range(n):
cmd=input().split()
cmds[cmd[0]](cmd)
print(*q)
|
# -*- coding: utf-8 -*-
from collections import deque
N = int(input())
q = deque()
for i in range(N):
lst = input().split()
command = lst[0]
if command == 'insert':
q.appendleft(lst[1])
elif command == 'delete':
try:
q.remove(lst[1])
except Exception:
pass
elif command == 'deleteFirst':
q.popleft()
elif command == 'deleteLast':
q.pop()
print(*q)
| 1 | 52,517,070,752 | null | 20 | 20 |
a,b,c,d,e = map(int,input().split())
z = (c-a)*60 + (d-b)- e
print(z)
|
h1, m1, h2, m2, k = map(int, input().split())
st = h1*60 + m1
end = h2*60 + m2
print(end-st-k)
| 1 | 18,089,296,569,630 | null | 139 | 139 |
while True:
(H,W) = [int(x) for x in input().split()]
if H == W == 0:
break
for h in range(0, H):
for w in range(0, W):
print("#", end="")
if w == W - 1:
print()
break
print()
|
H,A = map(int,input().split())
print(H//A if H%A == 0 else (H//A)+1)
| 0 | null | 38,894,991,421,310 | 49 | 225 |
def main():
n, m = map(int, input().split())
if n%2:
for i in range(m):
print(i+1, n-i)
else:
for i in range(m):
if n-2*i-1 > n//2:
print(i+1, n-i)
else:
print(i+1, n-i-1)
if __name__ == "__main__":
main()
|
N,M = map(int, input().split())
ans = []
if N%2==1:
for i in range(2,N//2+2):
ans.append((i,N+2-i))
else:
l = 2
r = N
while r-l>N//2:
ans.append((l,r))
l += 1
r -= 1
l += 1
while r>l:
ans.append((l,r))
l += 1
r -= 1
for i in range(M):
print(*ans[i])
| 1 | 28,577,526,194,624 | null | 162 | 162 |
from collections import Counter
N, P = map(int, input().split())
S = input()
if 10 % P == 0:
ans = 0
for i, s in enumerate(S, start=1):
if int(s) % P != 0:
continue
ans += i
print(ans)
else:
X = [0]
for i, s in enumerate(S[::-1]):
X.append((X[-1] + pow(10, i, P) * int(s)) % P)
C = Counter(X)
ans = 0
for v in C.values():
ans += v * (v - 1) // 2
print(ans)
|
i = input()
i_l = i.split()
count = 0
for each in range(int(i_l[0]),int(i_l[1])+1):
if int(i_l[2]) % each == 0:
count += 1
else:
print(count)
| 0 | null | 29,251,552,066,242 | 205 | 44 |
lines = int(input())
mini = int(input())
maxi = -1000000000
for i in range(1,lines):
s = int(input())
maxi = max(maxi,s - mini)
mini = min(s,mini)
print(maxi)
|
n = int(input())
R = []
for i in range(n):
R.append(int(input()))
minv = R[0]
maxv = R[1] - R[0]
for r in R[1:]:
maxv = max(maxv, r - minv)
minv = min(minv, r)
print(maxv)
| 1 | 12,680,188,552 | null | 13 | 13 |
from math import *
n,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
def is_ok(arg):
tmp=0
for i in a:
tmp+=ceil(i/arg)-1
return tmp<=k
def meguru_bisect(ng, ok):
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
print(meguru_bisect(0, max(a)))
|
import sys
from itertools import product
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(input())
def dfs(s, num):
if len(s) == n:
print(s)
return
for i in range(num + 1):
t = s + chr(97 + i)
dfs(t, max(num, i + 1))
dfs("", 0)
if __name__ == '__main__':
resolve()
| 0 | null | 29,646,614,215,970 | 99 | 198 |
n = int(input())
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
if n == 1:
print(0)
exit()
primes = prime_factorize(n)
max_primes = primes[-1]
dic = {}
tmp = 0
for i in primes:
if i not in dic:
dic[i] = 1
tmp = 0
continue
if tmp == 0:
tmp = i
else:
tmp *= i
if tmp not in dic:
dic[tmp] = 1
tmp = 0
print(len(dic))
|
n=int(input())
def f(x):
z=1
while not(z*(z+1)<=2*x<(z+1)*(z+2)):
z+=1
return z
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
if n==1:
print(0)
exit()
y=0
j=2
while j*j<=n:
if n%j==0:
y=1
j+=1
if y==0:
print(1)
exit()
a=[]
q=0
for i in range(len(prime)):
p=prime[i]
while n%p==0:
q+=1
n=n//p
if q>0:a.append(q)
q=0
ans=0
for i in range(len(a)):
ans+=f(a[i])
print(ans if n==1 else ans+1)
| 1 | 16,861,161,079,070 | null | 136 | 136 |
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)
|
N, K = map(int, input().split())
S = [i+1 for i in range(N)]
H = [0 for i in range(N)]
for i in range(K):
d = int(input())
A = list(map(int, input().split()))
for j in A:
for k in S:
if j==k:
H[k-1] += 1
ans = 0
for i in H:
if i==0:
ans += 1
print(ans)
| 1 | 24,413,438,537,700 | null | 154 | 154 |
w = str.lower(raw_input())
t = []
while True:
line = raw_input()
if line == "END_OF_TEXT":
break
else:
t += (map(str.lower, line.split(" ")))
count = 0
for i in xrange(len(t)):
if w == t[i]:
count += 1
print count
|
w = raw_input()
words = []
while True:
line = raw_input()
if line == "END_OF_TEXT":
break
else:
line_list = line.split(" ")
words += line_list
#print words
cnt = 0
for word in words:
if w.lower() == word.lower():
cnt += 1
print cnt
| 1 | 1,820,508,038,140 | null | 65 | 65 |
# coding:utf-8
class FLOOR:
def __init__(self):
self.room = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
class BUILD:
def __init__(self):
self.floor = [FLOOR(), FLOOR(), FLOOR()]
# 3??????10??¨?±????4?£?
all_rooms = [BUILD(), BUILD(), BUILD(), BUILD()]
# ??\???
n = int(input())
for i in range(n):
b, f, r, v = map(int, input().split())
all_rooms[b-1].floor[f-1].room[r-1] += v
for b in range(4):
for f in range(3):
display = []
for r in range(10):
display.append(str(all_rooms[b].floor[f].room[r]))
print(' ' + ' '.join(display))
if (b < 3):
print('#'*20)
|
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))
| 0 | null | 1,198,935,261,060 | 55 | 58 |
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
n = int(input())
d = set()
for i in range(n):
command,s = input().split()
if command == "insert":
d.add(s)
else:
if s in d:
print("yes")
else:
print("no")
|
K, N = [int(x) for x in input().split()]
A = list([int(x) for x in input().split()])
result = []
for i in range(N):
if i == N - 1:
result.append(K - A[i] + A[0])
else:
result.append(A[i + 1] - A[i])
result.sort()
print(sum(result[:-1]))
| 0 | null | 21,685,434,355,168 | 23 | 186 |
"""dfs"""
import sys
sys.setrecursionlimit(10**6)
n = int(input())
to = [[] for _ in range(n)]
eid = [[] for _ in range(n)]
ans = [0]*(n-1)
def dfs(v, c=-1, p=-1): # v:これから見るnode、c:pとvを繋ぐedgeの色、p:親node
k = 1
for i in range(len(to[v])):
u = to[v][i]
ei = eid[v][i]
if u == p: continue # 親nodeは確認済みなので見ない
if k == c: k += 1 # 親nodeとの間のedgeの色と同じではいけないのでインクリメントする
ans[ei] = k
k += 1
dfs(u,ans[ei],v)
for i in range(n-1):
a,b = map(int, input().split())
a -= 1; b -= 1
to[a].append(b); eid[a].append(i) # to:nodeの繋がり、eid:edgeの色
to[b].append(a); eid[b].append(i)
dfs(0)
mx = 0
for i in range(n):
mx = max(mx, len(to[i]))
print(mx)
for i in range(n-1):
print(ans[i])
|
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
from collections import deque
from fractions import gcd
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
#############
# Functions #
#############
######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n):
return kaijo_memo[n]
if(len(kaijo_memo) == 0):
kaijo_memo.append(1)
while(len(kaijo_memo) <= n):
kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n):
return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0):
gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n):
gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if(n == r):
return 1
if(n < r or r < 0):
return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#############
# Main Code #
#############
N = inputI()
graph = [[] for _ in range(N)]
edges = []
for _ in range(N - 1):
a, b = inputIL()
edges.append((a-1, b-1))
for a, b in edges:
graph[a].append(b)
graph[b].append(a)
k = max(len(edges) for edges in graph)
colors = [color for color in range(1, k + 1)]
usedcolor = [ None for _ in range(N) ]
colored = {}
def youcanusethiscolor(u):
for c in colors:
if c == usedcolor[u]:
continue
yield c
for u in range(N):
color = youcanusethiscolor(u)
for v in graph[u]:
if (u,v) not in colored and (v,u) not in colored:
now = next(color)
colored[(u,v)] = colored[(v,u)] = now
usedcolor[v] = now
print(k)
for a,b in edges:
print(colored[(a,b)])
| 1 | 135,845,130,175,900 | null | 272 | 272 |
N = int(input())
ans = 0
if N%2 == 1:
print(0)
else:
for i in range(1,len(str(N))+100):
ans += N//(2*5**i)
print(ans)
|
n = int(input())
ANS = [0] * (n+1)
for x in range(1, 101):
for y in range(1, 101):
for z in range(1, 101):
tmp = (x + y + z)**2 - z*(x + y) - (x*y)
if tmp > n: continue
ANS[tmp] += 1
for ans in ANS[1:]:
print(ans)
| 0 | null | 62,219,235,971,760 | 258 | 106 |
def resolve():
k = int(input())
a, b = list(map(int, input().split()))
for i in range(a, b + 1):
if i % k == 0:
print('OK')
return
print('NG')
resolve()
|
import math
k=int(input())
[a,b]=list(map(int, input().split()))
A=math.floor(a/k)
B=math.floor(b/k)
if A!=B:
print("OK")
elif k==1:
print("OK")
elif a%k==0 or b%k==0:
print("OK")
else:
print("NG")
| 1 | 26,543,415,938,808 | null | 158 | 158 |
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
"""
N, K = LI()
A = LI()
def abssort(A):
return sorted(A, key = lambda x:abs(x), reverse= True)
tmps = []
A_abs = abssort(A)
cnt = 0
while len(tmps) > K:
# for i in range(K):
if A_abs[cnt] != 0:
tmps.append(A_abs[i])
cnt += 1
cnt = 0
for i in range(K):
if tmps[i] < 0:
cnt += 1
if cnt % 2 == 0:
ans = 1
for i in range(K):
ans *= tmps[i]
ans = ans % mod
print(ans)
sys.exit()
else:
tmp_1 = copy.deepcopy(tmps)
tmp_2 = copy.deepcopy(tmps)
tmp_1.reverse()
tmp_2.reverse()
tmp_2_ = 0
tmp_1_ = 0
# -を一つ消す
for i in range(K):
if tmp_1[i] < 0:
tmp_1.remove(tmp_1[i])
break
# + を一つたす
for i in range(K, N):
if A_abs[i] > 0:
tmp_1.append(A_abs[i])
tmp_1_ = 1
break
else:
# +がなかった時
tmp_1 = []
tmp_1_ = -1
A_abs.reverse()
for i in range(K):
tmp_1.append(A_abs[i])
# +を消して-を追加
cnt = 0
for i in range(K):
if tmp_2[i] > 0:
tmp_2.remove(tmp_2[i])
cnt += 1
break
if cnt == 1:
for i in range(K, N):
if A_abs[i] < 0:
tmp_2.append(A_abs[i])
tmp_2_ = 1
break
else:
tmp_2_ = 0
else:
tmp_2_ = -1
# print(tmp_1, tmp_2)
tmp_1_m = 1
tmp_2_m = 1
for i in range(K):
tmp_1_m *= tmp_1[i]
tmp_1_m = tmp_1_m % mod
if tmp_2_ == 0:
pass
else:
for i in range(K):
tmp_2_m *= tmp_2[i]
tmp_2_m = tmp_2_m % mod
# print(tmp_1_, tmp_2_)
if tmp_2_ == 0:
print(tmp_1_m)
elif tmp_1_ == 1 and tmp_2_ == -1:
print(tmp_1_m)
elif tmp_1_ == -1 and tmp_2_ == 1:
print(tmp_2_m)
elif tmp_1_ == 1 and tmp_2_ == 1:
for i in range(K):
if tmp_1[i] == tmp_2[i]:
pass
elif abs(tmp_1[i]) > abs(tmp_2[i]):
print(tmp_2_m)
sys.exit()
else:
print(tmp_1_m)
sys.exit()
else:
print(tmp_1_m)
# for i in range(K):
# if tmp_1[i] == tmp_2[i]:
# pass
# elif abs(tmp_1[i]) > abs(tmp_2[i]):
# print(tmp_2_m)
# sys.exit()
# else:
# print(tmp_1_m)
# sys.exit()
"""
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
# 正負に関係なくsort
A_abs = sorted(A, key = lambda x:abs(x))
A_p = [] # plusを入れる
A_n = [] # -を入れる
for i in range(N):
if A[i] < 0:
A_n.append(A[i])
else:
A_p.append(A[i])
A_n.sort()
A_p.sort(reverse = True)
ok = True
if len(A_p) > 0:
# 正の数が存在している
if N == K:
# 選択肢がない時
ok = (len(A_n) % 2 == 0)
# 負の数が偶数個
else:
ok = True
else:
ok = (K % 2 == 0)
ans = 1
if ok == False:
for i in range(K):
ans *= A_abs[i]
ans = ans % mod
else:
if K % 2 == 1:
# 奇数個選ぶ
ans *= A_p[0]
ans = ans % mod
A_p = A_p[1:]
position = 0
pairs = []
cnt_p = len(A_p)
cnt_n = len(A_n)
while cnt_p - position > 1:
pairs.append(A_p[position] * A_p[position + 1])
position += 2
position = 0
while cnt_n - position > 1:
pairs.append(A_n[position] * A_n[position + 1])
position += 2
pairs.sort(reverse=True)
for i in range(K // 2):
ans *= pairs[i]
ans = ans % mod
print(ans)
|
N = int(input())
ct = []
for i in range(N):
ct.append([int(i) for i in input().split()])
dist = 0
for a in ct:
for b in ct:
dist += (abs(a[0] - b[0])**2 +abs(a[1] - b[1])**2)**0.5
print(dist/N)
| 0 | null | 78,754,722,082,440 | 112 | 280 |
S=input()
N=int(input())
for i in range(N):
command=input().split()
if command[0]=="replace":
a=int(command[1])
b=int(command[2])
x=command[3]
A=S[:a]
B=S[b+1:]
S=A+x+B
elif command[0]=="reverse":
a=int(command[1])
b=int(command[2])
A=S[:a]
B=S[a:b+1]
C=S[b+1:]
T=""
for p in range(len(B)):
T+=B[len(B)-1-p]
S=A+T+C
else:
#command[0]=="print"
a=int(command[1])
b=int(command[2])
print(S[a:b+1])
|
a, b, c, d = map(int, input().split())
e = a*c
f = a*d
g = b*c
h = b*d
print(max(e,f,g,h))
| 0 | null | 2,553,474,239,222 | 68 | 77 |
import sys
input = sys.stdin.readline
H,W,K=map(int,input().split())
CO=[[0 for i in [0]*W] for j in [0]*H]
DO=[[0 for i in [0]*W] for j in [0]*H]
for i in range(H):
C=input()
for j in range(W):
DO[i][j]=int(C[j])
CO[H-1]=DO[H-1]
F=1000000
for s in range(2**(H-1)):
D=0
E=0
Sui=[0]*(H-1)
for t in range(H-1):
if ((s >> t) & 1):
Sui[t]+=1
for m in range(H-1):
E+=Sui[m]
for k in range(H-1):
if Sui[k]==0:
for i in range(W):
CO[H-k-2][i]=DO[H-k-2][i]+CO[H-k-1][i]
else:
for i in range(W):
CO[H-k-2][i]=DO[H-k-2][i]
lst=[0]*H
for h in range(W):
c=max(CO[x][h] for x in range(H))
d=max(lst[y]+CO[y][h] for y in range(H))
if c>K:
E=1000000
break
elif d>K:
D+=1
lst=[0]*H
for z in range(H):
lst[z]+=CO[z][h]
F=min(F,D+E)
print(F)
|
prize = {1:300000,2:200000,3:100000}
a,b = [int(i) for i in input().split()]
if a == b == 1:
print(1000000)
elif a < 4 and b < 4:
print(prize[a] + prize[b])
elif a >= 4 and b < 4:
print(prize[b])
elif b >= 4 and a < 4:
print(prize[a])
else:
print(0)
| 0 | null | 94,111,987,055,940 | 193 | 275 |
S=input()
if (S[2]==S[3]) and (S[4]==S[5]):print('Yes')
else:print('No')
|
s=input()
a=s[2]
b=s[3]
c=s[4]
d=s[5]
if a==b and c==d:
print("Yes")
else :
print("No")
| 1 | 42,289,563,553,020 | null | 184 | 184 |
N = int(input())
clips = [input().split() for _ in range(N)]
X = input()
ans = 0
for i,title in enumerate(clips):
if X in title:
for j in range(i+1, N):
ans += int(clips[j][1])
break
print(ans)
|
n = int(input())
s = []
t = []
ans = 0
for i in range(n):
s1,t1 = input().split()
s.append(str(s1))
t.append(int(t1))
x = str(input())
for j in range(n):
if s[j] == x:
print(sum(t[j+1:n+1]))
| 1 | 97,074,553,185,290 | null | 243 | 243 |
S = input()
T = ''
for _ in range(len(S)):
T += 'x'
print(T)
|
s=input()
ans="x"*len(s)
print(ans)
| 1 | 72,799,370,530,620 | null | 221 | 221 |
n=int(input())
c=0
for a in range(1,n+1):
c+=(n-1)//a
print(c)
|
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)))
| 0 | null | 7,603,207,978,780 | 73 | 123 |
import bisect
n, m, k = map(int, input().split())
aaa = list(map(int, input().split()))
bbb = list(map(int, input().split()))
sum_a = [0] * (n + 1)
sum_b = [0] * (m + 1)
for i in range(n):
sum_a[i + 1] = sum_a[i] + aaa[i]
for j in range(m):
sum_b[j + 1] = sum_b[j] + bbb[j]
ans = 0
for i in range(n + 1):
if sum_a[i] > k:
break
tmp = bisect.bisect_right(sum_b, k - sum_a[i])
ans = max(ans, i + tmp - 1)
print(ans)
|
from collections import defaultdict
from itertools import product
H,W,K = map(int,input().split())
S = [input() for i in range(H)]
C = [[int(S[i][k]) for i in range(H)] for k in range(W)]
answer = H*W #出力がこれを超えることはない
for X in product([False,True],repeat = H-1):
M = [[0]]
ans = sum(X)
if ans > answer:#初期値がanswerよりも大きかったら考える必要がない
continue
for i,x in enumerate(X):#配列Mの作成
if x:
M.append([])
M[-1].append(i+1)
D = [0]*len(M)
for c in C:
for k,m in enumerate(M):
D[k] += sum(c[i] for i in m)#k番目の要素に足していく
#Dにどんどん代入することによってどの列まで足すことができるか算出することができる
if any(d>K for d in D):#一つでもKを超えていたら
ans += 1
if ans >answer:
break
D = [sum(c[i] for i in m) for m in M]#超えた行について再び調査
if any(d>K for d in D):
ans = answer + 1
#デフォルトanswerの結果より高い値にしてこの結果が出力にならないように設定する
break
answer = min(answer,ans)#あるXに対してanswerを算出(更新)
print(answer)
| 0 | null | 29,735,957,129,446 | 117 | 193 |
l, r, d = map(int, input().split())
if (l/d).is_integer():
print(r//d-l//d+1)
else:
print(r//d-l//d)
|
a,b,c=map(int,input().split())
if b%c==0 or a%c==0:
print(int((b-a)/c)+1)
else:
print(int((b-a)/c))
| 1 | 7,588,609,704,882 | null | 104 | 104 |
#!/usr/bin/env python3
# coding: utf-8
import collections
def debug(arg):
if __debug__:
pass
else:
import sys
print(arg, file=sys.stderr)
def main():
pass
N, *A = map(int, open(0).read().split())
a = dict(enumerate(A, 1))
dp = collections.defaultdict(lambda: -float("inf"))
dp[0, 0] = 0
dp[1, 0] = 0
dp[1, 1] = a[1]
for i in range(2, N + 1):
jj = range(max(i // 2 - 1, 1), (i + 1) // 2 + 1)
for j in jj:
x = dp[i - 2, j - 1] + a[i]
y = dp[i - 1, j]
dp[i, j] = max(x, y)
print(dp[N, N // 2])
if __name__ == "__main__":
main()
|
def isprime(x):
if x==2:
return True
if x<2 or x&1==0:
return False
return pow(2,x-1,x)==1
cnt=0
n=int(input())
for i in range(n):
a=int(input())
if isprime(a):
cnt+=1
print(cnt)
| 0 | null | 18,788,496,550,548 | 177 | 12 |
from collections import deque
que = deque()
l = input()
S = 0
S2 = []
for j in range(len(l)):
i = l[j]
if i == '\\':
que.append(j)
continue
elif i == '/':
if len(que) == 0:
continue
k = que.pop()
pond_sum = j-k
S += pond_sum
while S2 and S2[-1][0] > k:
pond_sum += S2[-1][1]
S2.pop()
S2.append([k,pond_sum])
elif i == '_':
continue
data = [i for j,i in S2]
print(S)
print(len(S2),*data)
|
t=input()
s1=[]
s2=[]
pond=[]
totalsum=0
for i in range(len(t)):
if t[i]=="\\" :
s1.append(i)
elif t[i]=="/" and len(s1)!=0:
p1=s1.pop()
sum=i-p1
totalsum+=sum
while len(s2)>0:
if s2[-1]>p1:
s2.pop()
sum+=pond.pop()
else:
break
pond.append(sum)
s2.append(i)
print(totalsum)
print(len(pond),*pond)
| 1 | 58,913,820,630 | null | 21 | 21 |
s = input()
for _ in range(int(input())):
o = input().split()
a, b = map(int, o[1:3])
b += 1
c = o[0][2]
if c == 'p':
s = s[:a]+o[3]+s[b:]
elif c == 'i':
print(s[a:b])
elif c == 'v':
s = s[:a]+s[a:b][::-1]+s[b:]
|
N = int(input())
A = list(map(int, input().split()))
all_fav_num_xor = 0
for a in A:
all_fav_num_xor ^= a
l = [all_fav_num_xor ^ a for a in A]
print(*l)
| 0 | null | 7,338,050,555,538 | 68 | 123 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.