code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 6.82M
181,637B
⌀ | question_pair_id
float64 101M
180,471B
⌀ | code1_group
int64 2
299
| code2_group
int64 2
299
|
|---|---|---|---|---|---|---|
l=[]
l.append(int(input()))
l.append(int(input()))
l.append(int(input()))
l.append(int(input()))
l.append(int(input()))
l.append(int(input()))
l.append(int(input()))
l.append(int(input()))
l.append(int(input()))
l.append(int(input()))
l.sort()
l.reverse()
print l[0]
print l[1]
print l[2]
|
n = int(input())
ans = 0
for i in range(1, n):
x = n//i
y = x-1 if n==x*i else x
ans += y
print(ans)
| 0 | null | 1,303,969,608,192 | 2 | 73 |
s = input()
ans = chk = 0
ans = [-1] * (len(s)+1)
if s[0] == "<":
ans[0] = 0
if s[-1] == ">":
ans[-1] = 0
for i in range(len(s) - 1):
if s[i] == ">" and s[i+1] == "<":
ans[i+1] = 0
for i in range(len(s)):
if s[i] == "<":
ans[i+1] = ans[i] + 1
for i in range(-1, -len(s)-1,-1):
if s[i] == ">":
ans[i-1] = max(ans[i-1], ans[i]+1)
print(sum(ans))
|
# coding: utf-8
# hello worldと表示する
#dpでできないかな？
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
from math import floor, ceil,pi
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7
s=SI()
if s[0]!="<":
s="<"+s
if s[-1]!=">":
s=s+">"
#print(s)
state="<"
strs=[]
count=0
for i in range(len(s)):
if state=="<":
if s[i]=="<":
count+=1
else:
strs.append(count)
count=1
state=">"
else:
if s[i]==">":
count+=1
else:
strs.append(count)
count=1
state="<"
strs.append(count)
#print(strs)
ans=0
for i in range(len(strs)//2):
u=min(strs[2*i],strs[2*i+1])
v=max(strs[2*i],strs[2*i+1])
ans+=(u-1)*u//2+v*(v+1)//2
print(ans)
| 1 | 156,734,227,295,628 | null | 285 | 285 |
import statistics
while True:
n = int(input())
if n == 0:
break
str = input().split()
list = []
for i in range(n):
list.append(int(str[i]))
print(statistics.pstdev(list))
|
n=int(input())
d=list(map(int,input().split()))
if d[0] != 0:
print(0)
exit()
d.sort()
if d[1] == 0:
print(0)
exit()
cnt = 1
pre = 1
ans =1
i = 1
mod = 998244353
while i < n:
if d[i]-1 != d[i-1]:
ans = 0
while i!=n-1 and d[i+1] == d[i]:
i+=1
cnt+=1
ans *= pow(pre,cnt,mod)
ans %= mod
pre =cnt
cnt = 1
i+=1
print(ans)
| 0 | null | 77,200,050,076,500 | 31 | 284 |
def ST(A,k):
#標準形の文字列を与えたときに
#長さが1大きい標準形の文字列の集合を出力
OP = []
for a in A:
max_cord = 0
for i in range(len(a)):
max_cord = max(ord(a[i]),max_cord)
for i in range(97,max_cord+2):
OP.append(a+chr(i))
return OP
N = int(input())
n,A = 1,["a"]
while n < N:
A = ST(A,n)
n += 1
A.sort()
for i in range(len(A)):
print(A[i])
|
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools, bisect
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def S(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
alphabets = "abcdefghijklmnopqrstuvwxyz"
sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007
# nodeをリストに変換したらクソ遅かった
import pprint
class BalancingTree:
def __init__(self, n):
self.N = n
self.root = self.node(1<<n, 1<<n)
def __str__(self):
def debug_info(nd):
return (nd.value - 1, nd.left.value - 1 if nd.left else None, nd.right.value - 1 if nd.right else None)
def debug_node(nd):
v = debug_info(nd) if nd.value else ()
left = debug_node(nd.left) if nd.left else []
right = debug_node(nd.right) if nd.right else []
return [v, left, right]
return pprint.PrettyPrinter(indent=4).pformat(debug_node(self.root))
__repr__ = __str__
def append(self, v):# v を追加（その時点で v はない前提）
v += 1
nd = self.root
while True:
# v がすでに存在する場合に何か処理が必要ならここに書く
if v == nd.value:
return 0
else:
mi, ma = min(v, nd.value), max(v, nd.value)
if mi < nd.pivot:
nd.value = ma
if nd.left:
nd = nd.left
v = mi
else:
p = nd.pivot
nd.left = self.node(mi, p - (p&-p)//2)
break
else:
nd.value = mi
if nd.right:
nd = nd.right
v = ma
else:
p = nd.pivot
nd.right = self.node(ma, p + (p&-p)//2)
break
def leftmost(self, nd):
return self.leftmost(nd.left) if nd.left else nd
def rightmost(self, nd):
return self.rightmost(nd.right) if nd.right else nd
def find_l(self, v): # vより真に小さいやつの中での最大値（なければ-1）
v += 1
nd = self.root
prev = nd.value if nd.value < v else 0
while True:
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return prev - 1
else:
prev = nd.value
if nd.right:
nd = nd.right
else:
return prev - 1
def find_r(self, v): # vより真に大きいやつの中での最小値（なければRoot）
v += 1
nd = self.root
prev = nd.value if nd.value > v else 0
while True:
if v < nd.value:
prev = nd.value
if nd.left:
nd = nd.left
else:
return prev - 1
else:
if nd.right:
nd = nd.right
else:
return prev - 1
def max(self):
return self.find_l((1<<self.N)-1)
def min(self):
return self.find_r(-1)
def delete(self, v, nd = None, prev = None): # 値がvのノードがあれば削除（なければ何もしない）
v += 1
if not nd:
nd = self.root
if not prev:
prev = nd
while v != nd.value:
prev = nd
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return
else:
if nd.right:
nd = nd.right
else:
return
if (not nd.left) and (not nd.right):
if nd.value < prev.value:
prev.left = None
else:
prev.right = None
elif not nd.left:
if nd.value < prev.value:
prev.left = nd.right
else:
prev.right = nd.right
elif not nd.right:
if nd.value < prev.value:
prev.left = nd.left
else:
prev.right = nd.left
else:
nd.value = self.leftmost(nd.right).value
self.delete(nd.value - 1, nd.right, nd)
# v以下のものの中での最大値
def upper_bound(self, v):
upper = self.find_r(v)
return self.find_l(upper)
def lower_bound(self, v):
lower = self.find_l(v)
return self.find_r(lower)
def __contains__(self, v: int) -> bool:
return self.find_r(v - 1) == v
class node:
def __init__(self, v, p):
self.value = v
self.pivot = p
self.left = None
self.right = None
def main():
N = I()
s = S()
Q = I()
query = LR(Q)
trees = {ch: BalancingTree(25) for ch in alphabets}
for i, ch in enumerate(s):
trees[ch].append(i)
for q in query:
if q[0] == "1":
_, i, c = q
i = int(i) - 1
prev = s[i]
trees[prev].delete(i)
s[i] = c
trees[c].append(i)
else:
_, l, r = q
l, r = int(l) - 1, int(r) - 1
count = 0
for _, tree in trees.items():
first = tree.lower_bound(l)
if first != tree.root.value - 1 and first <= r:
count += 1
print(count)
if __name__ == '__main__':
main()
| 0 | null | 57,317,158,750,652 | 198 | 210 |
n=int(input())
s=input()
ans=0
for i in range(1000):
cs=str(i).zfill(3)
p=0
for c in cs:
p=s.find(c,p)
if p==-1:
break
p+=1
else:
ans+=1
print(ans)
|
class Factorial():
def __init__(self, mod=10**9 + 7):
self.mod = mod
self._factorial = [1]
self._size = 1
self._factorial_inv = [1]
self._size_inv = 1
def __call__(self, n):
return self.fact(n)
def fact(self, n):
''' n! % mod '''
if n >= self.mod:
return 0
self._make(n)
return self._factorial[n]
def _make(self, n):
if n >= self.mod:
n = self.mod
if self._size < n+1:
for i in range(self._size, n+1):
self._factorial.append(self._factorial[i-1]*i % self.mod)
self._size = n+1
def fact_inv(self, n):
''' n!^-1 % mod '''
if n >= self.mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
self._make(n)
if self._size_inv < n+1:
self._factorial_inv += [-1] * (n+1-self._size_inv)
self._size_inv = n+1
if self._factorial_inv[n] == -1:
self._factorial_inv[n] = self.modinv(self._factorial[n])
return self._factorial_inv[n]
@staticmethod
def xgcd(a, b):
'''
Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
'''
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(self, n):
g, x, _ = self.xgcd(n, self.mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % self.mod
def comb(self, n, r):
''' nCr % mod '''
if r > n:
return 0
t = self(n)*self.fact_inv(n-r) % self.mod
return t*self.fact_inv(r) % self.mod
def comb_with_repetition(self, n, r):
''' nHr % mod '''
t = self(n+r-1)*self.fact_inv(n-1) % self.mod
return t*self.fact_inv(r) % self.mod
def perm(self, n, r):
''' nPr % mod '''
if r > n:
return 0
return self(n)*self.fact_inv(n-r) % self.mod
n, m, k = map(int, input().split())
mod = 998244353
comb = Factorial(mod).comb
s = 0
for i in range(k+1, n):
t = comb(n-1, i)*m % mod
t = t*pow(m-1, n-1-i, mod) % mod
s = (s+t) % mod
ans = (pow(m, n, mod)-s) % mod
print(ans)
| 0 | null | 76,229,958,216,608 | 267 | 151 |
#!/usr/bin/env python3
def main():
import sys
input = sys.stdin.readline
A, B, N = map(int, input().split())
x = min(B - 1, N)
print((A * x) // B - A * (x // B))
if __name__ == '__main__':
main()
|
#176 A
N, X, T = list(map(int, input().split()))
if N % X == 0:
print((int(N/X)) * T)
else:
print((int(N/X) + 1) * T)
| 0 | null | 16,297,324,533,312 | 161 | 86 |
a, b = input().split()
a = int(a)
b = str(b).replace(".", "")
x = a * int(b)
if x < 100:
print(0)
else:
print(str(x)[:-2])
|
n = int(input())
S = list(map(int, input().split()))
c = 0
def merge(left, mid, right):
global c
L = S[left:mid] + [float('inf')]
R = S[mid:right] + [float('inf')]
i, j = 0, 0
for k in range(left, right):
if L[i] <= R[j]:
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
c += right - left
def merge_sort(left, right):
if left + 1 < right:
mid = (left + right) // 2
merge_sort(left, mid)
merge_sort(mid, right)
merge(left, mid, right)
merge_sort(0, n)
print(*S)
print(c)
| 0 | null | 8,409,965,193,762 | 135 | 26 |
f = list(map(int, input().split()))
print(str(min(f)) * max(f))
|
N = int(input())
A = [ x for x in input().split(" ")]
orig_A = A[:]
#bubblesort
for i in range(0, N):
for j in range(N-1, i, -1):
if int(A[j][1]) < int(A[j-1][1]):
A[j], A[j-1] = A[j-1], A[j]
print(*A)
print("Stable")
#selectionsort
for i in range(0, N):
minj = i
for j in range(i, N):
if int(orig_A[j][1]) < int(orig_A[minj][1]):
minj = j
orig_A[i], orig_A[minj] = orig_A[minj], orig_A[i]
print(*orig_A)
print("Stable" if A == orig_A else "Not stable")
| 0 | null | 42,109,401,809,002 | 232 | 16 |
import math
n=int(input())
print(int(360/math.gcd(n,360)))
|
while True:
n, x = [int(a) for a in input().split()]
if n == x == 0:
break
cnt = 0
for i in range(1, n):
for j in range(i + 1, n):
flag = False
for k in range(j + 1, n + 1):
if flag:
break
if (i + j + k) == x:
cnt += 1
flag = True
print(cnt)
| 0 | null | 7,120,104,886,404 | 125 | 58 |
a = list(map(str, input().strip()))
for i in range(0, len(a)):
if a[i] == '?':
a[i] = 'D'
print(''.join(a))
|
line = list(input())
N = len(line)
i = 1
for i in range(N):
if line[i] == "?":
line[i] = "D"
print("".join(line))
| 1 | 18,497,221,542,160 | null | 140 | 140 |
n = input()
a = int(n)
print(a**2)
|
r=int(input())
print(int(r**2))
| 1 | 145,760,336,661,378 | null | 278 | 278 |
s=input()
values=[int(val) for val in s.split()]
if sum(values)>=22:
print("bust")
else:
print("win")
|
tmp = input().split(" ")
a = int(tmp[0])
b = int(tmp[1])
c = int(tmp[2])
if a + b + c >= 22:
print("bust")
else:
print("win")
| 1 | 118,551,325,656,910 | null | 260 | 260 |
a,b,k=map(int,input().split())
if a>k:
a=a-k
b=b
elif a+b<=k:
b=0
a=0
elif a<=k:
b=b+(a-k)
a=0
print(a,b)
|
a,b,c = map(int,input().split())
if a>= c:
print(a-c,b)
elif a+b<=c:
print("0 0")
elif a < c and c < a+b:
print("0",a+b-c)
| 1 | 104,095,433,233,152 | null | 249 | 249 |
# coding: utf-8
# Here your code !
array = []
for i in range(10):
line = int(input())
array += [line]
result = sorted(array)[::-1]
print(result[0])
print(result[1])
print(result[2])
|
n, a, b = map(int, input().split())
if (b - a) % 2 == 0:
print((b-a) // 2)
exit()
else:
c = min(a - 1, n - b)
print(c + (b - a + 1) // 2)
exit()
| 0 | null | 54,820,050,643,970 | 2 | 253 |
n, m = map(int, input().split())
a = list(map(int, input().split()))
num = sum(a)
cnt = 0
for i in range(n):
if a[i] < num/(4*m):
continue
else:
cnt += 1
if cnt >= m:
print("Yes")
else:
print("No")
|
N, M = map(int, input().split())
A = list(map(int, input().split()))
A = sorted(A)
A = A[::-1]
X = sum(A)
Y = 1/4/M
ans = 'Yes'
for i in range(M):
if A[i]/X < Y:
ans = 'No'
print(ans)
| 1 | 38,484,764,352,898 | null | 179 | 179 |
H, W, K = map(int, input().split())
S = [input() for _ in range(H)]
def count(n):
A = [0]
c = 0
i = 1
while(n):
if n & 1:
A.append(i)
c += 1
n >>= 1
i += 1
A.append(H)
return c, A
ans = 2000
for n in range(1 << (H-1)):
c, A = count(n)
X = [0]*(len(A)-1)
j = 0
flag=True
while j < W:
for k in range(len(A)-1):
for i in range(A[k], A[k+1]):
if S[i][j] == "1":
X[k] += 1
for x in X:
if x > K:
if flag:
c += 10000
break
flag = True
c += 1
X = [0]*(len(A)-1)
break
else:
flag = False
j += 1
if c > 10000:
break
ans = min(ans, c)
print(ans)
|
#!/usr/bin/env python
# coding: utf-8
# In[1]:
N = int(input())
# In[15]:
def func(i,j,N):
ans = []
for x in range(1,N+1):
x_ = str(x)
if x_[0] == str(i) and x_[-1] == str(j):
ans += [x]
return ans
# In[23]:
ans = 0
for i in range(10):
for j in range(10):
ans += len(func(i,j,N))*len(func(j,i,N))
print(ans)
# In[ ]:
| 0 | null | 67,101,254,842,898 | 193 | 234 |
n = int(input())
a_list = list(map(int, input().split()))
ans_list =[0]*n
for i in range(n):
ans_list[a_list[i]-1] = i+1
print(*ans_list)
|
import sys
import bisect
input = sys.stdin.readline
n, d, a = map(int, input().split())
xh = sorted([tuple(map(int, input().split()))for _ in range(n)])
x_list = [x for x, h in xh]
damage = [0]*(n+1)
ans = 0
for i in range(n):
x, h = xh[i]
h -= damage[i]
if h <= 0:
damage[i+1] += damage[i]
continue
cnt = -(-h//a)
ans += cnt
damage[i] += cnt*a
end_idx = bisect.bisect_right(x_list, x+2*d)
damage[end_idx] -= cnt*a
damage[i+1] += damage[i]
print(ans)
| 0 | null | 130,774,999,383,560 | 299 | 230 |
import fileinput
for i, line in enumerate(fileinput.input()):
x = line.strip()
if x != '0':
print "Case %d: %s" % (i + 1, x)
else:
break
|
import math
import sys
if __name__ == '__main__':
for line in sys.stdin:
a,b = map(int,line.split())
print(math.gcd(a,b),(a*b) // math.gcd(a,b))
| 0 | null | 238,430,872,608 | 42 | 5 |
n,s = [input() for _ in range(2)]
print(s.count("ABC"))
|
X = int(input())
print(X + X**2 + X**3)
| 0 | null | 54,841,630,380,008 | 245 | 115 |
N, K = map(int, input().split())
h = list(map(int, input().split()))
ans = 0
for i in range(N):
if h[i] >= K: ans += 1
print(ans)
|
import math
import itertools
import sys
n,k = list(map(int,input().split()))
h = list(map(int,input().split()))
h.sort(reverse=True)
ans = 0
for i in range(len(h)):
if(h[i] < k):
ans = i
print(ans)
sys.exit()
print(len(h))
| 1 | 178,983,697,079,338 | null | 298 | 298 |
A = int(input())
B = int(input())
print(6//(A*B))
|
a = int(input())
b = int(input())
l = [a, b]
if not 1 in l:
print('1')
elif not 2 in l:
print('2')
else:
print('3')
| 1 | 110,760,966,974,012 | null | 254 | 254 |
s = input()
ans = "No"
for i in range(3):
if s[i]=="7" :
ans = "Yes"
print(ans)
|
N = input()
ans = 0
for i in range(3):
if N[i] == '7':
ans = 1
break
if ans == 1:
print('Yes')
else :
print('No')
| 1 | 34,567,155,250,630 | null | 172 | 172 |
S = input()
N = len(S)
def palindrome(string):
return 0 if string==string[::-1] else 1
ls1 = S[0:int((N-1)/2)]
ls2 = S[int((N+3)/2-1):N]
#print(ls1)
#print(ls2)
if palindrome(S) == palindrome(ls1) == palindrome(ls2) == 0:
print('Yes')
else:
print('No')
|
S = input()
N = len(S)
def is_palindrome(s):
return s == ''.join(list(reversed(s)))
ans = 'Yes' if is_palindrome(S) and is_palindrome(S[:(N-1)//2]) and is_palindrome(S[(N+1)//2:]) else 'No'
print(ans)
| 1 | 46,308,655,111,148 | null | 190 | 190 |
def fibonacci(n):
if n == 0 or n == 1:
F[n] = 1
return F[n]
if F[n] is not None:
return F[n]
F[n] = fibonacci(n - 1) + fibonacci(n - 2)
return F[n]
n = int(input())
F = [None]*(n + 1)
print(fibonacci(n))
|
# -*- coding: utf_8 -*-
n = int(input()) + 1
arr = [-1] * n
arr[0] = 1
arr[1] = 1
for i in range(2, len(arr)):
arr[i] = arr[i - 1] + arr[i - 2]
print(arr[n - 1])
| 1 | 1,954,787,408 | null | 7 | 7 |
N = int(input())
if(N > 81):
print("No")
else:
state='No'
for i in range(1,10):
for j in range(1,10):
if(i*j == N):
state='Yes'
break
if(i*j > N):
break
print(state)
|
n = int(input())
min_price = int(input())
max_diff = -1e9
for _ in range(n - 1):
p = int(input())
max_diff = max(p - min_price, max_diff)
min_price = min(p, min_price)
print(max_diff)
| 0 | null | 79,702,109,685,668 | 287 | 13 |
N = int(input())
print(input().count("ABC"))
|
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N,M=MI()
S=list(input())
S2=S[::-1]
now=0
ans=[]
while now!=N:
nxt=now+M
if nxt>N:
nxt=N
while S2[nxt]=="1":
nxt-=1
if now==nxt:
ans=[-1]
break
ans.append(nxt-now)
now=nxt
print(' '.join(map(str, ans[::-1])))
main()
| 0 | null | 119,829,423,178,300 | 245 | 274 |
A,B,C,D=map(int,input().split())
nT = 0
nA = 0
while C-B>0:
C -= B
nT += 1
while A-D>0:
A -= D
nA += 1
if nT <= nA:
print('Yes')
else:
print('No')
|
a, b, c, d = map(int, input().split())
t_death = a // d + 1 if a % d else a // d
a_death = c // b + 1 if c % b else c // b
if t_death >= a_death:
print('Yes')
else:
print('No')
| 1 | 29,534,935,976,640 | null | 164 | 164 |
given = input()
target = given*2
keyword = input()
if keyword in target:
print("Yes")
else:
print("No")
|
h,w,k = map(int,input().split())
s = [list(input()) for i in range(h)]
a = [[0]*w for i in range(h)]
num = 1
for i in range(h):
b = s[i]
if "#" in b:
t = b.count("#")
for j in range(w):
c = b[j]
# print(c)
if c=="#" and t!=1:
a[i][j] = num
num += 1
t -= 1
elif c=="#" and t==1:
a[i][j] = num
t = -1
else:
a[i][j] = num
if t==-1:
num += 1
else:
if i==0:
continue
else:
for j in range(w):
a[i][j] = a[i-1][j]
index = 0
for i in range(h):
if "#" not in s[i]:
index += 1
else:
break
for j in range(index):
for k in range(w):
a[j][k] = a[index][k]
for j in a:
print(*j)
| 0 | null | 72,508,809,316,818 | 64 | 277 |
N, K = map(int, input().split())
def sub_sum(l, r):
return (l + r) * (r - l + 1) / 2
ans = 0
for i in range(K, N+2):
l = sub_sum(0, i-1)
r = sub_sum(N-i+1, N)
ans += r - l + 1
ans = ans % (10**9+7)
print(int(ans))
|
n,k = map(int,input().split())
A = list(map(int,input().split()))
mod = 10**9 + 7
A.sort(key = lambda x:abs(x),reverse = True)
ans = 1
last = -1
lastp = -1
cnt = 0
for a in A:
if a >= 0:break
else:
if k&1:
for i in range(k):
ans *= A[n-i-1]
ans %= mod
else:
for i in range(k):
ans *= A[i]
ans %= mod
print(ans)
exit()
for i in range(k):
ans *= A[i]
ans %= mod
if A[i] < 0:
last = i
cnt += 1
if A[i] > 0:
lastp = i
if n == k:
print(ans%mod)
exit()
if cnt&1:
first = 0
firstp = 0
for a in A[k:]:
if a > 0 and firstp == 0:
firstp = a
if a < 0 and first == 0:
first = a
if first == 0 and firstp == 0:
ans = 0
elif first == 0 or lastp == -1:
ans *= pow(A[last],mod-2,mod)*firstp%mod
ans %= mod
elif firstp == 0:
ans *= pow(A[lastp],mod-2,mod)*first%mod
ans %= mod
else:
if A[lastp]*firstp <= A[last]*first:
ans *= pow(A[lastp],mod-2,mod)*first%mod
ans %= mod
else:
ans *= pow(A[last],mod-2,mod)*firstp%mod
ans %= mod
print(ans%mod)
| 0 | null | 21,284,302,039,800 | 170 | 112 |
K = int(input())
mod = 7
for i in range(K):
mod = mod % K
if(mod == 0):
print(i+1)
exit()
else:
mod *=10
mod += 7
print("-1")
|
k = int(input())
s = 7
num = 1
res = True
if k == 2:
print(-1)
else:
for i in range(k):
s %= k
if s == 0:
res = False
print(num)
break
num += 1
s *= 10
s += 7
if res:
print(-1)
| 1 | 6,145,402,088,292 | null | 97 | 97 |
while True:
n,x = map(int,input().split(" "))
if n == 0 and x == 0:
break
#データリスト作成
data = [m for m in range(1,n+1)]
data_list = []
cnt = 0
#n種類の数字があって、xになる組み合わせは？
for i in range(1,n+1):
for j in range(1+i,n+1):
for k in range(1+j,n+1):
if i+j+k == x:
cnt += 1
print(cnt)
|
A,B,K = map(int,input().split())
if A>=K:
answer = A-K,B
elif A+B>=K:
answer = 0,B-(K-A)
else:
answer = 0,0
print(answer[0],answer[1])
| 0 | null | 53,034,230,171,968 | 58 | 249 |
n, k, c = map(int, input().split())
s = input()
l = len(s) - 1
i = 0
lb = []
le = []
while i < len(s) and len(lb) < k:
if s[i] == 'o':
lb.append(i)
i += c + 1
continue
i += 1
while l > -1 and len(le) < k:
if s[l] == 'o':
le.append(l)
l -= (c + 1)
continue
l -= 1
le.sort()
for j in range(0, len(lb)):
if lb[j] == le[j]:
print(lb[j]+1)
|
n, k, c = map(int, input().split())
S = input()
# 要素の値は何回目の働く日か(0は働いていない状態)
by_left = [0] * n
by_right = [0] * n
# 左から貪欲
rest = 0
cnt = 1
for itr, s in enumerate(S):
rest -= 1
if rest <= 0 and s == "o":
by_left[itr] = cnt
cnt += 1
rest = c + 1
# 右から貪欲
rest = 0
cnt = k
for itr, s in enumerate(S[::-1]):
rest -= 1
if rest <= 0 and s == "o":
by_right[n - itr- 1] = cnt
cnt -= 1
rest = c + 1
# 左右からの貪欲で、どちらでも同じ働く回数の値が入っている日が必ず働く日
ans = [itr + 1 for itr, (i, j) in enumerate(zip(by_left, by_right)) if i != 0 and i == j]
for a in ans:
print(a)
| 1 | 40,697,935,628,668 | null | 182 | 182 |
# Aizu Problem ITP_1_11_A: Dice I
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def do_roll(dice, roll):
d1, d2, d3, d4, d5, d6 = dice
if roll == 'E':
return [d4, d2, d1, d6, d5, d3]
elif roll == 'W':
return [d3, d2, d6, d1, d5, d4]
elif roll == 'N':
return [d2, d6, d3, d4, d1, d5]
elif roll == 'S':
return [d5, d1, d3, d4, d6, d2]
else:
assert False, "We should never reach this point!"
dice = [int(_) for _ in input().split()]
for roll in input().strip():
dice = do_roll(dice, roll)
print(dice[0])
|
n = int(input())
a = list(map(int, input().split()))
a = a + [0]
state = a[0]
money = 1000
stock = 0
for i in range(1, n+1):
if state < a[i] and stock == 0:
stock += (money // state)
money %= state
elif state > a[i] and stock > 0:
money += (stock * state)
stock = 0
state = a[i]
print(money)
| 0 | null | 3,803,188,133,442 | 33 | 103 |
l = int(input())
ans = 0
edge = l/3
ans = edge**3
print(ans)
|
#!/usr/bin/env python3
n = int(input())
n /= 3
print(n**3)
| 1 | 47,215,752,744,022 | null | 191 | 191 |
S=str(input())
T=str(input())
c=len(S)
for i in range(len(S)):
if S[i]==T[i]: c=c-1
print(c)
|
s = input()
t = input()
n = len(s)
ans = n
for i in range(n):
if s[i] == t[i]:
ans -= 1
print(ans)
| 1 | 10,517,117,153,268 | null | 116 | 116 |
class Stack:
def __init__(self):
self.values = []
self.n = 0
def pop(self):
if self.n == 0:
raise Exception("stack underflow")
else:
v = self.values[-1]
del self.values[-1]
self.n -= 1
return v
def push(self,x):
self.values.append(x)
self.n += 1
operators = set(['+', '-', '*'])
stack = Stack()
for op in raw_input().split(' '):
if op in operators:
b = stack.pop()
a = stack.pop()
if op == '+':
stack.push(a+b)
elif op == '-':
stack.push(a-b)
elif op == '*':
stack.push(a*b)
else:
raise Exception("Unkown operator")
else:
stack.push(int(op))
print stack.pop()
|
def reverse_polish_notation(A):
ops = {'+': lambda a, b: b + a,
'-': lambda a, b: b - a,
'*': lambda a, b: b * a}
stack = []
for i in A:
if i in ops:
stack.append(ops[i](stack.pop(), stack.pop()))
else:
stack.append(int(i))
return stack[0]
if __name__ == '__main__':
A = list(input().split())
print(reverse_polish_notation(A))
| 1 | 34,508,286,400 | null | 18 | 18 |
import sys
def input(): return sys.stdin.readline().strip()
def resolve():
x,y=map(int, input().split())
ans=0
if x<=3:
ans+=100000
if x<=2:
ans+=100000
if x==1:
ans+=100000
if y<=3:
ans+=100000
if y<=2:
ans+=100000
if y==1:
ans+=100000
if x==1 and y==1:
ans+=400000
print(ans)
resolve()
|
money = [0, 300000, 200000, 100000]
a,b = map(int, input().split())
st = money[a if a < len(money) else 0] \
+ money[b if b < len(money) else 0]
if a == 1 and b == 1:
st += 400000
print(st)
| 1 | 140,716,609,435,908 | null | 275 | 275 |
#!/usr/bin/env pypy
print((int(input())+1)%2)
|
k, n =map(int,input().split())
a = list(map(int,input().split()))
longest = k - a[-1] + a [0]
for i in range(len(a)-1):
longest = max(longest,a[i+1]-a[i])
print(k-longest)
| 0 | null | 23,244,755,994,888 | 76 | 186 |
import sys
def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()
INF = float('inf')
n = I()
# 区間スケジューリング問題 : いくつかの区間の中から重ならないように最大で何個選べるか
# ソート + 貪欲法 で解ける
arm_pos = []
for _ in range(n):
x, l = LI()
arm_pos.append([x - l, x + l])
arm_pos = sorted(arm_pos, key=lambda x: x[1]) # アームの終点の位置でソート
ans = n
for i in range(n - 1):
if arm_pos[i][1] > arm_pos[i + 1][0]: # i のアームの終点が i + 1 のアームの始点 と重なっていた場合
arm_pos[i + 1] = arm_pos[i] # i + 1 のアームを取り除く
ans -= 1
print(ans)
|
import sys
input = sys.stdin.readline
n = int(input())
robots = [tuple(map(int, input().split())) for _ in range(n)]
robots.sort(key=(lambda robo: robo[0] + robo[1]))
z = -float('inf')
ans = 0
for x, l in robots:
if z <= x - l:
ans += 1
z = x + l
print(ans)
| 1 | 90,319,772,907,268 | null | 237 | 237 |
def main():
n,x,m = map(int,input().split())
a = [0] * m
b = [x]
ans = x
i = 1
while i < n:
x = (x*x) % m
if x == 0:
print(ans)
exit()
if a[x] == 0:
a[x] = i
b.append(x)
ans += x
i += 1
else :
q = len(b) - a[x]
qq = (n-len(b)) // q
qqq = (n-len(b)) % q
ans += sum(b[a[x]:]) * qq
ans += sum(b[a[x]:a[x]+qqq])
#print(b + b[a:] * qq + b[a:a+qqq])
print(ans)
exit()
print(ans)
if __name__ == '__main__':
main()
|
N, X, M = map(int, input().split())
sup = 10**11
db = [[0]*M for _ in range(sup.bit_length())]
dbcum = [[0]*M for _ in range(sup.bit_length())]
db[0] = [i**2 %M for i in range(M)]
dbcum[0] = [i**2 %M for i in range(M)]
for i in range(1,sup.bit_length()):
for j in range(M):
db[i][j] = db[i-1][db[i-1][j]]
dbcum[i][j] = dbcum[i-1][j]+dbcum[i-1][db[i-1][j]]
ans = X
p = 0
N -= 1
while N:
if N%2:
ans += dbcum[p][X]
X = db[p][X]
p += 1
N >>= 1
print(ans)
| 1 | 2,782,474,242,980 | null | 75 | 75 |
from math import gcd
class Factor:
def __init__(self, max_element):
self.minFactor = [-1]*(max_element+1)
for i in range(2, max_element+1):
if self.minFactor[i] == -1:
for j in range(i, max_element+1, i):
self.minFactor[j] = i
def getFactorSet(self, element):
retSet = set(1)
while element > 1:
retSet.add(element)
retSet.add(self.minFactor[element])
element //= self.minFactor[element]
return retSet
def getPrimeFactorSet(self, element):
retSet = set()
while element > 1:
retSet.add(self.minFactor[element])
element //= self.minFactor[element]
return retSet
def getPrimeFactorDic(self, element):
retDic = {}
while element > 1:
val = self.minFactor[element]
if val in retDic:
retDic[val] += 1
else:
retDic[val] = 1
element //= val
return retDic
def main():
n = int(input())
a = list(map(int, input().split()))
f = True
fact = Factor(max(a))
st = set()
for v in a:
fac_set = fact.getPrimeFactorSet(v)
for u in fac_set:
if u in st:
f = False
break
st.add(u)
if not f:
break
if f:
print("pairwise coprime")
else:
all_gcd = a[0]
for i in range(1, n):
all_gcd = gcd(all_gcd, a[i])
if all_gcd == 1:
print("setwise coprime")
else:
print("not coprime")
if __name__ == "__main__":
main()
|
from math import gcd
N = int(input())
A = list(map(int,input().split()))
g = A[0]
for i in range(1,N):
g = gcd(g,A[i])
if g>1:
print("not coprime")
exit()
MAXN = 10**6 + 9
D = [i for i in range(MAXN+1)]
p = 2
while(p*p <=MAXN):
if D[p]==p:
for q in range(2*p,MAXN+1,p):
if D[q]==q:
D[q]=p
p+=1
st = set()
for a in A:
tmp = set()
while(a>1):
tmp.add(D[a])
a //=D[a]
for p in tmp:
if p in st:
print("setwise coprime")
exit()
st.add(p)
print("pairwise coprime")
| 1 | 4,100,388,828,678 | null | 85 | 85 |
K = int(input())
s = 7
flg = False
cnt = 0
for i in range(K+1):
cnt += 1
if s % K == 0:
flg = True
break
s *= 10
s %= K
s += 7
if flg:
print(cnt)
else:
print(-1)
|
import numpy as np
from numba import njit
N, K = map(int, input().split(' '))
A = list(map(int, input().split(' ')))
a = np.array(A, dtype=int)
fin = [N] * N
@njit(cache=True)
def calc_b(a):
b = np.zeros(N, dtype=np.int64)
for i, _a in enumerate(a):
l = max(0, i - _a)
r = min(N - 1, i + _a)
# imos hou
b[l] += 1
if r + 1 < N:
b[r + 1] -= 1
b = np.cumsum(b)
# print('b_sum', b)
return b
for k in range(min(K,100)):
# print('a', a)
a = calc_b(a)
# if all(a == fin):
# break
a = [str(_) for _ in a]
print(' '.join(a))
# print('step=', k)
| 0 | null | 10,879,470,941,060 | 97 | 132 |
n=int(input())
if 30<=n :
print('Yes')
else:
print('No')
|
import sys
import itertools
input = sys.stdin.readline
sys.setrecursionlimit(100000)
def read_values():
return map(int, input().split())
def read_index():
return map(lambda x: x - 1, map(int, input().split()))
def read_list():
return list(read_values())
def read_lists(N):
return [read_list() for n in range(N)]
def functional(N, mod):
F = [1] * (N + 1)
for i in range(N):
F[i + 1] = (i + 1) * F[i] % mod
return F
INV = dict()
def inv(a, mod):
if a in INV:
return INV[a]
i = pow(a, mod - 2, mod)
INV[a] = i
return i
def C(F, a, b, mod):
return F[a] * inv(F[a - b], mod) * inv(F[b], mod) % mod
def main():
N, K = read_values()
mod = 10 ** 9 + 7
F = functional(5 * 10 ** 5, mod)
res = 0
if N <= K:
res = C(F, 2 * N - 1, N - 1, mod)
else:
for k in range(K + 1):
res += C(F, N, k, mod) * C(F, N - 1 , k, mod) % mod
print(res % mod)
if __name__ == "__main__":
main()
| 0 | null | 36,189,199,605,020 | 95 | 215 |
import sys
def ISI(): return map(int, sys.stdin.readline().rstrip().split())
h, a =ISI()
print((h+a-1)//a)
|
# abc149_b
A, B, K = map(int, input().split(" "))
if A>=K:
print(A-K, B)
elif B>=K-A:
print(0, B+A-K)
else:
print(0, 0)
| 0 | null | 90,531,051,687,758 | 225 | 249 |
k = int(input())
s = input()
if k>=len(s):
print(s)
else: print(s[:k] + "...")
|
n = int(input())
cnt = [-1] + [1] + [2] * 10000000
for i in range(2, 10000002 // 2):
for j in range(2 * i, 10000001, i):
cnt[j] += 1
ans = 0
for i in range(1, n + 1):
ans += i * cnt[i]
print(ans)
| 0 | null | 15,296,333,801,142 | 143 | 118 |
from fractions import gcd
from collections import Counter
slope=Counter()
slope_zero=0
slope_inf=0
both_zero=0
n=int(input())
for _ in range(n):
a,b=map(int,input().split())
if a==0 and b==0:
both_zero+=1
else:
if a==0:
slope_zero+=1
elif b==0:
slope_inf+=1
else:
sign=(a//abs(a))*(b//abs(b))
a=abs(a)
b=abs(b)
gc=gcd(a,b)
a//=gc
b//=gc
if sign==1:
slope[(a,b)]+=1
else:
slope[(-a,b)]+=1
ans=1
mod=10**9+7
for a,b in slope.keys():
if slope[(a,b)]>0:
aa=-b
bb=a
if bb<0:
bb*=-1
aa*=-1
if slope[(aa,bb)]>0:
ans*=(pow(2,slope[(a,b)],mod)+pow(2,slope[(aa,bb)],mod)-1+mod)%mod
ans%=mod
slope[(aa,bb)]=0
else:
ans*=(pow(2,slope[(a,b)],mod))%mod
ans%=mod
ans*=(pow(2,slope_zero,mod)+pow(2,slope_inf,mod)-1+mod)%mod
ans%=mod
ans+=both_zero
if ans>=mod:
ans%=mod
print((ans-1+mod)%mod)
|
# 解説と 13355391 を参考に実装予定
import math
def solve():
N = int(input())
ABs = [[int(i) for i in input().split()] for _ in range(N)]
mod = 10 ** 9 + 7
lonlieness = 0
pairs = {}
for AB in ABs:
a, b = AB
if a == 0 and b == 0:
lonlieness += 1
continue
elif a == 0:
a, b = -1, 0
bad_a, bad_b = 0, 1
elif b == 0:
a, b = (0, 1)
bad_a, bad_b = -1, 0
else:
_gcd = math.gcd(a, b)
a //= _gcd
b //= _gcd
bad_a = -b
bad_b = a
if b < 0:
a, b = -a, -b
if bad_b < 0:
bad_a, bad_b = -bad_a, -bad_b
pairs.setdefault((a, b), 0)
pairs.setdefault((bad_a, bad_b), 0) # 仲の悪いグループも登録しておく
pairs[(a, b)] += 1
permutations = []
for i, pair in enumerate(pairs.keys()):
if i % 2 == 1:
continue # 仲の悪いグループは隣り合っているので飛び石で計算
a, b = pair
bad_a, bad_b = -b, a
if bad_b < 0:
bad_a, bad_b = -bad_a, -bad_b
# gourp1 から1匹以上選ぶパターン + group2 から1匹以上選ぶパターン + どちらからも選ばないパターン計算する.
# group1 と group2 は仲が悪いので同時に選ばれることはない.
group_num = pow(2, pairs[(a, b)], mod) - 1
badgroup_num = pow(2, pairs[(bad_a, bad_b)], mod) - 1
permutations.append(group_num + badgroup_num + 1)
result = 1
for p in permutations:
result = result * p % mod
# 全員と仲が悪いイワシのパターンを足し, すべてのイワシを選ばないパターンを除外.
result = (result + lonlieness - 1) % mod
print(result)
if __name__ == '__main__':
solve()
| 1 | 21,031,454,195,764 | null | 146 | 146 |
W, H, x, y ,r = [int(i) for i in input().split()]
if x <= 0 or y <= 0:
print("No")
elif W - x >= r and H - y >= r:
print("Yes")
else:
print("No")
|
#!/usr/bin python3
# -*- coding: utf-8 -*-
def main():
N,S=map(int, input().split())
A = list(map(int,input().split()))
mod = 998244353
dp = [[0]*(S+1) for i in range(N+1)]
dp[0][0]=1
for i in range(N):
vi = A[i]
for j in range(S+1):
dp[i+1][j] += 2 * dp[i][j]
dp[i+1][j] %= mod
if j+vi<=S:
dp[i+1][j+vi] += dp[i][j]
dp[i+1][j+vi] %= mod
print(dp[N][S])
if __name__ == '__main__':
main()
| 0 | null | 9,145,810,500,700 | 41 | 138 |
S = input()
Sliststr = list(S)
Slist = [int(s) for s in Sliststr]
Smod = [0]
mod10 = [1]
count = [0]*2019
ans = 0
for i in range(len(S)-1):
mod10.append(mod10[i]*10%2019)
for i in range(len(S)):
Smod.append((Smod[i]+Slist[-i-1]*mod10[i])%2019)
for i in range(len(Smod)):
count[Smod[i]] += 1
for i in range(2019):
ans += count[i] * (count[i]-1) // 2
print(ans)
|
s = input()
len_s = len(s)
s_array = [int(i) for i in s]
mod = 2019
mod_array = [0]*mod
num = 0
mod_array[0] += 1
for i in range(len_s):
num = pow(10, i, mod) * s_array[len_s - i - 1] + num
num %= mod
mod_array[num] += 1
ans = 0
for i in mod_array:
ans += (i * (i - 1)) / 2
print(int(ans))
| 1 | 30,728,013,467,360 | null | 166 | 166 |
# 問題文
# 高橋君の夏休みはN日間です。
# 夏休みの宿題が M個出されており、i番目の宿題をやるにはAi日間かかります。
# 複数の宿題を同じ日にやることはできず、また、宿題をやる日には遊ぶことができません。
# 夏休み中に全ての宿題を終わらせるとき、最大何日間遊ぶことができますか？
# ただし、夏休み中に全ての宿題を終わらせることができないときは、かわりに -1 を出力してください。
# n（夏休みの日数）,m（宿題の数）：標準入力
# リストの中のA(宿題日)：リストを作成し、標準入力
n, m = map(int, input().split())
A = list(map(int, input(). split()))
# 最大で n −合計(A1+. . .+AM)日間遊ぶことができる
if n < sum(A): # 夏休みの日数より宿題日が多い場合：宿題をやる日数が足りない→終わらせることができない
print(-1)
else:
print(n-sum(A)) # その他→宿題は終わる→夏休みの日数-宿題日
# NameError: name 'N' is not defined
|
N,M = map(int, input().split())
A_list = [int(i) for i in input().split()]
playable_days = N - sum(A_list)
if playable_days >= 0:
print(playable_days)
else:
print("-1")
| 1 | 32,080,597,528,692 | null | 168 | 168 |
# -*- coding: utf-8 -*-
class dice_class:
def __init__(self, top, front, right, left, back, bottom):
self.top = top
self.front = front
self.right = right
self.left = left
self.back = back
self.bottom = bottom
def roll(self, s):
for i in s:
if i == 'E':
self.rollE()
elif i == 'N':
self.rollN()
elif i == 'S':
self.rollS()
elif i == 'W':
self.rollW()
def rollE(self):
tmp = self.top
self.top = self.left
self.left = self.bottom
self.bottom = self.right
self.right = tmp
def rollN(self):
tmp = self.top
self.top = self.front
self.front = self.bottom
self.bottom = self.back
self.back = tmp
def rollS(self):
tmp = self.top
self.top = self.back
self.back = self.bottom
self.bottom = self.front
self.front = tmp
def rollW(self):
tmp = self.top
self.top = self.right
self.right = self.bottom
self.bottom = self.left
self.left = tmp
if __name__ == "__main__":
a = map(int, raw_input().split())
s = str(raw_input())
dice = dice_class(a[0], a[1], a[2], a[3], a[4], a[5])
dice.roll(s)
print dice.top
|
# Aizu Problem ITP_1_11_A: Dice I
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def do_roll(dice, roll):
d1, d2, d3, d4, d5, d6 = dice
if roll == 'E':
return [d4, d2, d1, d6, d5, d3]
elif roll == 'W':
return [d3, d2, d6, d1, d5, d4]
elif roll == 'N':
return [d2, d6, d3, d4, d1, d5]
elif roll == 'S':
return [d5, d1, d3, d4, d6, d2]
else:
assert False, "We should never reach this point!"
dice = [int(_) for _ in input().split()]
for roll in input().strip():
dice = do_roll(dice, roll)
print(dice[0])
| 1 | 226,690,774,952 | null | 33 | 33 |
import math
while True:
n = int(input())
if n == 0:
break
s = list(map(int, input().split()))
m = sum(s)/n
v = 0
for i in s:
v += (i - m) ** 2
ans = math.sqrt(v/n)
print("{:.5f}".format(ans))
|
r = input()
p = 3.141592653589
print "%.6f %.6f" % (p*r*r,2*p*r)
| 0 | null | 412,445,961,380 | 31 | 46 |
N=int(input())
d=list(map(int,input().split()))
a=0
for i in range(N):
for k in range(1,N-i):
a=a+d[i]*d[i+k]
print(a)
|
K = int(input())
A = [i for i in range(1, 10)]
if K <= 9:
print(A[K-1])
else:
K -= 9
f = 1
while f:
B = []
for a in A:
k = a % 10
if k != 0:
B.append(a * 10 + k - 1)
K -= 1
if K == 0:
print(B[-1])
f = 0
break
B.append(a * 10 + k)
K -= 1
if K == 0:
print(B[-1])
f = 0
break
if k != 9:
B.append(a * 10 + k + 1)
K -= 1
if K == 0:
print(B[-1])
f = 0
break
A = B
| 0 | null | 104,493,576,536,268 | 292 | 181 |
h, w, k = map(int, input().split())
s = [[int(i) for i in input()] for _ in range(h)]
ans = (h-1)+(w-1)
for i in range(2**(h-1)):
d = [(i >> j) & 1 for j in range(h-1)]
count, count_tmp = [0]*(sum(d)+1), [0]*(sum(d)+1)
ans_, res = 0, 0
flag = False
for w_ in range(w):
count[0] += s[0][w_]
count_tmp[0] += s[0][w_]
res += 1
tmp = 0
for h_ in range(1, h):
if d[h_-1]: tmp += 1
if s[h_][w_]:
count[tmp] += 1
count_tmp[tmp] += 1
for j in count:
if j > k:
if res==1:
flag = True
break
else:
for idx in range(sum(d)+1):
count[idx] = count_tmp[idx]
ans_ += 1
res = 1
break
if flag: break
count_tmp = [0]*(sum(d)+1)
if flag: continue
ans_ += sum(d)
ans = min(ans, ans_)
print(ans)
|
import numpy as np
def main():
H, W, K = map(int, input().split())
S = []
for _ in range(H):
S.append(list(map(int, list(input()))))
S = np.array(S)
if S.sum() <= K:
print(0)
exit(0)
answer = float('INF')
for i in range(0, 2 ** (H - 1)):
horizons = list(map(int, list(bin(i)[2:].zfill(H - 1))))
result = greedy(W, S, K, horizons, answer)
answer = min(answer, result)
print(answer)
# ex. horizons = [0, 0, 1, 0, 0, 1]
def greedy(W, S, K, horizons, current_answer):
answer = sum(horizons)
# ex.
# S = [[1, 1, 1, 0, 0],
# [1, 0, 0, 0, 1],
# [0, 0, 1, 1, 1]]
# horizons = [0, 1]のとき,
# S2 = [[2, 1, 1, 0, 0],
# [0, 0, 1, 1, 1]]
# となる
top = 0
bottom = 0
S2 = []
for h in horizons:
if h == 1:
S2.append(S[:][top:(bottom + 1)].sum(axis=0).tolist())
top = bottom + 1
bottom += 1
S2.append(S[:][top:].sum(axis=0).tolist())
# ブロック毎の累積和を計算する
h = len(S2)
partial_sums = [0] * h
for right in range(W):
current = [0] * h
for idx in range(h):
current[idx] = S2[idx][right]
partial_sums[idx] += S2[idx][right]
# 1列に含むホワイトチョコの数がkより多い場合
if max(current) > K:
return float('INF')
# 無理な(ブロックの中のホワイトチョコの数をk以下にできない)場合
if max(partial_sums) > K:
answer += 1
if answer >= current_answer:
return float('INF')
partial_sums = current
return answer
if __name__ == '__main__':
main()
| 1 | 48,443,322,825,258 | null | 193 | 193 |
import bisect
def is_ok(a, target, m):
num = 0
for val in a:
index = bisect.bisect_left(a, target - val)
num += len(a) - index
if num <= m:
return True
else:
return False
n, m = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
ok, ng = 10 ** 10, -1
while ok - ng > 1:
mid = (ok + ng) // 2
if is_ok(a, mid, m):
ok = mid
else:
ng = mid
rui = [0] * (n + 1)
for i in range(n):
rui[i+1] = rui[i] + a[i]
cnt = 0
ret = 0
for val in a:
index = bisect.bisect_left(a, ok - val)
num = len(a) - index
cnt += num
ret += (num * val) + (rui[-1] - rui[index])
ret += (m - cnt) * ng
print(ret)
|
from collections import Counter
from itertools import accumulate
N, K = map(int,input().split())
A = list(map(int,input().split()))
d = Counter()
A = [0] + list(accumulate(A))
A = [a % K for a in A]
ans = 0
for i in range(N+1):
ans += d[(A[i]-i) % K]
d[(A[i]-i) % K] += 1
if i-K+1 >= 0:
d[(A[i-K+1] - (i-K+1)) % K] -= 1
print(ans)
| 0 | null | 122,812,778,539,010 | 252 | 273 |
N, K = map(int, input().split())
h = list(map(int, input().split()))
h = sorted(h)
if K == 0:
print(sum(h))
else:
print(sum(h[:-K]))
|
_, K = [int(i) for i in input().split()]
H = [int(i) for i in input().split()]
H.sort(reverse=True)
print(sum(H[K:]))
| 1 | 78,774,582,416,272 | null | 227 | 227 |
while True:
n = int(input())
if n == 0:
break
s = list(map(int, input().split()))
kei = 0
for p in s:
kei += p
m = kei / n
a = 0
for p in s:
a += ((p - m)**2) / n
import math
h = math.sqrt(a)
print(h)
|
while True:
n = int(input())
if n == 0:
break
else:
data_set = [int(i) for i in input().split()]
m = sum(data_set) / n
v = 0
for i in data_set:
diff = i - m
v += diff ** 2
v /= n
print(v ** 0.5)
| 1 | 190,023,123,420 | null | 31 | 31 |
a,b=map(int, input().split())
if a > b:
s = '>'
elif a<b:
s = '<'
else:
s = '=='
print('a {} b'.format(s))
|
import sys
input = sys.stdin.readline
from string import ascii_uppercase
letters = ascii_uppercase + ascii_uppercase
shift = int(input())
s = input()[:-1]
for char in s: print(letters[letters.index(char) + shift], end = '')
print()
| 0 | null | 67,759,420,499,870 | 38 | 271 |
import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
import sys
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
N =I()
_P= LI()
#AB = [LI() for _ in range(N)]
#A,B = zip(*AB)
P = np.array(_P)
#C = np.zeros(N + 1)
def main():
# count = 1
# # if (len(P)==1):
# # return count
# min_array =[P[0]]
# for i in range(1,N):
# if (P[i]<=min_array[i-1]):
# count += 1
# if P[i-1]>P[i]:
# min_array.append(P[i])
# else:
# min_array.append(P[i-1])
# return count
# print(min_array)
Q = np.minimum.accumulate(P)
count = np.count_nonzero(P <= Q)
return count
print(main())
# if ans:
# print('Yes')
# else:
# print('No')
|
N, M, X = map(int, input().split())
CA = [list(map(int, input().split())) for _ in range(N)]
min_num = 10**18
for i in range(1<<N):
cost = 0
l = [0]*M
for j in range(N):
if (i>>j)&1:
c, *a = CA[j]
cost += c
for k, ak in enumerate(a):
l[k] += ak
if all(lj >= X for lj in l):
min_num = min(min_num, cost)
# print(l)
print(-1 if min_num == 10**18 else min_num)
| 0 | null | 53,721,420,534,980 | 233 | 149 |
# coding: utf-8
# Here your code !
def func():
try:
word=input().rstrip().lower()
words=[]
while(True):
line=input().rstrip()
if(line == "END_OF_TEXT"):
break
else:
words.extend(line.lower().split(" "))
except:
return inputError()
print(words.count(word))
def inputError():
print("input Error")
return -1
func()
|
INF = 10**12
def warshall_floyd(d,n):
#d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
def main():
n,m,l = map(int, input().split())
d = [ [INF]*(n) for _ in range(n) ]
for _ in range(m):
a,b,c = map(int, input().split())
d[a-1][b-1] = c
d[b-1][a-1] = c
warshall_floyd(d, n)
d2 = [ [INF]*(n) for _ in range(n) ]
for i in range(n):
for j in range(n):
if d[i][j] <= l:
d2[i][j] = 1
warshall_floyd(d2,n)
ans = []
q = int(input())
for _ in range(q):
s,t = map(int, input().split())
dist = d2[s-1][t-1]
if dist == INF: dist = 0
ans.append(dist-1)
for a in ans:
print(a)
if __name__ == "__main__":
main()
| 0 | null | 87,695,995,831,954 | 65 | 295 |
while True:
score = [int(i) for i in input().split()]
if score == [-1, -1, -1]:
break
sum = score[0] + score[1]
if sum < 30 or score[0] == -1 or score[1] == -1:
print('F')
elif sum < 50 and score[2] < 50:
print('D')
elif sum < 65 or (sum < 65 and score[2] >= 50):
print('C')
elif sum < 80:
print('B')
elif sum >= 80:
print('A')
|
while True:
m, f, r = map(int, raw_input().split(" "))
if m==f==r==-1:
break
if m==-1 or f==-1:
print("F")
elif m+f >= 80:
print("A")
elif 65 <= m+f < 80:
print("B")
elif 50 <= m+f < 65:
print("C")
elif 30 <= m+f < 50:
if r >= 50:
print("C")
else:
print("D")
elif m+f < 30:
print("F")
| 1 | 1,220,295,048,542 | null | 57 | 57 |
W,H,x,y,r = map(int, input().split())
if W < (x+r) or H < (y + r) or 0 > (x-r) or 0 > (y-r) :
print("No")
else :
print("Yes")
|
H, W = map(int, input().split())
arr = [input().rstrip() for h in range(H)]
ans = [[0] * W for _ in range(H)]
for h, row in enumerate(arr):
for w, val in enumerate(row):
if h == 0 and w == 0:
if arr[h][w] == "#":
ans[h][w] = 1
continue
nv = 1e+9
if h > 0:
nv = ans[h-1][w]
if arr[h-1][w] == "." and val == "#":
nv += 1
if w > 0:
tmp = ans[h][w-1]
if arr[h][w-1] == "." and val == "#":
tmp += 1
nv = min(nv, tmp)
ans[h][w] = nv
print(ans[-1][-1])
| 0 | null | 25,015,847,058,112 | 41 | 194 |
# import itertools
import math
# import sys
# import numpy as np
# K = int(input())
# S = input()
# n, *a = map(int, open(0))
A, B, H, M = map(int, input().split())
# H = list(map(int, input().split()))
# Q = list(map(int, input().split()))
# S = input()
# d = sorted(d.items(), key=lambda x:x[0]) # keyでsort
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement([i for i in range(1, M + 1)], N))
# print(a[0][0])
# print(conditions[0])
kakudo_H = (H * 60 + M) / 720 * 360
kakudo_M = M / 60 * 360
print(math.sqrt(A ** 2 + B ** 2 - 2 * A * B * math.cos(math.radians(abs(kakudo_H - kakudo_M)))))
|
import math
def solve():
a,b,h,m=map(int,input().split())
sita=math.pi*2*((h+m/60)/12-m/60)
c=math.sqrt(a*a+b*b-2*a*b*math.cos(sita))
return c
print(solve())
| 1 | 20,025,546,089,730 | null | 144 | 144 |
X, Y, Z = [int(x) for x in input().split()]
print('{} {} {}'.format(Z, X, Y))
|
d,t,s = map(int, input().split())
if d/s > t: print('No')
else: print('Yes')
| 0 | null | 20,726,190,968,622 | 178 | 81 |
N=list(map(int,input().split()))
ans=0
for x in range(2):
if N[x]==0 or N[x]==1:
pass
else:
ans += N[x]*(N[x]-1)/2
print(int(ans))
|
N, M = map(int, input().split())
if N < 2:
A = 0
else:
A = int(N * (N - 1) / 2)
if M < 2:
B = 0
else:
B = int(M * (M - 1) / 2)
print(A + B)
| 1 | 45,732,814,578,614 | null | 189 | 189 |
for i in sorted([input() for _ in xrange(10)])[:-4:-1]: print i
|
a,b,c=map(int,input().split())
d={"a":a,"b":b,"c":c}
for i in range(int(input())+1):
if d["a"]<d["b"]<d["c"]:
print("Yes")
exit()
elif d["a"]>=d["c"]: d["c"]*=2
elif d["a"]>=d["b"]: d["b"]*=2
elif d["b"]>=d["c"]: d["c"]*=2
print("No")
| 0 | null | 3,410,229,956,462 | 2 | 101 |
from collections import deque
n,m=map(int,input().split())
data=[[] for i in range(n+1)]
for i in range(m):
a,b=map(int,input().split())
data[a].append(b)
data[b].append(a)
que=deque()
que.append(1)
cnt=[0]*(n+1)
while que:
h=que.popleft()
for u in data[h]:
if cnt[u]!=0:
continue
cnt[u]=h
que.append(u)
print('Yes')
for i in range(2,n+1):
print(cnt[i])
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N = int(readline())
cnt = 0
ans = -1
for _ in range(N):
x, y = map(int, readline().split())
if x == y:
cnt += 1
ans = max(ans, cnt)
else:
cnt = 0
if ans >=3:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| 0 | null | 11,609,967,077,898 | 145 | 72 |
# coding: utf-8
import math
def main():
a, b = map(int, input().split())
tmp_a_min = math.ceil(a / 0.08)
tmp_a_max = math.ceil((a+1) / 0.08)
tmp_b_min = math.ceil(b / 0.1)
tmp_b_max = math.ceil((b+1) / 0.1)
tmp_a = list(range(tmp_a_min, tmp_a_max))
tmp_b = list(range(tmp_b_min, tmp_b_max))
tmp = set(tmp_a) & set(tmp_b)
if len(tmp) != 0:
print(min(tmp))
else:
print(-1)
main()
|
A,B=map(int,input().split())
for x in range(1,1001):
if A==int(x*0.08) and B==int(x*0.1):
print(x)
break
elif x==1000:
print(-1)
| 1 | 56,283,494,949,498 | null | 203 | 203 |
N=int(input())
w =0
x =0
y =0
z =0
for i in range(N):
s =input()
if s =='AC':
w +=1
elif s == 'WA':
x +=1
elif s == 'TLE':
y +=1
elif s == 'RE':
z +=1
print ('AC x '+str(w))
print ('WA x '+str(x))
print ('TLE x '+str(y))
print ('RE x '+str(z))
|
n = int(input())
j_list = [input() for x in range(n)]
print("AC x",j_list.count("AC"))
print("WA x",j_list.count("WA"))
print("TLE x",j_list.count("TLE"))
print("RE x",j_list.count("RE"))
| 1 | 8,674,605,665,640 | null | 109 | 109 |
from collections import deque
def main():
d = deque()
for _ in range(int(input())):
command = input()
if command[0] == 'i':
d.appendleft(command[7:])
elif command[6] == ' ':
try:
d.remove(command[7:])
except ValueError:
pass
elif len(command) == 11:
d.popleft()
else:
d.pop()
print(*d)
if __name__ == '__main__':
main()
|
import fractions
lst = []
for i in range(200):
try:
lst.append(input())
except EOFError:
break
nums = [list(map(int, elem.split(' '))) for elem in lst]
# gcd
res_gcd = [fractions.gcd(num[0], num[1]) for num in nums]
# lcm
res_lcm = [nums[i][0] * nums[i][1] // res_gcd[i] for i in range(len(nums))]
for (a, b) in zip(res_gcd, res_lcm):
print('{} {}'.format(a, b))
| 0 | null | 25,922,985,102 | 20 | 5 |
A, B=(input().split())
A=int(A)
C=int(B[0])*100+int(B[2])*10+int(B[3])
print(int(A*C//100))
|
a,b = input().split()
a = int(a)
b = int(b.replace(".",""))
print((a*b)//100)
| 1 | 16,529,180,328,628 | null | 135 | 135 |
def main():
d, t, s = map(int, input().split())
print('Yes' if t*s >= d else 'No')
if __name__ == '__main__':
main()
|
# 逆元を利用した組み合わせの計算
#############################################################
def cmb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % mod
mod = 10**9 + 7
NN = 10**6
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, NN + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
#############################################################
N, K = map(int, input().split())
# M = 空き部屋数の最大値
M = min(N - 1, K)
"""
m = 0,1,2,...,M
N部屋から、空き部屋をm個選ぶ
-> N_C_m
残りの(N-m)部屋に、N人を配置する（空き部屋が出来てはいけない）
まず、(N-m)部屋に1人ずつ配置し、残ったm人を(N-m)部屋に配置する
これは、m個のボールと(N-m-1)本の仕切りの並び替えに相当する
-> (m+N-m-1)_C_m = N-1_C_m
"""
ans = 0
for m in range(0, M + 1):
ans += cmb(N, m, mod) * cmb(N - 1, m, mod)
ans %= mod
print(ans)
| 0 | null | 35,547,774,735,902 | 81 | 215 |
# -*- coding: utf-8 -*-
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
write = sys.stdout.write
# template
def solve():
n,k=map(int, readline().split())
a = list(map(int, readline().split()))
b=[0]*(n+1)
for i in range(n):
b[i+1]=b[i]+a[i]-1
b[i+1]%=k
count=0
from collections import defaultdict
dp=defaultdict(list)
for i in range(n+1):
dp[b[i]].append(i)
#print(dp,b)
for item in dp:
#print(count)
if len(dp[item])<2:
continue
l=0
r=1
li=dp[item]
while(l<len(li)):
if l==r:
r+=1
continue
if r<len(li) and li[r]-li[l]<k:
r+=1
else:
count+=r-l-1
l+=1
print(count)
'''
for i in range(k):
if dp[i]<2:
continue
count+=dp[i]*(dp[i]-1)//2
'''
if __name__ == "__main__":
solve()
|
from collections import defaultdict
from sys import stdout
printn = lambda x: stdout.write(x)
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
DBG = True and False
BIG = 999999999
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
n,k = inm()
a = inl()
h =defaultdict(int)
b = [0]*(n+1)
s = [0]*(n+1)
for i in range(n):
s[i+1] = s[i]+a[i]
b[i+1] = (s[i+1]-i-1)%k
ddprint(s)
ddprint(b)
acc = 0
for i in range(n+1):
if i>=k:
h[b[i-k]] -= 1
acc += h[b[i]]
h[b[i]] += 1
#ddprint("i {} acc {} h {}".format(i,acc,h))
print(acc)
| 1 | 137,363,469,966,490 | null | 273 | 273 |
import math
def main():
r = int(input())
print(r * math.pi * 2)
main()
|
a = int(input())
print(2*a*3.14)
| 1 | 31,526,463,599,650 | null | 167 | 167 |
import itertools
n = int(input())
test = list(itertools.permutations([i for i in range(n)]))
data = []
for i in range(n):
x,y = map(int,input().split())
data.append([x,y])
total = 0
for i in test:
for k in range(n-1):
total += ((data[i[k]][0] - data[i[k+1]][0])**2 + (data[i[k]][1] - data[i[k+1]][1])**2 )**0.5
print(total/len(test))
|
from itertools import permutations as p
from math import factorial as f
from math import sqrt as s
def func(x1, x2, y1, y2): return s((x2-x1) ** 2 + (y2-y1) ** 2)
N = int(input())
xy = list(list(map(int,input().split())) for _ in range(N))
total = 0
for l in p(range(1, N+1)):
for i in range(N-1):
total += func(xy[l[i]-1][0], xy[l[i+1]-1][0], xy[l[i]-1][1], xy[l[i+1]-1][1])
print(total / f(N))
| 1 | 147,747,768,909,708 | null | 280 | 280 |
N ,M= input().split()
a=[]
N=int(N)
M=int(M)
for i in range(N):
a.append(list(map(int,input().split())))
b=[int(input()) for i in range(M)]
x=[0 for i in range(N)]
for i in range(N):
for j in range(M):
x[i]+=a[i][j]*b[j]
print("\n".join(map(str,x)))
|
n, m = map(int, input().split())
vector_a = []
vector_b = []
for i in range(n):
vector_a.append(list(map(int,input().split())))
for i in range(m):
vector_b.append(list())
vector_b[i]=int(input())
for i in range(n):
tmp=0
for j in range(m):
tmp+=vector_a[i][j]*vector_b[j]
print(tmp)
| 1 | 1,149,801,492,740 | null | 56 | 56 |
while True:
line = input()
data = line.split()
h = int(data[0])
w = int(data[1])
if h == 0 and w == 0:
break
for i in range(h):
for j in range(w):
if i == 0 or i == h -1:
print("#", end="")
else:
if j == 0 or j == w -1:
print("#", end="")
else:
print(".", end="")
print("")
print("")
|
q=int(input())
dic={}
for i in range(q):
s=input()
if not s in dic:
dic[s]=1
else:
dic[s]+=1
max_val=max(dic.values())
a=sorted([i for i, k in dic.items() if k == max_val])
for i in a:
print(i)
| 0 | null | 35,390,866,008,302 | 50 | 218 |
import sys
def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()
INF = float('inf')
n = I()
# 区間スケジューリング問題 : いくつかの区間の中から重ならないように最大で何個選べるか
# ソート + 貪欲法 で解ける
arm_pos = []
for _ in range(n):
x, l = LI()
arm_pos.append([x - l, x + l])
arm_pos = sorted(arm_pos, key=lambda x: x[1]) # アームの終点の位置でソート
ans = n
for i in range(n - 1):
if arm_pos[i][1] > arm_pos[i + 1][0]: # i のアームの終点が i + 1 のアームの始点 と重なっていた場合
arm_pos[i + 1] = arm_pos[i] # i + 1 のアームを取り除く
ans -= 1
print(ans)
|
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))
from collections import Counter
n=int(input())
d=lnii()
mod=998244353
c=Counter(d)
max_key=max(d)
if d[0]!=0 or c[0]!=1:
print(0)
exit()
ans=1
patterns=1
for i in range(max_key+1):
p_num=c[i]
ans*=patterns**p_num
ans%=mod
patterns=p_num
print(ans)
| 0 | null | 122,590,889,148,960 | 237 | 284 |
n, m, l = map(int, input().split())
A = [tuple(map(int, input().split())) for _ in range(n)]
B = [tuple(map(int, input().split())) for _ in range(m)]
B_T = [tuple(r) for r in zip(*B)]
for L in ((sum((a*b for a, b in zip(ai, bj))) for bj in B_T) for ai in A):
print(*L)
|
n, m, l = map(int, input().split())
mat_a = [list(map(int, input().split())) for _ in range(n)]
mat_b = [list(map(int, input().split())) for _ in range(m)]
for i in range(n):
row = []
for j in range(l):
tmp = 0
for k in range(m):
tmp += mat_a[i][k]*mat_b[k][j]
row.append(tmp)
print(*row)
| 1 | 1,441,087,065,220 | null | 60 | 60 |
import sys
from operator import or_
input=sys.stdin.readline
class SegTree():
def __init__(self, N, e=float("inf"), operator_func=min):
self.e = e
self.size = N
self.node = [self.e] * (2*N)
self.op = operator_func
def set_list(self, l):
for i in range(self.size):
self.node[i+self.size-1] = l[i]
for i in range(self.size-1)[::-1]:
self.node[i] = self.op(self.node[2*i+1], self.node[2*i+2])
def update(self, k, x):
k += self.size - 1
self.node[k] = x
while k >= 0:
k = (k - 1) // 2
self.node[k] = self.op(self.node[2*k+1], self.node[2*k+2])
def get(self, l, r):
x = self.e
l += self.size; r += self.size
a, b = [], []
while l<r:
if l&1:
a += [l-1]; l += 1
if r&1:
r -= 1; b += [r-1]
l >>= 1; r >>= 1
for i in a+(b[::-1]):
x = self.op(x, self.node[i])
return x
def main():
N = int(input())
S = list(input())[:-1]
trees = {chr(97+i):SegTree(N, e=0, operator_func=or_) for i in range(26)}
for i, s in enumerate(S):
trees[s].update(i, 1)
Q = int(input())
for _ in range(Q):
mode, i, v = input().split()
if mode=="1":
i = int(i)-1
trees[S[i]].update(i, 0)
trees[v].update(i, 1)
S[i] = v
else:
i = int(i)-1
v = int(v)
ans = sum(trees[chr(97+j)].get(i, v) for j in range(26))
print(ans)
if __name__ == "__main__":
main()
|
class SegTree:
# n : 元の配列の長さ
# init_list: 元の配列
# segfunc : 載せる関数（演算）
# ide_ele : segfuncの単位元
def __init__(self, n, init_list ,segfunc, ide_ele):
# num : 2**num >= n となる最小の整数 （葉の数）
# seg : segtreeのリスト
self.num = 2**((n-1).bit_length())
self.seg = [ide_ele]*(2*self.num)
self.segfunc = segfunc
self.ide_ele = ide_ele
# 葉の要素をセット
for i in range(n):
self.seg[i+self.num-1] = init_list[i]
# segtreeの構築
for i in range(self.num-2, -1, -1):
self.seg[i] = segfunc(self.seg[2*i+1],self.seg[2*i+2])
#memo: 要素iの子ノードは要素2*i+1, 2*i+2
# : 要素iの親ノードは要素(i-1)//2
# 要素の更新 (init_list[k]=x)
def update(self,k,x):
k += self.num-1 #葉のノードのインデックス
self.seg[k] = x
#末端から頂点まで更新
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[2*k+1], self.seg[2*k+2])
# 区間クエリ （区間[l,r)に対する演算結果）
def query(self, l,r):
if r<=l:
return self.ide_ele
l += self.num-1 #葉のノードのインデックス
r += self.num-2 #半開区間から閉区間へ
ret = self.ide_ele
while r-l>1:
if l&1 == 0:
ret = self.segfunc(ret,self.seg[l])
if r&1 == 1:
ret = self.segfunc(ret,self.seg[r])
r -= 1
# 親ノードへ遷移
l = l//2
r = (r-1)//2
if r==l:
ret = self.segfunc(ret, self.seg[r])
else:
ret = self.segfunc(ret, self.seg[l])
ret = self.segfunc(ret, self.seg[r])
return ret
def segfunc(x,y):
return max(x,y)
def segfunc2(x,y):
return min(x,y)
def segfunc3(x,y):
return x | y
def ctoi(c):
return ord(c) - ord('a')
def main():
N = int(input())
S = list(input())
Q = int(input())
Segtree = [SegTree(N,[0] * N,segfunc,0) for _ in range(26)]
for i, c in enumerate(S):
Segtree[ctoi(c)].update(i,1)
for _ in range(Q):
q, *query = map(str, input().split())
if q == '1':
i, c = query
i = int(i) - 1
if c == S[i]:
continue
Segtree[ctoi(c)].update(i, 1)
Segtree[ctoi(S[i])].update(i,0)
S[i] = c
else:
l, r = query
l = int(l) - 1
r = int(r)
ans = 0
for j in range(26):
if Segtree[j].query(l,r):
ans += 1
print(ans)
if __name__ == "__main__":
main()
| 1 | 62,554,160,502,148 | null | 210 | 210 |
S = input()
T = input()
if T.startswith(S):
if len(T)-len(S)==1:
print("Yes")
else:
print("No")
else:
print("No")
|
a,b,c,d = list(map(int,input().split()))
t_win_turn = c // b
if c % b > 0:
t_win_turn += 1
a_win_turn = a // d
if a % d > 0:
a_win_turn += 1
if t_win_turn <= a_win_turn:
print('Yes')
else:
print('No')
| 0 | null | 25,598,805,842,808 | 147 | 164 |
n=int(input())
A=tuple(map(int, input().split()))
cnt=0
def merge_sort(A,cnt):
m=len(A)
if m == 1:
return A,cnt
else:
mid=(m+1)//2
A1=tuple(A[:mid])
A2=tuple(A[mid:])
A1,cnt=merge_sort(A1,cnt)
A2,cnt=merge_sort(A2,cnt)
n1=len(A1)
n2=len(A2)
i1=0
i2=0
ans=[0]*(n1+n2)
j=0
while j < n1+n2:
if i1 == n1:
ans[j]=A2[i2]
i2+=1
cnt+=1
elif i2 == n2:
ans[j]=A1[i1]
i1+=1
cnt+=1
elif A1[i1] < A2[i2]:
ans[j]=A1[i1]
i1+=1
cnt+=1
else:
ans[j]=A2[i2]
i2+=1
cnt+=1
j += 1
return ans,cnt
sorted_A,cnt=merge_sort(A,0)
print(*sorted_A)
print(cnt)
|
n=int(input())
def dfs(s):
if len(s)==n:print(s)
else:
for i in range(97,ord(max(s))+1+1):
dfs(s+chr(i))
dfs("a")
| 0 | null | 26,343,367,797,470 | 26 | 198 |
n = int(input())
def dfs(n, s, idx):
l = len(s)
if n == l:
print(s)
return
alpha = "abcdefghijklmnopqrstuvwxyz"
i = 0
while i < idx + 1:
if i == idx:
dfs(n, s + alpha[i], idx + 1)
else:
dfs(n, s + alpha[i], idx)
i += 1
dfs(n, "", 0)
|
y,x=[int(i) for i in input().split()]
s=[[int(0)for i in range(x+1)]for j in range(y+1)]
for i in range(y):
k=input().split()
for j in range(x):
s[i][j]=int(k[j])
for i in range(y):
for j in range(x):
s[i][x]=s[i][x]+s[i][j]
s[y][j]=s[y][j]+s[i][j]
for i in range(y):
s[y][x]=s[y][x]+s[i][x]
for i in range(y+1):
for j in range(x):
print(s[i][j],"",end="")
print(s[i][x])
| 0 | null | 26,810,168,276,258 | 198 | 59 |
def LinearSearch1(S, n, t):
for i in range(n):
if S[i] == t:
return i
break
else:
return -1
"""
def LinearSearch2(S, n, t):
S.append(t)
i = 0
while S[i] != t:
i += 1
S.pop()
if i == n:
return -1
else:
return i
"""
n = int(input())
S = [int(s) for s in input().split()]
q = int(input())
T = {int(t) for t in input().split()}
ans = sum(LinearSearch1(S, n, t) >= 0 for t in T)
print(ans)
|
S=[]
T=[]
S_num=int(input())
S=input().split()
T_num=int(input())
T=input().split()
cnt=0
for i in range(T_num):
for j in range(S_num):
if(S[j]==T[i]):
cnt+=1
break
print(cnt)
| 1 | 65,729,800,772 | null | 22 | 22 |
line = input()
A = line.split()
stack = []
for c in A:
if c == '+':
rhs = stack.pop()
lhs = stack.pop()
stack.append(lhs + rhs)
elif c == '-':
rhs = stack.pop()
lhs = stack.pop()
stack.append(lhs - rhs)
elif c == '*':
rhs = stack.pop()
lhs = stack.pop()
stack.append(lhs * rhs)
else:
stack.append(int(c))
print(stack.pop())
|
def Cal(sym,n1,n2):
n1 = int(n1)
n2 = int(n2)
if sym == '+':
ans = n1 + n2
elif sym == '-':
ans = n1 - n2
else:
ans = n1 * n2
return ans
stack = []
for item in raw_input().split():
if item.isdigit():
stack.append(item)
else:
n2 = stack.pop()
n1 = stack.pop()
sym = item
ans = Cal(sym,n1,n2)
stack.append(ans)
Ans = stack.pop()
print Ans
| 1 | 35,777,117,270 | null | 18 | 18 |
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
import networkx as nx
n,x,y = inpm()
x -= 1
y -= 1
if x > y:
x,y = y,x
d = np.zeros((n,n),int)
ans = np.zeros(n,int)
for i in range(n):
for j in range(i+1,n):
a = j - i
b = abs(x - i) + abs(j - y) + 1
ans[min(a,b)] += 1
for i in range(1,n):
print(ans[i])
|
# -*- coding: utf-8 -*-
import io
import sys
import math
def solve():
# implement process
pass
def main():
# input
s,t= input().split()
# process
ans = t+s
# output
print(ans)
return ans
### DEBUG I/O ###
_DEB = 0 # 1:ON / 0:OFF
_INPUT = """\
humu humu
"""
_EXPECTED = """\
humuhumu
"""
def logd(str):
"""usage:
if _DEB: logd(f"{str}")
"""
if _DEB: print(f"[deb] {str}")
### MAIN ###
if __name__ == "__main__":
if _DEB:
sys.stdin = io.StringIO(_INPUT)
print("!! Debug Mode !!")
ans = main()
if _DEB:
print()
if _EXPECTED.strip() == ans.strip(): print("!! Success !!")
else: print(f"!! Failed... !!\nANSWER: {ans}\nExpected: {_EXPECTED}")
| 0 | null | 73,348,677,871,112 | 187 | 248 |
def main():
N, K = map(int, input().split())
A = list(map(int, input().split()))
for k in range(K):
A_temp=[0]*(N+1)
for i in range(N):
A_temp[max(0,i-A[i])]+=1
if i+A[i]+1<=N-1:
A_temp[i+A[i]+1]-=1
A[0]=A_temp[0]
for j in range(1,N):
A_temp[j]+=A_temp[j-1]
A[j]=A_temp[j]
for ai in A:
if ai != N:
break
else:
break
print(' '.join([str(a) for a in A]))
if __name__ == "__main__":
main()
|
#import sys
#input = sys.stdin.readline
def main():
a, b ,c, d = map( int, input().split())
A = [a*c, a*d, b*c, b*d]
if a < b:
A.append((a+1)*c)
A.append((b-1)*c)
A.append((a+1)*d)
A.append((b-1)*d)
if c < d:
A.append(a*(c+1))
A.append(a*(d-1))
A.append(b*(c+1))
A.append(b*(d-1))
if a < b and c < d:
A.append((a+1)*(c+1))
A.append((a+1)*(d-1))
A.append((b-1)*(c+1))
A.append((b-1)*(d-1))
print(max(A))
if __name__ == '__main__':
main()
| 0 | null | 9,271,725,053,888 | 132 | 77 |
from collections import Counter
n = int(input())
A = list(map(int, input().split()))
ANS = sum(A)
A = Counter(A)
Q = int(input())
for i in range(Q):
B, C = map(int, input().split())
print(ANS + (C - B) * A[B])
ANS += (C - B) * A[B]
A[C] = A[C] + A[B]
A[B] = 0
|
def main():
N = int(input())
A = [int(a) for a in input().split(" ")]
S = sum(A)
cA = [0] * 1000001
for i in range(len(A)):
cA[A[i]] += 1
Q = int(input())
for i in range(Q):
B, C = [int(x) for x in input().split(" ")]
diff = (C-B)*cA[B]
S += diff
cA[C] += cA[B]
cA[B] = 0
print(S)
main()
| 1 | 12,204,072,244,238 | null | 122 | 122 |
#!/usr/bin/env python3
import sys
from itertools import product
def input():
return sys.stdin.readline()[:-1]
def main():
N, M, X = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(N)]
for m in range(1, M + 1):
s = 0
for n in range(N):
s += A[n][m]
if s < X:
print(-1)
exit()
# bit全探索
# repeat=2だと(0,0), (0,1), (1,0), (1,1)になる
ans = 10 ** 15
for i in product([0,1], repeat=N):
c = 0
for m in range(1, M + 1):
s = 0
for n in range(N):
if i[n] == 1:
s += A[n][m]
if s >= X:
c += 1
if c == M:
money = 0
for n in range(N):
if i[n] == 1:
money += A[n][0]
ans = min(ans, money)
print(ans)
if __name__ == '__main__':
main()
|
def resolve():
n=int(input())
a=list(map(int,input().split()))
q=int(input())
m=list(map(int,input().split()))
sa=[0]*100000
for i in range(2**n):
s=0
for j in range(n):
if i>>j&1:
s+=a[j]
sa[s]=1
for i in m:
if sa[i]==0:
print('no')
else:
print('yes')
if __name__ == '__main__':
resolve()
| 0 | null | 11,256,624,648,592 | 149 | 25 |
#!/usr/bin/python3
import sys
from collections import Counter
input = lambda: sys.stdin.readline().strip()
n = int(input())
a = [int(x) for x in input().split()]
c = Counter(a)
def c2(n):
return n * (n - 1) // 2
ans = sum(c2(v) for v in c.values())
def add(x):
global ans
ans -= c2(c[x])
c[x] += 1
ans += c2(c[x])
def remove(x):
global ans
ans -= c2(c[x])
c[x] -= 1
ans += c2(c[x])
for x in a:
remove(x)
print(ans)
add(x)
|
N = int(input())
A = [-1] + list(map(int, input().split()))
lis = [0]*(N+1)
for a in A[1:]:
lis[a] += 1
sum_combinations = 0
for x in lis[1:]:
if x >= 2:
sum_combinations += x*(x-1)//2
for i in range(1,N+1):
ans = sum_combinations
num = lis[A[i]]
if num >= 2:
ans += (num-1)*(num-2)//2 - num*(num-1)//2
print(ans)
| 1 | 47,805,859,694,028 | null | 192 | 192 |
def main():
N = int(input())
result = []
while N > 0:
N -= 1
mod = N % 26
result.append(chr(mod + ord('a')))
N //= 26
result_str = ""
for i in range(len(result)-1, -1, -1):
result_str += result[i]
print(result_str)
main()
|
N=int(input())
X=[int(x) for x in input().split()]
ans=10**9
for p in range(-200, 200):
ref=0
for x in X:
ref+=(x-p)**2
#print(ref)
ans=min(ans, ref)
print(ans)
| 0 | null | 38,657,334,072,538 | 121 | 213 |
def gcd(a,b):
x = max(a,b)
y = min(a,b)
while True:
n = x%y
if n == 0:
print(y)
break
else:
x = y
y = n
a,b = map(int,input().split())
gcd(a,b)
|
N = int(input())
x = N%10
if x==0 or x==1 or x==6 or x==8:
print('pon')
elif x==2 or x==4 or x==5 or x==7 or x==9:
print('hon')
elif x==3:
print('bon')
| 0 | null | 9,596,841,779,070 | 11 | 142 |
N=str(input())
if "7" in N:
print("Yes")
else:
print("No")
|
s = input().split()
print(''.join(reversed(s)))
| 0 | null | 68,473,657,464,850 | 172 | 248 |
# ALDS1_5_B Merge Sort
import sys
count = 0
def merge(A, left, mid, right):
global count
l = A[left: mid]
r = A[mid: right]
l.append(float('inf'))
r.append(float('inf'))
i = 0
j = 0
for k in range(left, right, 1):
count += 1
if l[i] <= r[j]:
A[k] = l[i]
i += 1
else:
A[k] = r[j]
j += 1
def merge_sort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
n = int(input())
S = [int(i) for i in sys.stdin.readline().strip().split()]
merge_sort(S, 0, n)
print(' '.join(map(str, S)))
print(count)
|
import math
import sys
# 比較回数をここに記録
# 理論上 n * lg n を越えることはない。
_exchange = 0
def merge_sort(A, left, right):
"""数列 A を in place に昇順にソートする。
left は A の先頭のインデックス、right は末尾のインデックスのひとつ後ろ。
"""
if left + 1 < right:
mid = (left + right) // 2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
def merge(A, left, mid, right):
"""ソート済みの部分列をマージする。
数列 A の left から mid - 1 の要素、mid から right - 1 までの
２つの部分列はソート済みである。これをマージして、left から right - 1 まで
ソートする。
"""
first = A[left:mid]
first.append(math.inf) # 番兵
second = A[mid:right]
second.append(math.inf) # 番兵
global _exchange
i = j = 0
for k in range(left, right):
_exchange += 1
if first[i] <= second[j]:
A[k] = first[i]
i += 1
else:
A[k] = second[j]
j += 1
if __name__ == '__main__':
n = int(input())
A = list(map(int, sys.stdin.readline().split()))
merge_sort(A, 0, n)
print(*A)
print(_exchange)
| 1 | 112,179,878,942 | null | 26 | 26 |
d, t, s = (int(i) for i in input().split())
if t*s-d >=0:
print("Yes")
else:
print("No")
|
A = list(map(int , input().split()))
B = list(map(int , input().split()))
print(sum(sorted(B)[:A[1]]))
| 0 | null | 7,556,748,654,532 | 81 | 120 |
num = int(input())
i = 1
while i <= 9:
j = 1
while j <= 9:
if (i * j) / num == 1:
print("Yes")
exit()
else:
j += 1
i += 1
print("No")
|
N = int(input())
ans = 'No'
if N<=82:
for i in range(1,10):
if N%i==0 and len(str(N//i))==1:
ans = 'Yes'
print(ans)
| 1 | 159,380,399,644,612 | null | 287 | 287 |
import itertools
n, m, x = map(int, input().split())
books = []
for i in range(n):
ins = list(map(int, input().split()))
books.append({"c": ins[0], "a": ins[1: m+1]})
ans = float('inf')
for i in range(1, n+1):
book_list = list(itertools.combinations(list(range(n)), i))
for lis in book_list:
cost_sum = 0
a_sum = [0] * m
ok = 0
ok_list = [False] * m
for j in lis:
cost_sum += books[j]['c']
for k in range(m):
a_sum[k] += books[j]['a'][k]
if not ok_list[k] and a_sum[k] >= x:
ok += 1
ok_list[k] = True
if ok == m and ans > cost_sum:
ans = cost_sum
if ans == float('inf'):
print(-1)
else:
print(ans)
|
import sys
def hantei(N,M,X,A,l):
skill = [0] * M
money = 0
for i in range(N):
if l[i] == '1':
money += A[i][0]
for j in range(M):
skill[j] += A[i][j+1]
for k in skill:
if k < X:
return -1
sys.exit()
return money
N,M,X = map(int, input().split())
A = [list(map(int, input().split())) for i in range(N)]
mny = 12 * (10 ** 5) + 1
for i in range(1,2**N):
l = bin(i)[2:].zfill(N)
if hantei(N,M,X,A,l) != -1 and hantei(N,M,X,A,l) < mny:
mny = hantei(N,M,X,A,l)
a = l
if mny == 12 * (10 ** 5) + 1:
print(-1)
else:
print(mny)
| 1 | 22,321,305,422,570 | null | 149 | 149 |
n=int(input())
s = ''
for i in range(11):
if n != 0:
n -= 1
s += chr(ord('a') + n % 26)
n //= 26
print(s[::-1])
|
d = {chr(i):i-96 for i in range(97,123)}
D = {val:key for key,val in d.items()}
N = int(input())
x = ""
while N>0:
a = N%26
if a!=0:
x += D[a]
N = N//26
else:
x += "z"
N = N//26
N -= 1
print(x[::-1])
| 1 | 11,914,934,725,760 | null | 121 | 121 |
from math import ceil
H, A = map(int, input().split())
print("{}".format(ceil(H / A)))
|
import sys
import math
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
H, A = map(int, readline().split())
print(math.ceil(H/A))
if __name__ == '__main__':
main()
| 1 | 77,085,131,645,486 | null | 225 | 225 |
n, k = map(int, input().split())
p_list = list(map(lambda x: int(x) - 1, input().split()))
c_list = list(map(int, input().split()))
max_score = -(1 << 64)
cycles = []
cycled = [False] * n
for i in range(n):
if cycled[i]:
continue
cycle = [i]
cycled[i] = True
while p_list[cycle[-1]] != cycle[0]:
cycle.append(p_list[cycle[-1]])
cycled[cycle[-1]] = True
cycles.append(cycle)
for cycle in cycles:
cycle_len = len(cycle)
accum = [0]
for i in range(cycle_len * 2):
accum.append(accum[-1] + c_list[cycle[i % cycle_len]])
cycle_score = accum[cycle_len]
max_series_sums = [max([accum[i + length] - accum[i]
for i in range(cycle_len)])
for length in range(cycle_len + 1)]
if cycle_len >= k:
score = max(max_series_sums[1:k + 1])
elif cycle_score <= 0:
score = max(max_series_sums[1:])
else:
max_cycle_num, cycle_rem = divmod(k, cycle_len)
score = max(cycle_score * (max_cycle_num - 1) + max(max_series_sums),
cycle_score * max_cycle_num + max(max_series_sums[:cycle_rem + 1]))
max_score = max(max_score, score)
print(max_score)
|
import math
import sys
import os
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))
if os.getenv("LOCAL"):
inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
sys.stdin = open(inputFile, "r")
INF = float("inf")
N,K = LI()
P = LI()
C = LI()
P = list(map(lambda x:x-1,P))
res = -INF
used = [False] * N
ss = []
for i in range(N):
# print('i',i)
if used[i]:
continue
cur = i
s = []
while not used[cur]:
used[cur] = True
s.append(C[cur])
cur = P[cur]
# print(cur)
ss.append(s)
# print(ss)
for vec in ss:
M = len(vec)
# 2周の累積和
sum = [0]*(2*M + 1)
for i in range(2*M):
sum[i+1] = sum[i]+vec[i%M]
# amari[r] := 連続するr個の最大値
amari = [-INF]*M
for i in range(M):
for j in range(M):
amari[j] = max(amari[j],sum[i+j] - sum[i])
for r in range(M):
if r>K:
continue
q = (K-r)//M
if r==0 and q==0:
continue
if sum[M]>0:
res = max(res, amari[r] + sum[M] * q)
elif r > 0:
res = max(res, amari[r])
print(res)
| 1 | 5,348,094,499,760 | null | 93 | 93 |
a,b=map(int,input().split())
c=a>b
print(str(b if c else a)*(a if c else b))
|
#
# author sidratul Muntaher
# date: Aug 19 2020
#
n = int(input())
from math import pi
print(pi* (n*2))
| 0 | null | 58,081,751,581,820 | 232 | 167 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.