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
|
|---|---|---|---|---|---|---|
def main():
N = int(input())
S = input()
dict = {'R':0, 'B':0, 'G':0}
for i in range(N):
dict[S[i]] += 1
ans = dict['R']*dict['B']*dict['G']
for i in range(N-2):
if (N-i)%2 == 0:
tmp = int((N-i)/2)-1
else:
tmp = (N-i)//2
for j in range(1,tmp+1):
if S[i]!=S[i+j] and S[i]!=S[i+2*j] and S[i+j]!=S[i+2*j]:
ans = ans - 1
return ans
print(main())
|
A = []
b = []
n,m = [int(i) for i in input().split()]
for i in range(n):
A.append([int(j) for j in input().split()])
for i in range(m):
b.append(int(input()))
for i in range(n):
print(sum([x*y for x,y in zip(A[i],b)]))
| 0 | null | 18,775,048,644,492 | 175 | 56 |
def F(x, y):
if x % y == 0:
return y
return F(y, x % y)
while True:
try:
x, y = map(int,input().split())
print('{0} {1}'.format(F(x, y), int(x * y / F(x, y))))
except EOFError:
break
|
r=input().split()
N=int(r[0])
A=int(r[1])
B=int(r[2])
x=N//(A+B)
y=N%(A+B)
if y<=A:
print(A*x+y)
else:
print(A*(x+1))
| 0 | null | 27,854,354,774,372 | 5 | 202 |
def comp(a,b):
if a[1] > b[1]:
return True
else:
return False
def bubble_sort(a):
for i in range(n):
for j in reversed(range(i+1,n)):
if comp(a[j-1],a[j]):
a[j],a[j-1]=a[j-1],a[j]
return a
def selection_sort(a):
for i in range(n):
mini = i
for j in range(i,n):
if comp(a[mini],a[j]):
mini=j
a[mini],a[i]=a[i],a[mini]
return a
def stable(original_a,sorted_a):
for num in range(1,10):
suite_ord = []
for v in original_a:
if v[1] == str(num):
suite_ord.append(v[0])
for v in sorted_a:
if v[1] == str(num):
if v[0]==suite_ord[0]:
del suite_ord[0]
else:
return "Not stable"
return "Stable"
n = int(raw_input())
cards = raw_input().split(' ')
sorted_cards = bubble_sort(cards[:])
print ' '.join(sorted_cards)
print stable(cards,sorted_cards)
sorted_cards = selection_sort(cards[:])
print ' '.join(sorted_cards)
print stable(cards,sorted_cards)
|
import sys
import math
input = sys.stdin.readline
A, B = map(int, input().split())
X = A / 0.08
Y = B/0.1
for i in range(math.floor(min(X, Y)), math.ceil(max(X, Y)) + 1):
if int(i * 0.08) == A and int(i * 0.10) == B:
print(i)
exit()
print(-1)
| 0 | null | 28,041,221,794,014 | 16 | 203 |
n=int(input())
itv=[]
for i in range(n):
x,l=map(int,input().split())
itv+=[(x+l,x-l)]
itv=sorted(itv)
l=-10**18
cnt=0
for t,s in itv:
if l<=s:
l=t
cnt+=1
print(cnt)
|
import math
from itertools import combinations
from itertools import combinations_with_replacement
from itertools import product
from collections import defaultdict
from collections import deque
from collections import Counter
import heapq
def input_li():
return list(map(int, input().split()))
N = int(input())
A_LI = input_li()
max_h = A_LI[0]
ans = 0
for i in range(1, N):
if A_LI[i] < max_h:
ans += max_h - A_LI[i]
else:
max_h = max(max_h, A_LI[i])
print(ans)
| 0 | null | 47,429,635,948,992 | 237 | 88 |
import sys
def input(): return sys.stdin.readline().rstrip()
from bisect import bisect_left,bisect
def main():
n=int(input())
S=list(input())
q=int(input())
set_s={chr(ord('a')+i):[] for i in range(26)}
for i,s in enumerate(S):
set_s[s].append(i)
for _ in range(q):
query=input().split()
if query[0]=="1":
i,c=int(query[1])-1,query[2]
if S[i]==c:continue
set_s[S[i]].remove(i)
set_s[c].insert(bisect_left(set_s[c],i),i)
S[i]=c
else:
l,r=int(query[1])-1,int(query[2])-1
ans=0
for i in range(26):
ss=chr(ord('a')+i)
if bisect(set_s[ss],r)>bisect_left(set_s[ss],l):
ans+=1
print(ans)
if __name__=='__main__':
main()
|
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
def main():
K = int(input())
S = input()
M = len(S)
N = M + K
MAXN = N + 2
fact = [1]
for i in range(1,MAXN + 1):
fact.append(fact[-1]*i%MOD)
inv_fact = [-1] * (MAXN + 1)
inv_fact[-1] = pow(fact[-1],MOD - 2,MOD)
for i in range(MAXN - 1,-1,-1):
inv_fact[i] = inv_fact[i + 1]*(i + 1)%MOD
nck = lambda N,K: 0 if K > N or K < 0 else fact[N]*inv_fact[N - K]*inv_fact[K]%MOD
power25 = [1]
power26 = [1]
for i in range(N):
power25.append(power25[-1]*25%MOD)
power26.append(power26[-1]*26%MOD)
ans = 0
for i in range(M,N + 1):
ans += nck(i - 1,M - 1) * power25[i - M] * power26[N - i] % MOD
ans %= MOD
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 37,805,823,721,578 | 210 | 124 |
n = int(input())
st = input()
if st[:n//2] == st[n//2:]: print("Yes")
else: print("No")
|
n=int(input())
s=str(input())
d=True
if len(s)%2==0:
for i in range(len(s)//2):
if s[i]!=s[len(s)//2+i]:
d=False
else:
d=False
if d:
print('Yes')
else:
print('No')
| 1 | 147,241,321,681,290 | null | 279 | 279 |
ini = lambda : int(input())
inm = lambda : map(int,input().split())
inl = lambda : list(map(int,input().split()))
gcd = lambda x,y : gcd(y,x%y) if x%y else y
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
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
#maincode-------------------------------------------------
n = ini()
s = input()
r = s.count('R')
g = s.count('G')
b = s.count('B')
ans = r*g*b
for j in range(n):
for i in range(j):
k = 2*j-i
if k < n:
if (s[i] == s[j]):
continue
if (s[i] == s[k]):
continue
if (s[j] == s[k]):
continue
ans -= 1
print(ans)
|
N = int(input())
S = input()
r = [0 for _ in range(N + 1)]
g = [0 for _ in range(N + 1)]
b = [0 for _ in range(N + 1)]
for i in reversed(range(N)):
r[i] = r[i + 1]
g[i] = g[i + 1]
b[i] = b[i + 1]
if S[i] == "R":
r[i] += 1
if S[i] == "G":
g[i] += 1
if S[i] == "B":
b[i] += 1
ans = 0
for i in range(N):
if S[i] == "R":
for j in range(i + 1, N):
if S[j] == "G":
if 2 * j - i < N:
if S[2 * j - i] == "B":
ans += (b[j + 1] - 1)
else:
ans += b[j + 1]
else:
ans += b[j + 1]
for i in range(N):
if S[i] == "R":
for j in range(i + 1, N):
if S[j] == "B":
if 2 * j - i < N:
if S[2 * j - i] == "G":
ans += (g[j + 1] - 1)
else:
ans += g[j + 1]
else:
ans += g[j + 1]
for i in range(N):
if S[i] == "B":
for j in range(i + 1, N):
if S[j] == "R":
if 2 * j - i < N:
if S[2 * j - i] == "G":
ans += (g[j + 1] - 1)
else:
ans += g[j + 1]
else:
ans += g[j + 1]
for i in range(N):
if S[i] == "B":
for j in range(i + 1, N):
if S[j] == "G":
if 2 * j - i < N:
if S[2 * j - i] == "R":
ans += (r[j + 1] - 1)
else:
ans += r[j + 1]
else:
ans += r[j + 1]
for i in range(N):
if S[i] == "G":
for j in range(i + 1, N):
if S[j] == "R":
if 2 * j - i < N:
if S[2 * j - i] == "B":
ans += (b[j + 1] - 1)
else:
ans += b[j + 1]
else:
ans += b[j + 1]
for i in range(N):
if S[i] == "G":
for j in range(i + 1, N):
if S[j] == "B":
if 2 * j - i < N:
if S[2 * j - i] == "R":
ans += (r[j + 1] - 1)
else:
ans += r[j + 1]
else:
ans += r[j + 1]
print(ans)
| 1 | 36,046,121,934,900 | null | 175 | 175 |
s = input()
t = input()
if (len(t)-len(s)==1) and (t[:-1]==s):
print("Yes")
else:
print("No")
|
A=[]
for _ in range(3):
A+=map(int,input().split())
N=int(input())
for _ in range(N):
b=int(input())
if b in A:
A[A.index(b)]=0
for i,j,k in [
(0,1,2),(3,4,5),(6,7,8),
(0,3,6),(1,4,7),(2,5,8),
(0,4,8),(2,4,6),
]:
if A[i]==A[j]==A[k]:
print('Yes')
break
else:
print('No')
| 0 | null | 40,655,727,490,862 | 147 | 207 |
a = list(input().split())
print("Yes" if len(set(a)) == 2 else "No")
|
from collections import deque
n, k = map(int, input().split())
a = list(map(int, input().split()))
#kを法とする配列を作る
a = [(i - 1) for i in a]
acc_a = [0 for i in range(n+1)]
acc_a[0] = 0
acc_a[1] = a[0] % k
#kを法とする累積和
for i in range(2,len(a) + 1):
acc_a[i] = (a[i - 1] + acc_a[i-1]) % k
ans = 0
count = {}
q = deque()
for i in acc_a:
if i not in count:
count[i] = 0
ans += count[i]
count[i] += 1
q.append(i)
if len(q) == k:
count[q.popleft()] -= 1
print(ans)
| 0 | null | 103,053,032,460,842 | 216 | 273 |
import math
A, B, H, M = map(int, input().split())
a = math.pi/360 * (H*60 + M)
b = math.pi/30 * M
# if abs(a - b) > math.pi:
# theta = 2 * math.pi - abs(a-b)
# else:
theta = abs(a-b)
L = math.sqrt(A**2 + B**2 - 2*A*B*math.cos(theta))
print(L)
|
"""
○ 角速度 = θ / t [rad/s]
・時針
ω = θ / t
= math.radians(360) / (12 * 60 * 60) [rad/s]
・分針
ω = θ / t
= math.radians(360) / (60 * 60) [rad/s]
"""
import math
def colon():
# 入力
A, B, H, M = map(int, input().split())
# 時針と分針の角速度
angular_velocity_h = math.radians(360) / (12 * 60 * 60)
angular_velocity_m = math.radians(360) / (60 * 60)
# 0時を基準に時針が何度傾いたか
radian_h = angular_velocity_h * ((H * 60 * 60) + (M * 60))
# 0時を基準に分針が何度傾いたか
radian_m = angular_velocity_m * (M * 60)
# 時針と分針の間の角度
radian_hm = abs(radian_h - radian_m)
if radian_hm > math.pi:
radian_hm = 2 * math.pi - radian_hm
elif radian_hm == math.pi:
return A + B
elif math.pi > radian_hm:
pass
# 端点の距離
distance = math.sqrt((A**2 + B**2) - (2 * A * B * math.cos(radian_hm)))
# 戻り値
return distance
result = colon()
print(result)
| 1 | 20,043,910,631,360 | null | 144 | 144 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
A, B = mapint()
from math import gcd
print(A*B//gcd(A, B))
|
import sys
input = sys.stdin.readline
from math import sqrt
def main():
N = int(input())
A = [0]*(N+1)
n = int(sqrt(N)) + 1
for x in range(1, n):
for y in range(1, n):
for z in range(1, n):
tmp = x*x + y*y + z*z + x*y + y*z + z*x
if tmp <= N:
A[tmp] += 1
for i in range(1,N+1):
print(A[i])
if __name__ == '__main__':
main()
| 0 | null | 60,794,938,357,670 | 256 | 106 |
from decimal import *
x,y,z = map(int,input().split())
a=Decimal(x)
b=Decimal(y)
c=Decimal(z)
if Decimal((c-a-b)**Decimal(2)) > Decimal(Decimal(4)*a*b) and c-a-b > 0:
print('Yes')
else:
print('No')
|
# C - Sqrt Inequality
import decimal
a,b,c = input().split()
a,b,c = map(decimal.Decimal,[a,b,c])
sqrt = decimal.Decimal(0.5)
if a**sqrt + b**sqrt < c**sqrt:
print('Yes')
else:
print('No')
| 1 | 51,431,243,492,902 | null | 197 | 197 |
n, m = map(int, input().split())
h = [int(x) for x in input().split()]
cnt = [1] * n
for _ in range(m):
a, b = map(int, input().split())
if h[a-1] > h[b-1]:
cnt[b-1] = 0
elif h[a-1] < h[b-1]:
cnt[a-1] = 0
else:
cnt[a-1] = 0
cnt[b-1] = 0
print(cnt.count(1))
|
from sys import stdin,stdout
from collections import defaultdict
n,e=list(map(int,stdin.readline().split()))
h=list(map(int,stdin.readline().split()))
g=defaultdict(list)
for _ in range(e):
a,b=map(int,stdin.readline().split())
g[a]+=[b]
g[b]+=[a]
ans=0
for cur in range(1,n+1):
f=1
for neigh in g[cur]:
if h[neigh-1]>=h[cur-1]:
f=0
break
if f:ans+=1
print(ans)
| 1 | 25,165,403,187,972 | null | 155 | 155 |
import sys
def input():
return sys.stdin.readline().rstrip()
def main():
R, C, K = map(int, input().split())
field = [[0 for j in range(C)] for i in range(R)]
for _ in range(K):
r, c, v = map(int, input().split())
field[r - 1][c - 1] = v
dp = [[[0] * C for j in range(R)] for i in range(4)]
for i in range(R):
for j in range(C):
ct = field[i ][j ]
pm = max(dp[0][i-1][j],dp[1][i-1][j],dp[2][i-1][j],dp[3][i-1][j])
if ct == 0:
dp[0][i][j] = max(dp[0][i][j-1],pm)
for k in range(1, 4):
if j>0:
dp[k][i][j] = dp[k][i][j - 1]
else:
dp[0][i][j] = max(dp[0][i][j - 1],pm)
dp[1][i][j] = max(ct + max(dp[0][i][j - 1], pm),dp[1][i][j-1])
for k in range(2, 4):
if j >0:
dp[k][i][j] = max(dp[k - 1][i][j - 1] +ct,dp[k][i][j-1])
print(max(dp[0][R-1][C-1],dp[1][R-1][C-1],dp[2][R-1][C-1],dp[3][R-1][C-1]))
if __name__ == "__main__":
main()
|
def main():
N = int(input())
digits = []
while N != 0:
digits.append(N % 26)
if digits[-1] == 0:
digits[-1] = 26
N //= 26
N -= 1
else:
N //= 26
digits.reverse()
for d in digits:
print(chr(96 + d), end='')
print() # 改行
if __name__ == '__main__':
main()
| 0 | null | 8,636,273,601,212 | 94 | 121 |
import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
from numba import njit,i8
@njit(i8(i8,i8,i8,i8[:,:],i8[:],i8,i8))
def give_dp(N,K,mod,LR,dp,l,r):
for i in range(N):
if i > 0:
dp[i] += dp[i-1]
dp[i] %= mod
for k in range(K):
l = LR[k][0]
r = LR[k][1]
if i + l < N:
dp[i+l] += dp[i]
dp[i+1] %= mod
if i + r < N:
dp[i+r+1] -= dp[i]
dp[i+1] %= mod
return dp[-1]
def main():
N,K = map(int,input().split())
LR = [list(map(int,input().split())) for i in range(K)]
LR = np.array(LR)
mod = 998244353
dp = [0 for i in range(N)]
dp[0] = 1
dp[1] = -1
dp = np.array(dp)
res = give_dp(N,K,mod,LR,dp,0,0)
res %= mod
print(res)
main()
|
MOD = 998244353
N, K = map(int, input().split())
rl = [list(map(int, input().split())) for _ in range(K)]
dp = [0] * (N + 1)
sdp = [0] * (N + 1)
dp[1] = 1
sdp[1] = 1
for i in range(2, N + 1):
for j in range(K):
l, r = rl[j][0], rl[j][1]
tl = max(1, i - r)
tr = max(0, i - l)
dp[i] += sdp[tr] - sdp[tl - 1]
dp[i] %= MOD
sdp[i] += dp[i] + sdp[i - 1]
sdp[i] %= MOD
print(dp[N])
| 1 | 2,683,479,291,192 | null | 74 | 74 |
while True:
s = input().split(" ")
H = int(s[0])
W = int(s[1])
if H == 0 and W == 0:
break
for i in range(H):
for j in range(W):
if i == 0 or i == H-1:
print("#",end="")
else:
if j == 0 or j == W-1:
print("#",end="")
else:
print(".",end="")
print("")
print("")
|
# -*- 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()
| 1 | 830,839,875,452 | null | 50 | 50 |
x = int(input())
if x == 0:
x = 1
else:
x = 0
print(x)
|
N = input()
ans = 'No'
for i in range(3):
if int(N[i]) == 7:
ans = 'Yes'
print(ans)
| 0 | null | 18,716,657,510,582 | 76 | 172 |
import math
N,D = map(int, input().split())
count = 0
for i in range(0, N):
x = list(map(int, input().split()))
if D >= math.sqrt(x[0]**2 + x[1]**2):
count = count + 1
print(count)
|
input_line = input().split()
n = int(input_line[0])
d = int(input_line[1])
count = 0
for i in range(n):
c = input().split()
x = int(c[0])
y = int(c[1])
if x**2 + y**2 <= d**2:
count += 1
print(count)
| 1 | 5,956,585,449,400 | null | 96 | 96 |
# Sum of Numbers
end = 0
while end == 0:
number = list(input())
if number == ["0"]:
end += 1
else:
# print(number)
digitTotal = 0
for digit in number:
digitTotal += int(digit)
print(digitTotal)
|
while(1):
num = list(map(int,input()))
if num[0] == 0:
break
print(sum(num[:]))
| 1 | 1,574,297,354,042 | null | 62 | 62 |
n, d = map(int, input().split())
A = []
for i in range(n):
A_i = list(map(int, input().split()))
A.append(A_i)
ans = 0
for j in A:
if (j[0] ** 2 + j[1] ** 2) <= d **2 :
ans += 1
print(ans)
|
import sys
input = lambda: sys.stdin.readline()[:-1]
n,k=map(int,input().split())
w = [int(input()) for i in range(n)][::-1]
def maxnumber(p):
wc=w.copy()
for i in range(k):
lim=p
while len(wc):
if wc[-1]<=lim:
lim-=wc.pop()
else:break
return len(wc)
minp=float('inf')
left,right=1,10**9+1
while left<right:
mid=(left+right)//2
maxn=maxnumber(mid)
if maxn>0:
left=mid+1
else:
right=mid
minp=min(mid,minp)
print(minp)
| 0 | null | 2,976,790,985,988 | 96 | 24 |
import sys
sys.setrecursionlimit(300000)
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI0(): return map(lambda s: int(s) - 1, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
def LMI0(): return list(map(lambda s: int(s) - 1, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')
X, K, D = MI()
if abs(X) >= K * D:
print(abs(X) - K * D)
else:
a = abs(abs(X) - (abs(X) // D) * D)
K -= (abs(X) // D)
if K % 2 == 0:
print(a)
else:
print(abs(a - D))
|
n,m = map(int, input().split())
height = list(map(int, input().split()))
c = 0
net = [[] for i in range(n)]
for j in range(m):
a,b = map(int, input().split())
net[a-1].append(height[b-1])
net[b-1].append(height[a-1])
for i in range(n):
net[i].append(0)
if max(net[i]) < height[i]:
c += 1
print(c)
| 0 | null | 15,259,855,488,682 | 92 | 155 |
a = input()
print(a.swapcase())
|
#C
A,B=map(int,input().split())
GCD=1
for i in range(2,10**5+1):
if A%i==0 and B%i==0:
GCD=i
LCM=A*B/GCD
print(int(LCM))
| 0 | null | 57,534,630,103,350 | 61 | 256 |
import sys
input = sys.stdin.readline
class Dice:
"""
0:top, 1:south, 2:east, 3:west, 4:north, 5:bottom
"""
def __init__(self, surfaces):
self.init_surface = surfaces
self.surface = surfaces
def roll(self, direction: str):
if direction == "E":
self.surface = [self.surface[3], self.surface[1], self.surface[0],
self.surface[5], self.surface[4], self.surface[2]]
elif direction == "N":
self.surface = [self.surface[1], self.surface[5], self.surface[2],
self.surface[3], self.surface[0], self.surface[4]]
elif direction == "S":
self.surface = [self.surface[4], self.surface[0], self.surface[2],
self.surface[3], self.surface[5], self.surface[1]]
elif direction == "W":
self.surface = [self.surface[2], self.surface[1], self.surface[5],
self.surface[0], self.surface[4], self.surface[3]]
return
def spin(self):
self.surface = [self.surface[0], self.surface[3], self.surface[1],
self.surface[4], self.surface[2], self.surface[5]]
return
def get_surface(self, num):
return self.surface.index(num)
def get_top(self):
return self.surface[0]
def get_south(self):
return self.surface[1]
def get_east(self):
return self.surface[2]
def main():
surface = [int(i) for i in input().strip().split()]
cases = int(input().strip())
dice = Dice(surface)
for _ in range(cases):
top, south = [int(i) for i in input().strip().split()]
# get current surface
cur = dice.get_surface(top)
if cur == 0:
pass
elif cur == 1:
dice.roll("N")
elif cur == 2:
dice.roll("W")
elif cur == 3:
dice.roll("E")
elif cur == 4:
dice.roll("S")
elif cur == 5:
dice.roll("S")
dice.roll("S")
for _ in range(4):
dice.spin()
if dice.get_south() == south:
print(dice.get_east())
if __name__ == "__main__":
main()
|
n = int(input())
squares = list(map(int, input().split(" ")))
odd = 0
for i in range(0, n, 2):
if squares[i] % 2:
odd += 1
print(odd)
| 0 | null | 4,053,110,001,120 | 34 | 105 |
from collections import defaultdict, Counter
MOD = 10**9+7
n, K = map(int, input().split())
cnt = Counter(map(int, input().split()))
keys = sorted(cnt.keys())
key_to_idx = defaultdict(int)
for i, k in enumerate(keys):
key_to_idx[k] = i
Acum = [0]
for k in keys:
Acum.append(Acum[-1]+cnt[k])
U = n
fact = [0]*(U+1)
fact[0] = 1
for i in range(1, U+1):
fact[i] = fact[i-1]*i % MOD
invfact = [0]*(U+1)
invfact[U] = pow(fact[U], MOD-2, MOD)
for i in reversed(range(U)):
invfact[i] = invfact[i+1]*(i+1) % MOD
def nCr(n, r):
if r < 0 or n < r:
return 0
return fact[n]*invfact[r]*invfact[n-r]
ans = 0
for k in keys:
x = Acum[key_to_idx[k]+1]
y = Acum[key_to_idx[k]]
cmax = nCr(x, K) - nCr(y, K)
cmin = nCr(n-y, K) - nCr(n-x, K)
ans += k*(cmax-cmin)
ans %= MOD
print(ans)
|
N,K=map(int,input().split())
A=list(map(int,input().split()))
Nlist=[0]*(10**5+1)
P=10**9+7
Nlist[1]=1
for i in range(1, 10**5):
Nlist[i+1]=(Nlist[i]*(i+1))%P
Ninv=[1]*(10**5+1)
Ninv[-1]=pow(Nlist[-1], P-2,P)
for i in range(0,10**5):
Ninv[-1-i-1]=(Ninv[-1-i]*(10**5-i))%P
for i in range(N):
A[i]=[A[i], i]
A.sort()
ans=0
for i in range(K-1,N):
if A[i][0]>=0:
ans+=(A[i][0]*Nlist[i]*Ninv[K-1]*Ninv[i-K+1])%P
else:
ans+=(A[i][0]*Nlist[i]*Ninv[K-1]*Ninv[i-K+1])%P-P
for i in range(0,N-K+1):
if A[i][0]>=0:
ans-=(A[i][0]*Nlist[N-i-1]*Ninv[K-1]*Ninv[N-i-K])%P
else:
ans-=(A[i][0]*Nlist[N-i-1]*Ninv[K-1]*Ninv[N-i-K])%P-P
print(ans%P)
| 1 | 95,522,352,128,448 | null | 242 | 242 |
n, k, s = map(int, input().split())
for i in range(n):
if k == 0:
if s-1 > 0:
print(s-1, end=' ')
else:
print(s+1, end=' ')
else:
print(s, end=' ')
k -= 1
print()
|
n, k, s = map(int, input().split())
if s == 10 ** 9:
l = [s] * k + [1] * (n - k)
else:
l = [s] * k + [s + 1] * (n - k)
print(*l)
| 1 | 91,044,489,134,148 | null | 238 | 238 |
a, b = map(int, input().split())
c = []
if a > b:
a, b = b, a
if b%a == 0:
print(a)
else:
while True:
for i in range(a):
x = i + 2
#print(a, x)
if a%x == 0:
if b%x == 0:
c.append(x)
a = a//x
b = b//x
#print(c)
break
elif b%(a//x) == 0:
c.append(a//x)
a = x
b = b//(a//x)
#print(c)
break
#if x%1000 == 0:
#print(x)
if x > a**0.5:
break
if x > a**0.5:
break
s = 1
for j in c:
s = s * j
print(s)
|
def gcd(a,b):
r = a % b
while r != 0:
a, b = b, r
r = a % b
return b
a,b = list(map(int,input().split()))
print (gcd(a,b))
| 1 | 7,625,112,308 | null | 11 | 11 |
from collections import deque
H,W = map(int,input().split())
A = [input().strip() for _ in range(H)]
d = 0
if A[0][0]=="#":
d += 1
que = deque([(0,0,d)])
hist = [[H*W for _ in range(W)] for _ in range(H)]
hist[0][0] = d
while que:
i,j,d = que.popleft()
if j+1<W and A[i][j+1]==A[i][j]:
if hist[i][j+1]>d:
hist[i][j+1] = d
que.append((i,j+1,d))
elif j+1<W and A[i][j+1]!=A[i][j]:
if hist[i][j+1]>d+1:
hist[i][j+1] = d+1
que.append((i,j+1,d+1))
if i+1<H and A[i+1][j]==A[i][j]:
if hist[i+1][j]>d:
hist[i+1][j] = d
que.append((i+1,j,d))
elif i+1<H and A[i+1][j]!=A[i][j]:
if hist[i+1][j]>d+1:
hist[i+1][j] = d+1
que.append((i+1,j,d+1))
m = hist[H-1][W-1]
print((m+1)//2)
|
import sys
readline = sys.stdin.readline
inf = float('inf')
def main():
H, W = map(int, readline().split())
grid = []
grid.append(['*'] * (W+2))
for _ in range(H):
grid.append(['*'] + list(readline()[:-1]) + ['*'])
grid.append(['*']*(W+2))
DP = [[inf] * (W+2) for _ in range(H+2)]
DP[1][1] = (grid[1][1] == '#')*1
for i in range(1, H+1):
for j in range(1, W+1):
if i == 1 and j == 1:
continue
k = i
gridkj = grid[k][j]
if gridkj == '.':
DP[k][j] = min(DP[k][j-1], DP[k-1][j])
if gridkj == '#':
DP[k][j] = min(DP[k][j-1]+(grid[k][j-1] in ['.', '*']), DP[k-1][j] + (grid[k-1][j] in ['.', '*']))
ans = DP[H][W]
print(ans)
if __name__ == "__main__":
main()
| 1 | 49,335,658,740,160 | null | 194 | 194 |
# coding: utf-8
num_array = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
k = int(input())
print("{}".format(num_array[k-1]))
|
def main():
params = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
return params[int(input())-1]
print(main())
| 1 | 50,351,313,312,378 | null | 195 | 195 |
import sys
import re
import math
import collections
import decimal
import bisect
# import copy
# import heapq
# from collections import deque
# import decimal
# sys.setrecursionlimit(100001)
INF = sys.maxsize
# MOD = 10 ** 9 + 7
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
a, b, c = ns()
tmp = decimal.Decimal(a).sqrt() + decimal.Decimal(b).sqrt() - decimal.Decimal(c).sqrt()
print("Yes" if tmp < 0 else "No")
if __name__ == '__main__':
main()
|
import math
a, b = map(int, input().split())
ans = -1
for i in range(1010):
if math.floor(i*0.08) == a and math.floor(i*0.1) == b:
ans = i
break
print(ans)
| 0 | null | 54,175,691,199,112 | 197 | 203 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N, M = mapint()
S = list(input())
def solve():
now = N
choice = []
while 1:
if now==0:
return choice[::-1]
for m in range(M, 0, -1):
nx = now-m
if nx<0: continue
if S[nx]=='1': continue
now = nx
choice.append(m)
break
else:
return [-1]
print(*solve())
|
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))
n=int(input())
a=lmp()
ans=0
for i in range(n-1):
for j in range(i+1,n):
ans+=a[i]*a[j]
print(ans)
| 0 | null | 153,360,261,251,274 | 274 | 292 |
n = int(input())
R = (int(input()) for _ in range(n))
ret = -(10 ** 9)
mn = next(R)
for r in R:
ret = max(ret, r - mn)
mn = min(mn, r)
print(ret)
|
import sys
x = []
for line in sys.stdin.readlines():
x.append(line.strip())
max = -(10**9)
min = int(x[1])
for i in range(2, int(x[0])+1):
sa = int(x[i]) - min
if max < sa:
max = sa
if min > int(x[i]):
min = int(x[i])
print max
| 1 | 12,772,094,230 | null | 13 | 13 |
import Queue
import sys
class Proc:
def __init__(self, name, time):
self.time = time
self.name = name
def main():
array = map(lambda x: int(x), sys.stdin.readline().strip().split(" "))
p_num = array[0]
q_time = array[1]
p_queue = Queue.Queue()
for i in range(0, p_num):
array = sys.stdin.readline().strip().split(" ")
p_queue.put(Proc(array[0], int(array[1])))
t = 0
while not p_queue.empty():
p = p_queue.get()
if p.time > q_time:
p.time = p.time - q_time
p_queue.put(p)
t += q_time
else:
t += p.time
print p.name + " " + str(t)
if __name__ == "__main__":
main()
|
A,B,K = map(int,input().split())
C = max(0,A+B-K)
B2 = min(C,B)
A2 = C-B2
print(A2,B2)
| 0 | null | 51,933,392,136,856 | 19 | 249 |
#List of Top 3 Hills
set = []
a = 9
for i in range(10):
n = int(input())
set.append(n)
set.sort()
while a >= 7:
print(set[a])
a -= 1
|
a=[]
while 1:
try:
a.append(int(input()))
except: break
a.sort(reverse=1)
for i in range(3):print(a[i])
| 1 | 32,959,040 | null | 2 | 2 |
s = str(input())
#s = "<>>><<><<<<<>>><"
ans = 0
def leftmore(ln):
ret = [0]
cur = 0
for c in ln:
if c == "<":
cur += 1
else:
cur = 0
ret.append(cur)
return ret
def rightless(ln):
revl = reversed(ln)
ret = [0]
cur = 0
for c in revl:
if c == ">":
cur += 1
else:
cur = 0
ret.append(cur)
return list(reversed(ret))
lm = leftmore(s)
rl = rightless(s)
for i in range(len(s)+1):
ans += max(lm[i],rl[i])
print(ans)
|
h1, m1, h2, m2, k = map(int, input().split())
if m2 >= m1:
print((h2 - h1) * 60 + (m2 - m1) - k)
else:
print((h2-1 - h1) * 60 + (m2 + 60 - m1) - k)
| 0 | null | 87,113,720,930,050 | 285 | 139 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
C = readline().strip()
print(chr(ord(C) + 1))
return
if __name__ == '__main__':
main()
|
st = input()
code = ord(st)
next_code = code + 1
print(chr(next_code))
| 1 | 91,742,357,343,868 | null | 239 | 239 |
n,a,b=map(int,input().split())
t=a+b
if n%t<=a:
diff=n%t
else:
diff=a
print(a*(n//t)+diff)
|
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#l = list(map(int, input().split()))
n, a, b = map(int, input().split())
if (a == 0):
print (0)
exit()
ans = n // (a+b) * a
amari = n % (a+b)
if (amari <= a):
ans += amari
else:
ans +=a
print (ans)
| 1 | 55,562,080,039,662 | null | 202 | 202 |
from functools import lru_cache
import math
def main():
n=int(input())
a=list(map(int,input().split()))
x=set()
y=a[0]
pair=True
for i in a:
if pair:
p=set(prime_factorize(i))
if len(x&p)>0:
pair=False
x|=p
y=math.gcd(y, i)
if pair:
print("pairwise coprime")
elif y==1:
print("setwise coprime")
else:
print("not coprime")
# 素数リスト（エラトステネスの篩）
@lru_cache(maxsize=None)
def primes(n:int) -> list:
'''n以下の全素数をlistで返す'''
is_prime = [True] * (n + 1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n**0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, n + 1, i):
is_prime[j] = False
return [i for i in range(n + 1) if is_prime[i]]
# 素数判定（単純な素数判定なら十分早い。大量にやる場合はX in primesがよさそう）
@lru_cache(maxsize=None)
def is_prime(n: int) -> bool:
'''引数nが素数であればTrue、そうでなければFalseを返す'''
if n == 1:
return False
elif n == 2:
return True
elif n % 2 == 0:
return False
for i in range(3, int(n**0.5)+1, 2):
if n % i == 0:
return False
return True
# 素因数分解
def prime_factorize(n: int) -> list:
'''引数nの素因数分解結果のlistを返す。'''
arr = []
# 2で割り続け奇数まで還元する
while n % 2 == 0:
arr.append(2)
n //= 2
# sqrt(n)までの素数で試し割
for f in primes(int(n**0.5)):
while n % f == 0:
arr.append(f)
n //= f
if n != 1:
arr.append(n)
return arr
if __name__ == "__main__":
main()
|
from math import gcd
def setwise_coprime_check_fun(A_list, N):
gcd_all = A_list[0]
for i in range(N - 1):
gcd_all = gcd(gcd_all, A_list[i + 1])
if gcd_all == 1:
break
return gcd_all
def preprocess_fun(A_max):
p_flg = [True] * (A_max + 1)
D = [0] * (A_max + 1)
p_flg[0] = False
p_flg[1] = False
for i in range(2, A_max + 1, 1):
if p_flg[i]:
for j in range(i, A_max + 1, i):
p_flg[j] = False
D[j] = i
return D
def pairwise_coprime_check(A_list, D, A_max):
p_count = [0] * (A_max + 1)
for A in A_list:
temp = A
d = 0
while temp != 1:
if p_count[D[temp]] == 1 and d != D[temp]:
return 0
p_count[D[temp]] = 1
d = D[temp]
temp = temp // D[temp]
return 1
## 標準入力
N = int(input())
A_list = list(map(int, input().split(" ")))
# 整数の最大値を取得
A_max = max(A_list)
# 本体
if(setwise_coprime_check_fun(A_list, N) != 1):
print("not coprime")
else:
D = preprocess_fun(A_max)
if pairwise_coprime_check(A_list, D, A_max) == 1:
print("pairwise coprime")
else:
print("setwise coprime")
| 1 | 4,086,194,131,610 | null | 85 | 85 |
# -*- coding: utf-8 -*-
import sys
import os
import math
while True:
N = int(input())
if N == 0:
break
scores = list(map(float, input().split()))
n = len(scores)
mean = sum(scores) / n
variance = 0
for score in scores:
variance += (score - mean) ** 2
variance /= n
print(math.sqrt(variance))
|
a = raw_input().lower()
s = 0
while True:
b = raw_input()
if b == 'END_OF_TEXT':
break
b = b.split()
b = map(str.lower,b)
s += b.count(a)
print s
| 0 | null | 994,939,981,440 | 31 | 65 |
a=int(input())
if a<30:
print("No")
else:
print("Yes")
|
X = int(input())
if X >= 30:
print('Yes')
else:
print('No')
| 1 | 5,754,546,094,308 | null | 95 | 95 |
X, N = map(int, input().split())
P = list(map(int, input().split()))
st = set(P)
ans = 111
for i in range(111):
if i in st:
continue
if abs(ans - X) > abs(i - X):
ans = i
print(ans)
|
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
print("YES" if A+T*V>= B+T*W and A-T*V <= B-T*W else "NO")
| 0 | null | 14,687,311,416,372 | 128 | 131 |
N = int(input())
A = list(map(int, input().split()))
A_MAX = 10 ** 5
idx = [0] * (A_MAX + 1)
sum = 0
for i in A:
idx[i] += 1
sum += i
Q = int(input())
for i in range(Q):
B, C = list(map(int, input().split()))
sub = C - B
num = idx[B]
idx[B] = 0
idx[C] += num
sum += (sub * num)
print(sum)
|
n=int(input())
a=list(map(int,input().split()))
cnt=[0]*(10**5+1)
for i in a:
cnt[i]+=1
xxx=sum(a)
q=int(input())
for i in range(q):
l,r=map(int,input().split())
pin=cnt[l]
cnt[r]+=pin
cnt[l]=0
xxx+=(r-l)*pin
print(xxx)
| 1 | 12,231,911,992,300 | null | 122 | 122 |
def main():
N, M = map(int, input().split())
if N == M:
return "Yes"
return "No"
if __name__ == '__main__':
print(main())
|
def main():
N,M = map(int,input().split())
if M == N:
return 'Yes'
else:
return 'No'
print(main())
| 1 | 83,560,236,401,862 | null | 231 | 231 |
X,Y,a,b,c = map(int,input().split())
if X < a + c or 0 > a - c:
print("No")
elif Y < b + c or 0 > b - c:
print("No")
else :
print("Yes")
|
x = input().split()
W, H, x, y, r = int(x[0]), int(x[1]), int(x[2]), int(x[3]), int(x[4])
if 0 <= x-r and x+r <= W and 0 <= y-r and y+r <= H:
print("Yes")
else:
print("No")
| 1 | 463,517,570,880 | null | 41 | 41 |
n=int(input())
cnt=0
a=1
while(a*a<n):
cnt+=1
cnt+=max((n-1)//a-a,0)*2
a+=1
print(cnt)
|
def resolve():
N = int(input())
count = 0
for A in range(1, N):
count += ((N-1)//A)
print(count)
if __name__ == "__main__":
resolve()
| 1 | 2,583,530,924,132 | null | 73 | 73 |
あ,い=map(int,input().split())
print(max(0,あ-い*2))
|
import math
l = float(input())/3
print(math.pow(l, 3))
| 0 | null | 107,129,137,381,308 | 291 | 191 |
s = input()
s = s.split()
n = []
for i in s:
n.append(int(i))
a = n[0]
b = n[1]
print("a",end = " ")
if a > b:
print(">",end = " ")
elif a < b:
print("<",end = " ")
else:
print("==",end = " ")
print("b")
|
#coding:UTF-8
while True:
a,op,b = map(str,raw_input().split())
a = int(a)
b = int(b)
if op == '+':
print a + b
elif op == '-':
print a - b
elif op == '*':
print a * b
elif op == '/':
print a / b
else:
break
| 0 | null | 529,365,712,548 | 38 | 47 |
N = int(input())
a = list(map(int, input().split()))
count = 1
if 0 in a:
print(0)
else:
for i in range(N):
count *= a[i]
if count > 10 ** 18:
print(-1)
break
else:
print(count)
|
N=int(input())
A=list(map(int,input().split()))
M=1000
S=0
for i in range(N-1):
if A[i+1]>A[i]:
S+=M//A[i]
M-=A[i]*(M//A[i])
else:
M+=S*A[i]
S=0
print(M+S*A[N-1])
| 0 | null | 11,676,834,711,468 | 134 | 103 |
(d,), cc, *sstt = [list(map(int, s.split())) for s in open(0)]
ss = sstt[:d]
tt = list(map(lambda x: x-1, sum(sstt[d:], [])))
comp = [0]*len(cc)
ans = 0
for i in range(d):
comp = [sum(x) for x in zip(comp, cc)]
t = tt[i]
ans += ss[i][t]
comp[t] = 0
ans -= sum(comp)
print(ans)
|
n, k = map(int, input().split())
mod = 10**9 + 7
res = 0
z = n*(n+1)//2
for x in range(k, n+2):
min_ = (x-1)*x//2
max_ = z - (n-x)*(n+1-x)//2
res += max_ - min_ + 1
res %= mod
print(res)
| 0 | null | 21,513,310,006,812 | 114 | 170 |
R=range
l=[[[0 for i in R(10)]for j in R(3)]for s in R(4)]
for i in R(int(input())):
b,f,r,v=map(int,input().split())
l[b-1][f-1][r-1]+=v
for i in R(4):
for k in l[i]:print("",*k)
if i!=3:print("#"*20)
|
nb=4
nf=3
nr=10
d = {}
n = int(input())
for i in range(n):
[b,f,r,v] = map(int, input().split())
key = "%2d %2d %2d" % (b,f,r)
if key in d:
d[key] += v
else:
d[key] = v
for b in range(1,nb+1):
for f in range(1,nf+1):
for r in range(1,nr+1):
key = "%2d %2d %2d" % (b,f,r)
if key in d:
print(" "+str(d[key]),end="")
else:
print(" "+str(0),end="")
if r==nr:
print()
if r==nr and f==nf and b != nb:
print('####################')
| 1 | 1,098,679,275,628 | null | 55 | 55 |
N = int(input())
ans = 0
for i in range(1, N + 1):
res = N // i
ans += res*(res+1)//2*i
print(ans)
|
h,w,K = map(int, input().split())
g = [[0]*w for _ in range(h)]
for i in range(h):
s=input()
for j in range(w):
g[i][j] = s[j]
ans=1001001001
for i in range(1<<(h-1)):
seg = [0]*h
segnow = 0
for j in range(h-1):
if i & 1 << j:
segnow += 1
seg[j+1] = segnow
segnow += 1
flag = True
div = 0
cnt = [0 for _ in range(segnow)]
for j in range(w):
now = [0]*segnow
for k in range(h):
if g[k][j] == '1':
cnt[seg[k]] += 1
now[seg[k]] += 1
if cnt[seg[k]] > K:
div+=1
for l in range(segnow):
cnt[l] = now[l]
if max(now)>K:
continue
ans = min(ans,segnow-1+div)
print(ans)
| 0 | null | 29,749,593,036,412 | 118 | 193 |
def solve():
X, Y, Z = map(int, input().split())
print(Z, X, Y)
if __name__ == '__main__':
solve()
|
n = list(map(int,input().split()))
m = []
for i in range(2):
m.append(n[0])
n.pop(0)
n.append(m[0])
n.append(m[1])
print(*n)
| 1 | 38,024,183,045,952 | null | 178 | 178 |
#coding:utf-8
l = map(int, raw_input(). split())
i = min(l)
l.remove(min(l))
n = min(l)
l.remove(min(l))
m = min(l)
print("{0} {1} {2}". format(i, n, m))
|
sortingThreeNum = list(map(int, input().split()))
sortingThreeNum.sort()
print(sortingThreeNum[0], sortingThreeNum[1], sortingThreeNum[2])
| 1 | 421,093,123,650 | null | 40 | 40 |
K = int(input())
S = input()
N = len(S)
mod = int(1e9+7)
### 123
### a1bb2ccc3dddd 10文字インサート
# pow(25,6) * pow(26,4) * 8C2
# (3はfixで、それより前の8mojiから1/2を入れる場所を決める）
# これを3の位置でループする（1-indexで 3<=i<=N)
# 123dddddddddd
# pow(25,0) * pow(26,10) * 2C2(1)
# 12x3ddddddddd
# pow(25,1) * pow(26,9) * 3C2( = 2C2 * 3 / 1)
# 12xx3dddddddd
# pow(25,2) * pow(26,8) * 4C2( = 3C2 * 4 / 2)
# ...
# 12xxxxxxxxxx3
# pow(25,10) * pow(26,0) * 12C2( = 11C2 * 12 / 10)
# 5C5, 6C5, 7C5 1, 6, 21, 56
def powinv(x,mod):
return pow1(x,mod-2,mod)
def pow1(x, n, mod):
ans = 1
while n>0:
if n % 2:
ans *= x
ans %= mod
x *= x
x %= mod
n = n // 2 # n >>= 1
return ans
wk = pow(26,K,mod)
inv26 = powinv(26,mod)
ans = wk
for i in range(1,K+1):
wk = (wk * 25 * inv26) % mod
wk = (wk * (N-1+i) * powinv(i,mod) % mod)
ans = (ans + wk)%mod
print(ans)
|
x = int(input())
cnt = 0
m_500 = x // 500
m_5 = (x - m_500*500) // 5
print(m_500*1000 + m_5*5)
| 0 | null | 27,826,037,650,312 | 124 | 185 |
n = int(input())
import math
l=0
for i in range(1,n+1):
for j in range(1,n+1):
p=math.gcd(i,j)
for k in range(1,n+1):
l+=math.gcd(p,k)
print(l)
|
n=int(input())
a=n%10
if a==2 or a==4 or a==5 or a==7 or a==9:
print("hon")
elif a==0 or a==1 or a==6 or a==8:
print("pon")
else:
print("bon")
| 0 | null | 27,394,916,070,148 | 174 | 142 |
n=str(input())
a=list(n)
b=0
for i in a:
b=b+int(i)
if b%9==0:
print("Yes")
else:
print("No")
|
N = input()
nums = []
for num in N:
nums.append(int(num))
s = sum(nums)
if s % 9 == 0:
print("Yes")
else:
print("No")
| 1 | 4,353,589,892,160 | null | 87 | 87 |
from bisect import bisect_left
n = int(input())
L = list(map(int, input().split()))
L.sort()
cnt = 0
for a in range(n-2):
for b in range(a+1, n-1):
cnt += bisect_left(L,L[a]+L[b])-(b+1)
print(cnt)
|
def dfs(v, time_, d, f, dp):
if d[v] == 0:
d[v] = time_
for i in range(len(dp[v])):
if d[dp[v][i]] == 0:
time_ = dfs(dp[v][i], time_ + 1, d, f, dp)
f[v] = time_ + 1
return time_ + 1
def main():
N = int(input())
dp = [[] for i in range(N)]
for i in range(N):
line = [int(k) for k in input().split()]
for j in range(len(line)):
if j == 0 or j == 1:
continue
dp[line[0] - 1].append(line[j] - 1)
d = [0] * N
f = [0] * N
time_ = 1
for i in range(N):
if d[i] == 0:
time_ = dfs(i, time_, d, f, dp)
time_ += 1
for i in range(N):
print(i + 1, d[i], f[i])
if __name__ == '__main__':
main()
| 0 | null | 85,913,511,229,472 | 294 | 8 |
n = int(input())
s = [input() for _ in range(n)]
uniq = set(s)
print(len(uniq))
|
N = int(input())
items = set(input() for i in range(N))
print(len(items))
| 1 | 30,417,656,194,448 | null | 165 | 165 |
A, B, C = map(int, input().split())
K = int(input())
for i in range((K + 1)):
for j in range((K + 1) - i):
for k in range((K + 1) - i - j):
if A * (2 ** i) < B * (2 ** j) < C * (2 ** k):
print("Yes")
exit()
print("No")
|
a, b, c = map(int, input().split())
k = int(input())
p = "No"
for i in range(k):
if not(a < b and b < c):
if b <= a:
b = b * 2
else:
c = c * 2
if a < b and b < c:
p = "Yes"
print(p)
| 1 | 6,977,298,396,882 | null | 101 | 101 |
N=input()
total=0
for i in N:
total += int(i)
print('Yes' if total % 9 == 0 else 'No')
|
S = input()
acc = 0
for ch in S:
acc += int(ch)
print('Yes' if acc % 9 == 0 else 'No')
| 1 | 4,443,440,414,010 | null | 87 | 87 |
from collections import deque
if __name__ == '__main__':
n, q = map(int, input().split())
Q = deque()
for i in range(n):
name, time = input().split()
Q.append([name, int(time)])
sum = 0
while Q:
qt = Q.popleft()
if qt[1] <= q:
sum += qt[1]
print(qt[0], sum)
else:
sum += q
qt[1] -= q
Q.append(qt)
|
n,m,x = list(map(int,input().split()))
cList = []
for i in range(n):
cList.append(list(map(int,input().split())))
priceList = []
for i in range(1,2**n):
price = 0
check = 1
skilList = [0 for i in range(m)]
bit = i
for j in range(1,n+1):
if bit % 2 == 1:
price += cList[j-1][0]
for k in range(m):
skilList[k] = skilList[k] + cList[j-1][k+1]
bit = bit // 2
for j in skilList:
if j < x:
check = 0
break
if check == 1:
priceList.append(price)
if len(priceList) > 0:
print(min(priceList))
else:
print(-1)
| 0 | null | 11,259,481,160,930 | 19 | 149 |
n = int(input())
s = input()
ans = 0
for i in range(1000):
i = '0' * (3 - len(str(i))) + str(i)
keep = 0
for j in range(n):
if s[j] == i[keep]:
keep += 1
if keep == 3:
ans += 1
break
print(ans)
|
n =int(input())
s = input()
cnt = 0
for a in range(10):
s_index = s.find(str(a))
if s_index == -1:
continue##この先はやらない
for b in range(10):
t_index = s.find(str(b),s_index+1)
if t_index==-1:
continue
for c in range(10):
u_index = s.find(str(c),t_index+1)
if u_index != -1:
cnt+=1
print(cnt)
| 1 | 128,644,332,132,110 | null | 267 | 267 |
# 入力
N = int(input())
A = list(map(int, input().split()))
R = max(A)
prime_factor_counter = [0]*(R+1)
# D[x]にxを割り切れる最初の素数を格納
# 次に行う素因数分解で試し割りのムダを削減するための前準備
D = [0]*(R+1)
for i in range(2, R+1):
if D[i]:
continue
n = i
while n < R+1:
if D[n] == 0:
D[n] = i
n += i
# 素因数分解し、素因子をカウント
# ex: 12 => 2と3のカウントを+1する
for a in A:
tmp = a
while tmp > 1:
prime_factor = D[tmp]
prime_factor_counter[prime_factor] += 1
while tmp%prime_factor == 0:
tmp //= prime_factor
# 回答出力
if max(prime_factor_counter) < 2:
print('pairwise coprime')
elif max(prime_factor_counter) - A.count(1) < N:
print('setwise coprime')
else:
print('not coprime')
|
def li():
return [int(x) for x in input().split()]
N = int(input())
A = li()
import math
from functools import reduce
from collections import defaultdict
# 最大公約数（リスト引数）
# 空のリストを渡さないよう注意
def GCD_list(numbers):
return reduce(math.gcd, numbers)
# 数列全ての高速素因数分解
MAX = 10 ** 6
is_prime = [True] * (MAX + 1)
divs = [1] * (MAX + 1)
is_prime[0], is_prime[1] = False, False
i = 1
while i * i <= MAX:
if not is_prime[i]:
i += 1
continue
for j in range(2 * i, MAX + 1, i):
is_prime[j] = False
divs[j] = i
i += 1
pairwise_coprime = True
all_primes = defaultdict(int)
for k in range(N):
n = A[k]
p = divs[n]
primes = defaultdict(int)
while p > 1:
primes[p] += 1
n = n // p
p = divs[n]
# 最後に残った数は1か素数にしかならない
if n != 1:
primes[n] += 1
for key in primes:
if all_primes[key] > 0 and primes[key] > 0:
pairwise_coprime = False
break
all_primes[key] += primes[key]
gcd = GCD_list(A)
setwise_comprime = (gcd == 1)
if pairwise_coprime:
print('pairwise coprime')
elif setwise_comprime:
print('setwise coprime')
else:
print('not coprime')
| 1 | 4,067,341,479,272 | null | 85 | 85 |
n,m = map(int,input().split())
a = list(map(int,input().split()))
ans = 0
for i in range(n):
ans += a[i]
a.sort()
if a[n-m]/ans < 1 / (4 * m):
print('No')
else:
print('Yes')
|
import math
n=int(input())
a=list(map(int,input().split()))
mxa=max(a)
def get_sieve_of_eratosthenes(mxa):
fact = [0]*(mxa+1)
limit = int(math.sqrt(mxa))
for i in range(2,limit+1):
if fact[i]!=0:
continue
else:
fact[i]=i
for j in range(i, mxa+1, i):
if fact[j]==0:
fact[j]=i
for i in range(2,mxa+1):
if fact[i]==0:
fact[i]=i
return fact
fact = get_sieve_of_eratosthenes(mxa)
lst=[0]*(len(fact))
for i in range(n):
divisor = set()
while a[i]!=1:
divisor.add(fact[a[i]])
a[i]//=fact[a[i]]
for d in divisor:
lst[d]+=1
pair=True
st=True
for i in lst:
if i>=2:
pair=False
if i==n:
st=False
if pair:
print("pairwise coprime")
elif st:
print("setwise coprime")
else:
print("not coprime")
| 0 | null | 21,381,146,641,678 | 179 | 85 |
import math
n,k = map(int,input().split())
s = n//k
if n-k*s>abs(n-k*s-k):
print(abs(n-k*s-k))
else:
print(n-k*s)
|
n, k = map(int, input().split())
t = n // k
re = n - t * k
i = True
while i == True:
if abs(re - k) < re:
re = abs(re - k)
i = True
else:
i = False
print(re)
| 1 | 39,248,039,694,978 | null | 180 | 180 |
def f(point):
k = K
for i in range(N):
a = A[i]
f = F[i]
if a*f > point:
k -= a - point//f
if k < 0:
return False
# print(point, k)
return True
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort()
F.sort(reverse=True)
l = -1
r = 10**18+1
while (r-l) > 1:
mid = (r+l)//2
if f(mid):
r = mid
else:
l = mid
print(r)
|
#E
N,K = map(int,input().split())
A = list(map(int,input().split()))
F = list(map(int,input().split()))
A.sort(reverse=True)
F.sort()
left = 0
right = 10**12
while True:
mid = (left+right)//2
if right - left <= 1:
count = 0
for i in range(N):
a = left//F[i]
count+=max(0,A[i]-a)
if count <= K:
ans = left
else:
ans = right
break
count = 0
for i in range(N):
a = mid//F[i]
count+=max(0,A[i]-a)
if count <= K:
right = mid
else:
left = mid
print(ans)
| 1 | 165,012,428,469,952 | null | 290 | 290 |
X, Y = map(int, input().split())
ans = 0
for v in [X, Y]:
if v == 1:
ans += 300000
elif v == 2:
ans += 200000
elif v == 3:
ans += 100000
if X == 1 and Y == 1:
ans += 400000
print(ans)
|
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,103,453,629,958 | null | 275 | 275 |
#import sys
#import numpy as np
import math
#from fractions import Fraction
import itertools
from collections import deque
from collections import Counter
import heapq
#from fractions import gcd
#input=sys.stdin.readline
import bisect
n,m=map(int,input().split())
class UnionFind(): #集合の取り扱い、辺に重み、階層を意識するときは使えない
def __init__(self,n):
self.n=n
self.par = [-1]*n
def find(self,x):
if self.par[x] <0: #負なら親、要素数
return x
else: #正なら親の番号
self.par[x]=self.find(self.par[x]) #一回調べたら根を繋ぎ変える、経路圧縮
return self.par[x]
def union(self,x,y):
x=self.find(x) #x,yの親
y=self.find(y)
if x==y: #親が同じなら何もしない
return
if self.par[x]>self.par[y]: #要素数が大きい方をxにする
x,y=y,x
self.par[x]+=self.par[y] #xがある集合にyが入った集合をくっつける
self.par[y]=x
def size(self,x):
return -self.par[self.find(x)] #親のサイズ
def same(self,x,y): #親が同じ、すなわち同じ集合か
return self.find(x)==self.find(y)
def member(self,x): #同じ木（集合）にある要素全部リストで返す
root = self.find(x)
return [i for i in range(self.n) if self.find(i)==root ]
def roots(self): #集合の根になってる要素をリストで返す
return [i for i , x in enumerate(self.par) if x<0]
def group_count(self): #集合の数、木の数
return len(self.roots())
def all_member(self): #辞書型で返す
return {r: self.member(r) for r in self.roots()}
def __str__(self):
return "\n".join('{}:{}'.format(r,self.member(r)) for r in self.roots)
tree=UnionFind(n)
for i in range(m):
a,b=map(int,input().split())
tree.union(a-1,b-1)
print(tree.group_count()-1)
|
A, B = map(int, input().split())
ans1 = 0
ans2 = 0
for i in range(10000):
ans1 = int(i * 0.08)
ans2 = int(i * 0.10)
if (ans1) == A and int(ans2) == B:
print(i)
exit()
print(-1)
| 0 | null | 29,273,053,741,724 | 70 | 203 |
a,b,c,d,e = map(int,input().split())
z = (c-a)*60 + (d-b)- e
print(z)
|
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
h1, m1, h2, m2, k = map(int,input().split())
print(h2*60+m2-h1*60-m1-k)
if __name__=='__main__':
main()
| 1 | 18,009,623,969,308 | null | 139 | 139 |
S=input()
print(S.replace('?','D'))
|
pd = list(input())
for i in range(len(pd)):
if '?' in pd[i]:
pd[i] = 'D'
print(pd[i], end = '')
| 1 | 18,467,977,675,862 | null | 140 | 140 |
list = [int(x) for x in input().split()]
list.sort()
print(list[0], list[1], list[2])
|
L=map(int, raw_input().split())
L=sorted(L)
for i in range(len(L)):
print L[i],
| 1 | 406,595,520,240 | null | 40 | 40 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
a[i] = a[i] % k
if k == 1:
print(0)
exit()
ruiseki = [0]
for i in range(n):
ruiseki.append((a[i]+ruiseki[-1])%k)
mini = 0
dic = {}
ans = 0
for j in range(1, n+1):
if j-k+1 > mini:
dic[(ruiseki[mini]-mini)%k] -= 1
mini += 1
if (ruiseki[j-1]-(j-1))%k in dic:
dic[(ruiseki[j-1]-(j-1))%k] += 1
else:
dic[(ruiseki[j-1]-(j-1))%k] = 1
if (ruiseki[j]-j)%k in dic:
ans += dic[(ruiseki[j]-j)%k]
print(ans)
|
import sys
sys.setrecursionlimit(10**9)
INF=10**18
def input():
return sys.stdin.readline().rstrip()
def main():
N,K=map(int,input().split())
A=list(map(int,input().split()))
B=[0]*(N+1)
for i in range(N):
B[i+1]=(A[i]+B[i]-1)%K
ans=0
d={}
for i in range(1,N+1):
if i-K<0:
if B[i-1] in d:
d[B[i-1]]+=1
else:
d[B[i-1]]=1
else:
if B[i-1] in d:
d[B[i-1]]+=1
else:
d[B[i-1]]=1
d[B[i-K]]-=1
if B[i] in d:
ans+=d[B[i]]
print(ans)
if __name__ == '__main__':
main()
| 1 | 137,495,412,759,398 | null | 273 | 273 |
import itertools
n = int(input())
p = [[0 for i in range(2)] for j in range(n)]
for i in range(n):
p[i][0],p[i][1] = map(int,input().split())
#print(p)
def dis(a,b):
dis = (a[0]-b[0]) ** 2 + (a[1]-b[1]) **2
return dis ** (1/2)
perm = [i for i in range(n)]
total = 0
num = 0
for v in itertools.permutations(perm,n):
path = 0
for i in range(n-1):
path += dis(p[v[i]],p[v[i+1]])
num += 1
total += path
print(total/num)
|
import math
import itertools
n = int(input())
data = []
for i in range(n):
x, y = map(int,input().split())
data.append((x, y))
cnt = 0
for a in itertools.permutations(range(n)):
for j in range(n-1):
cnt += ((data[a[j+1]][0]-data[a[j]][0])**2 + (data[a[j+1]][1]-data[a[j]][1])**2)**0.5
print(cnt / math.factorial(n))
| 1 | 148,484,213,499,986 | null | 280 | 280 |
h = int(input())
def rc(h):
if h == 1:
return 1
t = rc(h//2)*2
return t + 1
print(rc(h))
|
import math
def koch(n, p1, p2):
if n == 0:
return
s = [(2 * p1[0] + p2[0]) / 3, (2 * p1[1] + p2[1]) / 3]
t = [(p1[0] + 2 * p2[0]) / 3, (p1[1] + 2 * p2[1]) / 3]
u = [(t[0] - s[0]) * math.cos(math.radians(60))
- (t[1] - s[1]) * math.sin(math.radians(60)) + s[0],
(t[0] - s[0]) * math.sin(math.radians(60))
+ (t[1] - s[1]) * math.cos(math.radians(60)) + s[1]]
koch(n - 1, p1, s)
print(s[0], s[1])
koch(n - 1, s, u)
print(u[0], u[1])
koch(n - 1, u, t)
print(t[0], t[1])
koch(n - 1, t, p2)
n = int(input())
p1 = (0, 0)
p2 = (100, 0)
print(p1[0], p1[1])
koch(n, p1, p2)
print(p2[0], p2[1])
| 0 | null | 40,185,788,950,050 | 228 | 27 |
N,P = map(int, input().split())
S = input()
"""
たとえばSが 123456789 だとすると
3456 = (3456789 - 789) // 1000
と表せる。
これがPで割り切れる場合、基本的には 3456789 と 789 がPで割り切れるとよい。
これはPと 10**x が互いに素の場合。
なので、10**x とPが互いに素の場合は、
・S[l:]をPで割った時余りがXXXになるものが何個、という情報を、Sの右端から集めていく。ただし、
・あるindexのlのS[l:]を見ているときに、その部分をPで割って余りがKになるなら、そのlに対してlより右にあるrについて、
S[r:]をPで割った余りがKになるようにrを選んでS[l:r]を作ると、Pで割り切れる数字が得られる。その時点でのmod P = Kの個数に対応する。
ただし、rに何も選ばない場合（lから端までを数字にする場合）もあるので、これも考慮に入れる。
Pが10と互いに素でない場合は、2と5がありうる。
これについて、それぞれ末尾が2の倍数か5の倍数であれば割り切れるので、
Sを左から見ていって、その数字が見つかれば、そのindexをふくむ左の位置で数字を作ればPで割れる数字ができる
"""
ans = 0
if P in [2, 5]:
for i in range(N):
if int(S[i]) % P == 0:
ans += i+1
else:
mod_P = [0] * P
mod_P[0] += 1
# Sを右端から何個かまで見てできる数字をPで割ってできる余り。
# 数字のまま持っておいて、都度mod P をとるとTLEになるので。
# 3543 で 3543 % P = (3000 + 543) % P のような感じで右から左にSを見ていく
curr = 0
for i in range(N):
curr = curr + int(S[N-1-i]) * pow(10, i, P)
curr %= P
ans += mod_P[curr]
mod_P[curr] += 1
print(ans)
|
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
n,p = list(map(int, input().split()))
s = input()
ans = 0
if p == 2 or p == 5:
for i in range(n):
a = int(s[n-1-i])
if a % p == 0: ans += n-i
else:
d = {0: 1}
c = 0
for i in range(n):
c += (pow(10, i, p)*int(s[n-1-i])) % p
c %= p
if c not in d:
d[c] = 1
else:
d[c] += 1
for dd in d.values():
ans += dd*(dd-1)//2
print(ans)
| 1 | 58,211,930,476,518 | null | 205 | 205 |
(X1,X2,Y1,Y2)=list(map(int,input().split()))
ans=max(X2*Y2,X1*Y1,X1*Y2,X2*Y1)
print (ans)
|
import sys
from collections import defaultdict
from queue import deque
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10**8)
def geta(fn=lambda s: s.decode()):
return map(fn, readline().split())
def gete(fn=lambda s: s.decode()):
return fn(readline().rstrip())
def egcd(a: int, b: int):
"""
A solution of ax+by=gcd(a,b). Returns
(gcd(a,b), (x, y)).
"""
if a == 0:
return b, 0, 1
else:
g, x, y = egcd(b % a, a)
return g, y - (b // a) * x, x
def modinv(a: int, mod: int = 10**9 + 7):
"""
Returns a^{-1} modulo m.
"""
g, x, y = egcd(a, mod)
if g > 1:
raise Exception('{}^(-1) mod {} does not exist.'.format(a, mod))
else:
return x % mod
def main():
N, S = geta(int)
A = list(geta(int))
A.sort()
mod = 998244353
inv2 = modinv(2, mod)
dp = [[0] * (S + 1) for _ in range(N + 1)]
for s in range(S + 1):
dp[0][s] = 0
_t = pow(2, N, mod)
for n in range(N + 1):
dp[n][0] = _t
for i in range(1, N + 1):
for j in range(1, S + 1):
if j >= A[i - 1]:
dp[i][j] = dp[i - 1][j - A[i - 1]] * inv2 + dp[i - 1][j]
else:
dp[i][j] = dp[i - 1][j]
dp[i][j] %= mod
print(dp[N][S])
if __name__ == "__main__":
main()
| 0 | null | 10,457,355,316,672 | 77 | 138 |
ST = list(map(str, input().split()))
print(ST[1]+ST[0])
|
st = input().split(' ')
print(st[1]+st[0])
| 1 | 103,020,939,207,120 | null | 248 | 248 |
n = int(input())
t_score = 0
h_score = 0
for i in range(n):
t_card, h_card = input().split()
if t_card < h_card:
h_score += 3
elif t_card > h_card:
t_score += 3
else:
h_score += 1
t_score += 1
print(t_score, h_score)
|
n=int(input())
lr=[]
for i in range(n):
x,l=map(int,input().split())
lr.append((x-l,x+l))
lr.sort(key=lambda x: x[1])
ans=0
l=-10**18
r=0
for i in range(n):
if i==0:
tl,tr=lr[i]
l=tl
r=tr
ans+=1
continue
tl,tr=lr[i]
if tl>=r:
ans+=1
r=tr
l=tl
print(ans)
| 0 | null | 46,151,051,720,580 | 67 | 237 |
s=input()
a=[0]*(len(s)+1)
for i in range(len(s)):
if s[i]=="<":
a[i+1]=a[i]+1
for i in range(len(s)-1,-1,-1):
if s[i]==">":
a[i]=max(a[i],a[i+1]+1)
print(sum(a))
|
s = input()
cut = [0]
for i in range(len(s)-1):
if(s[i:i+2] == '><'):
cut.append(i+1)
cut.append(len(s)+1)
ans = 0
for i in range(len(cut)-1):
ss = s[cut[i]:cut[i+1]]
left = ss.count('<')
right = ss.count('>')
ans += left*(left+1)//2 + right*(right+1)//2 - min(left,right)
print(ans)
| 1 | 156,602,387,671,506 | null | 285 | 285 |
import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return input().rstrip().decode()
def II(): return int(input())
def FI(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()
import numpy as np
def main():
n=II()
A=LI()
A=np.array(A)
B=np.cumsum(A)
C=np.cumsum(A[::-1])
#print(B,C)
D=abs(B[:-1]-C[:-1][::-1])
#print(D)
print(np.min(D))
if __name__ == "__main__":
main()
|
import sys
H, A = map(int, next(sys.stdin.buffer).split())
print(-(-H // A))
| 0 | null | 109,781,824,330,698 | 276 | 225 |
s = []
while True:
x = int(input())
if x == 0:
break
s.append(x)
for (i,num) in enumerate(s):
print('Case {0}: {1}'.format(i+1,num))
|
i = 0
while 1:
x = raw_input()
i += 1
if x == "0":
break
print "Case %s: %s" % (i,x)
| 1 | 473,319,779,530 | null | 42 | 42 |
N = int(input())
S = str(input())
import itertools
ans=0
for num in range(1000):
num=str(num).zfill(3)
a0=S.find(str(num[0]))
if a0>=0:
S1=S[(a0+1):]
a1=S1.find(str(num[1]))
if a1>=0:
S2=S1[(a1+1):]
if str(num[2]) in S2:
ans+=1
print(ans)
# 2darray [[0] * 4 for i in range(3)]
|
n=int(input())
s=[int(x) for x in list(input())]
ans=0
for a in range(10):
for i in range(n):
if s[i]==a:
a_dx=i
break
else:
continue
for b in range(10):
for i in range(a_dx+1,n):
if s[i]==b:
b_dx=i
break
else:
continue
for c in range(10):
for i in range(b_dx+1,n):
if s[i]==c:
ans+=1
break
else:
continue
print(ans)
| 1 | 128,475,801,899,380 | null | 267 | 267 |
class Queue:
queue_list = []
start = 0
def enqueue(self, a):
self.queue_list.append(a)
def dequeue(self):
assert self.start != len(self.queue_list), "オーバーフローが発生しました。"
self.start += 1
return self.queue_list[self.start - 1]
def isEmpty(self):
return self.start == len(self.queue_list)
n, q = list(map(lambda x: int(x), input().strip().split()))
queue = Queue()
for i in range(n):
queue.enqueue(input().strip().split())
sum_time = 0
while not queue.isEmpty():
name, time = queue.dequeue()
if int(time) <= q:
sum_time += int(time)
print(name + ' ' + str(sum_time))
else:
queue.enqueue([name, str(int(time) - q)])
sum_time += q
|
h, w, k, = map(int, input().split())
c = [0] * h
for i in range(h):
c[i] = input()
y = 0
for i in range(2 ** (h + w)):
x = 0
a = [0] * (h + w)
for j in range(h + w):
if (i // (2 ** j)) % 2 == 1:
a[j] = 1
for j in range(h):
if a[j] == 0:
for l in range(w):
if a[h+l] == 0:
if c[j][l] == '#':
x += 1
if x == k:
y += 1
print(y)
| 0 | null | 4,495,656,136,246 | 19 | 110 |
N = int(input().rstrip())
l = list(map(int, input().rstrip().split()))
#l = list(set(l))
l.sort(reverse=True)
num = 0
for i in range(len(l) - 2):
for j in range(i + 1, len(l) - 1):
if l[i] == l[j]:
continue
for k in range(j + 1, len(l)):
if l[j] == l[k]:
continue
if l[i] < (l[j] + l[k]):
num += 1
print(num)
|
def check(a,b,c):
if a == b:
return False
if b == c:
return False
if c == a:
return False
m = max(a,b,c)
if m >= (a+b+c)-m:
return False
return True
N = int(input())
L = list(map(int,input().split()))
ans = 0
if N >= 3:
for i in range(0,N-2):
for j in range(i+1,N-1):
for k in range(j+1,N):
if check(L[i],L[j],L[k]):
ans += 1
print(ans)
| 1 | 5,033,753,229,020 | null | 91 | 91 |
'''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
t1,t2 = map(int,ipt().split())
a1,a2 = map(int,ipt().split())
b1,b2 = map(int,ipt().split())
d1 = t1*(a1-b1)
d2 = t2*(a2-b2)
if d1*(d1+d2) > 0:
print(0)
elif d1+d2 == 0:
print("infinity")
else:
dt = d1+d2
if abs(d1)%abs(dt):
print(abs(d1)//abs(dt)*2+1)
else:
print(abs(d1)//abs(dt)*2)
return None
if __name__ == '__main__':
main()
|
li = input().split()
li.sort()
print(li[0]*int(li[1]))
| 0 | null | 108,020,099,447,300 | 269 | 232 |
import math
radius=int(input())
print(2*math.pi*radius)
|
r = int(input())
print(r*6.2831)
| 1 | 31,566,093,498,976 | null | 167 | 167 |
import sys
# import math
# import bisect
# import numpy as np
# from decimal import Decimal
# from numba import njit, i8, u1, b1 #JIT compiler
# from itertools import combinations, product
# from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return map(int, sys.stdin.readline().strip().split())
def read_ints2(x): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)
class Combination:
def __init__(self, n, p):
self.n = n
self.p = p
self.note = [1, 1]
self.noteinv = [1, 1]
self.inv = [0, 1]
self.calc()
def calc(self):
for i in range(2, self.n + 1):
self.note.append((self.note[-1] * i) % self.p)
self.inv.append((-self.inv[self.p % i] * (self.p // i)) % self.p)
self.noteinv.append((self.noteinv[-1] * self.inv[-1]) % self.p)
def nCr(self, n, r):
n = self.n
if r < 0 or n < r:
return 0
r = min(r, n - r)
return (self.note[n] * self.noteinv[r] * self.noteinv[n - r]) % self.p
def Main():
n, m, k = read_ints()
# m * _{n-1}C_k * 1^k * (m-1)^{n-1-k}
p = 998244353
modm = [1]
for _ in range(1, n):
modm.append((modm[-1] * (m - 1)) % p)
cmb = Combination(n - 1, p)
ans = 0
for i in range(k + 1):
ans += (cmb.nCr(n - 1, i) * m * modm[n - 1 - i]) % p
ans %= p
print(ans)
if __name__ == '__main__':
Main()
|
import sys
from fractions import gcd
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def lcm(x, y):
return x * y // gcd(x, y)
def main():
N, M = map(int, input().split())
A = list(map(int, input().split(" ")))
A = [a // 2 for a in A]
semi_lcm = 1
for a in A:
semi_lcm = lcm(semi_lcm, a)
if semi_lcm > M or semi_lcm // a % 2 == 0:
print(0)
return
print((M // semi_lcm + 1) // 2)
return
if __name__ == '__main__':
main()
| 0 | null | 62,306,097,944,412 | 151 | 247 |
N, M = map(int, input().split())
a = list(map(int, input().split()))
for k in range(N):
a[k] //= 2
foo = 1
while a[0]%2 == 0:
foo *= 2
a[0] //= 2
for k in range(1, N):
if a[k] % foo == 0 and a[k]%(2*foo) !=0:
a[k] //= foo
continue
else:
print(0)
exit()
ans = 0
for odd in [3]:
flag = False
for k in range(N):
if a[k]%odd == 0:
a[k] //= odd
flag = True
if flag:
foo *= odd
import math
lcm = a.pop()
for k in range(1, N):
b = a.pop()
lcm = lcm * b // math.gcd(lcm, b)
if lcm* foo > M:
print(0)
exit()
lcm *= foo
ans = int((M / lcm -1)//2 + 1)
print(ans)
|
a = input()
print("Yes" if (a[2] == a[3]) and (a[4] == a[5]) else "No")
| 0 | null | 71,909,597,822,672 | 247 | 184 |
def check(P):
global w, k
t=1
wt=0
for wi in w:
if wt+wi>P:
wt=wi
t+=1
else:
wt+=wi
if t>k:
return False
return True
def search(l, r):
if r-l==1:
return r
else:
m=(l+r)//2
if not check(m):
return search(m,r)
else:
return search(l,m)
n,k=map(int,input().split())
w=[]
for i in range(n):
w.append(int(input()))
S=sum(w);M=max(w)
#print(S,M)
P0=M-1
#print(P0)
print(search(M-1,S))
|
n = int(input())
t = list(map(int,input().split()))
a = min(t)
b = max(t)
c = sum(t)
print(str(a),str(b),str(c))
| 0 | null | 403,216,249,162 | 24 | 48 |
import sys
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
K,X=nm()
print('Yes' if X<=500*K else 'No')
|
import sys
sys.setrecursionlimit(10000000)
def dfs(s):
if len(s)==11:
return
if s!="":
a.append(int(s))
for c in "0123456789":
if s=="" and c=="0":continue
if s!="":
if abs(ord(c)-ord(s[-1]))<=1:
dfs(s+c)
else:
dfs(s+c)
k=int(input())
a=[]
dfs("")
a=list(set(a))
a.sort()
print(a[k-1])
| 0 | null | 68,950,870,676,672 | 244 | 181 |
# coding: utf-8
H, W = list(map(int, input().split()))
S = []
for _ in range(H):
S.append(list(input()))
grid = [[0 for _ in range(W)] for _ in range(H)]
for h in range(1,H):
if S[h-1][0] == '#' and S[h][0] == '.':
grid[h][0] = grid[h-1][0] + 1
else:
grid[h][0] = grid[h-1][0]
for w in range(1,W):
if S[0][w-1] == '#' and S[0][w] == '.':
grid[0][w] = grid[0][w-1] + 1
else:
grid[0][w] = grid[0][w-1]
for w in range(1,W):
for h in range(1,H):
if S[h-1][w] == '#' and S[h][w] == '.':
next_h = grid[h-1][w] + 1
else:
next_h = grid[h-1][w]
if S[h][w-1] == '#' and S[h][w] == '.':
next_w = grid[h][w-1] + 1
else:
next_w = grid[h][w-1]
grid[h][w] = min([next_w, next_h])
if S[H-1][W-1] == '#':
grid[H-1][W-1] += 1
print(grid[H-1][W-1])
|
N = int(input())
s = input()
a = [chr(i) for i in range(65, 65+26)]
ls = []
for x in a:
ls.append(x)
for x in a:
ls.append(x)
ans = []
for x in s:
ans.append(ls[ls.index(x)+N])
print(''.join(ans))
| 0 | null | 92,021,474,226,878 | 194 | 271 |
x, n = map(int, input().split())
p = list(map(int, input().split()))
i = 0
while True:
if x-i not in p:
print(x-i)
break
if x+i not in p:
print(x+i)
break
i += 1
|
X, N = map(int, input().split())
P = list(map(int, input().split()))
st = set(P)
for i in range(111):
if not X - i in st:
print(X - i)
exit(0)
if not X + i in st:
print(X + i)
exit(0)
| 1 | 14,082,090,382,642 | null | 128 | 128 |
N, k = map(int, input().split())
dp = [0] * (N+1)
dp[1] = 1
S = []
for i in range(k):
S.append(list(map(int, input().split())))
for i in range(2, N+1):
for l, r in S:
dp[i] += (dp[max(i-l, 0)] - dp[max(i-r-1, 0)])
dp[i] += dp[i-1]
dp[i] %= 998244353
print((dp[N] - dp[N-1])%998244353)
|
MOD = 998244353
n, k = map(int, input().split())
l, r = [0]*k, [0]*k
for i in range(k):
_l, _r = map(int, input().split())
l[i], r[i] = _l, _r
dp, dpsum = [0]*(n+1), [0]*(n+1)
dp[1], dpsum[1] = 1, 1
for i in range(2, n+1):
for j in range(k):
li = i - r[j]
ri = i - l[j]
if ri<0: continue
li = max(li, 1)
dp[i] += dpsum[ri] - dpsum[li-1]
dp[i] %= MOD
dpsum[i] = dpsum[i-1] + dp[i]
print(dp[n])
| 1 | 2,685,090,266,150 | null | 74 | 74 |
def input_list():
return list(map(int, input().split()))
def main():
s = list(input())
k = int(input())
if len(set(s)) == 1:
print(int(len(s)*(k/2)))
exit()
sw = [s[0]]
num = 0
numbers = [num]
for i in range(1, len(s)):
if s[i-1] != s[i]:
num += 1
numbers.append(num)
if num == 0 and sw[0] == s[i]:
sw.append(s[i])
num = 0
end_w = s[-1]
ew = []
for i in range(len(s)-1, -1, -1):
if end_w != s[i]:
num += 1
if num == 0 and end_w == s[i]:
ew.append(s[i])
nc = collections.Counter(numbers)
a = 0
for n,c in nc.items():
if c == 1:
continue
if c % 2 == 0:
a += c // 2
else:
a += (c-1)//2
ans = a * k
b = 0
if ew[0] == sw[0]:
haji = len(sw) + len(ew)
if haji % 2 == 0:
print(a * k + (k-1))
exit()
print(ans - b)
import math
import fractions
import collections
import itertools
from functools import reduce
main()
|
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
S = list(input())
K = int(input())
leng = len(S)
if len(set(S))==1:
print(K*leng//2)
exit()
if S[0]!=S[-1] or K==1:
last = S[0]
cnt = 0
for s in S[1:]:
if s==last:
cnt += 1
last = '.'
else:
last = s
print(cnt*K)
else:
S += ['.']
cnt = 1
lis = []
last = S[0]
for s in S[1:]:
if s==last:
cnt += 1
else:
lis.append(cnt)
last = s
cnt = 1
first = lis.pop(0)
end = lis.pop()
others = sum([i//2 for i in lis])
ans = first//2 + others*K + (first+end)//2*(K-1)+end//2
print(ans)
| 1 | 175,140,298,722,268 | null | 296 | 296 |
n,m=map(int,input().split())
if m == 0:
print(0,0)
exit(0)
results=[]
for i in range(n+1):
results.append([0,0])
ac = 0
wa = 0
memo = [0]*(n+1)
for i in range(m):
p,s=input().split()
p = int(p)
s = s.strip()
if memo[p] != -1:
if s == 'WA':
memo[p] += 1
else:
ac += 1
wa += memo[p]
memo[p] = -1
print(ac,wa)
|
#coding: UTF-8
import math
def RN(n,a):
ans=""
for i in range(int(n)):
ans+=a[int(n)-1-i]+" "
print(ans[:-1])
if __name__=="__main__":
n=input()
a=input()
List=a.split(" ")
RN(n,List)
| 0 | null | 47,208,462,747,800 | 240 | 53 |
from collections import Counter
MOD = 998244353
n = int(input())
d = list(map(int,input().split()))
d_count = Counter(d)
ans = 1
pre_count = 1
if d[0] > 0: ans = 0
for i,(dist,count) in enumerate(sorted(d_count.items())):
if i != dist or (i==0 and count > 1):
ans = 0
break
ans *= pow(pre_count,count,MOD)
ans %= MOD
pre_count = count
print(ans)
|
global cnt
cnt = 0
def merge(A, left, mid, right):
L = A[left:mid] + [float("inf")]
R = A[mid:right] + [float("inf")]
i = 0
j = 0
global cnt
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
cnt += 1
def mergesort(A, left, right):
rsl = []
if left+1 < right:
mid = int((left+right)/2)
mergesort(A, left, mid)
mergesort(A, mid, right)
rsl = merge(A, left, mid, right)
return rsl
n = int(input())
S = list(map(int, input().split()))
mergesort(S, 0, n)
print(*S)
print(cnt)
| 0 | null | 77,356,073,544,540 | 284 | 26 |
def solve(N, data):
ret = N
data.sort(key=lambda x: x[0] - x[1])
most_right = float("-inf")
for idx, d in enumerate(data):
l, r = d[0] - d[1], d[0] + d[1]
if not idx:
most_right = r
continue
if most_right <= l:
most_right = r
continue
ret -= 1
most_right = min(r, most_right)
return ret
if __name__ == "__main__":
N = int(input())
data = []
for _ in range(N):
data.append(list(map(int, input().split())))
print(solve(N, data))
|
N = int(input())
A = list(map(int, input().split()))
MOD = 10**9 + 7
def gcd(n, m):
if m == 0:
return n
return gcd(m, n % m)
def lcm(n, m):
return n * m // gcd(n, m)
L = A[0]
for a in A:
L = lcm(L, a)
ans = 0
for a in A:
ans += L // a
print(ans % MOD)
| 0 | null | 88,643,679,758,480 | 237 | 235 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def main():
R = int(input())
print(int(R**2))
if __name__ == "__main__":
main()
|
# 1 <= N <= 1000000
N = int(input())
total = []
# N項目までに含まれる->N項目は含まない。だからN項目は+1で外す。
for x in range(1, N+1):
if x % 15 == 0:
"FizzBuzz"
elif x % 5 == 0:
"Buzz"
elif x % 3 == 0:
"Fizz"
else:
total.append(x) #リストに加える
print(sum(total))
| 0 | null | 89,881,589,767,412 | 278 | 173 |
A, B = map(int,input().split())
for i in range(max(A,B),0,-1):
if A%i==0 and B%i==0:
print(A*B//i)
break
|
def gcd(_a, _b):
if _a%_b==0:return _b
else:return gcd(_b, _a%_b)
A, B=map(int, input().split())
print(A*B//gcd(A, B))
| 1 | 113,423,498,489,120 | null | 256 | 256 |
def II(): return int(input())
def MI(): return map(int, input().split())
A,B,N=MI()
def f(x):
return A*x//B-A*(x//B)
if B-1<=N:
ans=f(B-1)
else:
ans=f(N)
print(ans)
|
A,B,N = map(int,input().split())
if B<=N:
print(int((A*(B-1))/B)-(A*int((B-1)/B)))
else:
print(int((A*N)/B)-(A*int(N/B)))
| 1 | 28,009,113,963,536 | null | 161 | 161 |
N = int(input())
query = []
ans = 0
for i in range(N):
A = int(input())
query.append([list(map(int, input().split())) for j in range(A)])
for i in range(1<<N):
count = 0
FLG = True
for j in range(N):
if (i >> j) & 1:
count += 1
for x, y in query[j]:
if (i >> (x - 1)) & 1 != y:
FLG = False
break
if not FLG:
break
else:
ans = max(ans, count)
print(ans)
|
n = int(input())
s = [input() for i in range(n)]
l, r = [], []
for i in s:
a, b = 0, 0
for j in range(len(i)):
if i[j] == "(":
b += 1
if i[j] == ")":
if b <= 0:
a += 1
else:
b -= 1
if b - a > 0:
l.append([a, b])
else:
r.append([a, b])
l.sort(key=lambda x:x[0])
r.sort(key=lambda x:x[1], reverse=True)
li = l + r
ans = 0
for i in li:
ans -= i[0]
if ans < 0:
exit(print("No"))
ans += i[1]
print("Yes" if ans == 0 else "No")
| 0 | null | 72,610,293,981,318 | 262 | 152 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.