code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
178,025B
⌀ | question_pair_id
float64 27.1M
177,113B
⌀ | code1_group
int64 1
297
| code2_group
int64 1
297
|
|---|---|---|---|---|---|---|
a = int(input())
res = 0
if a%2 ==0:
res = int(a/2)
else:
a +=1
res = int(a/2)
print(res)
|
def s_in():
return input()
def n_in():
return int(input())
def l_in():
return list(map(int, input().split()))
class Interval():
def __init__(self, li):
self.li = li
self.n = len(li)
self.sum_li = [li[0]]
for i in range(1, self.n):
self.sum_li.append(self.sum_li[i-1] + li[i])
def sum(self, a, b=None):
if b is None:
return self.sum(0, a)
res = self.sum_li[min(self.n-1, b-1)]
if a > 0:
res -= self.sum_li[a-1]
return res
N = s_in()[::-1]
n = len(N)
dp1 = [0 for _ in range(n)]
dp1[0] = int(N[0])
# dp1[i] は i桁目を同じ値だけ使ったとしたときの最小値
dp2 = [0 for _ in range(n)]
dp2[0] = 10 - int(N[0])
# dp2[i] は i桁目を繰り上げたとしたときの最小値
for i, s in enumerate(N[1:]):
i += 1
m = int(s)
dp1[i] = min(dp1[i-1] + m, dp2[i-1] + (m+1))
dp2[i] = min(dp1[i-1] + (10-m), dp2[i-1] + (10-m-1))
# print(dp1)
# print( dp2)
print(min(dp1[n-1], dp2[n-1]+1))
| 0 | null | 64,951,581,938,132 | 206 | 219 |
r, c = map(int, input().split())
a = [0]*(c+1)
for _ in range(r):
v = list(map(int, input().split()))
v.append(sum(v))
print(*v)
a = [x+y for x, y in zip(a, v)]
print(*a)
|
N = int(input())
A = list(map(int, input().split()))
A = sorted(A)
MAX_A = 1000001
dp = [0]*MAX_A
for i in A:
if dp[i] == 0:
for j in range(i, MAX_A,i):
dp[j] += 1
else:
dp[i] += 1
c = 0
for i in A:
if dp[i] == 1:
c += 1
print(c)
| 0 | null | 7,891,568,410,208 | 59 | 129 |
H, A = map(int, input().split())
h = H//A
c = H%A
if c == 0:
print(h)
else:
print(h+1)
|
n, m = map(int, input().split())
s=[]
c=[]
num=[]
for i in range(m):
S, C = map(int, input().split())
s.append(S)
c.append(C)
for i in range(10**(n+1)):
String=str(i)
if len(String) == n and all([String[s[j]-1] == str(c[j]) for j in range(m)]):
print(str(i))
exit()
print('-1')
| 0 | null | 68,709,677,178,858 | 225 | 208 |
n=int(input())
p=10**9+7
A=list(map(int,input().split()))
binA=[]
for i in range(n):
binA.append(format(A[i],"060b"))
exp=[1]
for i in range(60):
exp.append((exp[i]*2)%p)
ans=0
for i in range(60):
num0=0
num1=0
for j in range(n):
if binA[j][i]=="0":
num0+=1
else:
num1+=1
ans=(ans+num0*num1*exp[59-i])%p
print(ans)
|
n = int(input())
s0=list(str(n))
ans=0
if len(s0)==1:
print(n)
exit()
if len(s0)==2:
for i in range(1,n+1):
s1=list(str(i))
if s1[-1]=='0':
continue
if s1[0]==s1[-1]:
ans+=1
if int(s1[-1])*10+int(s1[0])<=n:
ans+=1
print(ans)
exit()
for i in range(1,n+1):
s1=list(str(i))
if s1[-1]=='0':
continue
if s1[0]==s1[-1]:
ans+=1
for j in range(2,len(s0)):#nより小さい桁数のものを足す
ans+=10**(j-2)
if int(s0[0])>int(s1[-1]):#nより入れ替えた数の最高位数が小さいとき、全て足す
ans+=10**(len(s0)-2)
elif s0[0]==s1[-1]:#nと入れ替えた数の最高位数が同じ時
ans+=int(''.join(s0[1:len(s0)-1]))+1
if int(s0[-1])<int(s1[0]):
ans-=1
print(ans)
| 0 | null | 104,573,922,529,450 | 263 | 234 |
n=int(input())
a=list(map(int,input().split()))
mod=10**9+7
def eucrid(a,b):
a,b=max(a,b),min(a,b)
while True:
if a%b==0:
return b
else:
a,b=b,a%b
m=a[0]
for i in range(n):
m=m//eucrid(m,a[i])*a[i]
b=0
m=m%mod
for i in a:
b+=m*pow(i,mod-2,mod)%mod
print(b%mod)
|
import sys
input = sys.stdin.readline
import math
big = 10 ** 9 + 7
N = int(input())
A = list(map(int, input().split()))
num = A[0]
for i in range(1, N):
num = num * A[i] // math.gcd(num, A[i])
res = 0
for a in A:
res += num // a
print(res % big)
| 1 | 87,395,844,186,460 | null | 235 | 235 |
a=int(input())
resultado=str(a*a*a)
print resultado
|
# coding: utf-8
a = input()
print(int(a)*int(a)*int(a))
| 1 | 283,016,934,684 | null | 35 | 35 |
in_num = list(map(int, input().split()))
print(in_num.index(0)+1)
|
n=input()
s=''
for i in range(1,int(n)+1):
s += (' '+str(i)) if i%3==0 or '3' in str(i) else ''
print(s)
| 0 | null | 7,103,868,104,740 | 126 | 52 |
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
def two(val):
ret = 0
tmp = val
while True:
if tmp != 0 and tmp % 2 == 0:
ret += 1
tmp = tmp // 2
else:
break
return ret
n, m = map(int, input().split())
a_list = list(map(int, input().split()))
b_list = []
for item in a_list:
b_list.append(item // 2)
cnt = -1
for item in b_list:
ret = two(item)
if cnt == -1:
cnt = ret
elif cnt != ret:
print(0)
exit()
val = b_list[0]
for item in b_list:
val = lcm(item, val)
ret = m // val
tmp1 = ret // 2
tmp2 = ret % 2
print(tmp1 + tmp2)
|
S = input()
if ("RRR" in S):
print("3")
elif ("RR" in S):
print("2")
elif ("R" in S):
print("1")
else:
print("0")
| 0 | null | 53,631,838,947,772 | 247 | 90 |
MOD=10**9+7
N=int(input())
ans=pow(10,N,MOD)
ans-=2*pow(9,N,MOD)
ans+=pow(8,N,MOD)
ans%=MOD
print(ans)
|
import math
from functools import reduce
"""[summary]
全体：10^N
0が含まれない：9^N
9が含まれない：9^N
0,9の両方が含まれない：8^N
0,9のどちらか一方が含まれない：9^N + 9^N - 8^N
"""
N = int(input())
mod = (10 ** 9) + 7
calc = (10**N - 9**N - 9**N + 8**N) % mod
print(calc)
| 1 | 3,155,061,836,458 | null | 78 | 78 |
a,b = map(int,input().split())
print('%d %d %.10f'%(a/b,a%b,a/b))
|
N,D=open(0)
*D,=map(int,D.split())
c=[0]*-~max(D)
for i in D:c[i]+=1
a=D[0]<1==c[0]
for i,j in zip(c,c[1:]):a*=i**j
print(a%998244353)
| 0 | null | 77,839,206,879,044 | 45 | 284 |
def main():
n = int(input())
a_list = []
b_list = []
for _ in range(n):
a, b = map(int, input().split())
a_list.append(a)
b_list.append(b)
a_sorted = list(sorted(a_list))
b_sorted = list(sorted(b_list))
if n%2:
print(b_sorted[n//2]-a_sorted[n//2]+1)
else:
print((b_sorted[n//2-1]+b_sorted[n//2]-a_sorted[n//2-1]-a_sorted[n//2])+1)
if __name__ == "__main__":
main()
|
n, s = open(0).read().split()
s = list(map(int, list(s)))
from itertools import product,repeat
ans = 0
for a,b,c in product(range(10), range(10), range(10)):
abc = [a,b,c]
tmp = 0
for dig in s:
if dig == abc[tmp]:
tmp += 1
if tmp == 3:
ans += 1
break
print(ans)
| 0 | null | 73,040,599,310,658 | 137 | 267 |
while True:
a = input()
if '?' in a:
break
print("%d" % eval(a))
|
a = []
while True:
b = raw_input().split()
if b[1] == '?':
break
c = [int(b[0]), b[1], int(b[2])]
a.append(c)
for list in a:
x, op, y = list
if op == '+':
print x + y
elif op == '-':
print x - y
elif op == '*':
print x * y
else:
print x / y
| 1 | 675,787,496,930 | null | 47 | 47 |
N, S = open(0).read().split()
S = list(map(int, list(S)))
N = int(N)
cnt = 0
for i in range(0, 10):
for j in range(0, 10):
for k in range(0, 10):
try:
n = S.index(i)
m = S[n+1:].index(j)
o = S[n+m+2:].index(k)
cnt += 1
except ValueError:
pass
print(cnt)
|
import sys
for line in range(int(input())):
str = input().split(" ")
nums = sorted([int(str[2]), int(str[1]), int(str[0])])
if nums[2]*nums[2] == nums[1]*nums[1] + nums[0]*nums[0]:
print("YES")
else:
print("NO")
| 0 | null | 64,674,471,714,798 | 267 | 4 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
t = input().rstrip()
list_t = []
for s in t:
list_t.append(s)
ans_str = ""
for i, s in enumerate(list_t):
if s == "?":
list_t[i] = "D"
print("".join(list_t))
|
N,M,K=map(int,input().split())
mod=998244353
fact=[1 for i in range(N+1)]
for i in range(1,N):
fact[i+1]=(fact[i]*(i+1))%mod
def nCk(n,k):
return fact[n]*pow(fact[n-k]*fact[k],mod-2,mod)
result=0
for k in range(K+1):
result+=nCk(N-1,k)*M*pow(M-1,N-k-1,mod)
result=int(result)%mod
print(result)
| 0 | null | 20,822,909,297,890 | 140 | 151 |
N, M = map(int, input().split())
def factorial(n):
p = 1
for i in range(n, 0, -1):
p *= i
return p
def comb(n, k):
return factorial(n) // (factorial(k) * factorial(n-k))
res = comb(M, 2) + comb(N, 2)
print(res)
|
U = 2*10**6+1
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
fact_inv[U] = pow(fact[U], MOD-2, MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
def comb(n, k):
if k < 0 or k > n:
return 0
z = fact[n]
z *= fact_inv[k]
z *= fact_inv[n-k]
z %= MOD
return z
k = int(input())
S = input()
n = len(S)
ans = 0
for i in range(n-1, n+k):
temp = comb(i, n-1)*pow(25, i-(n-1), MOD)*pow(26, n+k-1-i, MOD)
temp %= MOD
ans += temp
ans %= MOD
print(ans)
| 0 | null | 29,429,107,805,130 | 189 | 124 |
S = input()
if S[1] == 'R':
T = 'ABC'
else:
T = 'ARC'
print(T)
|
if __name__ == "__main__":
a,b = map(int,input().split())
d,r,f = a/b,a%b,float(a/b)
print("%d %d %0.5f"%(d,r,f))
| 0 | null | 12,365,842,955,260 | 153 | 45 |
H = int(input())
W = int(input())
N = int(input())
print(-(-N//max(H,W)))
|
a = [list(map(int,input().split())) for _ in range(3)]
n = int(input())
b = [int(input()) for _ in range(n)]
for i in b:
for j in range(3):
for k in range(3):
if a[j][k] == i:
a[j][k] = 0
a_2 = list(zip(*a))
flag_1 = sum(a[0]) == 0 or sum(a[1]) == 0 or sum(a[2]) == 0
flag_2 = sum(a_2[0]) == 0 or sum(a_2[1]) == 0 or sum(a_2[2]) == 0
flag_3 = a[0][0] + a[1][1] + a[2][2] == 0 or a[0][2] + a[1][1] + a[2][0] == 0
print(['No','Yes'][flag_1 or flag_2 or flag_3])
| 0 | null | 74,481,978,308,500 | 236 | 207 |
from collections import deque
def deque_divisor(n):
d = deque()
for i in range(int(n**(1/2)),0,-1):
if i**2 == n:
d.append(i)
continue
if n % i == 0:
d.appendleft(i)
d.append(n//i)
return d
n = int(input())
candidate = (set(deque_divisor(n)) | set(deque_divisor(n-1)))
candidate.discard(1)
ans = 0
for i in candidate:
k = n
while k % i == 0:
k //= i
k %= i
if k == 1:
ans += 1
print(ans)
|
(X1,X2,Y1,Y2)=list(map(int,input().split()))
ans=max(X2*Y2,X1*Y1,X1*Y2,X2*Y1)
print (ans)
| 0 | null | 22,202,627,701,660 | 183 | 77 |
n = int(input())
a = list(map(int, input().split()))
def num_left(pos):
if pos % 2 == 0:
return (n - pos) // 2 + 1
else:
return (n - pos - 1) // 2 + 1
d = [{} for i in range(n)]
for i in range(n):
if i < 2:
d[i][0] = 0
d[i][1] = a[i]
else:
left = num_left(i + 2)
#print("i = ", i, left)
j = i - 2
while j >= 0:
max_count = max(d[j].keys())
if max_count + left + 1 < n // 2:
break
else:
for count, v in d[j].items():
#print(count, v)
if count + left + 1 >= n // 2:
if count + 1 in d[i]:
d[i][count + 1] = max(d[i][count + 1], v + a[i])
else:
d[i][count + 1] = v + a[i]
j -= 1
if 1 + left >= n // 2:
d[i][0] = 0
best = None
for i in range(n):
for count, result in d[i].items():
if count == n // 2:
if best is None:
best = result
else:
best = max(best, result)
#print(d)
print(best)
|
n = int(input())
a = [int(ai) for ai in input().split()]
if n % 2 == 0:
s = [0,0]
for i in range(n // 2):
s = [max(s[q] for q in range(p+1)) + a[i*2+p] for p in range(2)]
print(max(s))
else:
s = [0,0,0]
for i in range(n // 2):
s = [max(s[q] for q in range(p+1)) + a[i*2+p] for p in range(3)]
print(max(s))
| 1 | 37,293,035,047,280 | null | 177 | 177 |
H, W, K = map(int, input().split())
c = []
b_h = [0] * H
b_w = [0] * W
b = 0
for h in range(H):
c.append(input().rstrip())
for w in range(W):
if c[h][w] == "#":
b_h[h] += 1
b_w[w] += 1
b += 1
ans = 0
for hi in range(2 ** H):
for wi in range(2 ** W):
bsum = b
for h in range(H):
if hi & (2 ** h) != 0:
bsum -= b_h[h]
for w in range(W):
if wi & 2 ** w != 0:
if c[h][w] == '#':
bsum += 1
for w in range(W):
if wi & (2 ** w) != 0:
bsum -= b_w[w]
if bsum == K:
ans += 1
print(ans)
|
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
sys.setrecursionlimit(10 ** 7)
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
n = ni()
s = str(n)
K = ni()
dp = [[[0] * 2 for _ in range(K + 2)] for _ in range(len(s) + 1)]
dp[0][0][0] = 1
for i in range(len(s)):
for j in range(K + 1):
for k in range(2):
dmax = 9 if k else int(s[i])
for d in range(dmax + 1):
ni = i + 1
nj = j + (d != 0)
nk = k | (d < dmax)
dp[ni][nj][nk] += dp[i][j][k]
print(dp[len(s)][K][0] + dp[len(s)][K][1])
| 0 | null | 42,562,937,520,470 | 110 | 224 |
m = map(int,raw_input().split())
a = m[0]
b = m[1]
d = a / b
r = a % b
f = a * 1.0 / b
print '%d %d %f' %(d, r, f)
|
a,b = map(float, raw_input().split())
if b > 10**6:
f = 0.0
else:
f = a/b
d = int(a/b)
r = int(a%b)
print d, r, f
| 1 | 608,291,488,850 | null | 45 | 45 |
IN = [i for i in map(int,input().split())]
K = IN[3]
A = min(IN[0],K)
B = min(IN[1], K -A)
C = min(IN[2],K -A- B)
print(A*1+B*0+C*(-1))
|
import math
N = int(input())
A = list(map(int,input().split()))
A.sort(reverse=True)
comfortPoint = A[0]
for i in range(N-1)[1::]:
comfortPoint += A[math.ceil(i/2)]
print(comfortPoint)
| 0 | null | 15,395,377,602,720 | 148 | 111 |
def COMinit():
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,max):
fac[i] = fac[i-1]*i%mod
inv[i] = mod - inv[mod%i]*(mod//i)%mod
finv[i] = finv[i-1]*inv[i]%mod
def COM(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k]*finv[n-k]%mod)%mod
mod = 10**9+7
X, Y = map(int,input().split())
a = X%2 #1の数
b = X//2 #2の数
for i in range(b+1):
if a*2 + b*1 == Y:
break
a += 2
b -= 1
if a*2 + b*1 != Y:
print(0)
else:
max = a+b+1
fac = [0] * max
finv = [0] * max
inv = [0] * max
COMinit()
print(COM(a+b,a))
|
from sys import stdin
def calc(a, op, b):
if op == '+':
return a+b
if op == '-':
return a-b
if op == '*':
return a*b
if op == '/':
return int(a/b)
for line in stdin:
a, op, b = line.rstrip().split(' ')
if op == '?':
break
print(calc(int(a), op, int(b)))
| 0 | null | 75,328,342,551,600 | 281 | 47 |
N = int(input())
A = list(map(int, input().split()))
LN = max(A) + 1
L = [0 for i in range(LN)]
count = 0
for i in A:
for j in range(i, LN, i):
L[j] += 1
for i in A:
if L[i] == 1:
count += 1
print(count)
|
N, M, L = map(int, input().split())
dist = [[10**12] * N for _ in range(N)]
for i in range(N):
dist[i][i] = 0
for _ in range(M):
a, b, c = map(int, input().split())
if c <= L:
dist[a-1][b-1] = dist[b-1][a-1] = c
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
old_dist = [row[:] for row in dist]
for i in range(N):
for j in range(N):
if old_dist[i][j] <= L:
dist[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
Q = int(input())
for _ in range(Q):
start, end= map(int, input().split())
if dist[start-1][end-1] < 10**12:
print(dist[start-1][end-1] - 1)
else:
print(-1)
| 0 | null | 94,233,307,107,940 | 129 | 295 |
K = int(input())
def f(n, k, a):
if k == n:
return 1
res = 0
res += f(n, k+1, a)
if a > 0:
res += f(n, k+1, a-1)
if a < 9:
res += f(n, k+1, a+1)
return res
cnt = 0
for n in range(1, 12):
c2 = 0
for a in range(1, 10):
c2 += f(n, 1, a)
if cnt+c2 >= K:
num = n
ini = a
cnt += c2-f(n, 1, a)
c2 = -1
break
if c2 < 0:
break
cnt += c2
ans = [ini]
for k in range(2, num+1):
for a in range(max(0, ans[-1]-1), min(10, ans[-1]+2)):
cnt += f(num, k, a)
if cnt >= K:
ans.append(a)
cnt -= f(num, k, a)
break
for i in range(len(ans)):
ans[i] = str(ans[i])
print("".join(ans))
|
from collections import deque
K = int(input())
queue = deque(range(1, 10))
for _ in range(K):
x = queue.popleft()
if x % 10 != 0:
queue.append(10 * x + x % 10 - 1)
queue.append(10 * x + x % 10)
if x % 10 != 9:
queue.append(10 * x + x % 10 + 1)
print(x)
| 1 | 40,296,145,897,348 | null | 181 | 181 |
N = int(input())
S = input()
'''
Editorialのヒントを参照しました。
000 ~ 999の実現可能性を考えます。
'''
L = []
s = ''
Comb = 0
key_k = False
for i in range(0, 10):
for j in range(0, 10):
if key_k is not True:
s += str(j)
else:
s += str(i)
s += str(j)
key_k = False
for k in range(0, 10):
s += str(k)
L.append(s)
s = ''
s += str(i)
s += str(j)
s = ''
key_k = True
L.remove(L[0])
L.append('000') #生成、もう少し短くしたい
S_copy = S
A = []
for el in L:
c0 = el[0]
c1 = el[1]
c2 = el[2]
S = S_copy
N0 = S.find(c0)
if N0 == -1:
continue
else:
S = S[N0+1::]
N1 = S.find(c1)
if N1 == -1:
continue
else:
S = S[N1+1::]
N2 = S.find(c2)
if N2 == -1:
continue
else:
Comb += 1
print(Comb)
|
from collections import defaultdict as d
n=int(input())
a=list(map(int,input().split()))
p=d(int)
l=0
for i in a:
p[i]+=1
l+=i
for i in range(int(input())):
b,c=map(int,input().split())
l+=p[b]*(c-b)
p[c]+=p[b]
p[b]=0
print(l)
| 0 | null | 70,714,060,254,112 | 267 | 122 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
r, c, k = map(int, input().split())
itm = [[0]*(c) for _ in range(r)]
for i in range(k):
ri, ci, vi = map(int, input().split())
itm[ri-1][ci-1] = vi
dp0 = [[0]*4 for c_ in range(3005)]
dp1 = [[0]*4 for c_ in range(3005)]
for i in range(r):
for j in range(c):
nowv = itm[i][j]
dp0[j][3] = max(dp0[j][3], dp0[j][2] + nowv)
dp0[j][2] = max(dp0[j][2], dp0[j][1] + nowv)
dp0[j][1] = max(dp0[j][1], dp0[j][0] + nowv)
dp0[j+1][0] = max(dp0[j+1][0], dp0[j][0])
dp0[j+1][1] = max(dp0[j+1][1], dp0[j][1])
dp0[j+1][2] = max(dp0[j+1][2], dp0[j][2])
dp0[j+1][3] = max(dp0[j+1][3], dp0[j][3])
dp1[j][0] = max(dp1[j][0], max(dp0[j]))
dp0 = dp1.copy()
print(max(dp1[c-1]))
|
#!/usr/bin/env python3
r, c, k = map(int, input().split())
items = [[0] * (c+1) for _ in range(r+1)]
for _ in range(k):
R, C, V = map(int, input().split())
items[R][C] = V
dp1 = [[0] * (c+1) for _ in range(r+1)]
dp2 = [[0] * (c+1) for _ in range(r+1)]
dp3 = [[0] * (c+1) for _ in range(r+1)]
for i in range(1, r+1):
for j in range(1, c+1):
v = items[i][j]
dp1[i][j] = max(dp1[i][j-1], dp1[i-1][j] + v, dp2[i-1][j] + v, dp3[i-1][j] + v)
dp2[i][j] = max(dp2[i][j-1], dp1[i][j-1] + v)
dp3[i][j] = max(dp3[i][j-1], dp2[i][j-1] + v)
ans = max(dp1[r][c], dp2[r][c], dp3[r][c])
print(ans)
| 1 | 5,592,750,729,260 | null | 94 | 94 |
s = input()
cnt = 0
for i in range(len(s)//2):
if s[i] == s[-i-1]:
continue
else:
cnt += 1
print(cnt)
|
from collections import deque
H, W, M = map(int, input().split())
bomb = []
counth = [0 for k in range(H)]
countw = [0 for k in range(W)]
for k in range(M):
h, w = map(int, input().split())
h -= 1
w -= 1
bomb.append(h+ w*H)
counth[h] += 1
countw[w] += 1
counth = deque(counth)
countw = deque(countw)
maxh = max(counth)
maxw = max(countw)
index_h = deque([])
index_w = []
for k in range(H):
h = counth.popleft()
if h == maxh:
index_h.append(k)
for k in range(W):
w = countw.popleft()
if w == maxw:
index_w.append(k)
ans = maxh + maxw - 1
lenh = len(index_h)
lenw = len(index_w)
if lenh*lenw > M:
ans += 1
else:
bomb.sort()
bomb = deque(bomb)
kouho = []
for i in range(lenh):
h = index_h.pop()
for j in range(lenw):
w = index_w[j]
kouho.append(h+ H*w)
kouho.sort()
kouho = deque(kouho)
B = bomb.popleft()
K = kouho.popleft()
while True:
if B > K:
ans += 1
break
elif B == K:
if len(kouho) == 0:
break
else:
K = kouho.popleft()
if len(bomb) == 0:
ans += 1
break
else:
B = bomb.popleft()
else:
if len(bomb) == 0:
ans += 1
break
else:
B = bomb.popleft()
print(ans)
| 0 | null | 62,236,515,705,088 | 261 | 89 |
import sys
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b / gcd(a, b)
for s in sys.stdin:
a, b = map(int, s.split())
print "%d %d"%(gcd(a, b), lcm(a, b))
|
# D - Prediction and Restriction
N,K = map(int,input().split())
RSP = tuple(map(int,input().split()))
T = input()
# じゃんけんの勝敗を返す関数
def judge(a,b):
if a == 'r' and b == 2:
return True
elif a == 's' and b == 0:
return True
elif a == 'p' and b == 1:
return True
return False
# dp[i][j]: i 回目のじゃんけんで j を出したときの最大値
# グー:0, チョキ:1, パー:2
dp = [[0]*3 for _ in range(N+1)]
# v 回目のじゃんけん
for v in range(1,N+1):
# v 回目に出した手
for w in range(3):
# v-K 回目に出した手
for k in range(3):
if w == k:
continue
# じゃんけんで勝ったとき
if judge(T[v-1],w):
dp[v][w] = max(dp[v][w],dp[v-K][k] + RSP[w])
# じゃんけんで負けか引き分けたとき
else:
dp[v][w] = max(dp[v][w],dp[v-K][k])
# K 個に分けた各グループの部分和の最大値の総和を求める
ans = 0
for a in range(1,K+1):
ans += max(dp[-a])
print(ans)
| 0 | null | 53,208,709,518,290 | 5 | 251 |
N = int(input())
S = input()
ret = ''
for s in S:
o = ord(s) - ord('A') + N
ret += chr(ord('A') + o % 26)
print(ret)
|
x='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
from collections import Counter
c=Counter([])
for i in range(len(x)):
c[x[i]]=i
n=int(input())
s=input()
ans=''
for i in range(len(s)):
m=c[s[i]]
ans+=x[(m+n)%26]
print (ans)
| 1 | 135,166,556,903,378 | null | 271 | 271 |
a=int(input())
print(sum(divmod(a,2)))
|
print(-(-int(input()) // 2))
| 1 | 59,096,518,460,210 | null | 206 | 206 |
n, k = map(int, input().split())
p = [0] + list(map(int, input().split()))
c = [0] + list(map(int, input().split()))
ans = - 10 ** 18
for i in range(1, n+1):
base = i
nxt = p[i]
cnt = 0
score = 0
while True:
cnt += 1
if cnt > k:
break
score += c[nxt]
ans = max(ans, score)
#print("i = ", i, "ans = ", ans, "score = ", score)
if nxt == base:
break
nxt = p[nxt]
if cnt >= k:
continue
extra = k - cnt
score_tmp = score
nxt = p[nxt]
nxt_tmp = nxt
for j in range(min(extra, cnt)):
score += c[nxt]
ans = max(ans, score)
#print("ans = ", ans, "score = ", score, "nxt = ", nxt, "c[nxt] = ", c[nxt])
nxt = p[nxt]
#print("score = ", score, "ans = ", ans)
score = score_tmp
nxt = nxt_tmp
a = extra // cnt
if extra % cnt == 0:
a -= 1
score += score * max(a, 0)
ans = max(ans, score)
for j in range(extra - a * cnt):
score += c[nxt]
ans = max(ans, score)
#print("ans = ", ans, "score = ", score, "nxt = ", nxt, "c[nxt] = ", c[nxt])
nxt = p[nxt]
print(ans)
|
N, K = map(int, input().split())
P = [0] + list(map(int, input().split()))
C = [0] + list(map(int, input().split()))
#マスに与えられたスコアが全部負だった場合には，その中で最もダメージの小さいマスを一つ踏んで終わる。
C_max = max(C[1:])
if C_max < 0:
print(C_max)
exit()
ans = 0
done = [False] * (N + 1) #チェック済みのマスはTrueにしていく。(loopはバラバラの構成員で構成されてるので。)
#loopの構成員をもらう。 -→ loopの中でマスaから始まりマスbで止まる操作をする場合の最大スコアを数える。
#の順番で解く。
for i in range(1, N + 1):
if done[i]:
continue
#マスiがチェック済みの場合には何もせずiを次に進める。（continue）
loop = [i] #ここにloopの構成員が記録される。iは最初から入れておく。
now = P[i] #iから一歩進んだマスを起点として，loop構成員の記録を開始する。
while now != i:
loop.append(now)
done[now] = True
now = P[now]
#今立っているマスがiでない場合は，loop構成員リストに記録して，doneをTrueにして，足を一歩進める。
#print(loop)
#loopの構成員のメモが完了！
L = len(loop)
S = sum(C[v] for v in loop) #loopを一周した時のスコア
for a_ind in range(L):
a = loop[a_ind]
score_ab = -C[a]
#例えば[3, 6, 4, 7]のloopがあった時，a = 3→6→4→7 と移っていきたいので，a_ind = 0→1→2...として，a = loop[0]→loop[1]→loop[2]→loop[3]とする。bもまた然り。
for b_ind in range(a_ind, a_ind + L):#aから数週してaに戻るプレイも可能なので，b == aとなる場合も含んでおかなければならない。
dist_ab = b_ind - a_ind
if dist_ab > K:
break
b = loop[b_ind % L]
score_ab += C[b]
max_score = score_ab + max(0, S) * ((K - dist_ab) // L)
#スコアの最大値は，
# S > 0の場合，[aからbまで移動した時のスコア] ＋ S * [可能な限りloopを周回する] （周回した方が得なので）
# S < 0の場合，[aからbまで移動した時のスコア] （周回した方が損なので）
#上の場合分けの切り替えを max(0, S) で行っている！地味にすごい！
ans = max(ans, max_score)
print(ans)
| 1 | 5,388,846,159,070 | null | 93 | 93 |
import math
N = int(input())
for i in range(N+1):
if math.floor(1.08 * i) == N:
print(i)
exit()
print(":(")
|
# coding: utf-8
# Your code here!
import sys
n,k=map(int,input().split())
H=list(map(int,input().split()))
H.sort()
if n>k:
for i in range(k):
H[n-1-i]=0
else:
print(0)
sys.exit()
sum_H=sum(H)
print(sum_H)
| 0 | null | 102,191,391,470,362 | 265 | 227 |
from collections import deque
import sys
sys.setrecursion = 10000000
def solve():
n = int(input())
print([1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51][n-1])
solve()
|
container = [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]
unser = int(input())
print(container[unser - 1])
| 1 | 49,801,860,068,116 | null | 195 | 195 |
N = int(input())
*d, = map(int, input().split())
sum = 0
for i in range(len(d)):
for j in range(i+1, len(d)):
sum+=d[i]*d[j]
print(sum)
|
import math
import itertools
n = int(input())
d = list(map(int, input().split()))
ans = 0
for i in itertools.permutations(d, 2):
ans += i[0] *i[1]
print(ans //2)
| 1 | 167,784,989,218,562 | null | 292 | 292 |
N=int(input())
ans=0
ke=0
for i in range(N):
D,E=map(int,input().split())
if D==E:
ans+=1
else:
ans=0
if ans>=3:
ke=1
if ke==1:
print("Yes")
else:
print("No")
|
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
s = sum(a)
cnt = Counter(a)
q = int(input())
for i in range(q):
b, c = map(int, input().split())
s += (c - b)*cnt[b]
cnt[b], cnt[c] = 0, cnt[c] + cnt[b]
print(s)
| 0 | null | 7,421,331,420,688 | 72 | 122 |
# Nを１位上９以下の2つの整数の積として表せるならYes,できないならNo
N = int(input())
for i in range(1, 9+1):
if N%i == 0 and N//i <= 9:
print('Yes')
exit()
print('No')
|
def cub():
x = input()
print x ** 3
cub()
| 0 | null | 80,072,832,338,240 | 287 | 35 |
# -*- coding: utf-8 -*-
import random
import sys
import os
import pprint
#fd = os.open('ALDS1_5_A.txt', os.O_RDONLY)
#os.dup2(fd, sys.stdin.fileno())
n = int(input())
A = list(map(int, input().split()))
# memo table T[i][m]
row_num = len(A)
column_num = 2000
T = [[None for i in range(column_num)] for j in range(row_num)]
#pprint.pprint(T)
def solve(i, m):
# out of index
if i >= len(A):
return False
if m < 0:
return False
if T[i][m] is not None:
return T[i][m]
if m == 0:
T[i][m] = True
elif m == A[i]:
T[i][m] = True
#elif i >= len(A):
# T[i][m] = False
elif solve(i+1, m):
T[i][m] = True
elif solve(i+1, m - A[i]):
T[i][m] = True
else:
T[i][m] = False
return T[i][m]
test_num = int(input())
test_values = map(int, input().split())
for v in test_values:
result = solve(0, v)
if result is True:
print('yes')
else:
print('no')
|
import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
a, b, n = map(int, readline().split())
x = min(b - 1, n)
# if b == n:
# x = b - 1
# if x == 0:
# print(a)
# exit()
ans = math.floor((a * x) / b) - a * math.floor(x / b)
print(ans)
| 0 | null | 14,169,397,923,060 | 25 | 161 |
x = int(input())
if(x==0):
print("1")
elif(x==1):
print("0")
|
import copy
def main():
N, M, Q = [int(n) for n in input().split(" ")]
q = [[int(a) for a in input().split(" ")] for i in range(Q)]
all_series = get_series(N, M)
points = [0]
for l in all_series:
points.append(get_score(l, q))
print(max(points))
def get_score(l, q):
return sum([q[i][3] if l[q[i][1] - 1] - l[q[i][0] - 1] == q[i][2] else 0 for i in range(len(q))])
def get_series(N, M):
# N: number of elms
# M: upper limit of val of elm
all_series = []
checked = [[0] * M for i in range(N)]
to_check = [[0, j + 1] for j in range(M)]
series = [0 for k in range(N)]
while len(to_check) > 0:
checking = to_check.pop(-1)
series[checking[0]] = checking[1]
if checking[0] == N - 1:
l = copy.deepcopy(series)
all_series.append(l)
else:
to_check.extend([[checking[0] + 1, k] for k in range(checking[1], M + 1)])
return all_series
main()
| 0 | null | 15,319,203,631,018 | 76 | 160 |
delta = int(input())
tri_all = []
for i in range(delta):
tri = list(map(int, input().split(' ')))
tri.sort()
tri_all.append(tri)
for i in range(len(tri_all)):
if tri_all[i][0]**2 + tri_all[i][1]**2 == tri_all[i][2]**2:
print('YES')
else:
print('NO')
|
while 1:
a, op, b = input().split()
if op == '?':
break
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)
| 0 | null | 331,299,436,320 | 4 | 47 |
n = int(input())
A = list(map(int, input().split()))
count = 0
def merge(A, left, mid, right):
global count
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] = 1.0e+9 + 1
R[n2] = 1.0e+9 + 1
i = 0
j = 0
for k in range(left, right):
count += 1
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
def mergeSort(A, left, right):
if left + 1 < right:
mid = int((left + right) / 2)
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
mergeSort(A, 0, len(A))
print(" ".join(map(str, A)))
print(count)
|
n = input()
num = map(int, raw_input().split())
for i in range(n):
if i == n-1:
print num[n-i-1]
break
print num[n-i-1],
| 0 | null | 544,591,772,110 | 26 | 53 |
n = int(input())
sum=0
for j in range(1,n+1):
sum+=(n//j)*(n//j+1)//2*j
print(sum)
|
N,K=map(int,input().split())
A=sorted(map(int,input().split()))
M=10**9+7
t,b=A[K-1]-A[N-K],1
for i in range(1,N-K+1):
b=(b*(K-1+i)*pow(i,M-2,M))%M
t=(t+b*(A[K-1+i]-A[N-K-i]))%M
print(t)
| 0 | null | 53,560,242,679,768 | 118 | 242 |
h,n=map(int,input().split())
a,b=[],[]
for i in range(n):
A,B=map(int,input().split())
a.append(A)#ダメージ量
b.append(B)#消費魔力
dp=[float('inf')]*(h+1)
dp[0]=0
for i in range(h):
for j in range(n):
next=i+a[j] if i+a[j]<=h else h
dp[next]=min(dp[next],dp[i]+b[j])
print(dp[-1])
|
h, n = [int(i) for i in input().split()]
magics = [None]
class Magic:
def __init__(self, attack, cost):
self.attack = attack
self.cost = cost
maxA = 0
for i in range(n):
attack, cost = [int(i) for i in input().split()]
maxA = max(maxA, attack)
magics.append(Magic(attack, cost))
dp = [[10 ** 9 for i in range(h + maxA)] for j in range(n + 1)]
for i in range(n + 1):
for j in range(h + maxA):
if j == 0:
dp[i][j] = 0
elif i == 0:
continue
elif j - magics[i].attack >= 0:
dp[i][j] = min(dp[i - 1][j], dp[i][j - magics[i].attack] + magics[i].cost)
else:
dp[i][j] = dp[i - 1][j]
print(min(dp[-1][h:]))
| 1 | 81,156,713,954,088 | null | 229 | 229 |
#設定
import sys
input = sys.stdin.buffer.readline
#ライブラリインポート
from collections import defaultdict
con = 10 ** 9 + 7
#入力受け取り
def getlist():
return list(map(int, input().split()))
#処理内容
def main():
N = int(input())
ansL = [[] for i in range(10)]
ansL[0].append(["a", 1])
for i in range(N - 1):
n = len(ansL[i])
for j in range(n):
for k in range(ansL[i][j][1]):
ansL[i + 1].append([ansL[i][j][0] + chr(97 + k), ansL[i][j][1]])
ansL[i + 1].append([ansL[i][j][0] + chr(97 + ansL[i][j][1]), ansL[i][j][1] + 1])
n = len(ansL[N - 1])
for i in range(n):
print(ansL[N - 1][i][0])
if __name__ == '__main__':
main()
|
import sys, math
from functools import lru_cache
from collections import deque
sys.setrecursionlimit(500000)
MOD = 10**9+7
def input():
return sys.stdin.readline()[:-1]
def mi():
return map(int, input().split())
def ii():
return int(input())
def i2(n):
tmp = [list(mi()) for i in range(n)]
return [list(i) for i in zip(*tmp)]
def solve(d):
if d == 1:
return ['a']
l = solve(d-1)
rsl = []
for w in l:
m = ord(max(w))
for i in range(ord('a'), m+2):
rsl.append(w+chr(i))
return rsl
def main():
print(*solve(ii()), sep='\n')
if __name__ == '__main__':
main()
| 1 | 52,227,197,888,968 | null | 198 | 198 |
n = int(input())
print((10**n-2*9**n+8**n)%1000000007)
|
import sys
input = sys.stdin.readline
#n = int(input())
#l = list(map(int, input().split()))
'''
a=[]
b=[]
for i in range():
A, B = map(int, input().split())
a.append(A)
b.append(B)'''
k=int(input())
if k%2==0:
print("-1")
sys.exit()
flg=False
cnt=0
a=7
for i in range(k):
cnt+=1
a%=k
if a%k==0:
print(cnt)
sys.exit()
a*=10
a+=7
if not flg:
print(-1)
| 0 | null | 4,602,335,042,460 | 78 | 97 |
numbers = [int(i) for i in input().split()]
D, S, T = numbers[0], numbers[1], numbers[2]
if D <= S*T:
print("Yes")
else:
print("No")
|
while True:
a, op, b =input().split()
a,b =int(a),int(b)
if op=="?": break
if op=="+": print(a+b)
if op=="-": print(a-b)
if op=="*": print(a*b)
if op=="/": print(a//b)
| 0 | null | 2,093,053,289,380 | 81 | 47 |
S = input()
D = {"SUN":0, "MON":1, "TUE":2, "WED":3, "THU":4, "FRI":5, "SAT":6}
print(7 - D[S])
|
x = int(input())
n = 10 * x
primes = [True] * n
for i in range(2, n):
if primes[i]:
for j in range(i * i, n, i):
primes[j] = False
for i in range(x, n):
if primes[i]:
print(i)
exit()
| 0 | null | 119,548,138,481,668 | 270 | 250 |
a=int(input())
if a/2==int(a/2):
print(int(a/2))
else:
print(int(a/2)+1)
|
N = int(input())
print(max(N//2, (N+1)//2))
| 1 | 59,110,563,026,508 | null | 206 | 206 |
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()
ans = 0
for i in range(0, K):
rsp_K = T[i::K]
rsp_before = ''
for rsp in rsp_K:
if rsp == 'r':
if rsp_before != 'r':
ans += P
rsp_before = 'r'
else:
rsp_before = ''
elif rsp == 's':
if rsp_before != 's':
ans += R
rsp_before = 's'
else:
rsp_before = ''
elif rsp == 'p':
if rsp_before != 'p':
ans += S
rsp_before = 'p'
else:
rsp_before = ''
print(ans)
|
str=input()
print(str.swapcase())
| 0 | null | 53,971,783,653,340 | 251 | 61 |
import sys
tmp = '#.' * 151
def draw(H, W):
odd = tmp[:W]
even = tmp[1:W + 1]
print((odd + '\n' + even + '\n') * (H // 2) + (odd + '\n' if H % 2 else ''))
for line in sys.stdin:
H, W = map(int, line.split())
if H == W == 0:
break
draw(H, W)
|
import math
a=int(input())
b=int(input())
x=int(input())
print(math.ceil(x/max(a,b)))
| 0 | null | 45,090,630,902,808 | 51 | 236 |
print(eval(input().replace(' ','*')))
|
import math
cnt = 0
def insertionSort(A,n,g):
global cnt
for i in range(g,n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
cnt += 1
j -= g
A[j+g] = v
def shellSort(A, n):
g = int(n/2) + 1
G = []
while g > 0:
G.append(g)
insertionSort(A, n, g)
g = int(g/2)
return G
n = int(input())
A = []
for _ in range(n):
A.append(int(input()))
G = shellSort(A,n)
print(len(G))
print(" ".join(map(str, G)))
print(cnt)
for i in A:
print(i)
| 0 | null | 7,999,008,504,618 | 133 | 17 |
from string import ascii_lowercase, ascii_uppercase
s = open(0).read()
ans = [0]*26
for c in s:
i = ascii_lowercase.find(c)
if i > -1:
ans[i] += 1
i = ascii_uppercase.find(c)
if i > -1:
ans[i] += 1
for c, t in zip(ascii_lowercase, ans):
print("%s : %d" % (c, t))
|
N, K = map(int, input().split())
P = [(int(x)+1)/2 for x in input().split()]
total=ans=sum(P[:K])
for n in range(K,N):
total+=P[n]-P[n-K]
ans=max(ans, total)
print(ans)
| 0 | null | 38,529,791,107,808 | 63 | 223 |
s = raw_input()#,k = map(int, raw_input().split(' '))
print 'Yes ' if len(s) >= 6 and s[2] == s[3] and s[4] == s[5] else 'No' #f(n,k)
|
S=input()
if (S[2]==S[3]) and (S[4]==S[5]):print('Yes')
else:print('No')
| 1 | 42,083,754,012,810 | null | 184 | 184 |
s = []
while 1:
try :
x = raw_input()
except :
break
s.append(x.lower())
s = ''.join(s)
for i in range(26):
c = chr(i + 97)
print '%s : %d' % (c , s.count(c))
|
def main():
alphabets_table = [0 for i in range(26)]
while True:
try:
input_string = input()
lower_string = input_string.lower()
for i, _letter in enumerate("abcdefghijklmnopqrstuvwxyz"):
alphabets_table[i] += lower_string.count(_letter)
except EOFError:
break
for i, _letter in enumerate("abcdefghijklmnopqrstuvwxyz"):
print('%s : %s' % (_letter, alphabets_table[i]))
main()
| 1 | 1,688,627,371,152 | null | 63 | 63 |
from collections import deque
import sys
input=sys.stdin.readline
mod=10**9+7
n,k=map(int,input().split())
A=list(map(int,input().split()))
cnt=k
B,C=[],[]
for i in range(n):
num=A[i]
if num>=0:B.append(num)
else:C.append(num)
B.sort(reverse=True)
C.sort()
B,C=deque(B),deque(C)
ans,flag=1,1
while k!=0:
num=0
length_B,length_C=len(B),len(C)
if k>=2:
if length_B>=2 and length_C>=2:
plus=B[0]*B[1]
negative=C[0]*C[1]
if plus>negative:
ans *=B.popleft()
num=1
else:ans *=C.popleft()*C.popleft()
elif length_C>=2:ans *=C.popleft()*C.popleft()
elif length_B>=2:ans *=B.popleft()*B.popleft()
else:
ans *=B.popleft()*C.popleft()
flag=0
k -=2-num
else:
if 0<length_B:ans *=B.popleft()
elif 0<length_C:
ans *=C.popleft()
flag=0
k -=1
ans %=mod
if flag:print(ans);exit()
ans=1
A=sorted(A,key=lambda x:abs(x))
for i in range(cnt):
ans *=A[i]
ans %=mod
print(ans)
|
def main():
n, k = map(int, input().split())
a = sorted([int(i) for i in input().split()], reverse=True)
mod = 10**9 + 7
p = 1
if n == k:
for ai in a:
p = p * ai % mod
print(p)
return
if a[0] < 0 and k % 2:
for ai in a[:k]:
p = p * ai % mod
print(p)
return
b = sorted([(abs(ai), ai) for ai in a], reverse=True)
s = 0
for ba, bb in b[:k]:
p = p * ba % mod
if bb < 0:
s += 1
if s % 2 == 0:
print(p)
return
pa, na, pb, nb = [-1] * 4
for ba, bb in b[:k]:
if bb < 0:
na = ba
else:
pa = ba
for ba, bb in b[k:][::-1]:
if bb < 0:
nb = ba
else:
pb = ba
if pa == -1 or nb == -1:
print(p * pb * pow(na, mod - 2, mod) % mod)
elif pb == -1 or na == -1:
print(p * nb * pow(pa, mod - 2, mod) % mod)
elif pa * pb > na * nb:
print(p * pb * pow(na, mod - 2, mod) % mod)
else:
print(p * nb * pow(pa, mod - 2, mod) % mod)
if __name__ == '__main__':
main()
| 1 | 9,450,437,358,582 | null | 112 | 112 |
N, K = map(int, input().split())
X = list(map(int, input().split()))
ub = 10 ** 9 + 7
lb = 0
while ub - lb > 1:
mid = (ub + lb) // 2
cnt = 0
for v in X:
cnt += -(-v // mid) - 1
if cnt <= K:
ub = mid
else:
lb = mid
print(ub)
|
for j in range(1,10,1):
for k in range(1,10,1):
print("{}x{}={}".format(j,k,j*k))
| 0 | null | 3,220,157,013,580 | 99 | 1 |
class Stack():
def __init__(self):
self.el = []
def add(self, el):
self.el.append(el)
def pop(self):
return self.el.pop()
def isEmpty(self):
if len(self.el) == 0:
return True
else:
return False
a = raw_input().split()
#print a
st = Stack()
for index in range(len(a)):
#print a[index]
if a[index] in ['+', '-', '*']:
num1 = st.pop()
num2 = st.pop()
if a[index] == '+':
st.add(int(num1) + int(num2))
elif a[index] == '-':
st.add(int(num2) - int(num1))
else:
st.add(int(num1) * int(num2))
else:
st.add(a[index])
#print st.el
ans = st.pop()
print ans
|
cnt=0
radi=0
x=int(input())
while True:
cnt+=1
radi+=x
radi%=360
if radi==0:
print(cnt)
break
| 0 | null | 6,514,085,411,580 | 18 | 125 |
from collections import defaultdict
d = defaultdict(lambda: 0)
N = int(input())
for _ in range(N):
ord, str = input().split()
if ord == 'insert':
d[str] = 1
else:
if str in d:
print('yes')
else:
print('no')
|
import sys
import time
t = time.time()
n = int(input())
a = list(map(int, input().split(' ')))
b = list(range(n))
b.sort(key=lambda x: -a[x])
# print("b after:", b)
# print(list(map(lambda x:a[x],b)))
# print(time.time()-t)
cache = [[-1 for x in range(n)] for y in range(n)]
# print(cache)
def dfs(left, right):
if left > right:
return 0
if cache[left][right] != -1:
return cache[left][right]
which = n-(right-left+1)
ans1 = dfs(left+1, right)+abs(left-b[which])*a[b[which]]
ans2 = dfs(left, right-1)+abs(right-b[which])*a[b[which]]
cache[left][right] = max(ans1, ans2)
return cache[left][right]
sys.setrecursionlimit(2010)
print(dfs(0, n-1))
| 0 | null | 16,760,498,731,190 | 23 | 171 |
n,m = map(int,input().split())
par = []
for i in range(n):
par.append(-1) #初期親
rank = [1 for i in range(n)] #初期ランク
cut = []
def find(n): #親検索andランク短縮
global cut
if par[n] < 0:
for i in range(len(cut)):
par[cut[i]] = n
cut = []
return n
else:
cut.append(n)
find(par[n])
return find(par[n])
def shorten(n): # 根に直接接続する
global cut
if par[n] < 0:
for i in range(len(cut)):
par[cut[i]] = n
cut = []
else:
cut.append(n)
shorten(par[n])
def unite(a,b): #グループ併合
x = find(a)
y = find(b) #根っこ同士をくっつける
if x == y:
return #既に同一ユニオンなら何もしない
if rank[x] < rank[y]:
par[y] += par[x]
par[x] = y
elif rank[x] == rank[y]:
par[x] += par[y]
par[y] = x
rank[x] += 1
else:
par[x] += par[y]
par[y] = x
def judge(a,b):
return par[a] == par[b]
for i in range(m):
a,b = map(int,input().split())
a -= 1
b -= 1
unite(a,b)
ans = 0
for i in range(n):
ans = max(ans,-par[i])
print(ans)
|
N,M=map(int,input().split())
par=[i for i in range(N)]
size=[1 for i in range(N)]
def find(x):
if par[x]==x:
return x
else:
par[x]=find(par[x])
return par[x]
def union(a,b):
x=find(a)
y=find(b)
if x!=y:
if size[x]<size[y]:
par[x]=par[y]
size[y]+=size[x]
else:
par[y]=par[x]
size[x]+=size[y]
else:
return
for i in range(M):
a,b=map(int,input().split())
union(a-1,b-1)
print(max(size))
| 1 | 3,969,414,580,452 | null | 84 | 84 |
import datetime
def main():
H1, M1, H2, M2, K = map(int,input().split())
start = H1 * 60 + M1
end = H2 * 60 + M2
ans = end - start - K
print(ans)
if __name__ == "__main__":
main()
|
a, b, c, d, K = map(int, input().split())
hour = (c-a) * 60
min = d - b
ans = hour + min - K
print(ans)
| 1 | 17,930,461,527,680 | null | 139 | 139 |
n, m, l = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(n)]
b = [list(map(int, input().split())) for i in range(m)]
for i in range(n):
line = []
for j in range(l):
c = 0
for k in range(m):
c += a[i][k] * b[k][j]
line.append(str(c))
print(*line)
|
n, m, l = map(int, input().split())
A = []
B = []
for i in range(n):
A.append([int(j) for j in input().split()])
for i in range(m):
B.append([int(j) for j in input().split()])
# ??????????????????????????????B?????¢??????????????¨???????????????
B_T = list(map(list, zip(*B)))
C = [[0 for j in range(l)] for i in range(n)]
for i in range(n):
for j in range(l):
C[i][j] = sum([a * b for (a, b) in zip(A[i], B_T[j])])
for i in range(n):
print(*C[i])
| 1 | 1,409,018,462,868 | null | 60 | 60 |
M=10**9+7
n,k=map(int,input().split())
l=[1]
f=1
for i in range(n):
f=f*(i+1)%M
l+=[f]
a=0
for i in range(min(n,k+1)):
c=l[n]*l[n-1]%M
p=l[i]**2*l[n-i]*l[n-i-1]%M
a+=c*pow(p,M-2,M)
print(a%M)
|
def main():
K, X = map(int, input().split())
if 500 * K >= X:
ans = "Yes"
else:
ans = "No"
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 82,832,302,352,944 | 215 | 244 |
def insertionSort(A, N):
for i in range(1, N):
print (*A)
v = A[i]
j = i - 1
while j>= 0 and A[j] > v:
A[j+1] = A[j]
j -= 1
A[j+1] = v
return A
if __name__ == "__main__":
N = int(input())
A = [int(i) for i in input().split()]
print (*insertionSort(A, N))
|
a,b,c,d=map(int,input().split())
x=[]*4
x.append(a*c)
x.append(b*c)
x.append(a*d)
x.append(b*d)
x.sort()
print(x[-1])
| 0 | null | 1,544,040,680,030 | 10 | 77 |
n = int(input())
A = list(map(int,input().split()))
q = int(input())
M = list(map(int, input().split()))
d = {}
def solve(i, m):
if m == 0:
return True
if i >= n:
return False
if (i, m) in d:
return d[i, m]
res = solve(i + 1, m) or solve(i + 1, m - A[i])
d[i,m] = res
return res
for m in M:
if solve(0, m):
print('yes')
else:
print('no')
|
from itertools import combinations
n = int(input())
a = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))
answer = ['no']*q
for i in range(1, n+1):
for nums in combinations(a, i):
val = sum(nums)
if val in m:
index = [i for i, num in enumerate(m) if val == num]
for i in index:
answer[i] = 'yes'
for i in answer:
print(i)
| 1 | 95,506,613,848 | null | 25 | 25 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
15 6
1 2 7 8 12 50
output:
2
"""
import sys
def solve():
rec[0] = 0
for i in range(c_num):
for j in range(money - coins[i] + 1):
rec[j + coins[i]] = min(rec[j + coins[i]], rec[j] + 1)
return rec
if __name__ == '__main__':
_input = sys.stdin.readlines()
money, c_num = map(int, _input[0].split())
coins = list(map(int, _input[1].split()))
assert len(coins) == c_num
rec = [float('inf')] * (money + 1)
ans = solve()
print(ans[-1])
|
n,m=map(int,input().split())
c=list(map(int,input().split()))
c.sort(reverse=True)
#print(c)
dp=[0]
for i in range(1,n+1):
mini=float("inf")
for num in c:
if i-num>=0:
mini=min(mini,dp[i-num]+1)
dp.append(mini)
#print(dp)
print(dp[-1])
| 1 | 141,976,767,842 | null | 28 | 28 |
n = int(input().rstrip())
def calc(target):
result = 0
count = 0
if target % 2 == 0:
print(-1)
return
for i in range(n):
result = (result * 10 + 7) % target
count += 1
if result == 0:
print(count)
return
print(-1)
calc(n)
|
K = int(input())
if K % 2 == 0 or K % 5 == 0:
print(-1)
else:
i = 1
r = 7 % K
while(True):
if r == 0:
print(i)
break
r = (r * 10 + 7) % K
i += 1
| 1 | 6,138,984,894,898 | null | 97 | 97 |
t=input()
ans=str()
tmp=""
for s in t:
if s=="P" or s=="D":
ans+=s
tmp=s
else:
ans+="D"
tmp="D"
print(ans)
|
n = int(input())
lst = [[0 for j in range(10)] for i in range(10)]
for i in range(1, n+1):
num = str(i)
lst[int(num[0])][int(num[-1])] += 1
cnt = 0
for i in range(10):
for j in range(i, 10):
if i == j:
cnt += lst[i][j] * lst[j][i]
else:
cnt += lst[i][j] * lst[j][i] * 2
print(cnt)
| 0 | null | 52,769,082,477,238 | 140 | 234 |
while True:
H,W = list(map(int, input().split()))
if (H == 0 and W == 0):
break
else:
for n in range(H):
s = ""
for m in range(W):
if (0 < n and n < H-1) and (0 < m and m < W-1):
s += "."
else:
s += "#"
print(s)
print("")
|
# https://atcoder.jp/contests/abc165/tasks/abc165_c
from itertools import combinations_with_replacement
N, M, Q = map(int, input().split())
data = []
for _ in range(Q):
data.append(list(map(int, input().split())))
res = []
for A in combinations_with_replacement(range(1,M+1), N):
score = 0
for i in range(Q):
a,b,c,d = data[i]
if A[b-1] - A[a-1] == c:
score += d
res.append(score)
print(max(res))
| 0 | null | 14,281,480,479,522 | 50 | 160 |
N = int(input())
S = input()
ans = ""
for i in range(len(S)):
ans += chr(int(ord("A"))+(int(ord(S[i])+N)-int(ord("A")))%26)
print(ans)
|
#!/usr/bin/env python
x = int(input())
n = x//100
for i in range(n+1):
tmp = x
tmp -= i*100
if 5*i >= tmp:
print(1)
exit()
print(0)
| 0 | null | 130,799,958,224,412 | 271 | 266 |
import numpy as np
x, y, a, b, c = map(int, input().split())
p = np.array(list(map(int, input().split())))
q = np.array(list(map(int, input().split())))
r = np.array(list(map(int, input().split())))
p.sort()
q.sort()
r.sort()
ans = p[-x:].sum()+q[-y:].sum()
p_cnt = 0
q_cnt = 0
r_cnt = 0
while not(-x+p_cnt == 0 and -y+q_cnt == 0) and -1-r_cnt >= -c:
if -x+p_cnt == 0:
if r[-1-r_cnt] > q[-y+q_cnt]:
ans += r[-1-r_cnt] - q[-y+q_cnt]
q_cnt += 1
r_cnt += 1
else:
break
elif -y+q_cnt == 0:
if r[-1-r_cnt] > p[-x+p_cnt]:
ans += r[-1-r_cnt] - p[-x+p_cnt]
p_cnt += 1
r_cnt += 1
else:
break
elif p[-x+p_cnt] <= q[-y+q_cnt] and r[-1-r_cnt] > p[-x+p_cnt]:
ans += r[-1-r_cnt] - p[-x+p_cnt]
p_cnt += 1
r_cnt += 1
elif p[-x+p_cnt] > q[-y+q_cnt] and r[-1-r_cnt] > q[-y+q_cnt]:
ans += r[-1-r_cnt] - q[-y+q_cnt]
q_cnt += 1
r_cnt += 1
else:
break
print(ans)
|
r = input()
suq = int(r) * int(r)
print(suq)
| 0 | null | 94,855,991,750,300 | 188 | 278 |
n=int(input())
a=list(map(int,input().split()))
tot=sum(a)
b=0
c=10**10
d=0
for i in range(n):
b+=a[i]
d=abs(tot/2 - b)
if d<c:
c=d
print(int(2*c))
|
s = input()
ans = 0
if "RRR" == s:
ans = 3
elif "RR" in s:
ans = 2
elif "R" in s:
ans = 1
print(ans)
| 0 | null | 73,795,673,433,548 | 276 | 90 |
import sys
n = int(input())
x = sorted(list(map(int, input().split())))
if len(list(set(x))) == 1:
print(0)
sys.exit()
if n == 1:
print(0)
sys.exit()
x_min = x[0]
x_max = x[n-1]
min_sum = 10000000
for p in range(x_min, x_max):
sum = 0
for e in x:
len = (e - p)**2
sum += len
# print("p", p, "sum", sum, "min_sum", min_sum)
if sum <= min_sum:
min_sum = sum
print(min_sum)
|
[a,b] = input().split()
a = int(a)
b= int(b)
if(a == b):
print('a == b')
elif(a > b):
print("a > b")
else:
print("a < b")
| 0 | null | 32,745,083,905,290 | 213 | 38 |
n,m = map(int,input().split())
print("Yes" if n == m else "No")
|
N,M=input().split()
N=int(N)
M=int(M)
if N==M:
print("Yes")
else:
print("No")
| 1 | 82,929,789,070,432 | null | 231 | 231 |
n,a,b = map(int,input().split())
# (2**n-1)-nCa-nCb
mod = 10**9+7
M = pow(2,n,mod)-1
def comb(v):
ans = 1
for i in range(1,v+1):
ans *= n-i+1
ans *= pow(i,mod-2,mod)
ans %= mod
return ans
print((M-comb(a)-comb(b))%mod)
|
MOD = pow(10, 9)+7
def combi(n, k, MOD):
numer = 1
for i in range(n, n-k, -1):
numer *= i
numer %= MOD
denom = 1
for j in range(k, 0, -1):
denom *= j
denom %= MOD
return (numer*(pow(denom, MOD-2, MOD)))%MOD
def main():
n, a, b = map(int, input().split())
allsum = pow(2, n, MOD)
s1 = combi(n, a, MOD)
s2 = combi(n, b, MOD)
ans = (allsum - s1 - s2 - 1)%MOD
print(ans)
if __name__ == "__main__":
main()
| 1 | 66,016,433,668,352 | null | 214 | 214 |
import sys
from itertools import accumulate
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *D = map(int, read().split())
csum = accumulate(D)
ans = sum(s * d for s, d in zip(csum, D[1:]))
print(ans)
return
if __name__ == '__main__':
main()
|
N = int(input())
D = list(map(int, input().split()))
from itertools import combinations
ans = 0
for i , j in combinations(D,2):
ans += i*j
print(ans)
| 1 | 168,977,983,543,760 | null | 292 | 292 |
#coding:UTF-8
def BS(N,A):
count=0
flag=True
while flag==True:
flag=False
for i in range(1,N):
if A[N-i]<A[N-i-1]:
swap=A[N-i]
A[N-i]=A[N-i-1]
A[N-i-1]=swap
flag=True
count+=1
for i in range(len(A)):
A[i]=str(A[i])
print(" ".join(A))
print(count)
if __name__=="__main__":
N=int(input())
a=input()
A=a.split(" ")
for i in range(len(A)):
A[i]=int(A[i])
BS(N,A)
|
# -*- coding: utf-8 -*-
import math
r = float( input() )
area = r * r * math.pi
circle = 2 * r * math.pi
print(format(area, '.10f'), format(circle, '.10f'))
| 0 | null | 320,058,341,604 | 14 | 46 |
x = int(input())
y = 10**4
for i in range(y):
for j in range(-y,y):
if i ** 5 - j ** 5 == x:
print(i, j)
exit()
|
x = int(input())
print((1000 - x % 1000) % 1000)
| 0 | null | 16,902,770,652,988 | 156 | 108 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
visited = [-1 for _ in range(N)]
visited[0] = 0
k = 0
k = A[k] - 1
count = 0
while visited[k] == -1:
count += 1
visited[k] = count
k = A[k]-1
roop = count - visited[k] + 1
beforeroop = visited[k]
if K < beforeroop:
k = 0
for _ in range(K):
k = A[k] - 1
print(k+1)
else:
K = K - beforeroop
K = K % roop
for _ in range(K):
k = A[k]-1
print(k+1)
|
N, K = map(int,input().split())
As = list(map(int,input().split()))
visited = [0] * N
path = []
now_town = 1
while(True):
visited[now_town-1] = 1
path.append(now_town)
now_town = As[now_town-1]
if visited[now_town-1] == 1:
break
index = path.index(now_town)
loop = path[index:len(path)]
loop_len = len(loop)
if index < K:
k = K - index
r = k % loop_len
print(loop[r])
else:
print(path[K])
| 1 | 22,788,970,236,490 | null | 150 | 150 |
import sys
import numpy as np
mod=10**9+7
n=int(sys.stdin.buffer.readline())
a=np.fromstring(sys.stdin.buffer.readline(),dtype=np.int64,sep=' ')
ans=0
b=1
for i in range(60):
s=int((a&1).sum())
ans=(ans+s*(n-s)*b)%mod
a>>=1
b=b*2%mod
print(ans)
|
N = int(input())
s = 0
for i in range(1,N+1):
if i%2 != 0:
s += 1
print(s/N)
| 0 | null | 149,873,175,904,860 | 263 | 297 |
S = input()[::-1]
## 余りを0~2018で総数保持
counts = [0]*2019
## 0桁の余りは0
counts[0] = 1
num, d = 0, 1
for c in S:
## 右から~桁の数字
num += int(c) * d
num %= 2019
## 次の桁
d *= 10
d %= 2019
counts[num] += 1
ans = 0
for cnt in counts:
## nC2の計算
ans += cnt * (cnt-1) //2
print(ans)
|
S = input().strip()
N = len(S)
A = [0 for _ in range(N)]
B = [0 for _ in range(N)]
B[0] = 1
for i in range(1,N):
B[i] = (B[i-1]*10)%2019
a = 0
for i in range(N-1,-1,-1):
a = (int(S[i])*B[N-1-i]+a)%2019
A[i] = a
C = {i:0 for i in range(2019)}
for i in range(N):
C[A[i]] += 1
cnt = C[0]
for i in range(2019):
cnt += (C[i]*(C[i]-1))//2
print(cnt)
| 1 | 30,746,717,582,980 | null | 166 | 166 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
x, n, *p = map(int, read().split())
sa = 10000
r = 10000
for i1 in range(-101, 202):
if i1 not in p:
if abs(x - i1) < sa:
sa = abs(x - i1)
r = i1
print(r)
if __name__ == '__main__':
main()
|
import sys
x,n = map(int,input().split())
p = list(map(int,input().split()))
s = 100
min_i = -1
if x not in p:
print(x)
sys.exit()
for i in range(-1,102):
if i not in p and abs(i-x) < s:
s = abs(i-x)
min_i = i
print(min_i)
| 1 | 14,067,860,135,360 | null | 128 | 128 |
n,m = map(int,input().split())
h = list(map(int,input().split()))
l = list({i} for i in range(n+1))
for i in range(m):
a,b = map(int,input().split())
l[a].add(b)
l[b].add(a)
for i in range(len(l)):
l[i] = list(l[i])
good = set()
for i in range(1,len(l)):
l[i].remove(i)
for j in range(len(l[i])):
if h[l[i][j]-1] >= h[i-1]:
break
else:
good.add(i)
print(len(good))
|
N, M, *HAB = map(int, open(0).read().split())
H, AB = [0] + HAB[:N], HAB[N:]
good = [False] + [True] * N
for a, b in zip(*[iter(AB)] * 2):
if H[a] >= H[b]:
good[b] = False
if H[b] >= H[a]:
good[a] = False
print(sum(good))
| 1 | 25,044,039,891,930 | null | 155 | 155 |
s = input()
#print(s.replace("?", "D"))
ans = []
for i in s:
if i == "P":
ans.append("P")
else:
ans.append("D")
print("".join(ans))
|
S = list(str(input()))
for i in range(len(S)-1):
if i == 0 and S[0] == '?':
if S[i+1] == 'P':
S[0] = 'D'
else:
S[0] = 'P'
if S[i] == '?':
if S[i+1] == 'P':
S[i] = 'D'
else:
if S[i-1] == 'P':
S[i] = 'D'
else:
S[i] = 'P'
if S[len(S)-1] == '?':
S[len(S)-1] = 'D'
strS = "".join(S)
print(strS)
| 1 | 18,559,083,999,680 | null | 140 | 140 |
N,A,B = map(int,input().split())
kotae= N//(A+B)*A
am = N%(A+B)
if am>A:
am=A
print(kotae+am)
|
N,A,B = map(int, input().split())
C = A + B
print(min(A, N%C) + N//C * A)
| 1 | 55,515,555,455,072 | null | 202 | 202 |
x,n=map(int,input().split())
*p,=map(int,input().split())
q=[0]*(102)
for pp in p:
q[pp]=1
diff=1000
ans=-1
for i in range(0,102):
if q[i]:
continue
cdiff=abs(i-x)
if cdiff<diff:
diff=cdiff
ans=i
print(ans)
|
x,n = map(int,input().split())
if n == 0:
print(x)
else:
p = list(map(int,input().split()))
k = [i for i in range(-200,201)]
for i in range(n):
if p[i] in set(k):
k.remove(p[i])
minimum = 99999
ans = 0
for i in range(len(k)):
if abs(k[i] - x ) < minimum :
minimum = abs(k[i] - x)
ans = k[i]
print(ans)
| 1 | 13,956,559,193,518 | null | 128 | 128 |
import sys
a = list(map(int,input().split()))
b = list(map(int,input().split()))
t = int(input())
if a[1] <= b[1]:
print('NO')
sys.exit()
elif abs(a[0]-b[0])/abs(a[1]-b[1]) <= t:
print('YES')
sys.exit()
else:
print('NO')
|
p1 , s1=map(int , input().split())
p2 , s2=map(int , input().split())
t=int(input())
if abs(p1-p2) > t*(s1-s2):
print("NO")
else:
print("YES")
| 1 | 14,979,722,770,648 | null | 131 | 131 |
num = raw_input()
num = num.split()
a = int(num[0])
b = int(num[1])
if a < b:
print "a < b"
elif a > b:
print "a > b"
else:
print "a == b"
|
def solve():
P.sort(reverse = True)
M.sort()
P.append(-1)
M.append(1) # add endpoint
p, m = [], []
while len(p) + len(m) < k:
if P[len(p)] < -M[len(m)]:
m.append(M[len(m)])
else:
p.append(P[len(p)])
if len(m)%2 == 0: return p + m
exist_p = len(p) > 0
exist_m = len(m) > 0
remain_P = len(P) - 1 > len(p)
remain_M = len(M) - 1 > len(m)
if exist_p & remain_M & exist_m & remain_P:
if abs(p[-1] * P[len(p)]) < abs(m[-1] * M[len(m)]):
p.pop()
m.append(M[len(m)])
else:
m.pop()
p.append(P[len(p)])
elif exist_p & remain_M:
p.pop()
m.append(M[len(m)])
elif exist_m & remain_P:
m.pop()
p.append(P[len(p)])
else:
M.pop() # del endpoint
m = sorted(M, reverse = True)[:k]
return p + m
n, k = map(int, input().split())
P, M = [], [] # plus, minus
for a in map(int, input().split()):
if a < 0: M.append(a)
else: P.append(a)
ans, MOD = 1, 10**9 + 7
for a in solve(): ans *= a; ans %= MOD
ans += MOD; ans %= MOD
print(ans)
| 0 | null | 4,920,361,876,540 | 38 | 112 |
# -*- coding: utf-8 -*-
def main():
from math import gcd
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
max_a = 10 ** 6
numbers = [0 for _ in range(max_a + 1)]
# KeyInsight:
# 調和級数: 計算量 O(AlogA)
# ◯: 素因数分解をすればよいことには気がつけた。
# △: 4ケースWA・TLEが取れず
for ai in a:
numbers[ai] += 1
is_pairwise = True
# 素因数の判定
# 素因数の倍数の要素を数えている
for i in range(2, max_a + 1):
count = 0
for j in range(i, max_a + 1, i):
count += numbers[j]
# 2つ以上ある数の倍数があった場合は、少なくともpairwiseではない
if count > 1:
is_pairwise = False
if is_pairwise:
print("pairwise coprime")
exit()
value_gcd = 0
# 全ての要素のGCDが1かどうかを判定
for i in range(n):
value_gcd = gcd(value_gcd, a[i])
if value_gcd == 1:
print("setwise coprime")
exit()
print("not coprime")
if __name__ == '__main__':
main()
|
X = list(map(int,input().split()))
num = 1
for i in X:
if i == 0:
print(num)
num += 1
| 0 | null | 8,818,415,542,752 | 85 | 126 |
h,n= map(int, input().split())
p = [list(map(int, input().split())) for _ in range(n)]
m = 10**4
dp = [0]*(h+m+1)
for i in range(m+1,h+m+1):
dp[i] = min(dp[i-a] + b for a,b in p)
print(dp[h+m])
|
from sys import stdin
input = stdin.readline
def main():
H, N = list(map(int, input().split()))
A = [0]*N
B = [0]*N
for i in range(N):
A[i], B[i] = map(int, input().split())
# dp = [[0]*(H+1) for _ in range(N+1)]
dp = [0]*(H+1)
for j in range(H+1):
dp[j] = float('inf')
dp[0] = 0
for i in range(1, N+1):
for j in range(1, H+1):
# dp[i][j] = dp[i-1][j]
if j > A[i-1]:
dp[j] = min(dp[j], dp[j-A[i-1]]+B[i-1])
else:
dp[j] = min(dp[j], B[i-1])
# for i in range(N+1):
# print(dp[i])
print(dp[H])
if(__name__ == '__main__'):
main()
| 1 | 81,121,456,813,870 | null | 229 | 229 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
l = 0
r = max(A)
while l + 1 < r:
m = (l+r)//2
n = sum([(x-1)//m for x in A])
if n > K:
l = m
else:
r = m
print(r)
|
import sys
import math
import itertools
import collections
from collections import deque
from collections import defaultdict
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
MOD2 = 998244353
INF = float('inf')
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def main():
N, K = NMI()
A = NLI()
ng = 0 #ng:とり得る最小の値-1
ok = 10**9+10 #ok:とり得る最大の値+1
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
cut = 0
for a in A:
if a % mid == 0:
cut += math.floor(a/mid)-1
else:
cut += math.floor(a/mid)
if cut <= K:
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
main()
| 1 | 6,454,749,174,660 | null | 99 | 99 |
N, K = map(int, input().split())
P = sorted([int(i) for i in input().split()])
print(sum(P[:K]))
|
S = input()
T = input()
N = len(S)
cnt = 0
for i in range(N):
if S[i] != T[i]:
cnt += 1
else:
cnt += 0
print(cnt)
| 0 | null | 11,127,563,484,270 | 120 | 116 |
def main():
H1,M1,H2,M2,K = map(int,input().split())
time1 = H1*60 + M1
time2 = H2*60 + M2
time = time2-time1
ans = time-K
return ans
print(main())
|
a=list(map(int, input().split(' ')))
# 起きてる時間（分）の計算
h=a[2]-a[0]
m=a[3]-a[1]
mt=h*60+m
# 時間の表示
print(mt-a[4])
| 1 | 18,225,922,176,600 | null | 139 | 139 |
X,Y=list(map(int, input().split()))
a=(2*X-Y)//3
b=(2*Y-X)//3
if not (2*a+b==X and a+2*b==Y and a>=0 and b>=0):
print(0)
exit()
C=10**9+7
A=1
B=1
D=1
for i in range(a):
A*=i+1
A=A%C
for j in range(b):
B*=j+1
B=B%C
for k in range(a+b):
D*=k+1
D=D%C
D*=pow(A,C-2,C)
D*=pow(B,C-2,C)
print(D%C)
|
MOD = 10**9 + 7
MAX = 10**6
X, Y = map(int, input().split())
m, n = 2*Y-X, 2*X-Y
if (X+Y) % 3 != 0 or m%3!=0 or n%3!=0 or m<0 or n<0:
print(0)
exit()
m //= 3
n //= 3
fac, inv = [0]*MAX, [0]*MAX
fac[0] = 1
for i in range(1, MAX):
fac[i] = fac[i-1] * i % MOD
inv[-1] = pow(fac[-1], MOD-2, MOD)
for i in range(MAX-2, 0, -1):
inv[i] = inv[i+1] * (i+1) % MOD
def com(n, k):
if n<k:return 0
if n<0 or k<0:return 0
if n==k or k==0:return 1
return int(fac[n] * (inv[k]*inv[n-k]%MOD) % MOD)
print(com(n=m+n,k=n))
| 1 | 149,316,712,997,410 | null | 281 | 281 |
import math
from functools import reduce
def gcd_list(numbers):
return reduce(math.gcd, numbers)
N=int(input())
A=list(map(int,input().split()))
mA = max(A)
D = [-1]*(mA+1)
D[0]=1
D[1]=1
for i in range(2,mA+1):
if D[i] != -1: continue
D[i] = i
cnt = 2*i
while cnt < mA+1:
if D[cnt] == -1:
D[cnt]=i
cnt += i
done = set()
for a in A:
tmp = set()
while a > 1:
tmp.add(D[a])
a //= D[a]
if len(done&tmp) > 0:
if gcd_list(A) == 1: print('setwise coprime')
else: print('not coprime')
exit()
done |= tmp
print('pairwise coprime')
|
from collections import defaultdict
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
# 素因数分解、リストで返す
#############################################################
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
a.sort()
return a
#############################################################
primes = defaultdict(int)
for i in range(N):
p = prime_factorize(A[i])
p_set = set(p)
for pi in p_set:
primes[pi] += 1
# 全て1の時、primesが空になってmaxが取れない
if len(primes) == 0:
print("pairwise coprime")
exit()
max_cnt = max(primes.values())
# min_cnt = min(primes.values())
if max_cnt == 1:
print("pairwise coprime")
elif max_cnt != N:
print("setwise coprime")
else:
print("not coprime")
| 1 | 4,061,065,761,270 | null | 85 | 85 |
import sys
for line in sys.stdin:
l = line.replace('\n', '')
a, b = l.split()
a = int(a)
b = int(b)
print(len(str(a+b)))
|
while True:
try:
a,b=[int(i) for i in input().split()]
print(len(str(a+b)))
except:
break
| 1 | 66,571,076 | null | 3 | 3 |
N = int(input())
A = list(map(int,input().split()))
from collections import Counter
ctr = Counter(A)
tmp = sum(v*(v-1)//2 for v in ctr.values())
for a in A:
print(tmp - ctr[a] + 1)
|
import sys
s = ''
for line in sys.stdin:
s += line
s = s.lower()
count = {letter: s.count(letter) for letter in set(s)}
for c in range(97,97+26):
if chr(c) in count:
print("%c : %d" % (chr(c), count[chr(c)]))
else:
print("%c : 0" % chr(c))
| 0 | null | 24,846,481,078,660 | 192 | 63 |
from collections import defaultdict
from math import gcd
n = int(input())
zeros = 0
d = defaultdict(lambda: [0, 0])
for _ in range(n):
a, b = map(int, input().split())
if a == 0 and b == 0:
zeros += 1
continue
g = gcd(a, b)
a, b = a // g, b // g
if a == 0:
b = 1
if b == 0:
a = 1
if b < 0:
a, b = -a, -b
if a <= 0:
d[(b, -a)][1] += 1
else:
d[(a, b)][0] += 1
mod = 1000000007
ans = 1
for v in d.values():
ans = ans * (pow(2, v[0], mod) + pow(2, v[1], mod) - 1) % mod
ans = (ans - 1 + zeros) % mod
print(ans)
|
from math import gcd
n = int(input())
ab = [list(map(int, input().split())) for _ in range(n)]
mod = 1000000007
#%%
kai = [1]*(n+1)
gyaku = [1]*(n+1)
for i in range(2, n+1):
kai[i] = kai[i-1]*i % mod
gyaku[i] = gyaku[i-1]*pow(i, mod-2, mod) %mod
azero = 0
bzero = 0
zerozero = 0
dict_patterns = {}
dict_patterns_minus = {}
all_effective = 0
answer = 0
dict_patterns["1,0"] = 0
dict_patterns["0,-1"] = 0
for i in range(n):
minus = False
a, b = ab[i]
if a == 0 and b == 0:
zerozero += 1
continue
elif b == 0:
dict_patterns["1,0"] += 1
continue
elif a == 0:
dict_patterns["0,-1"] += 1
continue
common = gcd(a,b)
a = a//common
b = b//common
#%%
if a < 0 and b < 0:
a = -a
b = -b
elif a < 0:
a = -a
b = -b
to_str = str(a)+","+str(b)
if to_str not in dict_patterns:
dict_patterns[to_str] = 1
else:
dict_patterns[to_str] += 1
keys = list(dict_patterns.keys())
patterns = []
test = []
for i in range(len(keys)):
pattern_A = dict_patterns[keys[i]]
dict_patterns[keys[i]] = 0
pattern_B = 0
a, b = map(int, keys[i].split(","))
if str(b)+","+str(-a) in dict_patterns:
pattern_B += dict_patterns[str(b)+","+str(-a)]
dict_patterns[str(b)+","+str(-a)] = 0
if str(-b)+","+str(a) in dict_patterns:
pattern_B += dict_patterns[str(-b)+","+str(a)]
dict_patterns[str(-b)+","+str(a)] = 0
if pattern_A != 0 or pattern_B != 0:
patterns.append(max(2**pattern_A-1,0) + max(2**pattern_B-1,0)+1)
test.append([pattern_A, pattern_B])
answer = 1
for i in range(len(patterns)):
answer = answer*patterns[i] % mod
print((answer-1+zerozero)%mod)
| 1 | 20,971,316,127,850 | null | 146 | 146 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def f(x):
cnt = 0
while x%2 == 0:
cnt += 1
x //= 2
return cnt
def lcm(x,y):
return x*y//math.gcd(x,y)
n,m = inpl()
a = inpl()
a = list(set(a))
c = list(set([f(x) for x in a]))
if len(c) != 1:
print(0)
quit()
c = c[0]
x = 1
for i in range(len(a)):
x = lcm(a[i]//2, x)
# print(x)
print((m+x)//(2*x))
|
n, m = map( int, input().split() )
a = list( map( int, input().split() ) )
def f( a_k ): # 2で割り切れる回数
count = 0
while a_k % 2 == 0:
count += 1
a_k = a_k // 2
return count
b = []
f_0 = f( a[ 0 ] )
for a_k in a:
f_k = f( a_k )
if f_k != f_0:
print( 0 )
exit()
b.append( a_k // pow( 2, f_k ) )
import math
def lcm( x, y ):
return x * y // math.gcd( x, y )
b_lcm = 1
for b_k in b:
b_lcm = lcm( b_lcm, b_k )
a_lcm = b_lcm * pow( 2, f_0 )
# print( b_lcm, f_0, b )
print( ( m + a_lcm // 2 ) // a_lcm )
| 1 | 101,684,915,055,068 | null | 247 | 247 |
import sys
for line in sys.stdin:
datas =line.split()
if (len(datas)):
v = int(datas[0]) + int(datas[1])
print(len(str(v)))
else:
break
|
n,x,y = map(int,input().split())
l= [0]*n
for i in range(1,n+1):
for j in range(i+1,n+1):
k = min(abs(j-i),abs(x-i)+1+abs(j-y))
l[k] += 1
for k in range(1,n):
print(l[k])
| 0 | null | 22,074,614,186,952 | 3 | 187 |
#
import sys
input=sys.stdin.readline
def main():
N,K=map(int,input().split())
A=list(map(lambda x: int(x)-1,input().split()))
latest=[-1]*N
latest[0]=0
now=0
while(K>0):
K-=1
to=A[now]
if latest[A[now]]!=-1:
K%=latest[now]-latest[A[now]]+1
latest[A[now]]=latest[now]+1
now=to
print(now+1)
if __name__=="__main__":
main()
|
k = input().split()
n1 = int(k[0])
n2 = int(k[1])
ans = n1 * n2
print(ans)
| 0 | null | 19,320,072,630,688 | 150 | 133 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.