code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 6.82M
181,637B
⌀ | question_pair_id
float64 101M
180,471B
⌀ | code1_group
int64 2
299
| code2_group
int64 2
299
|
|---|---|---|---|---|---|---|
from math import cos, sin, pi
def make_koch_curve(N, n1, n2):
s = ((2 * n1[0] + n2[0]) / 3, (2 * n1[1] + n2[1]) / 3)
t = ((n1[0] + 2 * n2[0]) / 3, (n1[1] + 2 * n2[1]) / 3)
u = ((t[0] - s[0])*cos(pi/3) - (t[1] - s[1])*sin(pi/3) + s[0],
(t[0] - s[0])*sin(pi/3) + (t[1] - s[1])*cos(pi/3) + s[1])
if N == 0:
return
make_koch_curve(N-1, n1, s)
print(*s)
make_koch_curve(N-1, s, u)
print(*u)
make_koch_curve(N-1, u, t)
print(*t)
make_koch_curve(N-1, t, n2)
def main():
N = int(input())
n1 = (0., 0.)
n2 = (100., 0.)
print(*n1)
make_koch_curve(N, n1, n2)
print(*n2)
if __name__ == '__main__':
main()
|
import math
SIN_T = math.sin(math.pi / 3)
COS_T = math.cos(math.pi / 3)
def koch(p0, p4):
p1 = ((p0[0]*2 + p4[0])/3, (p0[1]*2 + p4[1])/3)
p3 = ((p0[0] + p4[0]*2)/3, (p0[1] + p4[1]*2)/3)
p2 = (COS_T*(p3[0]-p1[0]) + -SIN_T*(p3[1]-p1[1]) + p1[0],
SIN_T*(p3[0]-p1[0]) + COS_T*(p3[1]-p1[1]) + p1[1])
return [p1, p2, p3, p4]
if __name__ == "__main__":
n = int(input())
points = [(0, 0), (100, 0)]
for _ in [0]*n:
_points = [points[0]]
for origin, dest in zip(points, points[1:]):
_points += koch(origin, dest)
points = _points
for p in points:
print(*p)
| 1 | 128,400,632,360 | null | 27 | 27 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
N = int(input())
res = set()
a = ord("a")
mx = lambda x: max(list(map(ord, x))) - a
def dfs(s):
if len(s) == N:
res.add("".join(s))
return
for k in range(mx(s) + 2): dfs(s + [chr(k + a)])
dfs(["a"])
for r in sorted(res): print(r)
|
while 1:
x,y=sorted(map(int,raw_input().split()))
if x==y==0:break
print str(x)+" "+str(y)
| 0 | null | 26,392,214,369,508 | 198 | 43 |
N=int(input())
A = list(map(int,input().split()))
val = 0
for i in range(N):
val = val ^ A[i]
ans = []
for i in range(N):
s = val ^ A[i]
ans.append(s)
print(*ans)
|
import sys
def Ii():return int(sys.stdin.readline())
def Mi():return map(int,sys.stdin.readline().split())
def Li():return list(map(int,sys.stdin.readline().split()))
n = Ii()
a = Li()
b = 0
for i in range(n):
b ^= a[i]
ans = []
for i in range(n):
print(b^a[i],end=' ')
| 1 | 12,434,654,671,912 | null | 123 | 123 |
def plus(x):
yen = 0
if x < 4:
yen = yen + 100000
if x < 3:
yen = yen + 100000
if x < 2:
yen = yen + 100000
return yen
x, y = map(int, input().split())
res = plus(x) + plus(y)
if x == 1 and y == 1:
res = res + 400000
print(res)
|
x, y = (int(x) for x in input().split())
if x == y == 1: print(1000000)
else:
ans = 0
points = [300000, 200000, 100000]
if x <= 3: ans += points[x-1]
if y <= 3: ans += points[y-1]
print(ans)
| 1 | 140,149,325,678,190 | null | 275 | 275 |
n, k = list(map(int, input().split()))
while n > abs(n - k):
if n >= k:
n = min(n, n % k)
elif k > n:
n = min(n, k % n)
print(n)
|
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N, K = mapint()
v = N//K
print(min(N-v*K, K-(N-v*K)))
| 1 | 39,425,078,948,130 | null | 180 | 180 |
N, K = (int(a) for a in input().split())
p = [int(a) for a in input().split()]
p.sort()
print(sum(p[:K]))
|
from collections import deque
import math
N, D, A = map(int, input().split())
monster = [list(map(int, input().split())) for _ in range(N)]
monster.sort(key=lambda x:x[0])
bomb = deque()
s = 0
ans = 0
for i in range(N):
x, h = monster[i]
while len(bomb) > 0 and bomb[0][1] < x:
s -= bomb.popleft()[2]
h -= s
if h > 0:
cnt = math.ceil(h/A)
damage = cnt*A
bomb.append([x, x+2*D, damage])
s += damage
ans += cnt
print(ans)
| 0 | null | 47,041,479,826,514 | 120 | 230 |
n=int(input())
a=list(map(int,input().split()))
ans=0
for i,x in enumerate(a):
i+=1
if (i*x)%2==0:
continue
ans+=1
print(ans)
|
K, N = map(int, input().split())
A = [int(x) for x in input().split()]
mx = A[0] + K - A[-1]
for i in range(len(A) - 1):
dis = A[i + 1] - A[i]
if dis > mx:
mx = dis
print(K - mx)
| 0 | null | 25,470,688,210,462 | 105 | 186 |
def judge(m, f, r):
p = m + f
if (m == -1 or f == -1 or p < 30):
a = 'F'
elif (p >= 80):
a = 'A'
elif (p >= 65 and p < 80):
a = 'B'
elif (p >= 50 and p < 65 or r >= 50):
a = 'C'
elif (p >= 30 and p < 50):
a = 'D'
return a
while True:
m, f, r = map(int, input().split())
if (m == -1 and f == -1 and r == -1):
break
print(judge(m, f, r))
|
#coding: utf-8
while True:
m, f, r = (int(i) for i in input().split())
if m == f == r == -1:
break
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) or r >= 50:
print("C")
elif m + f >= 30 and m + f < 50:
print("D")
elif m + f < 30:
print("F")
| 1 | 1,252,906,253,456 | null | 57 | 57 |
def mergeArray(a,b,bLength,c,cLength):
global count
apos,bpos,cpos=(0,0,0)
while bpos<bLength and cpos<cLength:
if b[bpos]<=c[cpos]:
a[apos]=b[bpos]
bpos+=1
else:
a[apos]=c[cpos]
cpos+=1
apos+=1
count+=1
while bpos<bLength:
a[apos]=b[bpos]
apos+=1
bpos+=1
count+=1
while cpos<cLength:
a[apos]=c[cpos]
apos+=1
cpos+=1
count+=1
def mergeSort(a,aLength):
b=[]
c=[]
if aLength>=2:
b=a[:aLength//2]
c=a[aLength//2:]
mergeSort(b,len(b))
mergeSort(c,len(c))
mergeArray(a,b,len(b),c,len(c))
count=0
aLength=int(input())
a=list(map(int,input().split()))
mergeSort(a,aLength)
print(*a)
print(count)
|
def merge(A, left, mid, right, c):
global counter
n1 = mid - left
n2 = right - mid
L = [0] * (n1+1)
R = [0] * (n2+1)
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = 1000000000
R[n2] = 1000000000
i = 0
j = 0
for k in range(left,right):
c += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else :
A[k] = R[j]
j += 1
L.pop()
R.pop()
return c
def mergeSort(A, left, right, c):
if left+1 < right:
mid = int((left + right)/2)
c = mergeSort(A, left, mid, c)
c = mergeSort(A, mid, right, c)
c = merge(A, left, mid, right, c)
return c
if __name__ == '__main__':
num = int(input())
m = list(map(int,input().split()))
c = 0
c = mergeSort(m, 0, num, c)
print(' '.join(map(str,m)))
print(str(c))
| 1 | 112,687,846,538 | null | 26 | 26 |
isExist = [False]*2001
n = int( raw_input() )
A = [ int( val ) for val in raw_input().rstrip().split( ' ' ) ]
for i in A:
for j in range( 2000-i, 0, -1 ):
if isExist[j]:
isExist[ i+j ] = True
isExist[i] = True
q = int( raw_input() )
M = [ int( val ) for val in raw_input().rstrip().split( ' ' ) ]
for i in range( 0, q ):
if isExist[ M[i] ]:
print( "yes" )
else:
print( "no" )
|
# ALDS1_5_A.
def intinput():
a = input().split()
for i in range(len(a)):
a[i] = int(a[i])
return a
def binary_search(S, k):
a = 0; b = len(S) - 1
if b == 0: return S[0] == k
while b - a > 1:
c = (a + b) // 2
if k <= S[c]: b = c
else: a = c
return S[a] == k or S[b] == k
def show(a):
# 配列aの中身を出力する。
_str = ""
for i in range(len(a) - 1): _str += str(a[i]) + " "
_str += str(a[len(a) - 1])
print(_str)
def main():
n = int(input())
A = intinput()
q = int(input())
m = intinput()
# 配列Aの作る数を調べる。
nCanMake = [0]
for i in range(n):
for k in range(len(nCanMake)):
x = nCanMake[k] + A[i]
if not x in nCanMake: nCanMake.append(x)
# show(nCanMake)
for i in range(q):
if m[i] in nCanMake: print("yes")
else: print("no")
if __name__ == "__main__":
main()
| 1 | 95,387,902,030 | null | 25 | 25 |
k=int(input())
s=len(input())
def cmb(n,r,mod):
if r<0 or n<r:
return 0
r=min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
mod=10**9+7
g1=[1,1]#元table
g2=[1,1]#逆元table
inv=[0,1]#逆元table計算用
for i in range(2,k+s+1):
g1.append(g1[-1]*i%mod)
inv.append(-inv[mod%i]*(mod//i)%mod)
g2.append(g2[-1]*inv[-1]%mod)
ans=1
for i in range(1,k+1):
ans=(ans*26+cmb(i+s-1,s-1,mod)*pow(25,i,mod))%mod
print(ans)
|
#６回目、2020-0612
#2重ループ ＋O(1)
#場合分けを近道と通常のみ（絶対値を使う）
#初期入力
N, x, y = map(int, input().split())
normal =0
short =0
ans ={i:0 for i in range(1,N)}
for i in range(1,N):
for j in range(i+1,N+1):
normal =j -i
short =abs(x-i) +1 +abs(j-y)
dist =min(normal,short)
ans[dist] +=1
#答え出力
for i in range(1,N):
print(ans[i])
| 0 | null | 28,367,816,017,222 | 124 | 187 |
import sys
import math
n, k = map(int, sys.stdin.readline().split())
W = []
for _ in range(n):
w = int(sys.stdin.readline())
W.append(w)
r = sum(W)
l = max(W)
pre_p = 0
while l < r:
current = 0
num_tracks = 1
p = (l + r) // 2 # 値を設定
# 積み込めるか確認
for w in W:
if current + w > p:
num_tracks += 1 # 次のトラックを持ってくる
current = w
else:
current += w
if num_tracks > k: # 現在の p ではトラックが足りない場合
l = p + 1 # 最少値を上げる
else:
r = p # 最大値を下げる
print(l)
|
def p_is_smaller(p):
total = 0
number_of_track = 1
for w in W:
total += w
if total > p:
number_of_track += 1
if number_of_track > k:
return 1
total = w
return 0
if __name__ == "__main__":
n, k = map(int, input().split())
W = [int(input()) for _ in range(n)]
left, right = max(W), sum(W)
while right > left:
mid = (left + right) // 2
if p_is_smaller(mid):
left = mid + 1
else:
right = mid
print(right)
| 1 | 86,363,683,528 | null | 24 | 24 |
a,b,c,k = map(int,input().split())
if k < a:
ans = k
elif k < a + b:
ans = a
else:
ans = a - (k - a - b)
print(ans)
|
x,y,z,k=map(int,input().split())
s=min(k,x)
k=k-s
if(k>0):
k=k-min(k,y)
if(k>0):
f=min(k,z)
s=s-f
print(s)
| 1 | 21,779,069,137,540 | null | 148 | 148 |
import math
n = int(input())
List = []
n_sqrt = int(math.sqrt(n))
for i in range(1,n_sqrt+1):
if n % i == 0:
number = i + (n // i) -2
List.append(number)
print(min(List))
|
N = int(input())
x = int(N**(0.5)) + 1
while True:
if N % x == 0:
print((x-1)+((N//x)-1))
break
x -= 1
| 1 | 161,719,510,214,360 | null | 288 | 288 |
a = input()
ar = [0 for i in range(len(a)+1)]
for i in range(len(a)):
if a[i] == '<':
ar[i+1] = max(ar[i] + 1,ar[i+1])
for i in range(len(a)-1,-1,-1):
if a[i] == '>':
ar[i] = max(ar[i+1] + 1,ar[i])
print(sum(ar))
|
S = input()
ans = 0
l, r = 0, 0
i = 0
while i < len(S):
while i < len(S) and S[i] == "<":
l += 1
i += 1
while i < len(S) and S[i] == ">":
r += 1
i += 1
ans += l * (l + 1) // 2
ans += r * (r + 1) // 2
ans -= min(l, r)
l, r = 0, 0
print(ans)
| 1 | 156,492,597,903,476 | null | 285 | 285 |
N,A,B = map(int,input().split())
if N % (A+B) > A:
C = A
elif N % (A+B) <= A:
C = N % (A+B)
print((N//(A+B))*A + C)
|
N, A, B = map(int, input().split())
a = N//(A+B)
b = N%(A+B)
if b > A:
b = A
ans = a*A + b
print(ans)
| 1 | 55,292,693,086,400 | null | 202 | 202 |
N = int(input())
A = list(map(int, input().split()))
Q = int(input())
B = []
C = []
for q in range(Q):
b, c = map(int, input().split())
B.append(b)
C.append(c)
sam = sum(A)
baketu = [0]*(100001)
for a in A:
baketu[a] += 1
for q in range(Q):
sam = sam + baketu[B[q]] * (C[q] - B[q])
baketu[C[q]] += baketu[B[q]]
baketu[B[q]] = 0
#print(baketu)
print(sam)
|
from collections import Counter
n = int(input())
a = list(map(int,input().split()))
q = int(input())
num = Counter(a)
s = sum(a)
for _ in range(q):
b,c = map(int,input().split())
s += (c-b)*num[b]
num[c] += num[b]
num[b] = 0
print(s)
| 1 | 12,109,909,692,360 | null | 122 | 122 |
n = int(input())
S = input()
distinct = 1
for i in range(1, len(S)):
if S[i-1] != S[i]:
distinct += 1
print(distinct)
|
def check3(m):
m = str(m)
if '3' in m:
return True
else:
return False
n = int(input())
i = 1
while i <= n:
x = i
if x%3 == 0 or x%10 == 3:
print(" %d" % i, end = '')
i += 1
else:
isThree = check3(x)
if isThree:
print(" %d" % i, end = '')
i += 1
print("")
| 0 | null | 85,952,391,784,380 | 293 | 52 |
#problems2
#silver fox vs monster
import math
N,D,A=map(int,input().split())
d=[]
for _ in range(N):
x,h=map(int,input().split())
d.append((x,h))
d.sort(key=lambda x:x[0])
now_damage=0
from collections import deque
d=deque(d)
ans=0
d_field=deque()
while d:
x=d.popleft()
place,life=x
if d_field:
while (d_field and d_field[0][0]<place) :
now_damage-=A*d_field[0][1]
d_field.popleft()
if life<=now_damage:
pass
elif life>now_damage:
K=math.ceil((life-now_damage)/A)
ans+=K
now_damage+=K*A
d_field.append((2*D+place,K))
print(ans)
|
#!/usr/bin/env python3
def main():
h,w,k = map(int, input().split())
s = [input() for i in range(h)]
l = [[0]*w for i in range(h)]
from collections import deque
d = deque()
c = 1
for i in range(h):
for j in range(w):
if s[i][j] == '#':
d.append([i, j])
l[i][j] = c
c += 1
while len(d) > 0:
x,y = d.pop()
c = l[x][y]
l[x][y] = c
f1 = True
f2 = True
for i in range(1,w):
if y+i < w and l[x][y+i] == 0 and s[x][y+i] != '#' and f1:
l[x][y+i] = c
else:
f1 = False
if 0 <= y-i and l[x][y-i] == 0 and s[x][y-i] != '#' and f2:
l[x][y-i] = c
else:
f2 = False
for i in range(h):
if all(l[i]) == 0:
k1 = 1
while 0 < i+k1 < h and all(l[i+k1]) == 0:
k1 += 1
# print("test: ", i, k1)
if i+k1 < h:
for j in range(i, i+k1):
for r in range(w):
l[j][r] = l[i+k1][r]
for i in range(h-1, -1, -1):
if all(l[i]) == 0:
k1 = 1
while 0 < i-k1 < h and all(l[i-k1]) == 0:
k1 += 1
# print("test: ", i, k1)
if 0 <= i-k1 < h:
for j in range(i, i-k1, -1):
for r in range(w):
l[j][r] = l[i-k1][r]
for i in range(h):
print(' '.join(map(str, l[i])))
if __name__ == '__main__':
main()
| 0 | null | 113,275,820,023,530 | 230 | 277 |
while True:
data = input()
if(data == "-"):break
m = int(input())
tmp = []
for i in range(m):
num = int(input())
if(len(tmp) == 0):
tmp = data[num:] + data[:num]
data = ""
else:
data = tmp[num:] + tmp[:num]
tmp = ""
if(data): print(data)
else: print(tmp)
|
while True:
str_shuffled = input()
if str_shuffled == '-':
break
shuffle_time = int(input())
for _ in range(shuffle_time):
num_to_shuffle = int(input())
str_shuffled = str_shuffled[num_to_shuffle:] + str_shuffled[:num_to_shuffle]
print(str_shuffled)
| 1 | 1,896,835,289,700 | null | 66 | 66 |
n=list(map(int,input()))
if 7 in n:
print("Yes")
else:
print("No")
|
n,k,s=map(int,input().split())
a=[s]*(k)
for i in range(n-k):
a.append(max((s+1)%(10**9),1))
b=[]
for i in range(n):
b.append(str(a[i]))
print(" ".join(b))
| 0 | null | 62,740,971,175,690 | 172 | 238 |
if __name__ == "__main__":
a = []
for i in range(0,10):
val = input()
a.append(int(val))
a.sort()
a.reverse()
for i in range(0,3):
print(a[i])
|
array = [int(input()) for i in range(10)]
array.sort()
for i in range(9,6,-1):
print(array[i])
| 1 | 24,461,292 | null | 2 | 2 |
import sys
import math
input = sys.stdin.readline
def main():
k = int(input())
ans = 0
for a in range( 1 , k+1 ):
for b in range( a , k+1 ):
x = math.gcd( a , b )
for c in range( b , k+1 ):
y = math.gcd( x , c )
if a == b == c:
ans += y
elif a==b or b==c or c==a:
ans += 3 * y
else:
ans += 6 * y
print(ans)
main()
|
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
def main():
K = int(input())
s = sum([gcd(i+1, j+1, k+1) for i in range(K) for j in range(K) for k in range(K)])
print(s)
if __name__=="__main__":
main()
| 1 | 35,592,001,896,608 | null | 174 | 174 |
N = int(input())
X = []
for i in range(N):
X.append(input().split())
S = input()
flg = False
ans = 0
for x in X:
if flg:
ans += int(x[1])
if S == x[0]:
flg = True
print(ans)
|
N=int(input())
st=[]
for i in range(N):
s,t=input().split()
st.append((s,int(t)))
X=input()
time=0
s=False
for i in range(N):
if s:
time+=st[i][1]
if st[i][0]==X:
s=True
print(time)
| 1 | 96,935,070,573,280 | null | 243 | 243 |
def main():
n = int(input())
a_list = sorted(list(map(int, input().split())), reverse=True)
ans = a_list[0]
cnt = 1
i = 1
while True:
if cnt >= n - 2:
break
ans += a_list[i] * 2
i += 1
cnt += 2
if cnt == n - 2:
ans += a_list[i]
print(ans)
if __name__ == "__main__":
main()
|
ARGS=input().split()
N=int(ARGS[0])
R=int(ARGS[1])
if N >= 10:
NAIBU = R
else:
NAIBU = R + (100 * (10 - N))
print(str(NAIBU))
| 0 | null | 36,424,300,081,374 | 111 | 211 |
n=int(input())
a=[0]+list(map(int,input().split()))
b=[0 for i in range(n+1)]
for i in range(n):
b[a[i]]+=1
[print(i) for i in b[1:]]
|
n = int(input())
a = list(map(int, input().split()))
number_buka = [0]*n
for i in a:
number_buka[i-1] += 1
for j in number_buka:
print(j)
| 1 | 32,642,867,445,100 | null | 169 | 169 |
import math
import collections
import itertools
def YesNo(Bool):
if(Bool):
print("Yes")
else:
print("No")
return
def resolve():
N=int(input())
L=list(map(int,input().split()))
cnt=0
for i in range(N):
for j in range(i+1,N):
for k in range(j+1,N):
if((L[i]!=L[j] and L[i]!=L[k] and L[j]!=L[k] )and (L[i]<L[j]+L[k])and (L[j]<L[i]+L[k])and (L[k]<L[j]+L[i])):
cnt+=1
print(cnt)
resolve()
|
n = int(input())
l = list(map(int,input().split()))
ans = 0
for i in range(len(l)-2):
for j in range(i+1,len(l)-1):
for k in range(j+1,len(l)):
if l[i] != l[j] and l[j] != l[k] and l[k] != l[i] and 2 * max(l[i],l[j],l[k]) < l[i]+l[j]+l[k]:
ans += 1
print(ans)
| 1 | 4,998,279,286,212 | null | 91 | 91 |
if __name__ == "__main__":
a, b = map( int, input().split() )
print("%d %d %.5f"%(int(a/b),a%b,float(a/b)))
|
a,b=map(int,raw_input().split())
print a/b,a%b,'%.8f'%(a/(b+0.0))
| 1 | 605,362,828,212 | null | 45 | 45 |
WHITE = 0
GRAY = 1
BLACK = 2
NIL = -1
def dfs(u):
global time
color[i] = GRAY
time += 1
d[u] = time
for v in range(n):
if m[u][v] and (color[v] == WHITE):
dfs(v)
color[u] = BLACK
time += 1
f[u] = time
def next(u):
for v in range(nt[u], n + 1):
nt[u] = v + 1
if m[u][v]:
return v
return NIL
n = int(input())
m = [[0 for i in range(n + 1)] for j in range(n + 1)]
vid = [0] * n
d = [0] * n
f = [0] * n
S = []
color = [WHITE] * n
time = 0
nt = [0] * n
tmp = []
for i in range(n):
nums=list(map(int,input().split()))
tmp.append(nums)
vid[i] = nums[0]
for i in range(n):
for j in range(tmp[i][1]):
m[i][vid.index(tmp[i][j + 2])] = 1
for i in range(n):
if color[i] == WHITE:
dfs(i)
for i in range(n):
print(vid[i], d[i], f[i])
|
#!/usr/bin/env python3
import decimal
#import
#import math
#import numpy as np
#= int(input())
#= input()
A, B = map(decimal.Decimal, input().split())
print(int(A * B))
| 0 | null | 8,246,272,751,600 | 8 | 135 |
def dfs(c,lst):
n=len(lst)
ans=[0]*n
stack = [c-1]
check = [0]*n #チェック済みリスト
while stack != [] :
d=stack.pop()
if check[d]==0:
check[d]=1
for i in lst[d]:
if check[i]==0:
stack.append(i)
ans[i]=ans[d]+1
return(ans)
import sys
input = sys.stdin.readline
N,u,v=map(int,input().split())
ki=[[] for f in range(N)]
for i in range(N-1):
a,b = map(int,input().split())
ki[a-1].append(b-1)
ki[b-1].append(a-1)
U=dfs(u,ki)
V=dfs(v,ki)
ans=0
for i in range(N):
if V[i]>U[i]:
ans=max(ans,V[i]-1)
print(ans)
|
from bisect import bisect_left
n = int(input())
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n):
for j in range(i + 1, n):
k = l[i] + l[j]
pos = bisect_left(l, k)
ans += max(0, pos - j - 1)
print(ans)
| 0 | null | 144,753,284,641,492 | 259 | 294 |
def solve():
n = int(input())
a = list(map(int, input().split()))
res = 1000
for i in range(n-1):
if a[i] < a[i+1]:
res = res % a[i] + (res//a[i])*a[i+1]
print(res)
if __name__ == '__main__':
solve()
|
from collections import deque
n,p=map(int ,input().split())
que=deque([])
for i in range(n):
name,time=input().split()
time=int(time)
que.append([name,time])
t=0
while len(que)>0:
atop=que.popleft()
spend=min(atop[1],p)
atop[1]-=spend
t+=spend
if(atop[1]==0):
print(atop[0],t)
else:
que.append(atop)
| 0 | null | 3,701,201,635,780 | 103 | 19 |
def resolve():
a,b = map(int,input().split())
for i in range(20100):
ans = '-1'
if (i * 0.08)//1 == a and (i*0.1)//1==b:
ans = i
break
print(ans)
resolve()
|
MOD = 10**9 + 7
n, a, b = map(int, input().split())
def pow(x, n, MOD):
res = 1
while n:
if n & 1:
res *= x
res %= MOD
x *= x
x %= MOD
n >>= 1
return res
def fact(a, b, MOD):
res = 1
for i in range(a, b+1):
res *= i
res %= MOD
return res
def combi(n, k, MOD):
x = fact(n - k + 1, n, MOD)
y = fact(1, k, MOD)
return x * pow(y, MOD - 2, MOD) % MOD
def solve():
ans = pow(2, n, MOD) - 1 - combi(n, a, MOD) - combi(n, b, MOD)
print(ans % MOD)
#print(pow(2, MOD, MOD))
if __name__ == "__main__":
solve()
| 0 | null | 61,346,479,511,240 | 203 | 214 |
N = int(input())
S = input()
ans = []
for i in range(len(S)):
if i == len(S) - 1:
ans.append(S[i])
break
if S[i] != S[i+1]:
ans.append(S[i])
print(len(ans))
|
a = int(input())
s = input()
ans = ''
for i in range(a-1):
if s[i] == s[i+1]:
continue
else:
ans += s[i]
ans += s[-1]
#print(ans)
print(len(ans))
| 1 | 169,747,389,659,770 | null | 293 | 293 |
import sys, math
from collections import defaultdict
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def main():
n = int(input())
dic = defaultdict(int)
dic1 = defaultdict(int)
for _ in range(n):
a,b = map(int,input().split())
if a != 0 and b == 0:
a = 1
elif a == 0 and b != 0:
b = 1
else:
if not (a==0 and b==0):
m = gcd(a,b)
a //= m
b //= m
if a < 0 and b < 0:
a = -a
b = -b
if a < 0 and b > 0:
a = -a
b = -b
index = ' '.join([str(a),str(b)])
dic[index] += 1
dic1[index] += 1
ans = 1
dic2 = defaultdict(int)
for e in dic:
a,b = map(int,e.split())
if a == 0 and b == 0:
continue
flag = 0
if a == 0 and b == 1:
rev = ' '.join([str(1),str(0)])
elif a == 1 and b == 0:
rev = ' '.join([str(0),str(1)])
elif a > 0 and b > 0:
rev = ' '.join([str(b),str(-a)])
else:
rev = ' '.join([str(-b),str(a)])
if dic1[rev] > 0 and dic2[rev] == 0:
dic2[rev] = 1
dic2[e] = 1
flag = 1
if flag:
continue
n1 = pow(2,dic[e],mod)
n2 = pow(2,dic1[rev],mod)
ans *= (n1+n2-1)
ans %= mod
print((ans-1+dic['0 0'])%mod)
if __name__ == "__main__":
main()
|
import math
N = float(input())
if(N%2==0):
print(1/2)
else:
print((math.floor(N/2)+1)/N)
| 0 | null | 99,395,032,248,032 | 146 | 297 |
a, b, c, k = map(int, input().split())
if k <= a:
print(k)
elif k <= a + b:
print(a)
elif k <= a + b + c:
print(a - (k-a-b))
else:
print(a - c)
|
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]))
| 0 | null | 11,857,710,452,820 | 148 | 63 |
n, m = map (int, input().split())
ex1 = n*(n-1)//2
ex2 = m*(m-1)//2
ans = ex1 + ex2
print(ans)
|
i=0
while 1:
a = int(input())
if a == 0 : break
i+=1
print "Case %d: %d" % (i, a)
| 0 | null | 23,034,318,125,280 | 189 | 42 |
N=int(input())
S=str(input())
flg = True
if len(S)%2 != 0:
print("No")
else:
for i in range(len(S)//2):
if S[i] != S[i+len(S)//2]:
print("No")
flg = False
if flg == True:
print("Yes")
|
N = int(input())
S = input()
ans = 1
if N % 2:
ans = 0
else:
for i in range(N//2):
if S[i] != S[N//2 + i]:
ans = 0
if ans:
print("Yes")
else:
print("No")
| 1 | 146,688,917,670,972 | null | 279 | 279 |
import math
r = float(input())
print('{:.6f}'.format(r ** 2 * math.pi), '{:.6f}'.format(2 * r * math.pi))
|
H, A = map(int, input().split())
total = H // A
if H % A != 0:
print(total+1)
else:
print(total)
| 0 | null | 38,687,349,982,752 | 46 | 225 |
MOD=10**9+7
n, k = map(int, input().strip().split())
d=[0]*(k+1)
d[0]=None
for i in range(1,k+1):
d[i]=pow(k//i,n,MOD)
# update d
for i in range(k,0,-1):
for j in range(i*2,k+1,i):
d[i]-=d[j]
d[i]%=MOD
ans=0
for i in range(1,k+1):
ans+=d[i]*i%MOD
ans%=MOD
print(ans)
|
n,k=map(int,input().split())
#k以下のn個の数字
ans=[0]*(k+1)
p=10**9+7
result=0
for i in range(k):
num=k-i
ans[num]=pow(k//num,n,p)
j=2
while num*j<=k:
ans[num]-=ans[num*j]
j+=1
result+=((ans[num]*num)%p)
#print(num,ans)
print(result%p)
| 1 | 36,808,118,496,992 | null | 176 | 176 |
n=int(input())
l=sorted([list(map(int,input().split())) for i in range(n)],key=lambda x:x[0]-x[1],reverse=1)
now=float("INF")
ans=0
for i in l:
if sum(i)<=now:
now=i[0]-i[1]
ans+=1
print(ans)
|
print("Yes" if eval(input().replace(" ","-"))==0 else "No")
| 0 | null | 86,313,070,045,868 | 237 | 231 |
def resolve():
INF = 10 ** 18
N, M, L = map(int, input().split())
G = [[INF] * N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
G[a][b] = G[b][a] = c
for k in range(N):
for i in range(N):
for j in range(N):
G[i][j] = min(G[i][j], G[i][k] + G[k][j])
Cost = [[INF] * N for _ in range(N)]
for i in range(N):
for j in range(N):
if G[i][j] <= L:
Cost[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
Cost[i][j] = min(Cost[i][j], Cost[i][k] + Cost[k][j])
Q = int(input())
for _ in range(Q):
a, b = map(lambda x: int(x) - 1, input().split())
if Cost[a][b] == INF:
print(-1)
else:
print(Cost[a][b] - 1)
if __name__ == "__main__":
resolve()
|
from math import gcd
MOD = 10**9+7
n = int(input())
d = {}
zero = 0
for i in range(n):
a, b = map(int, input().split())
if a == 0 and b == 0:
zero += 1
continue
flip = 0
while not (a >= 0 and b > 0):
a, b = -b, a
flip ^= 1
g = gcd(a, b)
a //= g
b //= g
if not (a, b) in d:
d[(a, b)] = [0, 0]
d[(a, b)][flip] += 1
ans = 1
for (v1, v2) in d.values():
ans *= pow(2, v1, MOD) + pow(2, v2, MOD) - 1 # -1 is because need to remove the case that choose nothing
ans %= MOD
ans -= 1
ans += zero
ans %= MOD
print(ans)
| 0 | null | 96,943,957,995,228 | 295 | 146 |
A, B, C, D = map(int, input().split())
while(True):
C = C - B
if C <= 0:
ans = 'Yes'
break
A = A - D
if A <= 0:
ans = 'No'
break
print(ans)
|
a, b, c, d = list(map(int, input().split()))
turn = True
while True:
if turn:
c -= b
if c <= 0:
print("Yes")
import sys
sys.exit()
else:
a -= d
if a <= 0:
print("No")
import sys
sys.exit()
turn ^= True
| 1 | 29,686,984,458,240 | null | 164 | 164 |
# -*- coding: utf-8 -*-
def main():
from itertools import permutations
from math import sqrt
n = int(input())
x = [0 for _ in range(n)]
y = [0 for _ in range(n)]
for i in range(n):
xi, yi = map(int, input().split())
x[i] = xi
y[i] = yi
path = list(permutations(range(n)))
path_count = len(path)
length = 0
for p in path:
for i, j in zip(p, p[1:]):
length += sqrt((x[i] - x[j]) ** 2 + (y[i] - y[j]) ** 2)
print(length / path_count)
if __name__ == '__main__':
main()
|
#!/usr/bin/python3
#coding: utf-8
import math
N = int(input())
P = [[int(x) for x in input().split()] for _ in range(N)]
def calc(path):
r = 0
for i in range(len(path) - 1):
p1 = P[path[i-1]]
p2 = P[path[i]]
dx = p1[0] - p2[0]
dy = p1[1] - p2[1]
r += math.sqrt(dx*dx + dy*dy)
return r
ret = 0
numret = 0
def rec(path, rest):
if not rest:
global ret
global numret
ret += calc(path)
numret += 1
return
for i in range(len(rest)):
rec(path + [rest[i]], rest[:i] + rest[i+1:])
rec([], [i for i in range(N)])
print(ret/numret)
| 1 | 149,013,725,960,572 | null | 280 | 280 |
n = int(input())
ans = 0
for i in range(1, n+1):
if i % 3 == 0 and i % 5 == 0:
pass
elif i % 3 == 0:
pass
elif i % 5 == 0:
pass
else:
ans += i
if i >= n:
print(ans)
exit()
|
n=int(input())
ans=0
for i in range(n):
if (i+1)%3==0 and (i+1)%5==0:
continue
elif (i+1)%3==0:
continue
elif (i+1)%5==0:
continue
else:
ans+=i+1
print(ans)
| 1 | 34,703,792,864,900 | null | 173 | 173 |
n,k=map(int,input().split())
DIV = 10**9+7
count = 0
for i in range(k,n+2):
min_k = i*(i-1)/2
max_k = i*(2*n-i+1)/2
count += max_k - min_k + 1
print(int(count % DIV))
|
N, K = [int(_) for _ in input().split()]
mod = 10 ** 9 + 7
ans = 0
for i in range(K, N + 2):
ans += i * (N - i + 1) + 1
ans %= mod
print(ans)
| 1 | 33,246,739,834,412 | null | 170 | 170 |
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)
|
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
from collections import Counter
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
H, W, K = map(int, input().split())
A = [0] * H
for i in range(H):
A[i] = input()
X = [[0] * W for _ in range(H)]
cur = 1
for i in range(H):
if A[i].count('#') == 0:
continue
j = 0
k = A[i].find('#')
while j <= k:
X[i][j] = cur
j += 1
while j < W:
while j < W and A[i][j] == '.':
X[i][j] = cur
j += 1
if j < W:
cur += 1
X[i][j] = cur
j += 1
cur += 1
for i in range(H - 2, -1, -1):
for j in range(W):
if X[i][j] == 0:
X[i][j] = X[i + 1][j]
for i in range(1, H):
for j in range(W):
if X[i][j] == 0:
X[i][j] = X[i - 1][j]
for i in range(H):
print(*X[i])
| 0 | null | 75,394,449,888,252 | 103 | 277 |
n,x,m = map(int,input().split())
place = [0] * m
place[x] = 1
cur = [x]
ends = 0
for i in range(m):
x = (x**2) % m
if place[x] == 0:
place[x] = i+2
cur.append(x)
else:
ends = i+2
break
roopsum = sum(cur[place[x]-1:ends-1])
rooplen = ends - place[x]
curlen = cur[place[x]-1:]
mm = min(n,ends-1)
ans = 0
for i in range(mm):
ans += cur[i]
if n-mm == 0:
print(ans)
else:
roopamo = (n-mm) // rooplen
roopama = (n-mm) % rooplen
ans += roopamo * roopsum
for i in range(roopama):
ans += curlen[i]
print(ans)
|
n,x,m = map(int, input().split())
#xに何番目にきたかを記録していく。-1じゃなければ一回以上きている
table = [-1] * m
extra = []
l = 0
total = 0
#table[x]は周期が始まる点
while table[x] == -1:
extra.append(x)
table[x] = l
l += 1
total += x
x = (x*x) % m
#周期の長さ
c = l - table[x]
#周期の和
s = 0
for i in range(table[x], l):
s += extra[i]
ans = 0
#周期がnより長い場合
if n <= l:
for i in range(n):
ans += extra[i]
else:
#最初の一週目を足す
ans += total
n -= l
#残りの周期の周の和を足す
ans += s*(n//c)
n %= c
for i in range(n):
ans += extra[table[x]+i]
print(ans)
| 1 | 2,829,202,548,172 | null | 75 | 75 |
A, B = map(int, input().split())
print(max([0, A-2*B]))
|
A, B = list(map(int, input().split()))
ans = A - B*2
if ans <= 0:
print(0)
else:
print(A-B*2)
| 1 | 167,216,476,495,652 | null | 291 | 291 |
n = int(raw_input())
d = {}
for i in range(n):
p,q = map(str,raw_input().split())
if p == "insert":
d[q] = 1
elif p == "find":
if(q in d):
print "yes"
else:
print "no"
|
n = input()
dic = set([])
for i in xrange(n):
order = raw_input().split()
if order[0][0] == 'i':
dic.add(order[1])
else:
print "yes" if order[1] in dic else "no"
| 1 | 79,464,231,208 | null | 23 | 23 |
def therefore():
hon = [2, 4, 5, 7, 9]
pon = [0, 1, 6, 8]
bon = [3]
N = input()
n = int(N[-1])
if n in hon:
print("hon")
elif n in pon:
print("pon")
elif n in bon:
print("bon")
therefore()
|
n=int(input())
if n%10==3:
print("bon")
elif n%10==0 or n%10==1 or n%10==6 or n%10==8:
print("pon")
else:
print("hon")
| 1 | 19,444,484,572,828 | null | 142 | 142 |
N, M = map(int, input().split())
p = [0] * M
S = ['a'] * M
for i in range(M):
p[i], S[i] = input().split()
p[i] = int(p[i])
ansac = pen = 0
answa = [0] * N
flg = [0] * N
for i in range(M):
if flg[p[i]-1] == 1:
continue
if S[i] == 'WA':
answa[p[i]-1] += 1
elif S[i] == 'AC':
ansac += 1
pen += answa[p[i]-1]
flg[p[i]-1] = 1
print(ansac, pen)
|
X = int(input())
G = 100
after_year = 0
while X > G:
G += G // 100
after_year += 1
print(after_year)
| 0 | null | 60,316,737,594,800 | 240 | 159 |
n = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
print("{0} {1} {2}".format(min(a), max(a), sum(a)))
|
n = input()
m = map(int,raw_input().split())
a = 0
for i in xrange(n):
a += m[i]
print min(m),max(m),a
| 1 | 724,389,386,688 | null | 48 | 48 |
import numpy as np
H,N= map(int, input().split())
m = np.array([list(map(int, input().split())) for _ in range(N)])
max_a = np.max(m[:,0])
dp = np.zeros(H+max_a+1, dtype='i8')
for i in range(max_a+1, H+max_a+1):
dp[i] = np.min(dp[i-m[:,0]] + m[:,1])
print(dp[H+max_a])
|
from math import ceil
a, b, c, d = map(int, input().split())
x = ceil(c/b)
y = ceil(a/d)
if x <= y:
print('Yes')
else:
print('No')
| 0 | null | 55,576,045,575,568 | 229 | 164 |
N, M = map(int, input().split())
A = list(map(int,input().split()))
A.sort()
total=sum(A)
i=0
flg="Yes"
while i < M:
if A.pop() < total/(4*M):
flg="No"
break
i += 1
print(flg)
|
n, m = map(int,input().split())
A = list(map(int,input().split()))
sum = 0
count = 0
for a in A:
sum += a
for a in A:
if a >= sum/(4*m):
count += 1
if count >= m:
print('Yes')
else:
print('No')
| 1 | 38,865,187,694,930 | null | 179 | 179 |
import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())
a,b = MI()
c,d = MI()
print(1 if d == 1 else 0)
|
X, Y = map(int, input().split())
X1, Y1 = map(int, input().split())
if Y1 == 1:
print("1")
else:
print("0")
| 1 | 123,963,220,292,900 | null | 264 | 264 |
N, K = map(int, input().split())
n = N%K
m = K - n
print(min(abs(n), abs(m)))
|
n,k,s = map(int, input().split())
ans = []
if s == 10**9:
for i in range(k):
ans.append(10**9)
for i in range(n-k):
ans.append(1)
else:
for i in range(k):
ans.append(s)
for i in range(n-k):
ans.append(s+1)
print(*ans)
| 0 | null | 65,306,687,695,300 | 180 | 238 |
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)))
|
x, y, z = map(int, input().split())
answerList = [z, x, y]
for i in range(len(answerList)):
print(answerList[i], end=' ')
| 0 | null | 50,109,740,317,052 | 210 | 178 |
a,b=map(int,input().split())
def gcd(x, y):
while y:
x, y = y, x % y
return x
l=gcd(a,b)
print(int(a*b/l))
|
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF = float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353
A, B = map(int, input().split())
# リストのlcm
def lcm_base(x, y):
return (x * y) // math.gcd(x, y)
print(lcm_base(A, B))
| 1 | 112,998,662,816,672 | null | 256 | 256 |
X = int(input())
for k in range(3, 361):
if (k*X)%360==0:
print(k)
exit()
|
a=map(int,raw_input().split(" "))
#a = sorted(a)
#print a[0],a[1],a[2]
print" ".join(map(str,sorted(a)))
| 0 | null | 6,725,872,963,094 | 125 | 40 |
x = int(input())
r = 0
divider = ((500,1000), (5, 5))
for i in divider:
x, remain = divmod(x, i[0])
r += x * i[1]
x = remain
print(r)
|
x = 0
m_list = []
f_list = []
r_list = []
while x < 50:
m, f, r = map(int, input().split())
if m == -1 and f == -1 and r == -1:
break
m_list.append(m)
f_list.append(f)
r_list.append(r)
x = x+1
for(mlist,flist,rlist) in zip(m_list,f_list,r_list):
if mlist == -1 or flist == -1:
print("F")
elif 80 <= mlist + flist:
print("A")
elif 65 <= mlist + flist and mlist + flist < 80:
print("B")
elif 50 <= mlist + flist and mlist + flist < 65:
print("C")
elif 30 <= mlist + flist and mlist + flist < 50:
if 50 <= rlist:
print("C")
else:
print("D")
elif mlist + flist < 30:
print("F")
| 0 | null | 21,857,660,299,364 | 185 | 57 |
input_line = input()
Line = input_line.split()
Line = [int(s) for s in Line]
if Line[0] == Line[1]:
print("Yes")
else:
print("No")
|
n=int(input())
a=[]
b=[]
for i in range(n):
x,y=map(int,input().split())
a.append(x+y)
b.append(x-y)
a=sorted(a)
b=sorted(b)
ans=max(a[-1]-a[0],b[-1]-b[0])
print(ans)
| 0 | null | 43,196,786,441,120 | 231 | 80 |
num = list(map(int,input().split()))
print("%d %d" % (num[0]*num[1],(num[0]+num[1])*2))
|
a, b = map(int, input().split())
print("%d %d" % (a * b, 2 * (a + b)))
| 1 | 305,037,142,508 | null | 36 | 36 |
import sys
Stack = []
MAX = 1000
def push(x):
#if isFull():
# print "ERROR!"
# sys.exit()
Stack.append(x)
def pop():
#if isEmpty():
# print "ERROR!"
# sys.exit()
Stack.pop(-1)
def cul(exp):
for v in exp:
if v == "+":
x = reduce(lambda a,b:int(a)+int(b), Stack[-2:])
for i in range(2):
pop()
push(x)
elif v == "-":
x = reduce(lambda a,b:int(a)-int(b), Stack[-2:])
for i in range(2):
pop()
push(x)
elif v == "*":
x = reduce(lambda a,b:int(a)*int(b), Stack[-2:])
for i in range(2):
pop()
push(x)
else:
push(v)
return Stack[0]
if __name__ == "__main__":
exp = sys.stdin.read().strip().split(" ")
ans = cul(exp)
print ans
|
import math
n = int(input())
mod = 1000000007
ab = [list(map(int,input().split())) for _ in range(n)]
dic = {}
z = 0
nz,zn = 0,0
for a,b in ab:
if a == 0 and b == 0:
z += 1
continue
elif a == 0:
zn += 1
continue
elif b == 0:
nz += 1
if a< 0:
a = -a
b = -b
g = math.gcd(a,b)
tp = (a//g,b//g)
if tp not in dic:
dic[tp] = 1
else:
dic[tp] += 1
ans = 1
nn = n - z - zn - nz
for tp,v in dic.items():
if v == 0:
continue
vt = (tp[1],-1*tp[0])
if vt in dic:
w = dic[vt]
#print(tp)
e = pow(2,v,mod) + pow(2,w,mod) - 1
ans *= e
ans %= mod
nn -= v + w
dic[tp] = 0
dic[vt] = 0
ans *= pow(2,nn,mod)
if zn == 0:
ans *= pow(2,nz,mod)
elif nz == 0:
ans *= pow(2,zn,mod)
else:
ans *= pow(2,nz,mod) + pow(2,zn,mod) - 1
ans += z - 1
print(ans%mod)
#print(dic)
| 0 | null | 10,476,198,869,930 | 18 | 146 |
#bit全探索
n,m,x=map(int,input().split())
c=[]
a=[]
for i in range(n):
l=list(map(int,input().split()))
c.append(l[0])
a.append(l[1:])
min_cost=float('inf')
for i in range(2**n):
flag=True
cost_total=0
a_total=[0]*m
for j in range(n):
if (i>>j)&1:
cost_total+=c[j]
for k in range(m):
a_total[k]+=a[j][k]
for s in range(m):
if a_total[s]<x:flag=False
if flag:
min_cost=min(min_cost,cost_total)
if min_cost==float('inf'):
print(-1)
else:
print(min_cost)
|
N,M,X = map(int,input().split())
data = []
ans = 0
for i in range(N):
d = list(map(int,input().split()))
data.append(d)
ans += d[0]
x = 2**N + 1
ans_candidate = []
valid = False
ans += 1
ans_old = ans
for i in range(x):
if i != 0:
for l in range(len(sum)):
if sum[l] >= X and l == len(sum) -1:
valid = True
if sum[l] >= X:
continue
else:
valid = False
break
if valid and price < ans:
ans = price
sum = [0] * M
price = 0
for j in range(N):
if i >> j & 1 == 1:
price += data[j][0]
for k in range(M):
sum[k] += data[j][k+1]
if ans_old == ans:
print(-1)
else:
print(ans)
| 1 | 22,390,254,941,140 | null | 149 | 149 |
# 初期入力
from bisect import bisect_left
import sys
#input = sys.stdin.readline #文字列では使わない
N = int(input())
c =input().strip()
ans =0
r =[i for i, x in enumerate(c) if x == 'R'] #全体の中でRのIndex
r_num =len(r) #全体でRの数
ans =bisect_left(r,r_num) #呪われないためのRとWの境界
print(r_num -ans) #境界より右側のRの数
|
#coding:utf-8
a , b , c =input().rstrip().split(" ")
if int(a)<int(b):
if int(b)<int(c):
print("Yes")
else:
print("No")
else:
print("No")
| 0 | null | 3,319,379,004,072 | 98 | 39 |
N = int(input())
D = list(map(int, input().split()))
if D[0] != 0:
print(0)
else:
tmp = [0 for _ in range(10 ** 5)]
for i in range(N):
tmp[D[i]] += 1
if tmp[0] != 1:
print(0)
else:
ans = 1
flag = False
flag2 = False
for i in range(1, 10 ** 5 - 1):
if flag2 and tmp[i+1] != 0:
ans = 0
break
if tmp[i+1] == 0:
flag2 = True
ans = (ans * (tmp[i] ** tmp[i+1])) % 998244353
print(ans)
|
from collections import deque
import copy
H,W=map(int,input().split())
S=[list(input()) for _ in range(H)]
S1=copy.deepcopy(S)
ans=[]
sy=0
sx=0
for i in range(H):
for j in range(W):
c=0
route=deque([(i,j,0)])
S=copy.deepcopy(S1)
while route:
a,b,n=route.popleft()
c=n
if 0<=a<=H-1 and 0<=b<=W-1:
if S[a][b]=='.':
S[a][b]='#'
route.append((a+1,b,n+1))
route.append((a-1,b,n+1))
route.append((a,b+1,n+1))
route.append((a,b-1,n+1))
ans.append(c-1)
print(max(ans))
| 0 | null | 124,774,098,861,610 | 284 | 241 |
import sys
input = sys.stdin.buffer.readline
import numpy as np
D = int(input())
c = np.array(input().split(), dtype=np.int32)
s = np.array([input().split() for _ in range(D)], dtype=np.int32)
last = np.zeros(26, dtype=np.int32)
ans = []
point = 0
for i in range(D):
down = (i+1-last)*c
loss = down * 3 + s[i,:]
idx = np.argmax(loss)
ans.append(idx+1)
point += s[i, idx] - down.sum()
last[idx] = i+1
for i in range(D):
print(ans[i])
|
def main():
D = int(input())
C = [0] * 26
C = list(map(int,input().split()))
S = [ list(map(int,input().split(" "))) for i in range(D)]
last = [0] * 26
for i in range(D):
max = -9999999999999
max_t = 0
for t in range(26):
score = 0
for j in range(26):
if j == t:
#last[j] = 0
score += S[i][j]
else:
#last[j] += 1
score -= (last[j]+10)*C[j]
if score > max:
max = score
max_t = t
for j in range(26):
if j == max_t:
last[j] = 0
else:
last[j] += 1
print(max_t + 1)
if __name__ == '__main__':
main()
| 1 | 9,658,760,839,222 | null | 113 | 113 |
n, k, c = map(int, input().split())
s = input()
s2 = s[::-1]
dp1 = [0] * (n + 2)
dp2 = [0] * (n + 2)
for (dp, ss) in zip([dp1, dp2], [s, s2]):
for i in range(n):
if ss[i] == 'x':
dp[i+1] = dp[i]
elif i <= c:
dp[i+1] = min(1, dp[i] + 1)
else:
dp[i+1] = max(dp[i-c] + 1, dp[i])
dp2 = dp2[::-1]
for i in range(1, n+1):
if s[i-1] == 'o' and dp1[i-1] + dp2[i+1] < k:
print(i)
|
N, K, C = map(int, input().split())
S = str(input())
A = [0] * K
B = [0] * K
a = 0
b = N - 1
for i in range(K):
j = K - 1 - i
while S[a] == 'x':
a += 1
while S[b] == 'x':
b -= 1
A[i] = a
a += 1 + C
B[j] = b
b -= 1 + C
for i in range(K):
if A[i] == B[i]:
print(A[i] + 1)
| 1 | 40,728,618,622,688 | null | 182 | 182 |
import sys
printf = sys.stdout.write
mat = []
new_map = []
r,c = map(int, raw_input().split())
for i in range(r):
mat = map(int, raw_input().split())
new_map.append(mat)
for i in range(r):
new_map[i].append(sum(new_map[i][:]))
for j in range(c):
print new_map[i][j],
printf(" " + str(new_map[i][j + 1]) + "\n")
for j in range(c + 1):
a = 0
for i in range(r):
a += new_map[i][j]
if j == c:
printf(" " + str(a) + "\n")
break
else:
print a,
|
'''
ITP-1_7-C
??¨?¨????
??¨?¨??????????????°???????????????°???????????????????????????
??¨????????°r??¨?????°c???r ?? c ???????´????????????¨?????????????????§???????????¨??????????¨?????????\????????°????????¨???????????????
????????°?????????????????????????????????
???Input
???????????????r??¨c????????????????????§??????????????????????¶????r??????????????????c????????´??°????????????????????§?????????????????????
???Output
(r+1) ?? (c+1) ?????°????????¨??????????????????????????????????????£???????????´??°????????????????????§????????£???????????????
???????????????????????¨??????????????????????¨?????????????????????????????????¨??????????????????????¨??????????
???????????????????????¨??¨??????????¨????????????\??????????????????
'''
# inputData
r, c = map(int, input().split())
data = [list(map(int, input().split())) for i in range(r)]
for row in data:
row.append(sum(row))
print(*row)
# zip ????´?????????????????????????????????¨?????§????????????????????§??????
columnSum = [sum(Column) for Column in zip(*data)]
print(*columnSum)
| 1 | 1,362,157,687,532 | null | 59 | 59 |
INF = int(1e18)
def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [A[left + i] for i in range(n1)]
R = [A[mid + i] for i in range(n2)]
L.append(INF)
R.append(INF)
i, j = 0, 0
count = 0
for k in range(left, right):
count += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
return count
def merge_sort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
c1 = merge_sort(A, left, mid)
c2 = merge_sort(A, mid, right)
c = merge(A, left, mid, right)
return c + c1 + c2
else:
return 0
if __name__ == '__main__':
n = int(input())
A = list(map(int, input().split()))
c = merge_sort(A, 0, n)
print(" ".join(map(str, A)))
print(c)
|
N = int(input())
*A, = list(map(int, input().split()))
count = 0
def merge(a, left, mid, right):
global count
la = a[left:mid] + [float("inf")]
ra = a[mid:right] + [float("inf")]
i, j = 0, 0
for k in range(left, right):
count += 1
if la[i] <= ra[j]:
a[k] = la[i]
i += 1
else:
a[k] = ra[j]
j += 1
def merge_sort(a, left, right):
if left + 1 < right:
mid = int((left + right) / 2)
merge_sort(a, left, mid)
merge_sort(a, mid, right)
merge(a, left, mid, right)
merge_sort(A, 0, N)
print(*A)
print(count)
| 1 | 109,669,448,422 | null | 26 | 26 |
N = int(input())
N += 1
print(N // 2)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(read())
print((N + 1) // 2)
| 1 | 59,276,966,016,590 | null | 206 | 206 |
A,B,K = map(int, open(0).read().split())
if K <= A:
print(A-K,B)
elif K >= A + B:
print(0,0)
else:
print(0,B-K+A)
|
A,B,K = map(int,input().split())
A,rem = max(A-K,0),max(K-A,0)
B = max(B-rem,0)
print(A,B)
| 1 | 104,480,604,497,710 | null | 249 | 249 |
n=int(input())
if n%2==0:
print("0.5")
if n%2==1:
print((int(n/2)+1)/n)
|
# 142 A
n = int(input())
odd = 0
for i in range(1, n+1):
if i % 2 != 0:
odd += 1
x = odd/n
print('%.10f' % x)
| 1 | 177,176,623,616,058 | null | 297 | 297 |
import bisect
n = int(input())
l = list(map(int, input().split()))
l.sort()
cnt = 0
for i in range(n-2):
for j in range(i+1, n-1):
sum = l[i] + l[j]
index = bisect.bisect_left(l, sum)
cnt += index - j - 1
print(cnt)
|
import bisect
def main2():
N = int(input())
L = list(map(int, input().split()))
L = sorted(L)
ans = 0
for i in range(len(L) - 2):
for j in range(i + 1, len(L) - 1):
ab = L[i] + L[j]
r = bisect.bisect_left(L, ab)
l = j + 1
ans += r - l
print(ans)
if __name__ == "__main__":
main2()
| 1 | 171,940,977,468,260 | null | 294 | 294 |
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
MOD = 10 ** 9 + 7
N, K = map(int, readline().split())
d = [0] * (K+1)
for i in range(K,0,-1):
t = K // i
cnt = pow(t,N,MOD)
for j in range(2,t+1):
cnt -= d[i*j]
cnt %= MOD
d[i] = cnt
ans = 0
for num,cnt in enumerate(d):
ans += num * cnt
ans %= MOD
print(ans)
|
import math
n = int(input())
mod = 10**9+7
d = {}
zero = 0
for i in range(n):
a,b = map(int,input().split())
if a == 0 and b == 0:
zero += 1
else:
g = math.gcd(a,b)
a //= g
b //= g
if b < 0:
a = -a
b = -b
if b == 0 and a == -1:
a = 1
if a > 0:
if (a,b) in d:
d[(a,b)][0] += 1
else:
d[(a,b)] = [1,0]
else:
if (b,-a) in d:
d[(b,-a)][1] += 1
else:
d[(b,-a)] = [0,1]
ans = 1
for (a,b),(c,d) in d.items():
count = (pow(2,c,mod)+pow(2,d,mod)-1)%mod
ans *= count
ans %= mod
print((ans+zero-1)%mod)
| 0 | null | 28,857,601,940,990 | 176 | 146 |
string = input()
string = string*2
if string.count(input()):
print("Yes")
else:
print("No")
|
N, X, M = map(int, input().split())
"""
id[X] Xを何番目に訪問したか。-1で無ければ訪問済み。
Xをメモ A[i+1] = (A[i] * A[i]) % M
length = ループが終わるまでの長さ
"""
id = [-1] * M
A = [] # 訪問したものをメモ
length = 0
total = 0
while id[X] == -1:
A.append(X)
id[X] = length
length += 1
total += X
X = (X * X) % M
syuki = length - id[X]
syukisum = sum(A[id[X] : length])
# for i in range(id[X], length):
# syukisum += A[i]
ans = 0
if N <= length:
ans = sum(A[:N])
else:
ans += total
N -= length
loop, res = divmod(N, syuki)
ans += syukisum * loop
ans += sum(A[id[X] : id[X] + res])
print(ans)
| 0 | null | 2,240,151,730,530 | 64 | 75 |
X=int(input())
h500=X//500
h5=(X-h500*500)//5
print(h500*1000+h5*5)
|
a, b, c = map(int, input().split())
divisors = []
i = 1
while(i * i < c):
if(c % i == 0):
divisors.append(i)
divisors.append(c // i)
i += 1
if(i * i == c):
divisors.append(i)
ans = 0
for i in range(len(divisors)):
if(a <= divisors[i] <= b):
ans += 1
print(ans)
| 0 | null | 21,693,837,543,070 | 185 | 44 |
from operator import itemgetter
faces = list(map(int, input().split()))
commands = input()
for command in commands:
if command == 'N':
faces = itemgetter(1,5,2,3,0,4)(faces)
elif command == 'E':
faces = itemgetter(3,1,0,5,4,2)(faces)
elif command == 'S':
faces = itemgetter(4,0,2,3,5,1)(faces)
elif command == 'W':
faces = itemgetter(2,1,5,0,4,3)(faces)
print(faces[0])
|
class Dice():
def __init__(self, nums):
self.nums = nums
self.top, self.front, self.right = 0, 1, 2
def move(self, op):
for c in op:
if c == 'N':
self.top, self.front = self.front, 5 - self.top
elif c == 'S':
self.top, self.front = 5 - self.front, self.top
elif c == 'E':
self.top, self.right = 5 - self.right, self.top
else:
self.top, self.right = self.right, 5 - self.top
dice = Dice([int(n) for n in input().split()])
dice.move(input())
print(dice.nums[dice.top])
| 1 | 228,592,043,132 | null | 33 | 33 |
a, b, c = map(int, input().split())
if a < b and b < c:
ans = 'Yes'
else:
ans = 'No'
print(ans)
|
n=input()
print(sum(i&1 for i in list(map(int, input().split()))[::2]))
| 0 | null | 4,047,822,382,032 | 39 | 105 |
XS = open(0).read().split()
i = 0
while True:
t = XS[i]
i += 1
if t == "-":
break
n = int(XS[i])
i += 1
m = sum(map(int, XS[i:i+n])) % len(t)
i += n
print(t[m:] + t[:m])
|
ans = []
while (1) :
word = input().strip()
try :
inputLen = int( input().strip() )
except :
break
for i in range(0, inputLen) :
h = int( input().strip() )
word = word[h:] + word[:h]
ans.append(word)
for s in ans :
print(s)
| 1 | 1,887,579,711,050 | null | 66 | 66 |
#!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
def _cmb(N, mod):
N1 = N + 1
fact = [1] * N1
inv = [1] * N1
for i in range(2, N1):
fact[i] = fact[i-1] * i % mod
inv[N] = pow(fact[N], mod-2, mod)
for i in range(N-1, 1, -1):
inv[i] = inv[i+1]*(i+1) % mod
def cmb(a, b):
return fact[a] * inv[b] % mod * inv[a-b] % mod
return cmb
def resolve():
K = int(input())
s = input()
ls = len(s) - 1
mod = 10**9+7
cmb = _cmb(ls+K, mod)
ans = 0
pp = 1 * pow(26, K, mod) % mod
px = 25 * pow(26, mod-2, mod) % mod
for i in range(K+1):
ans = (ans + cmb(ls+i, ls) * pp % mod) % mod
pp = pp * px % mod
print(ans)
if __name__ == "__main__":
resolve()
|
K = int(input())
S = input()
N = len(S)
mod = int(1e9+7)
wk = pow(26,K,mod)
inv26 = pow(26,-1,mod)
ans = wk
for i in range(1,K+1):
wk = (wk * 25 * inv26) % mod
wk = (wk * (N-1+i) * pow(i,-1,mod) % mod)
ans = (ans + wk)%mod
print(ans)
| 1 | 12,807,995,999,460 | null | 124 | 124 |
x, y, z = map(int, raw_input().split())
cnt = 0
for i in range(x, y+1):
if z%i == 0:
cnt += 1
print cnt
|
import sys
a, b, c = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
cnt = 0
for i in range( a, b+1 ):
if 0 == c%i:
cnt += 1
print( "{}".format( cnt ) )
| 1 | 546,732,968,320 | null | 44 | 44 |
n = int(input())
ss = [input() for _ in range(n)]
cnt = {}
ans =0
for s in ss:
if s not in cnt:
cnt[s]=0
ans += 1
print(ans)
|
N = int(input())
S = [input() for i in range(N)]
S = set(S)
S = list(S)
print(len(S))
| 1 | 30,067,123,671,598 | null | 165 | 165 |
n = int(input())
n1 = n
pn = []
cnt = 2
ans = 0
while cnt <= int(n ** 0.5):
while n1 % cnt == 0:
n1 = n1 // cnt
pn.append(cnt)
cnt += 1
pns = list(set(pn))
ansa = []
for i in pns:
ansa.append(pn.count(i))
for i in ansa:
x = 1
while i > 0:
i -= x
if i < 0:
break
x += 1
ans += 1
print(ans + 1 if n1 != 1 else ans)
|
import sys
from io import StringIO
import unittest
import os
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr.append([i, cnt])
if temp != 1:
arr.append([temp, 1])
if not arr:
arr.append([n, 1])
return arr
# 実装を行う関数
def resolve(test_def_name=""):
n = int(input())
target_s = factorization(n)
# 素因数1だけ処理対象外。
if sum([i[1] for i in target_s]) == 1:
if target_s[0][0] == 1:
print(0)
else:
print(1)
return
# 少ない物から使っていく。
cnt = 0
for i in range(1, 1000):
if not any([True if j[1] >= i else False for j in target_s]):
break
for target in target_s:
if target[1] < i:
continue
target[1] -= i
cnt += 1
print(cnt)
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """24"""
output = """3"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """1"""
output = """0"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """64"""
output = """3"""
self.assertIO(test_input, output)
def test_input_4(self):
test_input = """1000000007"""
output = """1"""
self.assertIO(test_input, output)
def test_input_5(self):
test_input = """997764507000"""
output = """7"""
self.assertIO(test_input, output)
def test_1original_1(self):
test_input = """108"""
output = """3"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
| 1 | 16,882,250,054,010 | null | 136 | 136 |
import sys
sys.setrecursionlimit(10 ** 5)
n, u, v = map(int, input().split())
u -= 1
v -= 1
es = [[] for i in range(n)]
for i in range(n-1):
a, b = map(int, input().split())
es[a-1].append(b-1)
es[b-1].append(a-1)
def dfs(v, dist, p=-1, d=0):
dist[v] = d
for nv in es[v]:
if nv == p:
continue
dfs(nv, dist, v, d+1)
def calc_dist(x):
dist = [-1] * n
dfs(x, dist)
return dist
dist_t = calc_dist(u)
dist_a = calc_dist(v)
mx = 0
for i in range(n):
if dist_t[i] < dist_a[i]:
mx = max(mx, dist_a[i])
ans = mx - 1
print(ans)
|
n, u, v = map(int, input().split())
tree = [[] for i in range(n+1)]
for i in range(n-1):
a, b = map(int, input().split())
tree[a].append(b)
tree[b].append(a)
dist1 = [100005]*(n+1)
q = []
q.append(v)
dist1[v] = 0
while q:
now = q.pop()
for next in tree[now]:
if dist1[next] == 100005:
q.append(next)
dist1[next] = dist1[now] + 1
dist2 = [100005]*(n+1)
q = []
q.append(u)
dist2[u] = 0
while q:
now = q.pop()
for next in tree[now]:
if dist2[next] == 100005:
q.append(next)
dist2[next] = dist2[now] + 1
for i in range(1, n+1):
if dist1[i] <= dist2[i]:
dist2[i] = -1
for i in range(1, n+1):
if dist2[i] != -1:
dist2[i] = 100005
q = []
q.append(u)
dist2[u] = 0
while q:
now = q.pop()
for next in tree[now]:
if dist2[next] == 100005:
q.append(next)
dist2[next] = dist2[now] + 1
ans = 0
for i in range(1, n+1):
if dist2[i] != -1:
ans = max(ans, dist1[i])
print(ans-1)
| 1 | 117,673,285,855,052 | null | 259 | 259 |
while 1:
m, f, r = [int(i) for i in input().split()]
if m == -1 and f == -1 and r == -1:
break
elif m == -1 or f == -1:
print("F")
elif m + f >= 80:
print("A")
elif 65 <= m + f < 80:
print("B")
elif 50 <= m + f < 65:
print("C")
elif 30 <= m + f < 50:
if r >= 50:
print("C")
else:
print("D")
elif m + f < 30:
print("F")
|
X,Y=map(int,input().split());print((max((4-X),0)+max((4-Y),0)+((0,4)[X*Y==1]))*10**5)
| 0 | null | 71,248,315,904,250 | 57 | 275 |
from collections import defaultdict
def readInt():
return int(input())
def readInts():
return list(map(int, input().split()))
def readChar():
return input()
def readChars():
return input().split()
n = readInt()
a = readInts()
sum_a = sum(a)
v = sum(a)/2
ans = float("inf")
t = 0
for i in range(len(a)):
t+=a[i]
ans = min(ans,abs(sum_a-2*t))
print(ans)
|
n = int(input())
A = list(map(int, input().split()))
ans = 10**18
total = sum(A)
acc = 0
for a in A:
acc += a
ans = min(ans, abs(total - acc * 2))
print(ans)
| 1 | 142,523,558,695,100 | null | 276 | 276 |
N, M, K = list(map(int, input().split()))
A = [0] + [int(i) for i in input().split() ]
B = [0] + [int(i) for i in input().split() ]
best = 0
a_time = 0
b_time = sum(B)
b_i = len(B)-1
end_flag = False
for a_i in range(N+1):
a_time += A[a_i]
while a_time + b_time > K:
if b_i == 0:
end_flag = True
break
b_time -= B[b_i]
b_i -= 1
if end_flag == True:
break
if a_i + b_i > best:
best = a_i + b_i
print(best)
|
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 7 11:05:00 2020
@author: liang
"""
"""
片側を固定して、それぞれのケースに対して最適解を求める
それぞれのケースについて
index(b_i) =< index(b_i-1)
であるから、bの最大値bestを保存して探索することで重複探索を回避できる
"""
N, M, K = map(int, input().split())
A = [0] + [int(x) for x in input().split()]
B = [0] + [int(x) for x in input().split()]
s_b = 0
for i in range(M+1):
s_b += B[i]
if s_b > K:
s_b -= B[i]
best = i - 1
break
else:
best = M
res = best
#print(res)
s_a = 0
for i in range(N+1):
# print("i", i)
s_a += A[i]
if s_a > K:
break
for j in reversed(range(best+1)):
#print("j",j)
if s_b <= K - s_a:
if i + j > res:
res = i + j
best = j
#print(i, j, s_a, s_b)
break
else:
s_b -= B[j]
print(res)
| 1 | 10,687,548,010,142 | null | 117 | 117 |
import itertools
H, W, K = list(map(int,input().split()))
board = []
for i in range(H):
row = input()
board.append(row)
result = []
for n in range(len(board)+1):
for conb in itertools.combinations(board, n):
result.append(list(conb))
rotate_result = []
for i in range(len(result)):
rotate_result.append([list(x) for x in zip(*result[i])])
ans = 0
result2 = []
for i in range(len(rotate_result)):
for j in range(len(rotate_result[i])+1):
for conb in itertools.combinations(rotate_result[i], j):
result2.append(list(conb))
l = list(itertools.chain.from_iterable(list(conb)))
if l != []:
count = 0
for k in range(len(l)):
if l[k] == "#":
count += 1
if k == len(l)-1 and count == K:
ans += 1
print(ans)
|
n = int(input())
a = list(map(int, input().split()))
left = a[0]
right = a[-1]
center = 0
sum_a = sum(a)
flg = False
for i in range(1, n-1):
if left + a[i] > sum_a/2 and flg is False:
flg = True
center = a[i]
right -= a[i]
elif left + a[i] == sum_a / 2:
print(0)
exit()
if flg is False:
left += a[i]
else:
right += a[i]
print(abs(min(left+center-right, right+center-left)))
| 0 | null | 75,169,566,358,542 | 110 | 276 |
from functools import lru_cache
@lru_cache(maxsize=1024)
def fib(n):
if n in [0, 1]:
return 1
return fib(n - 1) + fib(n - 2)
if __name__ == '__main__':
print(fib(int(input())))
|
def fibonacci(n, memo=None):
if memo==None:
memo = [None]*n
if n<=1:
return 1
else:
if memo[n-2]==None:
memo[n-2] = fibonacci(n-2, memo)
if memo[n-1]==None:
memo[n-1] = fibonacci(n-1, memo)
return memo[n-1] + memo[n-2]
n = int(input())
print(fibonacci(n))
| 1 | 1,967,184,648 | null | 7 | 7 |
N = int(input())
primes = {}
for num in range(2, int(N**0.5)+1):
while N%num == 0:
if num in primes:
primes[num] += 1
else:
primes[num] = 1
N //= num
ans = 0
for p in primes.values():
n = 1
while n*(n+1)//2 <= p:
n += 1
ans += n-1
if N > 1:
ans += 1
print(ans)
|
a,b = list(map(int, input().split()))
d = int(a / b)
r = int(a % b)
f = a / b
print(str(d) + " " + str(r) + " " + str("{0:.10f}".format(f)))
| 0 | null | 8,733,800,201,548 | 136 | 45 |
import sys
def allocate(count, weights):
"""allocate all packages of weights onto trucks.
returns maximum load of trucks.
>>> allocate(2, [1, 2, 2, 6])
6
>>> allocate(3, [8, 1, 7, 3, 9])
10
"""
def loadable_counts(maxweight):
n = 0
l = 0
c = count
for w in weights:
l += w
if l > maxweight:
l = w
c -= 1
if c <= 0:
return n
n += 1
return n
i = max(weights)
j = max(weights) * len(weights) // count
while i < j:
mid = (i + j) // 2
if loadable_counts(mid) < len(weights):
i = mid + 1
else:
j = mid
return i
def run():
k, n = [int(i) for i in input().split()]
ws = []
for i in sys.stdin:
ws.append(int(i))
print(allocate(n, ws))
if __name__ == '__main__':
run()
|
n,t=[int(x) for x in input().split()]
w=[]
for i in range(n):
w.append(int(input()))
totalw=sum(w)
pmax=totalw
pmin=int(totalw/t)-1
def check(ptest):
tk=1
p=0
global t
global w
global n
i=0
while i<n:
p+=w[i]
if p<=ptest:
i+=1
else:
tk+=1
p=0
if tk>t:
return 0
#break
return 1
while (pmax-pmin)>1:
pmid=(pmax+pmin)//2
if check(pmid)==1:
pmax=pmid
else:
pmin=pmid
print(pmax)
| 1 | 88,858,625,938 | null | 24 | 24 |
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))
|
import heapq
(N,K) = map(int,input().split())
h = [int(x)*-1 for x in input().split()]
ans = 0
heapq.heapify(h)
if K <= N:
for i in range(K):
heapq.heappop(h)
while h != []:
ans -= heapq.heappop(h)
print(ans)
| 0 | null | 40,195,998,666,460 | 58 | 227 |
d,t,s = map(int,input().split())
T = d/s
if(t>=T):
print("Yes")
else:
print("No")
|
D,T,S = map(int,input().split())
x = S*T
if x >= D :
print("Yes")
else:
print("No")
| 1 | 3,564,831,959,058 | null | 81 | 81 |
A=[]
for _ in range(3):
A.append(list(map(int,input().split())))
n=int(input())
B=[]
for _ in range(n):
B.append(int(input()))
def get_unique_list(seq):
seen = []
return [x for x in seq if x not in seen and not seen.append(x)]
B=get_unique_list(B)
s=0
if A[0][0] in B and A[1][1] in B and A[2][2] in B:
s+=1
elif A[0][2] in B and A[1][1] in B and A[2][0] in B:
s+=1
else:
for i in range(3):
if A[0][i] in B and A[1][i] in B and A[2][i] in B:
s+=1
elif A[i][0] in B and A[i][1] in B and A[i][2] in B:
s+=1
if s>=1:
print("Yes")
else:
print("No")
|
n = int(input())
cnt = 0
judge = False
for i in range(n):
a,b = map(int,input().split())
if a == b:
cnt += 1
else:
cnt = 0
if cnt == 3:
judge = True
if judge:
print("Yes")
else:
print("No")
| 0 | null | 31,070,475,307,608 | 207 | 72 |
#93 B - Iron Bar Cutting WA (hint)
N = int(input())
A = list(map(int,input().split()))
# 差が最小の切れ目を見つける
length = sum(A)
left = 0
dist = 0
mdist = length
midx = 0
for i,a in enumerate(A):
left += a
right = length - left
dist = abs(left - right)
if dist < mdist:
mdist = dist
midx = i
ans = mdist
print(ans)
|
def main():
N, K = map(int, input().split())
LR = [list(map(int, input().split())) for _ in range(K)]
MOD = 998244353
dp = [0]*(N+1)
S = [0]*(N+1)
dp[1] = 1
S[1] = 1
for i in range(2, N+1):
for l, r in LR:
if i-l < 0:
continue
else:
dp[i] += S[i-l] - S[max(i-r-1, 0)]
dp[i] %= MOD
S[i] = S[i-1] + dp[i]
print(dp[-1]%MOD)
if __name__ == '__main__':
main()
| 0 | null | 72,431,812,549,852 | 276 | 74 |
# Aizu Problem ITP_1_11_A: Dice I
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def do_roll(dice, roll):
d1, d2, d3, d4, d5, d6 = dice
if roll == 'E':
return [d4, d2, d1, d6, d5, d3]
elif roll == 'W':
return [d3, d2, d6, d1, d5, d4]
elif roll == 'N':
return [d2, d6, d3, d4, d1, d5]
elif roll == 'S':
return [d5, d1, d3, d4, d6, d2]
else:
assert False, "We should never reach this point!"
dice = [int(_) for _ in input().split()]
for roll in input().strip():
dice = do_roll(dice, roll)
print(dice[0])
|
class Dice:
def __init__(self, labels):
self.up = labels[0]
self.front = labels[1]
self.right = labels[2]
self.left = labels[3]
self.back = labels[4]
self.down = labels[5]
def east(self):
self.up, self.right, self.down, self.left = self.left, self.up, self.right, self.down
def north(self):
self.up, self.back, self.down, self.front = self.front, self.up, self.back, self.down
def south(self):
self.up, self.front, self.down, self.back = self.back, self.up, self.front, self.down
def west(self):
self.up, self.left, self.down, self.right = self.right, self.up, self.left, self.down
dice = Dice(list(map(int, input().split())))
for cmd in list(input()):
if cmd == 'E':
dice.east()
if cmd == 'N':
dice.north()
if cmd == 'S':
dice.south()
if cmd == 'W':
dice.west()
print(dice.up)
| 1 | 235,531,052,354 | null | 33 | 33 |
n, k = map(int, input().split())
p = list(map(int, input().split()))
c = list(map(int, input().split()))
ans = -float('inf')
for i in range(n):
s = []
j = p[i]-1
s.append(c[j])
while j != i:
j = p[j]-1
s.append(s[-1]+c[j])
l = len(s)
if k <= l:
a = max(s[:k])
elif s[-1] <= 0:
a = max(s)
else:
w, r = divmod(k, l)
a1 = s[-1]*(w-1) + max(s)
a2 = s[-1]*w
if r != 0:
a2 += max(0, max(s[:r]))
a = max(a1, a2)
ans = max(ans, a)
print(ans)
|
N = list(map(int, input().split()))
fruits = list(map(int, input().split()))
sum = 0
fruits.sort()
for i in range(N[1]):
sum += fruits[i]
print(sum)
| 0 | null | 8,440,864,111,232 | 93 | 120 |
n = input()
s = 0
for i in range(len(n)):
s += int(n[i])
if s % 3 == 0:
print('Yes')
else:
print('No')
|
n = str(input())
s = 0
for x in n:
s += int(x)
if s % 9 == 0:
print('Yes')
else :
print('No')
| 1 | 4,424,507,870,560 | null | 87 | 87 |
import math
from functools import reduce
def getD(num):
input_list = [2 if i % 2 == 0 else i for i in range(num+1)]
input_list[0] = 0
bool_list = [False if i % 2 == 0 else True for i in range(num+1)]
sqrt = int(math.sqrt(num))
for serial in range(3, sqrt + 1, 2):
if bool_list[serial]:
for s in range(serial ** 2, num+1, serial):
if bool_list[s]:
input_list[s] = serial
bool_list[s] = False
return input_list
N = int(input())
A = list(map(int, input().split()))
D = getD(max(A))
flag = True
d_set = set()
for a in A:
while a != 1:
d = D[a]
if d in d_set:
flag = False
break
else:
d_set.add(d)
while a > 1 and a % d == 0:
a = a // d
if not(flag):
break
if flag:
print('pairwise coprime')
exit()
if reduce(math.gcd, A) == 1:
print('setwise coprime')
else:
print('not coprime')
|
from math import gcd
from functools import reduce
def facs(n):
yield 2
for x in range(3, n, 2):
yield x
def main():
input() # N
array = [int(x) for x in input().split()]
MAX_A = 10 ** 6 + 1
histogram = [0] * MAX_A
for x in array:
histogram[int(x)] += 1
for divider in facs(MAX_A):
count = sum(histogram[divider::divider])
if count > 1:
break
else:
return 'pairwise coprime'
gcd_total = reduce(gcd, array)
if gcd_total == 1:
return 'setwise coprime'
else:
return 'not coprime'
if __name__ == '__main__':
print(main())
| 1 | 4,132,765,168,412 | null | 85 | 85 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.