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
|
|---|---|---|---|---|---|---|
class Dice(object):
def __init__(self, num):
self.num = num
def rotate_S(self):
self.num = [self.num[4], self.num[0], self.num[2], self.num[3], self.num[5], self.num[1]]
def rotate_N(self):
self.num = [self.num[1], self.num[5], self.num[2], self.num[3], self.num[0], self.num[4]]
def rotate_W(self):
self.num = [self.num[2], self.num[1], self.num[5], self.num[0], self.num[4], self.num[3]]
def rotate_E(self):
self.num = [self.num[3], self.num[1], self.num[0], self.num[5], self.num[4], self.num[2]]
def get_right_num(self, a, b):
top_index = self.num.index(a) + 1
front_index = self.num.index(b) + 1
if [top_index, front_index] in [[2, 3], [3, 5], [5, 4], [4, 2]]:
return self.num[0]
elif [top_index, front_index] in [[1, 4], [4, 6], [6, 3], [3, 1]]:
return self.num[1]
elif [top_index, front_index] in [[1, 2], [2, 6], [6, 5], [5, 1]]:
return self.num[2]
elif [top_index, front_index] in [[1, 5], [5, 6], [6, 2], [2, 1]]:
return self.num[3]
elif [top_index, front_index] in [[1, 3], [3, 6], [6, 4], [4, 1]]:
return self.num[4]
elif [top_index, front_index] in [[2, 4], [4, 5], [5, 3], [3, 2]]:
return self.num[5]
dice = Dice(map(int, raw_input().split()))
Q = input()
for q in range(Q):
num_set = map(int, raw_input().split())
print dice.get_right_num(num_set[0], num_set[1])
|
n = int(input())
lst = list(map(int,input().split()))
num = [0] * n
for i in lst:
num[i-1] += 1
total = 0
for i in range(n):
m = num[i]
total += m*(m-1)//2
for k in range(n):
s = num[lst[k]-1]
t = total + 1- s
print(t)
| 0 | null | 23,971,046,098,692 | 34 | 192 |
list = list(map(int, input().split())) #i_1 i_2を取得し、iに値を入れる
print(15-list[0]-list[1]-list[2]-list[3]-list[4])
|
MOD = 10**9 + 7
class modint():
def __init__(self, value):
self.value = value % MOD
def __int__(self):
return int(self.value)
def __float__(self):
return float(self.value)
def __str__(self):
return str(self.value)
def __repr__(self):
return str(self.value)
def __add__(self, other):
return (modint(self.value + other.value) if isinstance(other, modint)
else modint(self.value + other))
def __sub__(self, other):
return (modint(self.value - other.value) if isinstance(other, modint)
else modint(self.value - other))
def __mul__(self, other):
return (modint(self.value * other.value) if isinstance(other, modint)
else modint(self.value * other))
def __truediv__(self, other):
return (modint(self.value * pow(other.value, MOD - 2, MOD))
if isinstance(other, modint)
else modint(self.value * pow(other, MOD - 2, MOD)))
def __pow__(self, other):
return (modint(pow(self.value, other.value, MOD))
if isinstance(other, modint)
else modint(pow(self.value, other, MOD)))
def __eq__(self, other):
return (self.value == other.value if isinstance(other, modint)
else self.value == (other % MOD))
def __ne__(self, other):
return (self.value == other.value if isinstance(other, modint)
else self.value == (other % MOD))
def __radd__(self, other):
return (modint(other.value + self.value) if isinstance(other, modint)
else modint(other + self.value))
def __rsub__(self, other):
return (modint(other.value - self.value) if isinstance(other, modint)
else modint(other - self.value))
def __rmul__(self, other):
return (modint(other.value * self.value) if isinstance(other, modint)
else modint(other * self.value))
def __rtruediv__(self, other):
return (modint(other.value * pow(self.value, MOD - 2, MOD))
if isinstance(other, modint)
else modint(other * pow(self.value, MOD - 2, MOD)))
def __rpow__(self, other):
return (modint(pow(other.value, self.value, MOD))
if isinstance(other, modint)
else modint(pow(other, self.value, MOD)))
def modinv(self):
return modint(pow(self.value, MOD - 2, MOD))
def main():
import sys
input = sys.stdin.buffer.readline
N = int(input())
A = [int(i) for i in input().split()]
def gcd(x, y):
if y == 0:
return x
while y != 0:
x, y = y, x % y
return x
def lcm(x, y):
return x*y//gcd(x, y)
num = 1
for a in A:
num = lcm(num, a)
n = modint(num)
ans = 0
for i, a in enumerate(A):
ans += n/a
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 50,716,306,561,468 | 126 | 235 |
'''
着想：大きいaほど左右の端に移動したい、小さいaを先に端にやるより必ず大きくなるから
問題：単純に貪欲に大きいaから左端(x-1)と右端(N-x)の大きい方に移動すると、
残りのaの組み合わせ的に最適でない場合がある
アイテムの左右端の単純な割り振りはO(2^N)
解決策の着想：大きい順のk個を(k=L+R)となる
左L個右R個にどのように割り振っても(k+1)個目の最適な割り振り方は変わらない
解決策：アイテムk個左右に割り振る状態をdp[L][R]で保存O(N^2)
'''
def solve():
N = int(input())
A = [[a, i] for a,i in zip(map(int, input().split()), range(N))]
A.sort(key=lambda a: a[0], reverse=True)
dp = [[0]*(N+1) for _ in range(N+1)] # 左からxマス右からyマス埋める
for i in range(0,N):
a, l = A[i]
for x in range(0,i+1):
y = i - x # 合計x+y=iマス既に埋まっている、次にi+1マス目を考える
dp[x+1][y] = max(dp[x+1][y], dp[x][y] + a * abs(l - x))
dp[x][y+1] = max(dp[x][y+1], dp[x][y] + a * abs(l - (N-y-1)))
print(max(dp[N-i][i] for i in range(N+1)))
solve()
|
N = int(input())
_L = list(map(int,input().split()))
L =[(v,i) for i,v in enumerate(_L)]
L = sorted(L,key = lambda x:(-x[0],x[1]))
dp = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):#i番目の数字まで見た
for k in range(N):#k回(i-pi)のパターン
if k>i:
continue
val,ind = L[i]
dp[i+1][k+1] = max(dp[i+1][k+1],dp[i][k] + val * abs(ind-k))#先頭からk番目に動かす
dp[i+1][k] = max(dp[i+1][k],dp[i][k]+val * abs(N-1-(i-k)-ind))#すでに後ろからi-k個は使ってる=>後ろからN- (i-k)+1番目に動かす
print(max(dp[-1]))
| 1 | 33,710,135,255,808 | null | 171 | 171 |
import math
def koch(n,p1,p2):
sx = 2/3 * p1[0] + 1/3 * p2[0]
sy = 2/3 * p1[1] + 1/3 * p2[1]
s = (sx,sy)
tx = 1/3 * p1[0] + 2/3 * p2[0]
ty = 1/3 * p1[1] + 2/3 * p2[1]
t = (tx,ty)
theta = math.radians(60)
ux = (tx - sx)*math.cos(theta) - (ty - sy)*math.sin(theta) + sx
uy = (tx - sx)*math.sin(theta) + (ty - sy)*math.cos(theta) + sy
u = (ux,uy)
if n>0:
koch(n-1,p1,s)
print(*s)
koch(n-1,s,u)
print(*u)
koch(n-1,u,t)
print(*t)
koch(n-1,t,p2)
else: return
n = int(input())
a = [0.00000000,0.00000000]
b = [100.00000000,0.00000000]
print(*map(float,a))
koch(n,a,b)
print(*map(float,b))
|
import math
c60 = math.cos(math.radians(60))
s60 = math.sin(math.radians(60))
def koch(d, p1, p2):
""" Print the coordinates of the vertices of Koch Curve.
d is the depth of recursion.
p1, p2 are coordinates of end point of the initial state.
"""
if d == 0:
return
sx = (2 * p1[0] + p2[0]) / 3
sy = (2 * p1[1] + p2[1]) / 3
tx = (p1[0] + 2 * p2[0]) / 3
ty = (p1[1] + 2 * p2[1]) / 3
dx = tx - sx
dy = ty - sy
ux = dx * c60 - dy * s60 + sx
uy = dx * s60 + dy * c60 + sy
koch(d - 1, p1, (sx, sy))
print("{0:.8f} {1:.8f}".format(sx, sy))
koch(d - 1, (sx, sy), (ux, uy))
print("{0:.8f} {1:.8f}".format(ux, uy))
koch(d - 1, (ux, uy), (tx, ty))
print("{0:.8f} {1:.8f}".format(tx, ty))
koch(d - 1, (tx, ty), p2)
n = int(input())
ax = 0
ay = 0
bx = 100
by = 0
print("{0:.8f} {1:.8f}".format(ax, ay))
koch(n, (ax, ay), (bx, by))
print("{0:.8f} {1:.8f}".format(bx, by))
| 1 | 126,882,471,208 | null | 27 | 27 |
N=int(input())
stones = list(input())
l = 0
r = N-1
count = 0
while(True):
while(stones[l] == "R" and l < N-1):
l += 1
while(stones[r] == "W" and r > 0):
r -= 1
if (l >= r):
print(count)
exit()
else:
count += 1
l += 1
r -= 1
|
INF = 10**8
def main():
N, M, X = (int(i) for i in input().split())
T = [[int(i) for i in input().split()] for j in range(N)]
answer = INF
for bit in range(1, 1 << N):
intelligibility = [0]*M
current_money = 0
for i in range(N):
if bit & 1 << i:
current_money += T[i][0]
for j, a in enumerate(T[i][1:]):
intelligibility[j] += a
if all(X <= intelligence for intelligence in intelligibility):
answer = min(answer, current_money)
print(answer if answer != INF else -1)
if __name__ == '__main__':
main()
| 0 | null | 14,415,926,169,778 | 98 | 149 |
X = int(input())-1
if X==1:
print(X+1)
else:
while True:
X+=1
R = int(X/2)+1 if X>5 else X
for i in range(2, R):
if X % i == 0:
break
if i==R-1:
break
print(X)
|
def bubbleSort(A, N):
flag = 1
cnt = 0
while flag:
flag = 0
for j in range(N - 1, 0, -1):
if A[j] < A[j - 1]:
cnt += 1
A[j], A[j - 1] = A[j - 1], A[j]
flag = 1
print(*A)
print(cnt)
N = int(input())
A = list(map(int, input().split()))
bubbleSort(A, N)
| 0 | null | 53,081,388,389,788 | 250 | 14 |
import math
from math import gcd,pi,sqrt
INF = float("inf")
import sys
sys.setrecursionlimit(10**6)
import itertools
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
import string
def main():
n,k = i_map()
r,s,p = i_map()
dic = {"r":p,"s":r,"p":s}
t = list(s_input())
ans = 0
for i,j in enumerate(t):
if i < k:
ans += dic[j]
else:
if j != t[i-k]:
ans += dic[j]
else:
t[i] = "z"
print(ans)
if __name__=="__main__":
main()
|
N,K=map(int,input().split())
R,S,P=map(int,input().split())
T=input()
cnt=[0 for _ in range(N)]
score={'r':P,'s':R,'p':S}
for i in range(N):
if i<K:
cnt[i]=score[T[i]]
else:
if T[i-K]!=T[i]:
cnt[i]=score[T[i]]
else:
if cnt[i-K]==0:
cnt[i]=score[T[i]]
print(sum(cnt))
| 1 | 106,965,227,853,166 | null | 251 | 251 |
class Dice:
def __init__(self,u,w,r,s,t,y):
self.s1 = u
self.s2= w
self.s3= r
self.s4= s
self.s5 = t
self.s6= y
def right_s3(self):
prev_s3 = self.s3
self.s3 = prev_s3
def right_s4(self):
prev_s4 = self.s4
self.s3 = prev_s4
def right_s5(self):
prev_s5 = self.s5
self.s3 = prev_s5
def right_s6(self):
prev_s6 = self.s6
self.s3 = prev_s6
def right_s1(self):
prev_s1 = self.s1
self.s3 = prev_s1
def right_s2(self):
prev_s2 = self.s2
self.s3 = prev_s2
def top(self):
return self.s3
s1,s2,s3,s4,s5,s6 = map(int,input().split())
order = int(input())
for c in range(order):
dice = Dice(s1,s2,s3,s4,s5,s6)
new_s1 , new_s2 = map(int,input().split())
if (new_s1 == s1 and new_s2 == s2) or (new_s1 ==s2 and new_s2 == s6) or (new_s1 == s6 and new_s2 ==s5) or (new_s1==s5 and new_s2 == s1):
dice.right_s3()
elif (new_s1 == s1 and new_s2 == s5) or (new_s1 ==s5 and new_s2 == s6) or (new_s1 == s6 and new_s2 ==s2) or (new_s1==s2 and new_s2 == s1):
dice.right_s4()
elif (new_s1 == s1 and new_s2 == s3) or (new_s1 ==s3 and new_s2 == s6) or (new_s1 == s6 and new_s2 ==s4) or (new_s1==s4 and new_s2 == s1):
dice.right_s5()
elif (new_s1 == s2 and new_s2 == s4) or (new_s1 ==s4 and new_s2 == s5) or (new_s1 == s5 and new_s2 ==s3) or (new_s1==s3 and new_s2 == s2):
dice.right_s6()
elif (new_s1 == s2 and new_s2 == s3) or (new_s1 ==s3 and new_s2 == s5) or (new_s1 == s5 and new_s2 ==s4) or (new_s1==s4 and new_s2 == s2):
dice.right_s1()
elif (new_s1 == s1 and new_s2 == s4) or (new_s1 ==s4 and new_s2 == s6) or (new_s1 == s6 and new_s2 ==s3) or (new_s1==s3 and new_s2 == s1):
dice.right_s2()
print(dice.top())
|
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')
| 0 | null | 19,457,106,884,240 | 34 | 179 |
from collections import deque
s = input()
q = int(input())
d = deque()
for v in s:
d.append(v)
r = False
for _ in range(q):
xs = input().split()
if xs[0] == "1":
r = not r
else:
if (not r and xs[1] == "1") or (r and xs[1] == "2"):
d.appendleft(xs[2])
else:
d.append(xs[2])
s = "".join(d)
print(s[::-1] if r else s)
|
def stackable(pack, tmp_p, k):
cur_w = 0
trucks = 1
for i in range(len(pack)):
if tmp_p < pack[i]:
return False
if cur_w + pack[i] <= tmp_p:
cur_w += pack[i]
else:
cur_w = pack[i]
trucks += 1
if k < trucks:
return False
return True
n, k = map(int, input().split())
pack = []
for i in range(n):
pack.append(int(input()))
left = int(sum(pack) / k)
right = max(pack) * n
while left < right - 1:
tmp_p = int((left + right) / 2)
if stackable(pack, tmp_p, k):
right = tmp_p
else:
left = tmp_p
if stackable(pack, left, k):
print(left)
else:
print(right)
| 0 | null | 28,541,018,129,728 | 204 | 24 |
N = int(input())
AB = [[int(_) for _ in input().split()] for _ in range(N)]
A = sorted([a for a, b in AB])
B = sorted([b for a, b in AB])
ans = B[N // 2] + B[(N - 1) // 2] - (A[N // 2] + A[(N - 1) // 2])
if N % 2:
ans //= 2
ans += 1
print(ans)
|
import collections
N = int(input())
A = [0] * N
B = [0] * N
for i in range(N):
a, b = map(int, input().split())
A[i] = a
B[i] = b
A.sort()
B.sort()
N_q, N_mod = divmod(N, 2)
if N_mod == 1:
ans = B[N_q] - A[N_q] + 1
else:
ans = B[N_q - 1] - A[N_q - 1] + B[N_q] - A[N_q] + 1
print(ans)
| 1 | 17,289,574,013,384 | null | 137 | 137 |
mod=998244353
class Combination:
def __init__(self,size):
self.size = size + 2
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % mod
self.inv[i] = -self.inv[mod % i] * (mod//i) % mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % mod
def npk(self,n,k):
if n < k or n < 0 or k < 0:
return 0
return self.fact[n] * self.factInv[n - k] % mod
def nck(self,n,k):
if n < k or n < 0 or k < 0:
return 0
return self.fact[n] * (self.factInv[k] * self.factInv[n - k] % mod) % mod
def nhk(self,n,k):
return self.nck(n + k - 1, n - 1)
n,m,k=map(int,input().split())
comb=Combination(n+k)
res=0
for i in range(k+1):
res+=((comb.nhk(n-i,i))*m)%mod*(pow(m-1,n-1-i,mod))
res%=mod
print(res)
|
n, m, k = map(int, input().split())
mod = 998244353
N = 10 ** 6
inv_t = [0]+[1]
for i in range(2, N):
inv_t += [inv_t[mod % i] * (mod - int(mod / i)) % mod]
kai = [1, 1]
rev_kai = [1, inv_t[1]]
for i in range(2, N):
kai.append(kai[-1] * i % mod)
rev_kai.append(rev_kai[-1] * inv_t[i] % mod)
def cmb(n, r):
return kai[n] * rev_kai[r] * rev_kai[n-r] % mod
base = m
ans = 0
for i in range(n-1):
base = base * (m-1) % mod
for i in range(0, k+1):
ans += base * cmb(n-1, n-1-i)
ans %= mod
base = base * inv_t[m-1] % mod
if m == 1 and k == n-1:
print(1)
else:
print(ans)
| 1 | 23,144,712,471,806 | null | 151 | 151 |
import collections,sys
def s():
d = collections.deque()
input()
for e in sys.stdin:
if "i"==e[0]: d.appendleft(e[7:-1])
else:
if " "==e[6]:
m = e[7:0-1]
if m in d: d.remove(m)
elif "i"==e[7]: d.popleft()
else: d.pop()
print(*d)
s()
|
from collections import deque
n = int(input())
dll = deque()
for i in range(n):
command = input().split()
if command[0] == 'insert':
dll.appendleft(command[1])
elif command[0] == 'delete':
try:
dll.remove(command[1])
except:
pass
elif command[0] == 'deleteFirst':
dll.popleft()
else:
dll.pop()
print(*dll)
| 1 | 52,954,841,550 | null | 20 | 20 |
n,m=map(int,input().split())
ac=[0]*n
wa=[0]*n
acc,wac=0,0
for i in range(m):
p,s=input().split()
p=int(p)
if ac[p-1]==1:
continue
else:
if s=="AC":
ac[p-1]=1
else:
wa[p-1]+=1
for i in range(n):
if ac[i]==1:
acc+=1
wac+=wa[i]
print(acc,wac)
|
N,M = map(int,input().split())
num_AC,num_WA = 0,0
res = [list(input().split()) for i in range(M)]
check = ['v']*N
WA_check = [0]*N
for i,j in res:
i = int(i)
if check[i-1] == 'v':
if j == 'WA':
WA_check[i-1] += 1
if j == 'AC':
num_AC += 1
num_WA += WA_check[i-1]
check[i-1] = '.'
print(num_AC,num_WA)
| 1 | 93,036,236,334,470 | null | 240 | 240 |
k = int(input())
a, b = map(int, input().split())
if a <= k <= b or k <= b/2:
print('OK')
else:
print('NG')
|
k = int(input())
a,b = map(int,input().split())
flag = False
for i in range(a,b + 1):
if i % k == 0:
flag = True
break
if flag:
print('OK')
else:
print('NG')
| 1 | 26,482,930,238,208 | null | 158 | 158 |
n, m = map(int, input().split())
lis = sorted(list(map(int, input().split())), reverse=True)
con = 0
for i in range(n):
if lis[i] >= sum(lis) * (1/(4*m)):
con += 1
if con == m:
print("Yes")
exit()
print("No")
|
import math
n, m = map(int,input().split())
a = list(map(int,input().split()))
sum = sum(a)
x = 0
for i in a:
if i * 4 * m >= sum:
x += 1
if x >= m:
print('Yes')
else:
print('No')
| 1 | 38,800,346,261,420 | null | 179 | 179 |
line_data = input()
H1, M1, H2, M2, K = map(lambda x: int(x), line_data.split(' '))
miniutes = (H2 - H1) * 60 + (M2 - M1)
print(miniutes - K)
|
h1,m1,h2,m2, k = [int(i) for i in input().split()]
time = abs(h2-h1)*60 + m2 -m1
print(time - k)
| 1 | 18,061,744,488,558 | null | 139 | 139 |
X = int(input())
primes = [1] * (10 ** 6)
n = 1
primes[0] = 0
primes[1] = 0
while True:
n += 1
if primes[n] == 0:
continue
if n >= X:
print(n)
break
i = 2
while i * n < len(primes):
primes[i * n] = 0
i += 1
|
import math
def prime_check(x):
if x == 2:
return True
limit = math.floor(math.sqrt(x)+1)
cnt = 0
for i in range(2,limit):
if x%i == 0:
cnt += 1
if cnt == 0:
return True
else:
return False
X = int(input())
while True:
if prime_check(X):
print(X)
break
else:
X += 1
| 1 | 105,946,282,140,802 | null | 250 | 250 |
A,B,C,K = map(int,input().split())
ans = 0
if K > A:
ans += A
K -= A
if K > B:
ans += 0
K -= B
if K > 0:
ans -= K
else:
ans += 0
else:
ans = K
print(ans)
|
a,b,c,k=map(int,input().split())
kk=k-a-b
if kk <= 0:
print(min(a,k))
else:
print(a-kk)
| 1 | 21,950,248,987,382 | null | 148 | 148 |
x,y = map(int, input().split())
ans = 'No'
for i in range(x+1):
for j in range(y+1):
if i + j > x:
continue
if i*2 + j*4 == y and i+j == x:
ans = 'Yes'
print(ans)
|
x,y = map(int,input().split())
for i in range(x+1):
if 2*i+4*(x-i) == y:
print('Yes')
exit()
print('No')
| 1 | 13,712,801,438,580 | null | 127 | 127 |
# -*- coding: utf-8 -*-
import math
def prime_number_identifier(num):
for candidate in range(2, int(math.sqrt(num)) + 1):
if num % candidate == 0:
return False
return True
input_num = int(raw_input())
counter = 0
found_number = 0
while counter < input_num:
candidate_number = int(raw_input())
if prime_number_identifier(candidate_number):
found_number += 1
counter += 1
print found_number
|
def is_prime(x):
if x == 1:
return 0
l = x ** 0.5
n = 2
while n <= l:
if x % n == 0:
return 0
n += 1
return 1
import sys
def solve():
N = int(input())
cnt = 0
for i in range(N):
cnt += is_prime(int(input()))
print(cnt)
solve()
| 1 | 11,289,018,102 | null | 12 | 12 |
import sys
from math import gcd
#import numpy as np
#import math
from fractions import Fraction
import itertools
input=sys.stdin.readline
def main():
ans=1
mod=1000000007
n0=0
na=nb=0
n=int(input())
d={}
for i in range(n):
a,b=map(int,input().split())
if b==0 and a==0:
n0+=1
elif b==0:
nb+=1
elif a==0:
na+=1
else:
g=gcd(a,b)
if b<0:
a*=-1
b*=-1
s=(a//g,b//g)
if s not in d:
d[s]=1
else:
d[s]+=1
for k,v in d.items():
a,b=k
if a>0:
if (-b,a) in d:
if d[(a,b)]!=-1:
ans*=pow(2,d[(-b, a)])-1+pow(2,d[(a,b)])-1+1
ans=ans%mod
d[(-b,a)]=-1
else:
ans*=pow(2,d[(a,b)])
ans=ans%mod
else:
if (b,-a) in d:
if d[(a,b)]!=-1:
ans*=pow(2,d[(b, -a)])-1+pow(2,d[(a,b)])-1+1
ans=ans%mod
d[(b,-a)]=-1
else:
ans*=pow(2,d[(a,b)])
ans=ans%mod
ans*=pow(2,na)-1+pow(2,nb)-1+1
print((ans-1+n0)%mod)
if __name__ == '__main__':
main()
|
N = int(input())
S = input()
cnt = 0
for i in range(N):
if S[i:i+3] == "ABC":
cnt += 1
print(cnt)
| 0 | null | 60,339,237,990,372 | 146 | 245 |
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))
n,p = mi()
s = input()
srev = s[::-1]
if p == 2 or p == 5:
ans = 0
for i in range(n):
if int(s[i]) % p == 0:
ans += i +1
print(ans)
exit()
acum = []
from collections import defaultdict
d = defaultdict(lambda :0)
d = [0] * p
num = 0
tenpow = 1
for i in range(0,n):
a = int(srev[i])
a = num + a *tenpow
tenpow = tenpow * 10 % p
modd = a % p
num = modd
d[modd] += 1
acum.append((modd,d[modd]))
ans = d[0]
for i in range(n):
ans += d[acum[i][0]] - acum[i][1]
print(ans)
|
a, b, c, k = map(int, input().split())
sum = 0
rest_k = k
if rest_k <= a:
sum += rest_k
rest_k = 0
else:
sum += a
rest_k -= a
if rest_k <= b:
rest_k = 0
else:
rest_k -= b
sum -= rest_k
print(sum)
| 0 | null | 39,972,066,509,600 | 205 | 148 |
def chk(l):
s=0
for r in l:
s+=r
if (s<0)|(s>9):
return False
return True
def nml(l):
ln=len(l)
for i in range(1,ln):
if l[-i]==2:
l[-i]=-1
l[-i-1]+=1
if l[0]==10:
return True
return False
a=[1]
for i in range(int(input())-1):
while True:
if len(a)==1:
a[0]+=1
if a[0]==10:
a=[1,-1]
else:
a[-1]+=1
if nml(a):
a=[1]+[-(j==0) for j in range(len(a))]
if chk(a):
break
rt=""
ss=0
for i in a:
ss+=i
rt+=str(ss)
print(rt)
|
from collections import deque
k = int(input())
d = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
for i in range(k - 1):
x = d.popleft()
if x%10 > 0:
d.append(x*10 + x%10 - 1)
d.append(x*10 + x%10)
if x%10 < 9:
d.append(x*10 + x%10 + 1)
print(d.popleft())
| 1 | 40,209,582,897,400 | null | 181 | 181 |
#3 Range Flip Find Route
h,w = map(int,input().split())
s= [None for i in range(h)]
for i in range(h):
s[i] = input()
dp = [[0]*w for i in range(h)]
dp[0][0] = int(s[0][0]=="#")
for i in range(1,w):
dp[0][i]=dp[0][i-1] + (s[0][i-1]=="." and s[0][i]=="#")
for i in range(1,h):
dp[i][0]=dp[i-1][0] + (s[i-1][0]=="." and s[i][0]=="#")
for i in range(1,h):
for j in range(1,w):
cand1 = dp[i-1][j] + (s[i-1][j]=="." and s[i][j]=="#")
cand2 = dp[i][j-1] + (s[i][j-1]=="." and s[i][j]=="#")
dp[i][j]=min(cand1,cand2)
print(dp[-1][-1])
|
h, w = map(int, input().split())
maze = [list(input()) for i in range(h)]
dp = [[0] * w for i in range(h)]
for i in range(h):
for j in range(w):
if i == j == 0:
if maze[i][j] == "#":
dp[i][j] += 1
if i == 0 and j != 0:
if maze[0][j] != maze[0][j - 1]:
dp[0][j] = dp[0][j - 1] + 1
else:
dp[0][j] = dp[0][j - 1]
if j == 0 and i != 0:
if maze[i][0] != maze[i - 1][0]:
dp[i][0] = dp[i - 1][0] + 1
else:
dp[i][0] = dp[i - 1][0]
if i != 0 and j != 0:
dp[i][j] = min(dp[i - 1][j] + (1 if maze[i][j] != maze[i - 1][j] else 0), dp[i][j - 1] + (1 if maze[i][j] != maze[i][j - 1] else 0))
if i == h - 1 and j == w - 1:
if maze[i][j] == "#":
dp[i][j] += 1
ans = dp[h - 1][w - 1] // 2
print(ans)
| 1 | 49,007,956,999,012 | null | 194 | 194 |
a, b = list(map(int, input().split()))
print("{0:d} {1:d} {2:f}".format(a//b, a%b, a / b))
|
a = int(input())
class calculate:
def __init__(self,a):
self.check = a
def get_ans(self,a):
return a + a**2 + a**3
valuable = calculate(a)
#Sprint(valuable.check)
ans = valuable.get_ans(a)
print(ans)
| 0 | null | 5,457,016,965,952 | 45 | 115 |
import sys
line = sys.stdin.readline()
inp = int(line)
h,mod = inp//3600, inp%3600
m,mod = mod//60, mod%60
s = mod
print ("%d:%d:%d" % (h,m,s))
|
x = input()
a = x/3600
b = x%3600/60
c = x - a*3600 - b*60
print '%d:%d:%d'%(a, b, c)
| 1 | 334,015,413,522 | null | 37 | 37 |
s, w=map(int, input().split())
if s>w:
print('safe')
elif s<=w:
print('unsafe')
|
#MLE注意！0や1のケースに注意
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
s,w = map(int, input().split())
if s<=w:
print('unsafe')
else:
print('safe')
if __name__ == '__main__':
main()
| 1 | 29,134,031,942,110 | null | 163 | 163 |
def resolve():
A, B, N = map(int, input().split())
if B <= N+1:
print(A*(B-1)//B)
else:
print(A*N//B)
resolve()
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#import numpy as np
#from decimal import *
N, X, Y = MAP()
graph = [[] for _ in range(N)]
for i in range(N-1):
graph[i].append(i+1)
graph[i+1].append(i)
graph[X-1].append(Y-1)
graph[Y-1].append(X-1)
dic = defaultdict(int)
for i in range(N):
q = deque([i])
dist = [-1]*N
dist[i] = 0
while q:
n = q.popleft()
for node in graph[n]:
if dist[node] == -1:
dist[node] = dist[n] + 1
q.append(node)
for i in range(N):
dic[dist[i]] += 1
for k in range(1, N):
print(dic[k]//2)
| 0 | null | 36,136,605,957,340 | 161 | 187 |
#!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
#%%code
def resolve():
N=input()
K,=pin()
#degit DP
#dp_table["index"][smaller][cond]=cond:=ちょうどK個の数がある を満たす総数
rb=(0,1)
dp_table=[[[0 for cnd in range(K+1)]for sml in rb]for ind in range(len(N)+1)]
dp_table[0][0][0]=1
#print(dp_table)
#print("degit,sml,k,prove,l,x<n,dp_table[degit-1][sml][k]")#
for degit in range(len(N)+1):
n=int(N[degit-1])
for sml in rb:
t=10 if sml else int(N[degit-1])+1
for k in range(K+1):
for prove in range(t):
x=prove
try:#Indexerror
#print(degit,sml,k,prove,"l",x<n,dp_table[degit-1][sml][k])
#if sml==False and x==n:print(n,":")
dp_table[degit][sml or x<n][k+(x!=0)]+=dp_table[degit-1][sml][k]
except :pass
print(dp_table[-1][0][K]+dp_table[-1][1][K])
#print(dp_table)
#%%submit!
resolve()
|
h, w = map(int, input().split())
s = []
score = [[0] * w for i in range(h)]
for i in range(h):
s.append(list(input()))
for j in range(w):
if i == 0:
if j == 0:
score[0][0] = 1 if s[0][0] == '#' else 0
else:
score[0][j] = score[0][j-1]
if s[0][j] == '#' and s[0][j-1] != '#':
score[0][j] += 1
else:
if j == 0:
score[i][0] = score[i-1][0]
if s[i][0] == '#' and s[i-1][0] != '#':
score[i][0] += 1
else:
r = score[i][j-1]
if s[i][j] == '#' and s[i][j-1] != '#':
r += 1
d = score[i-1][j]
if s[i][j] == '#' and s[i-1][j] != '#':
d += 1
score[i][j] += min(r, d)
print(score[-1][-1])
| 0 | null | 62,802,503,122,010 | 224 | 194 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def main():
N = int(input())
A = list(map(int, input().split()))
ans = 1000
for i in range(1, N):
if A[i - 1] < A[i]:
stock = ans // A[i - 1]
ans += stock * (A[i] - A[i - 1])
print(ans)
if __name__ == "__main__":
main()
|
N=int(input())
A=list(map(int, input().split()))
A.append(0)
L=[0]*N
L[0]=1000
# dpしろ
for i in range(1,N):
B=[0]*(i+1)
for j in range(i):
t=L[j]//A[j]
B[j]=L[j]%A[j] + t*A[i]
B[i]=L[i-1]
L[i]=max(B)
print(L[N-1])
| 1 | 7,302,398,995,684 | null | 103 | 103 |
MOD = 10 ** 9 + 7
from math import gcd
from collections import defaultdict
n = int(input())
plus = defaultdict(int)
minus = defaultdict(int)
zero = [0, 0, 0]
for _ in range(n):
a, b = map(int, input().split())
if a * b == 0:
if a == b == 0:
zero[0] += 1
elif a == 0:
zero[1] += 1
else:
zero[2] += 1
continue
g = gcd(a, b)
a //= g
b //= g
if a < 0:
a *= -1
b *= -1
if b >= 0:
s = str(a) + "-" + str(b)
plus[s] += 1
else:
s = str(-b) + "-" + str(a)
minus[s] += 1
pm = [[zero[1], zero[2]]]
cnt = sum(zero)
for key, value in plus.items():
if minus[key] != 0:
pm.append([value, minus[key]])
cnt += value + minus[key]
ans = pow(2, n - cnt, MOD)
for p, m in pm:
ans *= (pow(2, p, MOD) + pow(2, m, MOD) - 1)
ans %= MOD
ans += zero[0] - 1
ans %= MOD
print(ans)
|
from math import gcd
n = int(input())
ration = dict()
used = dict()
for _ in range(n):
a, b = map(int, input().split())
if a == 0 or b == 0:
if a == b == 0:
r = '0'
elif a == 0:
r = '0a'
else:
r = '0b'
else:
s = '-' if (a < 0) ^ (b < 0) else '+'
a = abs(a)
b = abs(b)
g = gcd(a, b)
r = f'{s} {a//g} {b//g}'
ration[r] = ration.get(r, 0) + 1
used[r] = 0
res = 1
mod = 10**9+7
add = 0
for k, v in ration.items():
if used[k]:
continue
if k == '0':
add += v
used[k] = 1
elif k == '0a' or k == '0b':
res *= 2**ration.get('0a', 0) + 2**ration.get('0b', 0) - 1
used['0a'] = used['0b'] = 1
else:
r = k.split()
l = f'{"-" if r[0]=="+" else "+"} {r[2]} {r[1]}'
res *= 2**v + 2**ration.get(l, 0) - 1
used[k] = used[l] = 1
res %= mod
res += add
res -= 1
if res < 0:
res += mod
print(res)
| 1 | 21,087,604,005,712 | null | 146 | 146 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
ans = []
for i in range(K, N):
ans.append(['No', 'Yes'][A[i] > A[i - K]])
print('\n'.join(ans))
|
N,S=map(int,input().split())
*a,=map(int,input().split())
mod=998244353
dp=[[0]*(S+1) for _ in range(N+1)]
dp[0][0]=1
for i in range(N):
for j in range(S+1):
dp[i+1][j]=2*dp[i][j]
if j>=a[i]:
dp[i+1][j]+=dp[i][j-a[i]]
dp[i+1][j]%=mod
print(dp[N][S])
| 0 | null | 12,319,437,376,092 | 102 | 138 |
def nishin(n):
return str(bin(n)[2:])[::-1]
N=int(input())
L=list(map(int,input().split()))
mod=1000000007
ans=sum(L)*(N-1)
c=[0]*61
for i in L:
i=nishin(i)
for j in range(len(i)):
if i[j]=="1":
c[j]+=1
for i in range(61):
ans-=(pow(2,i,mod)*c[i]*(c[i]-1))%mod
print(ans%mod)
|
while 1:
H, W = map(int, raw_input().split())
if H == W == 0:
break
for i in range(H):
print "#" * W
print ""
| 0 | null | 61,582,993,224,900 | 263 | 49 |
n, x, m = map(int, input().split())
mn = min(n, m)
S = set()
A = []
sum_9 = 0 # sum of pre + cycle
for _ in range(mn):
if x in S: break
S.add(x)
A.append(x)
sum_9 += x
x = x*x % m
if len(A) >= mn:
print(sum_9)
exit()
pre_len = A.index(x)
cyc_len = len(A) - pre_len
nxt_len = (n - pre_len) % cyc_len
cyc_num = (n - pre_len) // cyc_len
pre = sum(A[:pre_len])
cyc = sum_9 - pre
nxt = sum(A[pre_len: pre_len + nxt_len])
print(pre + cyc * cyc_num + nxt)
|
N,X,M=map(int, input().split())
m=[0]*M
t={}
def f(x,y):
return x*x % y
a = X
s=0
for i in range(N):
if a in t:
x = t[a]
nn = N - x
q,r = divmod(nn,i-x)
s = m[x-1] + (m[i-1] - m[x-1])*q + m[x-1+r] - m[x-1]
break
t[a]=i
s += a
m[i] = s
a = f(a,M)
print(s)
| 1 | 2,823,902,646,030 | null | 75 | 75 |
N = int(input())
A = sorted(list(map(int,input().split())),reverse=True)
if N%2==0:
cnt = A[0]
for i in range(1,N//2):
cnt += 2*A[i]
print(cnt)
else:
cnt = A[0]
for i in range(1,N//2):
cnt += 2*A[i]
cnt += A[N//2]
print(cnt)
|
def step_sum(n):
return (n*(n+1))//2
n = int(input())
table = [0]*n
ans = 0
for i in range(1, n+1):
ans += i*step_sum(n//i)
print(ans)
| 0 | null | 10,084,444,911,310 | 111 | 118 |
n=int(input())
a=list(map(int,input().split()))
if n%2==1:
dp=[[0 for j in range(3)] for i in range(n//2)]
dp[0][0]=a[0]
dp[0][1]=a[1]
dp[0][2]=a[2]
for i in range(n//2-1):
dp[i+1][0]=(dp[i][0]+a[2*(i+1)])
dp[i+1][1]=max(dp[i][0],dp[i][1])+a[2*(i+1)+1]
dp[i+1][2]=max(dp[i])+a[2*(i+1)+2]
print(max(dp[-1]))
if n%2==0:
dp=[[0 for j in range(2)] for i in range(n//2)]
dp[0][0]=a[0]
dp[0][1]=a[1]
for i in range(n//2-1):
dp[i+1][0]=(dp[i][0]+a[2*(i+1)])
dp[i+1][1]=max(dp[i][0],dp[i][1])+a[2*(i+1)+1]
#dp[i+1][2]=max(dp[i])+a[2*(i+2)+2]
print(max(dp[-1]))
|
N = int(input())
A = list(map(int, input().split()))
dp = [{} for _ in range(N + 2)]
dp[0][0] = 0
dp[-1][0] = 0
for i in range(1, N + 1):
f = (i - 1) // 2
t = (i + 1) // 2
for j in range(f, t + 1):
var1 = dp[i - 2][j - 1] + A[i - 1] if j - 1 in dp[i - 2] else -float('inf')
var2 = dp[i - 1][j] if j in dp[i - 1] else -float('inf')
dp[i][j] = max(var1, var2)
print(dp[N][N // 2])
| 1 | 37,223,471,503,298 | null | 177 | 177 |
n,m,k = map(int,input().split())
a_list = list(map(int,input().split()))
b_list = list(map(int,input().split()))
a_sum = [0]
b_sum = [0]
for i in range(n):
a_sum.append(a_sum[i] + a_list[i])
for i in range(m):
b_sum.append(b_sum[i] + b_list[i])
ans = 0
for i in range(n+1):
if a_sum[i] > k:
break
rem = k - a_sum[i]
while b_sum[m] > rem:
m -= 1
if ans < i + m:
ans = i + m
print(ans)
|
s=raw_input()
t=[]
for x in s:
if x=='?':
t.append('D')
else:
t.append(x)
print "".join(t)
| 0 | null | 14,703,224,758,558 | 117 | 140 |
n=int(input())
a=list(map(int,input().split()))
ans=[0]*(n+1)
for i in a:
ans[i]+=1
for i in range(n):
print(ans[i+1])
|
n = int(input())
a = map(int,input().split())
lst = [0]*(n+1)
for i in a:
lst[i] += 1
for i in lst[1:]:
print(i)
| 1 | 32,646,846,925,532 | null | 169 | 169 |
a,b,c,k=map(int,input().split())
if k < a:
print(k)
elif k <= a+b:
print(a)
else:
print(2*a+b-k)
|
# -*- coding: utf-8 -*-
import sys
from collections import deque,defaultdict
sys.setrecursionlimit(10**5)
H,W,K=map(int, sys.stdin.readline().split())
ichigo=[]
cnt=0 #イチゴに番号を振るための変数
h_visit=[0 for h in range(H)] #縦軸にイチゴがない箇所は0、ある箇所は1
L=[ [] for h in range(H) ]
for h in range(H):
s=sys.stdin.readline().strip()
for w,x in enumerate(s):
if x==".":
L[h].append(0)
elif x=="#":
cnt+=1
L[h].append(cnt)
ichigo.append((h,w))
h_visit[h]=1
D=(1,-1) #マスの横移動、または縦移動に使用
def yoko_dfs(h,w): #縦座標、横座標
for dw in D:
if 0<=w+dw<=W-1 and L[h][w+dw]==0:
L[h][w+dw]=L[h][w]
yoko_dfs(h,w+dw)
return
#横方向に空マスなら、自分のイチゴ番号で埋めていく
for h,w in ichigo:
yoko_dfs(h,w)
def tate_dfs(h): #縦座標
for dh in D:
if 0<=h+dh<=H-1:
if h_visit[h+dh]==1: continue
h_visit[h+dh]=1 #訪問済みにする
L[h+dh]=L[h] #行のコピー
tate_dfs(h+dh)
#縦方向にdfs。イチゴがない行を探して、イチゴがある行を行ごとコピーする
for h,w in ichigo:
tate_dfs(h)
for l in L:
for x in l:
print x,
print
| 0 | null | 82,603,148,402,940 | 148 | 277 |
_str = ""
_k = int(input())
for _i in range(_k):
_str += "ACL"
print(_str)
|
K = int(input())
a = ""
for i in range(K):
a += "ACL"
print("{}".format(a))
| 1 | 2,166,422,259,820 | null | 69 | 69 |
class SegmentTree:
def __init__(self,n):
self.siz = 1
while self.siz < n: self.siz *= 2
self.node = [0]*(2*self.siz-1)
def update(self,i,x):
i += self.siz-1
self.node[i] = x
while i > 0:
i = (i-1)//2
self.node[i] = self.node[i*2+1] | self.node[i*2+2]
def query(self,a,b,k=0,l=0,r=-1):
if r < 0: r = self.siz
if r <= a or b <= l: return 0
if a <= l and r <= b: return self.node[k]
vl = self.query(a,b,k*2+1,l,(l+r)//2)
vr = self.query(a,b,k*2+2,(l+r)//2,r)
return vl | vr
n = int(input())
st = SegmentTree(n)
s = list(input())
def f(c): return 1<<(ord(c) - ord("a"))
for i in range(n): st.update(i,f(s[i]))
q = int(input())
for _ in range(q):
typ,x,y = input().split()
if typ == "1":
i,c = int(x)-1,y
if s[i] == c: continue
st.update(i,f(c))
s[i] = c
else:
l,r = int(x)-1,int(y)
print(bin(st.query(l,r)).count("1"))
|
# -*- coding: utf-8 -*-
import sys
N=input()
S=["None"]+list(raw_input())
Q=input()
query=[ sys.stdin.readline().split() for _ in range(Q) ]
#BIT
bit=[ [ 0 for _ in range(N+1) ] for _ in range(27) ] #1-indexed bit[1]:aのbit, bit[2]:bのbit ...
def add(idx,a,w):
while a<=N:
bit[idx][a]+=w
a+=a&-a
def sum(idx,a):
ret=0
while 0<a:
ret+=bit[idx][a]
a-=a&-a
return ret
for i,x in enumerate(S):
if i==0: continue
add(ord(x)-96,i,1) #a~zのどのbit配列か,特定文字のbit配列の何番目,bitに代入する値
for q1,q2,q3 in query:
q1=int(q1)
q2=int(q2)
if q1==1:
before_q3=S[q2] #文字列Sの変更前の文字をbefore_q3に代入
S[q2]=q3 #文字列Sの変更部分1文字を更新
q3=ord(q3)-96 #変更後の文字をアスキーコード10進数で表現
before_q3=ord(before_q3)-96 #変更前の文字をアスキーコード10進数で表現
add(q3,q2,1) #a~zのどのbit配列か,特定文字のbit配列の何番目,bitに代入する値
add(before_q3,q2,-1) #置き代えた文字は-1しなきゃいけない
elif q1==2:
q3=int(q3)
cnt=0
for i in range(1,27):
if 0<sum(i,q3)-sum(i,q2-1):
cnt+=1
print cnt
| 1 | 62,429,051,889,568 | null | 210 | 210 |
import sys
input = sys.stdin.readline
class SegTree():
# ここでは操作の都合上根元のindexを1とする
def __init__(self, lists, function, basement):
self.n = len(lists)
self.K = (self.n-1).bit_length()
self.f = function
self.b = basement
self.seg = [basement]*2**(self.K+1)
X = 2**self.K
for i, v in enumerate(lists):
self.seg[i+X] = v
for i in range(X-1, 0, -1):
self.seg[i] = self.f(self.seg[i << 1], self.seg[i << 1 | 1])
def update(self, k, value):
X = 2**self.K
k += X
self.seg[k] = value
while k:
k = k >> 1
self.seg[k] = self.f(self.seg[k << 1], self.seg[(k << 1) | 1])
def query(self, L, R):
num = 2**self.K
L += num
R += num
vL = self.b
vR = self.b
while L < R:
if L & 1:
vL = self.f(vL, self.seg[L])
L += 1
if R & 1:
R -= 1
vR = self.f(self.seg[R], vR)
L >>= 1
R >>= 1
return self.f(vL, vR)
def main():
N = int(input())
S = list(input())
Q = int(input())
que = [tuple(input().split()) for i in range(Q)]
alpha = "abcdefghijklmnopqrstuvwxyz"
Data = {alpha[i]: [0]*N for i in range(26)}
for i in range(N):
Data[S[i]][i] += 1
SEG = {alpha[i]: SegTree(Data[alpha[i]], max, 0) for i in range(26)}
for X, u, v in que:
if X == "1":
u = int(u)-1
NOW = S[u]
S[u] = v
SEG[NOW].update(u, 0)
SEG[v].update(u, 1)
else:
u, v = int(u)-1, int(v)-1
res = 0
for j in range(26):
res += SEG[alpha[j]].query(u, v+1)
print(res)
if __name__ == "__main__":
main()
|
s=input()
t=input()
a=0
for i in range(len(s)):
if s[i]==t[i]:
a+=1
if a==len(s):
print('Yes')
else:
print('No')
| 0 | null | 41,899,687,552,292 | 210 | 147 |
#!/usr/bin/env python3
import collections as cl
import sys
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def main():
s = input()
for i in range(len(s)):
print("x", end="")
main()
|
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
ln = len(input())
print('x'*ln)
| 1 | 72,644,503,855,430 | null | 221 | 221 |
string = ''
while True:
hoge = input().strip()
if hoge == '-':
print (string)
break
if hoge.isalpha():
if string:
print (string)
string = hoge
count = 0
else:
if count == 0:
count = hoge
continue
else:
string = string[int(hoge):] + string[:int(hoge)]
|
while True:
st = list(raw_input())
if st[0] == '-':
break
m = int(raw_input())
for k in range(m):
h = int(raw_input())
st = st + st[:h]
del st[:h]
print ''.join(st)
| 1 | 1,884,130,267,262 | null | 66 | 66 |
x = list(map(int, input().split()))
for i, j in enumerate(x):
if j == 0:
print(i+1)
|
x = list(map(int, input().split()))
for i in range(len(x)):
if x[i] is 0:
print(i+1)
| 1 | 13,373,290,212,952 | null | 126 | 126 |
def show (nums):
for i in range(len(nums)):
if i!=len(nums)-1:
print(nums[i],end=' ')
else :
print(nums[i])
n = int(input())
a = list(map(int, input().split()))
for i in range(n):
for j in range(i):
if a[j] > a[i]:
a.insert(j, a[i])
a.pop(i+1)
break
show(a)
|
length = int(input())
targ = [int(n) for n in input().split(' ')]
for l in range(length):
for m in range(l):
if targ[l - m] < targ[l - m - 1]:
disp = targ[l-m -1]
targ[l-m-1] = targ[l-m]
targ[l-m] = disp
print(" ".join([str(n) for n in targ]))
| 1 | 6,186,227,406 | null | 10 | 10 |
import string
N = int(input())
S = input()
# string.ascii_uppercase を覚えよう
a = string.ascii_uppercase
# a = ABCDEFGHIJKLMNOPQRSTUVWXYZ
ans = ''
for s in S:
num = (a.index(s) + N) % len(a)
ans += a[num]
print(ans)
|
s=input()
if s=="ABC": print("ARC")
else : print("ABC")
| 0 | null | 79,662,716,552,924 | 271 | 153 |
n , d = map(int, input().split())
x = []
y = []
for i in range(n):
a = list(map(int, (input().split())))
x.append(a[0])
y.append(a[1])
ans = 0
for i in range(n):
if (x[i] ** 2 + y[i] ** 2) ** (0.5) <= d:
ans += 1
print(ans)
|
from collections import Counter
n, p = map(int, input().split())
s = input()
ans = 0
if p in {2, 5}:
lst = set(i for i in range(0, 10, p))
for i, num in enumerate(s):
if int(num) in lst:
ans += i + 1
else:
num = [0]
for i in range(len(s)):
tmp = num[-1] + pow(10, i, p) * int(s[-i - 1])
num.append(tmp % p)
mod = [0] * p
for i in num:
ans += mod[i]
mod[i] += 1
print(ans)
| 0 | null | 31,894,938,237,796 | 96 | 205 |
def solve(string):
n, k, *p = map(int, string.split())
p = sorted(p)
return str(sum(p[:k]))
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
|
N=int(input())
L= list(map(int,input().split()))
L_sorted=sorted(L,reverse=False)#昇順
count=0
import bisect
for i in range(N):
for j in range(i+1,N):
a=L_sorted[i]
b=L_sorted[j]
bisect.bisect_left(L_sorted,a+b)
count+=bisect.bisect_left(L_sorted,a+b)-j-1
print(count)
| 0 | null | 91,406,158,761,038 | 120 | 294 |
I=input;s=I()*2;print(['No','Yes'][I()in s])
|
import sys
while(1):
H,W = map(int, raw_input().split())
if H==0 and W==0:
break
for i in range(H):
for j in range(W):
sys.stdout.write("#")
print ""
print ""
| 0 | null | 1,264,591,046,432 | 64 | 49 |
s=input()
if len(s) % 2 == 0:
if s == "hi"*(len(s)//2):
print("Yes")
else:
print("No")
else:
print("No")
|
from math import gcd
n, m = (int(x) for x in input().split())
A = list(int(x) for x in input().split())
B = [a // 2 for a in set(A)]
lcm = 1
div2_count = -1
for b in B:
lcm = lcm * b // gcd(lcm, b)
if lcm > m:
print(0)
exit()
count = 0
while b % 2 == 0:
b //= 2
count += 1
if div2_count == -1 or div2_count == count:
div2_count = count
else:
print(0)
exit()
limit = m // lcm
ans = (limit + 1) // 2
print(ans)
| 0 | null | 77,640,177,825,148 | 199 | 247 |
n,m=map(int,input().split());print(n*m)
|
import numpy as np
a, b, c, d = map(int, input().split())
hoge = []
hoge.append(a*c)
hoge.append(a*d)
hoge.append(b*c)
hoge.append(b*d)
print(max(hoge))
| 0 | null | 9,403,889,886,226 | 133 | 77 |
from collections import deque
N = int(input())
A = [[] for i in range(N)]
B = []
for i in range(N-1):
a = list(map(int, input().split()))
A[a[0]-1].append([a[1]-1, 0])
A[a[1]-1].append([a[0]-1, 1])
B.append(a)
K = 0
D = {}
C = [0 for i in range(N)]
de = deque([[0, -1]])
while len(de):
n = de.pop()
C[n[0]] = 1
color = 1
for a in A[n[0]]:
if C[a[0]] == 1:
continue
if color == n[1]:
color += 1
if a[1] == 0:
D[str(n[0])+","+str(a[0])] = color
else:
D[str(a[0])+","+str(n[0])] = color
de.append([a[0], color])
K = max(K, color)
color += 1
print(K)
for b in B:
print(D[str(b[0]-1)+","+str(b[1]-1)])
|
n = int(input())
G = [[] for _ in range(n)]
edge = []
for _ in range(n-1):
a, b = map(int, input().split())
a -= 1
b -= 1
G[a].append(b)
edge.append(b)
from collections import deque
q = deque()
color = [0]*n
q.append(0)
while q:
cur = q.popleft()
c = 1
for nx in G[cur]:
if color[cur] == c:
c += 1
color[nx] = c
c += 1
q.append(nx)
print(max(color))
for e in edge:
print(color[e])
| 1 | 136,034,487,634,760 | null | 272 | 272 |
import sys
def input():
return sys.stdin.readline().strip()
sys.setrecursionlimit(20000000)
MOD = 10 ** 9 + 7
INF = float("inf")
def main():
L, R, d = map(int, input().split())
r = R // d
l = (L - 1) // d
print(r - l)
if __name__ == "__main__":
main()
|
l,R, d = map(int, input().split())
a =0
for i in range(l,R+1):
if i % d == 0:
a = a+1
print(a)
| 1 | 7,625,750,122,230 | null | 104 | 104 |
import time
import copy
start_time = time.time()
#input
D = int(input())
c_list = list(map(int, input().split()))
s_grid = []
for i in range(D):
array = list(map(int, input().strip().split(' ')))
s_grid.append(array)
def calculate_score(d,t,last):
score = s_grid[d][t]
last[t] = -1
for i in range(26):
score -= c_list[i]*(last[i]+1)
return score
t_list = [] #task_list
last_list = [0 for _ in range(26)]
total_score = 0
for k in range(0,D):
X = -1 # k-日目に変える番号を探す
p = 0
last = copy.deepcopy(last_list)
for i in range(26): # 26通り試す
tmp = calculate_score(k,i,last)
if tmp > p:
X = i
p = tmp
#最大のXを投入
total_score += p
t_list.append(X)
last_list = [i+1 for i in last_list]
last_list[X] = 0
#if time.time() - start_time > 1.9:
# break
for j in range(len(t_list)):
print(int(t_list[j]) + 1)
|
import queue
I=lambda:map(int,input().split())
N,M=I()
ls=[[] for _ in range(N+1)]
for _ in[0]*M:
A,B=I()
ls[A]+=[B]
ls[B]+=[A]
q = queue.Queue()
v=[-1]*(N+1)
v[0]=v[1]=0
q.put(1)
while not(q.empty()):
top=q.get()
for l in ls[top]:
if v[l]<0:
v[l]=top
q.put(l)
if -1 in v:
print("No")
else:
print("Yes")
[print(k) for k in v[2::]]
| 0 | null | 15,119,694,244,230 | 113 | 145 |
while True:
H, W = list(map(int, input().split()))
if H == 0 and W == 0:
break
for height in range(H):
if height%2 == 0:
flag = True
else:
flag = False
for wide in range(W):
if flag:
print('#', end='')
else:
print('.', end='')
flag = not(flag)
print('')
print('')
|
b = []
c = []
d = []
while True:
a = input().split()
a[0] = int(a[0])
a[1] = int(a[1])
if a[0] == 0 and a[1] == 0:
break
elif a[1]%2 == 0:
b.append("#."*(a[1]//2)+"#")
c.append((a[0],a[1]))
else:
b.append("#."*(a[1]//2)+"#.")
c.append((a[0],a[1]))
for i in range(len(c)):
if c[i][0]%2 == 0:
for j in range(c[i][0]//2):
print(b[i][0:-1])
print(b[i][1:])
else:
for j in range(c[i][0]//2):
print(b[i][0:-1])
print(b[i][1:])
print(b[i][0:-1])
print("\n",end="")
| 1 | 878,156,713,600 | null | 51 | 51 |
s=input()
dict1={7:'SUN',6:'MON',5:'TUE',4:'WED',3:'THU',2:'FRI',1:'SAT'}
keys = [k for k, v in dict1.items() if v == s]
print(keys[0])
|
weekday = ['SUN', 'SAT', 'FRI', 'THU', 'WED', 'TUE', 'MON']
val = input()
if val == 'SUN':
print("7")
else:
print(weekday.index(val))
| 1 | 133,500,975,778,940 | null | 270 | 270 |
def main():
n, k = map(int, input().split())
arr = list(map(int, input().split()))
L, R = 0, max(arr)
while L+1 < R:
P = (L+R+1)//2
cnt = 0
for a in arr:
if P < a:
if a % P == 0:
cnt += a//P - 1
else:
cnt += a//P
if cnt <= k:
R = P
else:
L = P
print(R)
if __name__ == "__main__":
main()
|
def General_Binary_Search(L,R,cond,Integer=True,ep=1/(1<<20)):
"""一般的な二部探索を行う.
L:解の下限
R:解の上限
cond:条件(1変数関数,単調減少を満たす)
Integer:解を整数に制限するか?
ep:Integer=Falseのとき,解の許容する誤差
"""
if Integer:
R+=1
while R-L>1:
C=L+(R-L)//2
if cond(C):
L=C
else:
R=C
return L
else:
C=(R-L)/2
while (R-C)>ep:
if cond(C):
L=C
else:
R=C
C=L+(R-L)/2
return C
#======================================
N,K=map(int,input().split())
A=list(map(int,input().split()))
def f(x):
r=0
for a in A:
r+=(a+x-1)//x
return r-N
print(-General_Binary_Search(-max(A),-1,lambda x:f(-x)<=K))
| 1 | 6,578,025,648,992 | null | 99 | 99 |
N = int(input())
A = []
for i in range(N+1):
if i % 3 == 0:
pass
elif i % 5 == 0:
pass
else:
A.append(i)
print(sum(A))
|
N = int(input())
A = 0
for i in range(1, N+1):
if i%3 > 0 and i%5 > 0:
A += i
print(A)
| 1 | 35,089,171,433,382 | null | 173 | 173 |
n,p=map(int,input().split())
s=input()
if p==2 or p==5:
ans=0
for i in range(n):
if int(s[i])%p==0:
ans+=i+1
print(ans)
else:
t=[]
ti=0
for i in range(n):
ti+=int(s[-i-1])*pow(10,i,p)
ti%=p
t.append(ti)
from collections import Counter
tc=Counter(t)
ans=0
for v in tc.values():
ans+=(v*(v-1))//2
if 0 in tc:
ans+=tc[0]
print(ans)
|
N, P = map(int, input().split())
S = [int(s) for s in input()]
if P == 2 or P == 5:
print(sum(i for i, s in enumerate(S, 1) if s % P == 0))
quit()
C = [0] * P
tens = 1
cur = 0
for s in reversed(S):
cur = (cur + s * tens) % P
C[cur] += 1
tens = (tens * 10) % P
print(C[0] + sum(c * (c - 1) // 2 for c in C))
| 1 | 58,064,350,602,232 | null | 205 | 205 |
def show (nums):
for i in range(len(nums)):
if i!=len(nums)-1:
print(nums[i],end=' ')
else :
print(nums[i])
n=int(input())
nums=list(map(int,input().split()))
show(nums)
for i in range(1,n):
v=nums[i]
j=i-1
while (j>=0 and nums[j]>v):
nums[j+1]=nums[j]
j-=1
nums[j+1]=v
show(nums)
|
# coding=utf-8
import sys
if __name__ == '__main__':
N = int(input())
li_A = list(map(int, input().split()))
ans = li_A[0]
if 0 in li_A:
print('0')
sys.exit()
for i in range(1, N):
if ans * li_A[i] > 1000000000000000000:
print('-1')
sys.exit()
else:
ans *= li_A[i]
print(ans)
| 0 | null | 8,006,482,035,420 | 10 | 134 |
k=int(input())
a,b = map(int,input().split())
while b>=a:
if b%k==0:
print('OK')
break
b-=1
if b<a:
print('NG')
|
k = int(input())
a, b = (int(i) for i in input().split())
if b // k > (a-1) // k:
print("OK")
else:
print("NG")
| 1 | 26,400,642,149,464 | null | 158 | 158 |
S = input()
N = len(S)
K = int(input())
dp = [[[0 for _ in range(5)] for _ in range(2)] for _ in range(N+1)]
dp[0][0][0] = 1
"""
遷移
dp[i][1][j] -> dp[i+1][1][j] : i-1桁目までに0以外の数字がj個あり、i桁目に0を入れた
dp[i][1][j] -> dp[i+1][1][j+1] : i-1桁目までに0以外の数字がj個あり、i桁目に0以外を入れた
dp[i][0][j] -> dp[i+1][1][j] : i-1桁目がSと一致していて、i-1桁目までに0以外の数字がj個あり、までに0以外の数字がj個あり、i桁目に0を入れた
dp[i][0][j] -> dp[i+1][1][j] : i-1桁目がSと一致していて、i-1桁目までに0以外の数字がj個あり、までに0以外の数字がj個あり、i桁目に0以外を入れた
dp[i][0][j] -> dp[i+1][0][j+?] : i桁目までSと一致。i桁目が0以外なら、?=1
"""
for i in range(N):
for k in range(4):
for j in range(10):
if j == 0:
# i桁目に0をあてた
dp[i+1][1][k] += dp[i][1][k]
else:
# i桁目に0以外をあてた
dp[i+1][1][k+1] += dp[i][1][k]
if j < int(S[i]):
if j == 0:
dp[i+1][1][k] += dp[i][0][k]
else:
dp[i+1][1][k+1] += dp[i][0][k]
elif j == int(S[i]):
if j == 0:
dp[i+1][0][k] += dp[i][0][k]
else:
dp[i+1][0][k+1] += dp[i][0][k]
print(dp[-1][0][K] + dp[-1][1][K])
|
a, b = map(int, input().split())
print('a ', end='')
if a < b:
print('<', end='')
elif a > b:
print('>', end='')
elif a == b:
print('==', end='')
print(' b')
| 0 | null | 38,201,039,383,648 | 224 | 38 |
n = input()
if len(n) < 3:
print(1000 - int(n))
else:
hasuu = n[len(n) - 3:]
if hasuu == '000':
print('0')
else:
print(1000-int(hasuu))
|
a, b, c, d = map(int, input().split())
x = [a, min(a+1, b), max(a, b-1), b]
y = [c, min(c+1, d), max(c, d-1), d]
ans = -int(1e19)
for i in x:
for j in y:
ans = max(ans, i*j)
print(ans)
| 0 | null | 5,765,280,841,332 | 108 | 77 |
from collections import deque
N = int(input())
K = 0
Ans = [0] * (N-1)
Edge = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, input().split())
a -= 1
b -= 1
Edge[a].append((b, _))
Edge[b].append((a, _))
Q = deque()
Q.append((0, 0))
P = [-1] * N
while Q:
now, color = Q.popleft()
cnt = 1
for nex, num in Edge[now]:
if cnt == color:
cnt += 1
if nex == P[now]:
continue
if Ans[num] != 0:
continue
Q.append((nex, cnt))
Ans[num] = cnt
K = max(cnt, K)
cnt += 1
print(K)
for a in Ans:
print(a)
|
N = int(input())
query = [[] for _ in range(N)]
color = []
m = [0]*N
for n in range(N-1):
a, b = map(int, input().split())
query[a-1].append(b-1)
query[b-1].append(a-1)
color.append((min(a, b), max(a, b)))
m[a-1] += 1
m[b-1] += 1
print(max(m))
from collections import deque
queue = deque()
queue.appendleft(0)
checked = [-1]*N
checked[0] = 0
dic = {}
while queue:
v = queue.pop()
oya = checked[v]
lis = query[v]
cnt = 1
for i in lis:
if checked[i]!=-1:
continue
if cnt==oya:
cnt += 1
queue.appendleft(i)
dic[(min(v+1, i+1), max(v+1, i+1))] = cnt
checked[i] = cnt
cnt += 1
for n in range(N-1):
a, b = color[n]
print(dic[(min(a, b), max(a, b))])
| 1 | 135,430,528,294,392 | null | 272 | 272 |
import statistics
N = int(input())
A = []
B = []
for _ in range(N):
a, b = map(int, input().split())
A.append(a)
B.append(b)
A.sort()
B.sort()
if N % 2 == 1:
med_min = A[N // 2]
med_max = B[N // 2]
print(med_max - med_min + 1)
else:
med_min_db = A[N // 2] + A[N // 2 - 1]
med_max_db = B[N // 2] + B[N // 2 - 1]
print(med_max_db - med_min_db + 1)
|
N = int(input())
A, B = [], []
for i in range(N):
a, b = map(int, input().split())
A += [a]
B += [b]
A.sort()
B.sort()
if N%2 == 1:
med_minimum = A[(N-1)//2]
med_maximum = B[(N-1)//2]
else:
med_minimum = (A[(N-2)//2] + A[(N-2)//2+1])
med_maximum = (B[(N-2)//2] + B[(N-2)//2+1])
print(med_maximum - med_minimum + 1)
| 1 | 17,255,487,310,880 | null | 137 | 137 |
import copy
from sys import stdin
N = int(stdin.readline().rstrip())
L = [ int(x) for x in stdin.readline().rstrip().split()]
count = 0
for i in range(N):
A = L.pop()
Ln = copy.copy(L)
for j in range(len(Ln)):
B = Ln.pop()
Lm = copy.copy(Ln)
for k in Lm:
C = k
if ( A != B ) and ( B != C ) and ( C != A ) and ( A + B > C ) and ( B + C > A ) and ( C + A > B ):
count+=1
print(count)
|
def check(a,b,c):
if a==b or a==c or b==c:
return False
if a+b>c and b+c>a and c+a>b:
return True
return False
n=int(input())
c=list(map(int,input().split()))
count=0
for i in range(len(c)-2):
for j in range(i+1,len(c)-1):
for k in range(j+1,len(c)):
if check(c[i],c[j],c[k]):
count+=1
print(count)
| 1 | 5,064,422,581,180 | null | 91 | 91 |
n, m = map(int, input().split())
s = input()
s = ''.join(reversed(s))
ans = []
index = 0
while index < n:
next_index = -1
for j in range(min(index + m, n), index, -1):
if s[j] == '0':
next_index = j
break
if next_index == -1:
ans = [-1]
break
ans.append(next_index - index)
index = next_index
print(' '.join(list(map(str, list(reversed(ans))))))
|
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
class Bisect:
def __init__(self, func):
self.__func = func
def bisect_left(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if self.__func(mid) < x:
lo = mid+1
else:
hi = mid
return lo
def bisect_right(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if x < self.__func(mid):
hi = mid
else:
lo = mid+1
return lo
@mt
def slv(N, M, S):
from functools import lru_cache
@lru_cache(maxsize=None)
def dfs(x):
if x == 0:
return []
for i in range(M, 0, -1):
if 0 <= x-i and S[x-i] == '0':
r = dfs(x-i)
if r is not None:
r.append(i)
return r
return None
ans = dfs(N)
if ans is None:
ans = [-1]
return ans
def main():
N, M = read_int_n()
S = read_str()
print(*slv(N, M, S))
if __name__ == '__main__':
main()
| 1 | 138,883,472,301,222 | null | 274 | 274 |
pages=int(input())
papers=pages/2
res=int(papers)
if pages%2==0:
print(res)
else:
print(res+1)
|
n = int(input())
print('{:.10f}'.format(1-(n//2 / n)))
| 0 | null | 117,882,504,489,010 | 206 | 297 |
n = input()
a = map(int, raw_input().split())
c = 0
for i in range(n):
mini = i
for j in range(i, n):
if a[j] < a[mini]:
mini = j
if a[i] != a[mini]:
a[i], a[mini] = a[mini], a[i]
c += 1
print(" ".join(map(str, a)))
print(c)
|
H, N = map(int, input().split())
Magic = [list(map(int, input().split())) for i in range(N)]
MAX_COST = max(Magic)[1]
# dp[damage] := モンスターに damage を与えるために必要な最小コスト
dp = [float('inf')] * (H + 1)
dp[0] = 0
for h in range(H):
for damage, cost in Magic:
next_index = min(h + damage, H)
dp[next_index] = min(dp[next_index], dp[h] + cost)
print(dp[-1])
| 0 | null | 40,703,519,154,640 | 15 | 229 |
N = int(input())
D = []
for i, a in enumerate(map(int, input().split())):
D.append((a<<11) + i)
D.sort(reverse=True)
dp = [0]*(N+1)
for i, d in enumerate(D,start=1):
x, a = d%(1<<11),d>>11
for j in reversed(range(i)):
dp[j+1] = max(dp[j] + a*(x-j), dp[j+1])
dp[j] += a*(N-(i-j)-x)
print(max(dp))
|
n = int(input())
A = list(map(int,input().split()))
A = sorted([(a,i) for i,a in enumerate(A)],reverse=True)
dp=[[0]*(n+1) for i in range(n+1)]
# i+j=n
for i in range(n):
for j in range(n-i):
a,k=A[i+j]
dp[i+1][j]=max(dp[i+1][j], dp[i][j]+abs(k-i)*a)
dp[i][j+1]=max(dp[i][j+1], dp[i][j]+abs((n-j-1)-k)*a)
ans=0
for i in range(n+1):
ans=max(ans,max(dp[i]))
print(ans)
| 1 | 33,836,372,123,372 | null | 171 | 171 |
#B問題
#ABSの定石使うとなぜかRE
#今回はPython解説サイト参照
#①入力を文字列で受け取る→②一文字ずつ整数に変換して、forループで回しながら足し算する
N = input()
cur = 0
for i in N:
cur += int(i)
if cur % 9 == 0:
print("Yes")
else:
print("No")
|
import sys
def lcm(a,b):
return a*b//gcd(a,b)
def gcd(a,b):
while True:
a,b = b,a%b
if b==0:
return a
for line in sys.stdin:
a,b = map(int, line.split())
print("{} {}".format(gcd(a,b),lcm(a,b)))
| 0 | null | 2,178,133,274,790 | 87 | 5 |
MOD = 10 ** 9 + 7
N, K = map(int, input().split())
# cnt(n): gcd = n となる数列の個数
cnt = [0] * (K + 1)
# A1,...,ANのすべてがxの倍数である数列の個数 = floor(k/x)^N個
for n in range(1, K + 1):
cnt[n] = pow(K // n, N, MOD)
res = 0
for k in range(K, 0, -1):
p = 2
while p * k <= K:
cnt[k] -= cnt[p * k]
cnt[k] %= MOD
p += 1
res += cnt[k] * k
res %= MOD
print(res)
|
a,b = map(int,input().split())
ans = 0
if a == 1 or b == 1:
print(1)
elif a*b % 2 == 0:
print(int(a*b/2))
else:
print(int((a*b-1)/2 + 1))
| 0 | null | 43,662,965,489,924 | 176 | 196 |
input()
A = [int(x) for x in input().split()]
input()
ms = [int(x) for x in input().split()]
enable_create = [False]*2000
for bit in range(1 << len(A)):
n = 0
for i in range(len(A)):
if 1 & (bit >> i) == 1:
n += A[i]
enable_create[n] = True
for m in ms:
print("yes" if enable_create[m] else "no")
|
while True:
number_of_input = int(raw_input())
if number_of_input == 0:
break
values = [float(x) for x in raw_input().split()]
second_moment = sum([x * x for x in values]) / number_of_input
first_moment = sum([x for x in values]) / number_of_input
print(second_moment - first_moment ** 2.0) ** 0.5
| 0 | null | 150,399,339,318 | 25 | 31 |
from fractions import gcd
n, m = map(int, input().split())
print(n * m // gcd(n, m))
|
def main():
r = int(input())
print(r**2)
return 0
if __name__ == '__main__':
main()
| 0 | null | 129,465,364,885,346 | 256 | 278 |
n,k = map(int,input().split())
count = 1
while k<=n:
n //= k
count += 1
print(count)
|
n = input()
data = [int(i) for i in input().split(' ')]
def insertion_sort(raw_list):
for i, v in enumerate(raw_list):
if i == 0:
continue
j = i - 1
while j >= 0 and v < raw_list[j]:
raw_list[j+1] = v
raw_list[j+1] = raw_list[j]
j -= 1
raw_list[j+1] = v
print(' '.join([str(i) for i in raw_list]))
return raw_list
print(' '.join([str(i) for i in data]))
insertion_sort(data)
#print(' '.join([str(i) for i in insertion_sort(data)]))
| 0 | null | 32,318,048,860,812 | 212 | 10 |
import sys
s = input()
k = int(input())
n = len(s)
all_same = True
for i in range(n-1):
if s[i] != s[i+1]:
all_same = False
if all_same:
print((n*k)//2)
sys.exit()
head_same = 1
for i in range(n-1):
if s[i] == s[i+1]:
head_same += 1
else:
break
tail_same = 1
for i in range(n-1,0,-1):
if s[i] == s[i-1]:
tail_same += 1
else:
break
head_tail_same = 0
if s[0] == s[-1]:
head_tail_same = head_same + tail_same
def return_internal_same(ls):
i = 0
same_count = 1
return_value = 0
while i < len(ls)-1:
if ls[i] != ls[i+1]:
i += 1
return_value += same_count // 2
same_count = 1
continue
else:
same_count += 1
i += 1
return_value += same_count // 2
return return_value
# head_tial_sameがあるかどうかで場合わけ
if head_tail_same > 0:
ans = head_same//2 + tail_same//2
ans += (k-1) * (head_tail_same//2)
ans += k*(return_internal_same(s[head_same:n-tail_same]))
else:
ans = k*(head_same//2 + tail_same//2)
ans += (k-1) * (head_tail_same//2)
ans += k*(return_internal_same(s[head_same:n-tail_same]))
print(ans)
|
s = input()
k = int(input())
n = len(s)
renzoku_flag =False
renzoku_count = 0
count = 0
for i in range(n):
if i != n-1:
if s[i] == s[i+1]:
renzoku_count += 1 #iのをカウントしている
else:
renzoku_count += 1 #i+1の分をカウント
count += renzoku_count // 2
renzoku_count = 0
else:
if s[n-2] == s[n-1]:
renzoku_count += 1
count += renzoku_count // 2
if s[0] != s[-1]:
print(count*k)
else:
ans = count*k
initial = s[0]
start_count = 0
for i in range(n):
if s[i] == initial:
start_count += 1
else:
break
else:
print(n*k//2)
exit()
end_count = 0
for i in range(n)[::-1]:
if s[i] == initial:
end_count += 1
else:
break
ans -= (start_count//2 + end_count//2 - (start_count+end_count)//2)*(k-1)
print(ans)
| 1 | 174,802,658,264,560 | null | 296 | 296 |
n,k = list(map(int,input().split()))
tmp = n % k
if tmp <= abs(tmp - k):
print(tmp)
else:
print(abs(tmp - k))
|
input_num = int(input())
sequence = '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'
list = sequence.split(',')
term = list[input_num - 1]
print(int(term))
| 0 | null | 44,624,117,744,840 | 180 | 195 |
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():
N, K = map(int, readline().split())
point = list(map(int, readline().split()))
T = readline().strip()
T = list(map(int, T.translate(str.maketrans('rsp', '012'))))
hand = [0] * N
ans = 0
for i, h in enumerate(T):
win = (h - 1) % 3
if i >= K and win == hand[i - K]:
hand[i] = -1
else:
hand[i] = win
ans += point[win]
print(ans)
return
if __name__ == '__main__':
main()
|
# -*- coding:utf-8 -*-
n = int(input())
s=''
for i in range(1,n+1):
if i%3==0 or i%10==3:
s = s + " " + str(i)
continue
else:
x = i
while x >0:
x //= 10
if x%10==3:
s = s + " " + str(i)
break
print(s)
| 0 | null | 53,666,005,623,428 | 251 | 52 |
from collections import deque
que = deque()
n = int(input())
for loop in range(n):
input_command = input()
if input_command == 'deleteFirst':
que.popleft()
elif input_command == 'deleteLast':
que.pop()
else:
command, x = input_command.split()
if command == 'insert':
que.appendleft(x)
elif command == 'delete':
try:
que.remove(x)
except:
pass
print(' '.join(que))
|
import collections,sys
def s():
d = collections.deque()
input()
for e in sys.stdin:
if "i"==e[0]: d.appendleft(e[7:-1])
else:
if " "==e[6]:
m = e[7:0-1]
if m in d: d.remove(m)
elif "i"==e[7]: d.popleft()
else: d.pop()
print(*d)
s()
| 1 | 50,415,116,180 | null | 20 | 20 |
print(sum(i**4%15%2*i for i in range(int(input())+1)))
|
def main():
n = int(input())
ans = 0
for i in range(1, n + 1):
if (i % 3 != 0) and (i % 5 != 0):
ans += i
print(ans)
main()
| 1 | 34,913,307,317,010 | null | 173 | 173 |
from collections import deque
n = int(input())
C = [input() for i in range(n)]
A = deque([])
for c in C:
if c == 'deleteFirst':
A.popleft()
elif c == 'deleteLast':
A.pop()
elif 'delete' in c:
q = int(c[7:])
if q in A:
A.remove(q)
elif 'insert' in c:
q = int(c[7:])
A.appendleft(q)
print(' '.join(map(str, A)))
|
import sys
input = sys.stdin.readline
N, M, L = map(int, input().split())
INF = float('inf')
VD = [[INF] * N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
VD[a][b] = c
VD[b][a] = c
for i in range(N):
VD[i][i] = 0
for k in range(N):
for i in range(N):
for j in range(N):
if VD[i][j] > VD[i][k] + VD[k][j]:
VD[i][j] = VD[i][k] + VD[k][j]
WD = [[INF] * N for _ in range(N)]
for i in range(N):
WD[i][i] = 0
for j in range(i+1,N):
d = VD[i][j]
if d <= L:
WD[i][j] = 1
WD[j][i] = 1
for k in range(N):
for i in range(N):
for j in range(N):
if WD[i][j] > WD[i][k] + WD[k][j]:
WD[i][j] = WD[i][k] + WD[k][j]
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
print(WD[s-1][t-1]-1 if WD[s-1][t-1] < INF else -1)
| 0 | null | 86,620,674,323,590 | 20 | 295 |
import sys
sys.setrecursionlimit(10**6)
N,M = map(int,input().split())
class Union_Find():
def __init__(self,n):
self.n = n
self.root = [-1]*(n+1)
self.rank = [0]*(n+1)
def find_root(self,x):
if self.root[x]<0:
return x
else:
self.root[x] = self.find_root(self.root[x])
return self.root[x]
def unite(self,x,y):
x = self.find_root(x)
y = self.find_root(y)
if x==y:
return
elif self.rank[x]>self.rank[y]:
self.root[x]+=self.root[y]
self.root[y]=x
else:
self.root[y]+=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y]+=1
def same(self,x,y):
return self.find_root(x)==self.find_root(y)
def cnt(self,x):
return -self.root[self.find_root(x)]
G=Union_Find(N)
ans=0
for i in range(M):
a,b=map(int,input().split())
G.unite(a,b)
for i in range(1,N+1):
ans = max(ans,G.cnt(i))
print(ans)
|
n, m = map(int, input().split())
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
#xが属する集合の個数
def size(x):
return -par[find(x)]
par = [-1]*(n+1)
for i in range(m):
a, b = map(int, input().split())
unite(a, b)
ans = 0
for i in range(1,n+1):
ans = max(ans, size(i))
print(ans)
| 1 | 3,978,886,810,858 | null | 84 | 84 |
import numpy as np
from numba import njit
@njit
def solve(stdin):
n, k = stdin[:2]
A = stdin[2: 2 + n]
A = np.sort(A)[::-1]
F = np.sort(stdin[2 + n:])
def is_ok(x):
tmp = 0
for a, f in zip(A, F):
y = a * f
if y > x:
tmp += a - x // f
return tmp <= k
ok = 10 ** 16
ng = -1
while ok - ng > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
print(solve(np.fromstring(open(0).read(), dtype=np.int64, sep=' ')))
|
def resolve():
N,M = map(int,input().split())
if N % 2 == 1:
for i in range(M):
print(str(i+1) + " " + str(N-i))
else:
for i in range((M-1) // 2 + 1):
print(str(i+1) + " " + str(N-i))
for i in range((M-1) // 2 + 1 , M):
print(str(i+1) + " " + str(N-i-1))
resolve()
| 0 | null | 96,627,715,793,470 | 290 | 162 |
n, k = map(int, input().split())
snukes = []
for _ in range(k):
okashi = int(input())
snukes += [int(v) for v in input().split()]
target = 1
cnt = 0
l = list(set(snukes))
s = [int(v) for v in range(1, n + 1)]
for p in s:
if p not in l:
cnt += 1
print(cnt)
|
n, k = map(int, input().split())
xs = set()
for i in range(k):
d = int(input())
xs = xs.union(set(map(int, input().split())))
print(n - len(xs))
| 1 | 24,568,209,821,048 | null | 154 | 154 |
l =int(input())
s =input()
r = s.count("R")
g = s.count("G")
b = s.count("B")
A = r * g * b
B = 0
gapmax = (l - 3) // 2
for _ in range(gapmax+1):
for i in range(l-2-2*_):
c1, c2, c3 = s[i], s[i+1+_],s[i+2+2*_]
if not (c1 == c2) and not (c1 == c3) and not (c2 ==c3):
B += 1
print(A-B)
|
n = int(input())
s = input()
ans = s.count('R')*s.count('G')*s.count('B')
for i in range(n-2):
for j in range(i, n-1):
if s[i] != s[j]:
if 2*j-i <= n-1 and s[i]!=s[j] and s[i]!=s[2*j-i] and s[j]!=s[2*j-i]:
ans -= 1
print(ans)
| 1 | 36,262,678,328,100 | null | 175 | 175 |
# -*- coding: utf-8 -*-
# 1つの文字列
s = str(input())
ans = ''
for i in range(3):
ans = ans + s[i]
print(ans)
|
s=input()
if len(s) % 2 == 0:
if s == "hi"*(len(s)//2):
print("Yes")
else:
print("No")
else:
print("No")
| 0 | null | 34,041,770,157,152 | 130 | 199 |
n = int(input())
arr = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))
result = set()
for i in range(2**n):
tmp = 0
for j in range(n):
if i >> j & 1:
tmp += arr[j]
result.add(tmp)
for x in m:
print("yes" if x in result else "no")
|
import math
N = int(input())
ans = math.floor(N / 2)
if N % 2 == 0:
print(ans - 1)
else:
print(ans)
| 0 | null | 76,899,834,942,294 | 25 | 283 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = map(int, input().split())
C = list(map(int, input().split()))
dp = [f_inf] * (n + 1)
dp[0] = 0
for c in C:
for i in range(1, n + 1):
if i - c >= 0:
dp[i] = min(dp[i], dp[i - c] + 1)
print(dp[-1])
if __name__ == '__main__':
resolve()
|
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10 ** 9)
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
INF=float('inf')
N,M=MAP()
C=LIST()
dp=[INF]*(N+1)
dp[0]=0
for i in range(N):
for j in range(M):
if i+C[j]<=N:
dp[i+C[j]]=min(dp[i+C[j]], dp[i]+1)
print(dp[N])
| 1 | 141,660,006,350 | null | 28 | 28 |
import math
from decimal import Decimal, ROUND_HALF_UP
def lcm(a):
x = a[0]
for i in range(1, len(a)):
x = (x * a[i]) // math.gcd(x, a[i])
return x
def gcd(a):
temp = math.gcd(a[0], a[1])
for i in a:
temp = math.gcd(temp, i)
return temp
n,m = map(int, input().split(" "))
a = list(map(int, input().split(" ")))
zero = False
count = 0
#a = list(map(lambda x: x // 2, na))
mini = lcm(a)
if len(a) != 1:
maxi = gcd(a)
else:
maxi = a[0]
maxi2 = maxi
nibai = 1
while(True):
if maxi2 % 2 == 0:
nibai *= 2
maxi2 //= 2
else:
break
for i in a:
if i % (2 * nibai) == 0:
zero = True
break
#print(nibai, maxi, mini)
if not zero:
t = Decimal(str((m * 2 // mini) / 2))
#print(t)
print(t.quantize(Decimal('0'), rounding=ROUND_HALF_UP))
else:
print(0)
|
import sys, re
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2
from collections import deque, defaultdict, Counter
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop, heapify
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
class UnionFind():
def __init__(self, n):
self.n = n
# parents[i]: 要素iの親要素の番号
# 要素iが根の場合、parents[i] = -(そのグループの要素数)
self.parents = [-1] * n
def find(self, x):
if 0 > self.parents[x]:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
# 要素xが属するグループの要素数を返す
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
# 要素xが属するグループに属する要素をリストで返す
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
# 全ての根の要素をリストで返す
def roots(self):
return [i for i, x in enumerate(self.parents) if 0 > x]
# グループの数を返す
def group_count(self):
return len(self.roots())
# 辞書{根の要素: [そのグループに含まれる要素のリスト], ...}を返す
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
# print()での表示用
# all_group_members()をprintする
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M, K = MAP()
tree = UnionFind(N)
friends = [[] for _ in range(N)]
for _ in range(M):
A, B = MAP()
tree.union(A-1, B-1)
friends[A-1].append(B-1)
friends[B-1].append(A-1)
blocks = [[] for _ in range(N)]
for _ in range(K):
C, D = MAP()
blocks[C-1].append(D-1)
blocks[D-1].append(C-1)
for i in range(N):
blocks_cnt = sum([tree.same(i, j) for j in blocks[i]])
print(tree.size(i) - len(friends[i]) - 1 - blocks_cnt, end=" ")
print()
| 0 | null | 81,342,497,303,928 | 247 | 209 |
import sys, os, math, bisect, itertools, collections, heapq, queue, copy, array
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
visited = [-1] * N
G = [[False] * N for _ in range(N)]
for n in range(N):
u, k, *V = il()
for v in V:
G[n][v - 1] = True
que = queue.Queue()
que.put(0)
visited[0] = 0
while not que.empty():
now = que.get()
for n in range(N):
if G[now][n] and visited[n] == -1:
visited[n] = visited[now] + 1
que.put(n)
for n in range(N):
print(n + 1, visited[n])
if __name__ == '__main__':
main()
|
def bfs(G, s):
d = {key: -1 for key in G.keys()}
d[s] = 0
Q = [s]
while len(Q) > 0:
u = Q.pop(0)
for v in G[u]:
if d[v] < 0:
d[v] = d[u] + 1
Q.append(v)
return d
if __name__ == '__main__':
G = {}
n = int(input())
for _ in range(n):
tmp = list(map(int, input().split()))
u = tmp.pop(0)
k = tmp.pop(0)
G[u] = tmp
d = bfs(G, 1)
for node in G:
print('{0} {1}'.format(node, d[node]))
| 1 | 4,400,293,770 | null | 9 | 9 |
N = int(input())
S = str(input())
cnt = 0
for i in range(N-2):
if S[i]=='A' and S[i+1]=='B' and S[i+2]=='C':
cnt += 1
print(cnt)
|
n = int(input())
a = input()
print(a.count("ABC"))
| 1 | 99,067,944,838,870 | null | 245 | 245 |
#!/usr/bin/env python
n = int(input())
if n%2 == 1:
print(0)
exit()
mp = tmp = 0
while True:
if 5**tmp > n:
break
mp = tmp
tmp += 1
ans = 0
for i in range(1, mp+1):
ans += n//(2*(5**i))
print(ans)
|
n = int(input())
i = 10
ans = 0
while i <= n:
ans += (n // i)
i *= 5
print(ans if n & 1 == 0 else 0)
| 1 | 116,362,266,960,292 | null | 258 | 258 |
h, w, k = map(int, input().split())
s = [input() for _ in range(h)]
ans = []
vacant = 0
cnt = 0
for x in range(h):
if s[x] == '.' * w:
vacant += 1
continue
else:
cnt += 1
tmp = []
yet = False
for y in range(w):
if s[x][y] == '#':
if not yet:
yet = True
else:
cnt += 1
tmp.append(cnt)
for _ in range(vacant + 1):
ans.append(tmp)
vacant = 0
for _ in range(vacant):
ans.append(ans[-1])
for a in ans:
print(*a, sep=" ")
|
import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
IN=lambda : map(int, input().split())
LIN=lambda : list(IN())
mod=1000000007
#+++++
def main():
#a = int(input())
h,w,k = IN()
ss=0
ret=[]
kv=1
for i in range(h):
wd = input()
if ss >= 0 and wd == '.'*w:
ss+=1
elif wd == '.'*w:
al=ret[-1][:]
ret.append(al)
else:
al=[]
stf=True
for c in wd:
if stf and c == '#':
stf = False
elif c == '#':
kv+=1
al.append(kv)
else:
kv+=1
if ss >= 0:
for i in range(ss+1):
ret.append(al)
ss=-1
else:
ret.append(al)
for l in ret:
print(*l)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| 1 | 143,615,433,541,570 | null | 277 | 277 |
s = input()
t = input()
a = len(s) - len(t) + 1
c1= 0
for i in range(a):
c2 = 0
for j in range(len(t)):
if s[i+j] == t[j]:
c2 += 1
else:
continue
c1 = max(c1,c2)
print(len(t)-c1)
|
S=input()
T=input()
lenS=len(S)
lenT=len(T)
count=[]
for i in range(lenS-lenT+1):
c=0
for j in range(lenT):
if T[j]!=S[i+j]:
c=c+1
j=j+1
count.append(c)
i=i+1
print(min(count))
| 1 | 3,703,619,338,480 | null | 82 | 82 |
K = int(input())
S = input()
MOD = 10**9 + 7
length = len(S)
length_all = K + length
ans = 0
list_25 = [1] * (10**6 + 5)
list_26 = [1] * (10**6 + 5)
for i in range(1,10**6 + 5):
list_25[i] = list_25[i - 1] * 25 % MOD
list_26[i] = list_26[i - 1] * 26 % MOD
fact = [1] * (2 * 10**6 + 5)
fact_inv = [1] * (2 * 10**6 + 5)
for i in range(1, 2 * 10**6 + 5):
fact[i] = fact[i-1] * i % MOD
fact_inv[i] = fact_inv[i - 1] * pow(i, MOD - 2, MOD) % MOD
for i in range(K + 1):
ans += list_26[i] * list_25[K - i] % MOD * fact[length_all - i - 1] * fact_inv[length - 1] * fact_inv[K - i] % MOD
print(ans % MOD)
|
from collections import defaultdict
import sys
input = sys.stdin.readline
# エラトステネスの篩
#############################################################
def get_sieve_of_eratosthenes(n):
if not isinstance(n, int):
raise TypeError('n is int type.')
if n < 2:
raise ValueError('n is more than 2')
prime = [2]
limit = int(n**0.5)
data = [i + 1 for i in range(2, n, 2)]
while True:
p = data[0]
if limit <= p:
return prime + data
prime.append(p)
data = [e for e in data if e % p != 0]
#############################################################
# 素因数分解、リストで返す
#############################################################
def prime_factorize(n, prime_list):
a = []
for p in prime_list:
if p * p > n:
break
while True:
if n % p == 0:
a.append(p)
n //= p
else:
break
if n != 1:
a.append(n)
a.sort()
return a
#############################################################
N = int(input())
A = list(map(int, input().split()))
data = set(get_sieve_of_eratosthenes(10**6))
primes = defaultdict(int)
for i in range(N):
p = prime_factorize(A[i], data)
p_set = set(p)
for pi in p_set:
primes[pi] += 1
# print(primes)
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")
| 0 | null | 8,531,962,627,860 | 124 | 85 |
h, w, k = map(int, input().split(' '))
c = [input() for x in range(h)]
cnt = 0
for m in range(2**(h+w)):
cc = c.copy()
for ij in range(h+w):
if ((m >> ij) & 1):
if ij in range(h):
cc[ij] = '.'*w
if ij in range(h,h+w):
for t in range(h):
cc[t] = cc[t][:ij-h]+'.'+cc[t][ij+1-h:]
num = sum(cc[s].count('#') for s in range(h))
if num == k:
cnt += 1
print(cnt)
|
n,m = map(int,input().split())
wa = [0] * 10**6
ac = [0] * 10**6
ans = 0
for i in range(m):
str_p,str_m = map(str,input().split())
p = int(str_p)
if str_m =='WA':
if ac[p] == 0:
wa[p] += 1
else:
if ac[p] == 0:
ac[p] = 1
ans += wa[p]
print(sum(ac),ans)
| 0 | null | 51,156,518,597,870 | 110 | 240 |
k = int(input())
ans = k * "ACL"
print(ans)
|
while True:
h, w = map(int, input().split())
if not h and not w:
break
result = []
w2 = w >> 1
if w % 2:
for i in range(h):
if i % 2:
result.append(".#" * w2 + ".")
else:
result.append("#." * w2 + "#")
else:
for i in range(h):
if i % 2:
result.append(".#" * w2)
else:
result.append("#." * w2)
print("\n".join(result) + "\n")
| 0 | null | 1,503,939,731,938 | 69 | 51 |
n = int(input())
x = input().split()
min = 2**50
for p in range(100):
min_i = 0
if p in x:
continue
for i in x:
min_i = min_i + (int(i) - p)**2
if min_i <= min:
min = min_i
print(min)
|
def Rally():
# 入力
N = int(input())
X = list(map(int, input().split()))
# リストの最大値と最小値
max_num = max(X)
min_num = min(X)
# Pの座標を移動させて各座標の体力消耗を調べる
min_sum = list()
for P in range(min_num, max_num+1):
sum = 0
for i in range(N):
sum += (X[i] - P)**2
min_sum.append(sum)
# 戻り値
return min(min_sum)
result = Rally()
print(result)
| 1 | 65,557,514,528,980 | null | 213 | 213 |
n = int(input())
lst = [int(i) for i in input().split()]
min_n = min(lst)
max_n = max(lst)
min_count = 1000000000
for i in range(min_n, max_n + 1):
count = 0
for j in range(n):
count += (lst[j] - i) ** 2
if count < min_count:
min_count = count
print(min_count)
|
input()
x=list(map(int,input().split()))
r=10**10
for i in range(min(x),max(x)+1):
s=0
for j in x:
s+=(i-j)**2
r=min(r,s)
print(r)
| 1 | 65,315,341,738,712 | null | 213 | 213 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.