code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
n = int(input())
print((n + n ** 2 + n ** 3) //1)
|
def resolve():
import sys
input = sys.stdin.readline
n = int(input().rstrip())
print(n + n*n + n*n*n)
if __name__ == "__main__":
resolve()
| 1 | 10,215,138,763,026 | null | 115 | 115 |
S = input()
W = ['SUN','MON','TUE','WED','THU','FRI','SAT']
w = W.index(S)
print(7 - w)
|
from math import gcd
a, b = [int(i) for i in input().split()]
print(int(a * b / gcd(a, b)))
| 0 | null | 122,963,225,000,408 | 270 | 256 |
cards = {
'S':[r for r in range(1,13+1)],
'H':[r for r in range(1,13+1)],
'C':[r for r in range(1,13+1)],
'D':[r for r in range(1,13+1)]
}
n = int(input())
for nc in range(n):
(s,r) = input().split()
index = cards[s].index(int(r))
del cards[s][index]
for s in ['S','H','C','D']:
for r in cards[s]:
print(s,r)
|
a = {}
for s in ["S", "H", "C", "D"]:
a.update({f'{s} {i}': 0 for i in range(1, 14)})
n = int(input())
for _ in range(n):
s = input()
del a[s]
a = list(a)
for i in range(len(a)):
print(a[i])
| 1 | 1,066,626,283,562 | null | 54 | 54 |
def main():
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
target = 1
for i in A:
if i == target:
target += 1
if target == 1:
print(-1)
return
print(N - target + 1)
main()
|
def resolve():
import sys
sys.setrecursionlimit(10 ** 6) # 再帰関数の再帰の深さを設定
to_index = lambda x: int(x) - 1 # 入力した数字に1を引いたものを返す
print_list_in_2D = lambda x: print(*x, sep="\n") # リストの要素を改行を挟んで表示する関数
# 入力を整数に変換して受け取る
def input_int():
return int(input())
def map_int_input():
return map(int, input())
MII = map_int_input
def MII_split():
return map(int, input().split())
def MII_to_index():
return map(to_index, input())
def MII_split_to_index():
return map(to_index, input().split())
# 入力全てを整数に変換したものの配列を受け取る
def list_int_inputs():
return list(map(int, input()))
LII = list_int_inputs
def LII_split():
return list(map(int, input().split()))
# 2次元リスト化
def LII_2D(rows_number):
return [LII() for _ in range(rows_number)]
def LII_split_2D(rows_number):
return [LII_split() for _ in range(rows_number)]
class UnionFind:
def __init__(self, n):
"""
:param n: 人数
:type n: int
"""
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
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
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
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 x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = MII_split()
# groups = []
uf = UnionFind(N)
for _ in range(M):
A, B = MII_split()
uf.union(A-1, B-1) # unionfindを使い、結合の計算量を減らす
# is_in_groups = False
# for group in groups:
# if A in group and B not in group:
# group.append(B)
# break
# elif B in group and A not in group:
# group.append(A)
# break
# elif A in group and B in group:
# is_in_groups = True
# break
# if not is_in_groups:
# groups.append([A, B])
print(max(uf.size(x) for x in range(uf.group_count())))
resolve()
| 0 | null | 59,391,646,922,530 | 257 | 84 |
import collections
n,k=map(int,input().split())
a=list(map(int,input().split()))
m=[0]
for i in range(n):
m.append((m[-1]+a[i]))
for i in range(n+1):
m[i]-=i
m[i]%=k
ans=0
dict=collections.defaultdict(int)
for i in range(1,n+1):
x=m[i]
if i<=k-1:
dict[m[i-1]]+=1
else:
dict[m[i-1]]+=1
dict[m[i-k]]-=1
ans+=dict[x]
print(ans)
|
a,b,h,m = map(int,input().split())
import math
C = abs(360 / 60 * m - 360 / 12 * h - 360 / 12 / 60 * m)
if C > 180:
C = 360 - C
#print(C)
cosC = math.cos(math.radians(C))
#print(cosC)
print(math.sqrt(a ** 2 + b ** 2 - 2 * a * b * cosC))
| 0 | null | 78,809,098,903,132 | 273 | 144 |
import math
a, b, deg = map(float, input().split())
rad = math.radians(deg)
area = 0.5 * a * b * math.sin(rad)
c = math.sqrt(a*a + b*b - 2*a*b*math.cos(rad))
h = area*2 / a;
print(area, a+b+c, h)
|
import math
a, b, ca = map(float, input().split())
ca = math.radians(ca)
s = a * b * math.sin(ca) / 2
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(ca)) ** 0.5
h = b * math.sin(ca)
print("{:.5f}".format(s))
print("{:.5f}".format(a + b + c))
print("{:.5f}".format(h))
| 1 | 176,007,964,928 | null | 30 | 30 |
N, K = map(int, input().split())
count = 1
while N >= K:
N //= K
count +=1
print(count)
|
X,n = map(int,input().split(" "))
def Base_10_to_n(X, n):
if (int(X/n)):
return Base_10_to_n(int(X/n), n)+str(X%n)
return str(X%n)
a=Base_10_to_n(X, n)
print(len(str(a)))
| 1 | 64,512,315,957,040 | null | 212 | 212 |
X = int(input())
Y = X ** 3
print(Y)
|
input_value = input()
value = int(input_value)
print(value**3)
| 1 | 274,890,835,088 | null | 35 | 35 |
S=input()
if S == "ABC":print("ARC")
else : print("ABC")
|
L = ['ABC', 'ARC']
S = input()
a = [i for i in L if i != S][0]
print(a)
| 1 | 24,084,193,532,740 | null | 153 | 153 |
N,M=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
from bisect import bisect_left
def isok(n):
sum=0
for i in range(N):
sum+=N-bisect_left(A,n-A[i])
return sum>=M
start,end=0,2*10**5+1
while end-start>1:
mid=(start+end)//2
if isok(mid):
start=mid
else:
end=mid
b=[A[0]]
for i in range(1,N):
b.append(b[-1]+A[i])
l=0
ans=0
bn=b[N-1]
for i in range(N):
a=bisect_left(A,start-A[i])
l+=N-a
if a>0:
ans+=A[i]*(N-a)+bn-b[a-1]
else:
ans+=A[i]*(N-a)+bn
ans-=start*(l-M)
print(ans)
|
#!python3
from itertools import accumulate
def my_bisect(a, x, key, lo=0, hi=None, side="left"):
if hi is None:
hi = len(a)
lov = key(a[lo])
hiv = key(a[hi])
if side == "left":
while lo < hi:
mid = (lo + hi) // 2
miv = key(a[mid])
if miv < val: lo, lov = mid+1, miv
else: hi, hiv = mid, miv
else:
while lo < hi:
mid = (lo + hi) // 2
miv = key(a[mid])
if val < miv: hi, hiv = mid, miv
else: lo, lov = mid+1, miv
return lo
from bisect import bisect_right
def resolve():
N, M = map(int, input().rstrip().split())
a = list(map(int, input().rstrip().split()))
a.sort(reverse=True)
b = list(accumulate(a))
c = [-i for i in a]
def count_shake(z):
n = 0
for i, x in enumerate(a):
y = x - z
#j = my_bisect(a, y, lambda x: -x, lo=i, side="right")
j = bisect_right(c, y, i)
if i == j:
break
n += 2 * (j - i) - 1
return n
lo = a[-1] * 2
hi = a[0] * 2
while True:
mid = (lo + hi) // 2
x = count_shake(mid)
if hi - lo <= 1:
break
if x < M: hi = mid
else: lo = mid
s = 0
d = [-1] * N
m = x
for i, x in enumerate(a):
y = x - mid
j = bisect_right(c, x - mid)
if j == 0: break
d[i] = j-1
s += b[j-1] + x * j
print(s - mid * (m-M))
if __name__ == "__main__":
resolve()
| 1 | 108,235,049,870,650 | null | 252 | 252 |
K = int(input())
s = len(input())
mod = 10 ** 9 + 7
N = 2 * 10**6
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fac.append( ( fac[-1] * i ) % mod )
inv.append( mod - ( inv[mod % i] * (mod // i) % mod ) )
finv.append( finv[-1] * inv[-1] % mod )
def cmb(n, r):
return fac[n] * ( finv[r] * finv[n-r] % mod ) % mod
p25 = [1]
p26 = [1]
for i in range(K):
p25.append(p25[i]*25%mod)
p26.append(p26[i]*26%mod)
ans = 0
for i in range(K+1):
ans += ( cmb(s+K-i-1, s-1) * p25[K-i] % mod ) * p26[i] % mod
ans %= mod
print(ans)
|
#input
K = int(input())
S = str(input())
#output
# (o以外) o (o以外) o (f以外) f (何でも)
#こちらもmodで割った余り。maxが決まっていて、大きくない時はこちらが早い。
mod = pow(10, 9) + 7
n_ = 5 * pow(10, 6)
fun = [1] * (n_+1)
for i in range(1, n_+1):
fun[i] = fun[i-1] * i % mod
rev = [1] * (n_+1)
rev[n_] = pow(fun[n_], mod-2, mod)
for i in range(n_-1, 0, -1):
rev[i] = rev[i+1] * (i+1) % mod
def cmb(n,r):
if n < 0 or r < 0 or r > n: return 0
return fun[n] * rev[r] % mod * rev[n-r] % mod
#重複組み合わせはH(n, r) = cmb(n+r-1, r)
L = len(S)
answer = 0
for i in range(K+1):
answer += pow(25, i, mod) * pow(26, K-i, mod) * cmb(L-1+i, i)
answer %= mod
print(answer)
| 1 | 12,687,919,131,680 | null | 124 | 124 |
# -*- 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}")
|
inp=input().split()
s = inp[0]
t = inp[1]
print(t+s)
| 1 | 102,708,809,268,660 | null | 248 | 248 |
X = int(input())
if 1800 <= X:
print(1)
elif 1600 <= X:
print(2)
elif 1400 <= X:
print(3)
elif 1200 <= X:
print(4)
elif 1000 <= X:
print(5)
elif 800 <= X:
print(6)
elif 600 <= X:
print(7)
else:
print(8)
|
x = int(input())
def check(input):
one = 1800
two = 1999
kyu = 1
while one >= 400:
if one <= input <= two:
return kyu
kyu += 1
one -= 200
two -= 200
print(check(x))
| 1 | 6,705,604,094,310 | null | 100 | 100 |
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 1
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
a,b = I()
A = str(a)*b
B = str(b)*a
print(min(A,B))
|
import sys
def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))
def RN(N): return [input().strip() for i in range(N)]
def main():
a, b = MI()
L = sorted([a, b])
if L[0] == a:
ans = int(str(a)*b)
else:
ans = int(str(b)*a)
print(ans)
if __name__ == "__main__":
main()
| 1 | 84,623,344,087,660 | null | 232 | 232 |
a=int(input())
d=0
for i in range(2,int(a**0.5)+1):
c=0
while a%i==0:
c+=1
a//=i
for i in range(1,60):
if c>=i:
c-=i
d+=1
else:
break
if a==1:
break
if a!=1:
d+=1
print(d)
|
n = int(input())
def factorize(x):
res = {}
p = 2
while p * p <= x:
if x % p != 0:
p += 1
continue
cnt = 0
while x % p == 0:
x //= p
cnt += 1
res[p] = cnt
p += 1
if x != 1:
res[x] = 1
return res
f = factorize(n)
ans = 0
for pe in f.items():
for e in range(1, pe[1] + 1):
z = pe[0] ** e
if n % z == 0:
n //= z
ans += 1
print(ans)
| 1 | 16,966,846,790,020 | null | 136 | 136 |
import bisect
def solve(n, k, a):
s = [0] * (n+1)
for i in range(n):
s[i+1] = s[i] + a[i]
D = {}
for i in range(n+1):
p = (s[i] - i) % k
if not p in D:
D[p] = []
D[p].append(i)
res = 0
for vs in D.values():
m = len(vs)
for j, vj in enumerate(vs):
i = bisect.bisect_left(vs, vj+k) - 1
res += i - j
return res
n, k = map(int, input().split())
a = list(map(int, input().split()))
print(solve(n, k, a))
|
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
INF = float("inf")
import bisect
N, K = list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
s = list(itertools.accumulate(a))
# print(s)
for i in range(0, N+1):
s[i] = (s[i] - i) % K
# print(s)
d = defaultdict(int)
count = 0
for j in range(1,N+1):
d[s[j-1]] += 1
if j-K >= 0:
d[s[j-K]] -= 1
# print(j,s[j],d)
count += d[s[j]]
# print(d)
print(count)
| 1 | 137,675,847,779,570 | null | 273 | 273 |
N,M=map(int,input().split())
ans=[]
if N%2==1:
for i in range(M):
ans.append([i+1,N-i])
else:
for i in range(M//2):
ans.append([i+1,2*M-i+1])
for j in range(M-M//2):
ans.append([j+M//2+1,2*M-M//2-j])
for k in ans:
print(*k,sep=' ')
|
def resolve():
N, K = list(map(int, input().split()))
cnt = 1
while N >= K**cnt:
cnt += 1
print(cnt)
if '__main__' == __name__:
resolve()
| 0 | null | 46,485,350,174,802 | 162 | 212 |
import math
class Pos:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return str(self.x) + ' ' + str(self.y)
def koch_curve(i, n, start, end):
if i < n:
f = get_pos(start, end, 1/3)
t = get_pos(start, end, 2/3)
s = get_sec_pos(start, end, f, t)
koch_curve(i + 1, n, start, f)
print(f)
koch_curve(i + 1, n, f, s)
print(s)
koch_curve(i + 1, n, s, t)
print(t)
koch_curve(i + 1, n, t, end)
def get_pos(start, end, m):
dX = (end.x - start.x) * m
dY = (end.y - start.y) * m
return Pos(start.x + dX, start.y + dY)
def get_sec_pos(start, end, f, t):
x = y = 0
if f.y == t.y:
x = start.x + (end.x - start.x) / 2
len = math.fabs(t.x - f.x)
h = math.sqrt(len**2 - (len/2)**2)
if start.x < end.x:
y = start.y + h
else:
y = start.y - h
elif f.x < t.x and f.y < t.y:
x = start.x
y = t.y
elif f.x > t.x and f.y < t.y:
x = end.x
y = f.y
elif f.x > t.x and f.y > t.y:
x = start.x
y = t.y
else:
x = end.x
y = f.y
return Pos(x, y)
n = int(input())
start = Pos(0, 0)
end = Pos(100, 0)
print(start)
koch_curve(0, n, start, end)
print(end)
|
a = [[[0 for i in range(10)] for j in range(3)] for k in range(4)]
n = int(input())
for i in range(1, n + 1):
b, f, r, v = map(int, input().split())
a[b-1][f-1][r-1] += v
for i in range(4):
for j in range(3):
for k in range(10):
print("", a[i][j][k], end="")
if k == 9:
print()
if j == 2 and i != 3:
print("####################")
| 0 | null | 606,014,598,592 | 27 | 55 |
situdo = input()
if int(situdo) >= 30:
print("Yes")
else:
print("No")
|
import sys
def input():
return sys.stdin.readline()[:-1]
def main():
s = int(input())
if s >= 30:
print('Yes')
else:
print('No')
if __name__ == "__main__":
main()
| 1 | 5,775,155,289,920 | null | 95 | 95 |
import math
a,b,c = map(float, input().split())
r = c * (math.pi/180)
h = b * math.sin(r)
S = 0.5*a*h
L = a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(r))
print(S)
print(L)
print(h)
|
from math import cos, radians, sin, sqrt
def g(a, b, c):
c_rad = radians(c)
yield a * b * sin(c_rad) / 2
yield a + b + sqrt(a ** 2 + b ** 2 - 2 * a * b * cos(c_rad))
yield b * sin(c_rad)
a, b, c = list(map(int, input().split()))
for i in g(a, b, c):
print("{:.8f}".format(i))
| 1 | 171,190,990,308 | null | 30 | 30 |
def solve(word1, word2):
n1, n2 = len(word1), len(word2)
res = []
for i in range(n1 - n2 + 1):
cur_s = word1[i : i + n2]
res.append(sum(cur_s[j] != word2[j] for j in range(len(cur_s))))
return min(res)
s = input()
p = input()
print(solve(s, p))
|
s = input()
ans = 0
if s[0] == "R":
ans += 1
if s[1] == "R":
ans += 1
if s[2] == "R":
ans += 1
elif s[1] == "R":
ans += 1
if s[2] == "R":
ans += 1
elif s[2] == "R":
ans += 1
print(ans)
| 0 | null | 4,278,257,941,342 | 82 | 90 |
import sys, fractions
[[print("{} {}".format(int(fractions.gcd(t[0], t[1])), int(t[0] * t[1] / fractions.gcd(t[0], t[1])))) for t in [[int(y) for y in x.split()]]] for x in sys.stdin]
|
#mathモジュールをインポートする
import math
try:
while True:
a,b = map(int,input().split())
#最小公約数
num1 = math.gcd(a,b)
#最大公倍数
num2 = int(a * b / num1)
print(str(num1) + " " + str(num2))
#EOFErrorをひろいコードを終了する
except EOFError:
pass
| 1 | 549,235,728 | null | 5 | 5 |
ab = list(map(int,input().split()))
ab.sort()
print(str(ab[0])*ab[1])
|
a = []
while True:
d = list(map(int,input().split()))
if d == [0,0]:
break
a.append(d)
for H,W in a:
print('#'*W)
for i in range(0,H-2):
print('#'+'.'*(W-2)+'#')
print('#'*W)
print('')
| 0 | null | 42,644,605,229,470 | 232 | 50 |
A, B, N = map(int, input().split())
val = min(B-1, N)
ans = (A*val/B/1.0)//1
print(int(ans))
|
A, B, N = map(int,input().split())
x = min(B-1, N)
print((A * x) // B - A * int(x // B))
| 1 | 28,084,369,193,902 | null | 161 | 161 |
h1, m1, h2, m2, k = map(int, input().split())
d = (h2 - h1) * 60 + (m2 - m1)
print(max(d - k, 0))
|
X = int(input())
for i in range(1, 1000):
if 100 * i <= X and X <= 105 * i:
print(1)
exit()
print(0)
| 0 | null | 72,555,428,359,700 | 139 | 266 |
N=int(input())
arr=list(map(int,input().split()))
print(' '.join(map(str,arr)))
for key in range(1,len(arr)):
temp=arr[key]
i=key-1
while i>=0 and arr[i]>temp:
arr[i+1]=arr[i]
i-=1
arr[i+1]=temp
print(' '.join(map(str,arr)))
|
a = []
def outputList(a):
for i in range(len(a)):
if i != len(a)-1:
print("%d"%a[i],end=' ')
else:
print("%d"%a[i],end='\n')
n = int(input().strip())
for i in input().split():
a.append(int(i))
if len(a)==n:
break
for i in range(1,len(a)):
outputList(a)
key = a[i]
j = i - 1
while j >= 0 and a[j] > key:
a[j+1] = a[j]
j -= 1
a[j+1] = key
outputList(a)
| 1 | 6,538,578,200 | null | 10 | 10 |
#WA
#桁DP
N=str(input())
K=int(input())
L=len(N)
#DP[i][smaller][j]=上からi桁(1<=i<=L)で0でない数字がj個(0<=j<=3)
DP=[[[0]*5 for index1 in range(2)] for index2 in range(L+1)]
#適当に初期設定
DP[0][0][0]=1
for i in range(1,L+1):
#smaller=1->smaller=1
DP[i][1][4]+=DP[i-1][1][4]*10+DP[i-1][1][3]*9
DP[i][1][3]+=DP[i-1][1][3]+DP[i-1][1][2]*9
DP[i][1][2]+=DP[i-1][1][2]+DP[i-1][1][1]*9
DP[i][1][1]+=DP[i-1][1][1]+DP[i-1][1][0]*9
DP[i][1][0]+=DP[i-1][1][0]
n=int(N[i-1])
#smaller=0->smaller=1
#n=0だとsmaller=0->smaller=1がない
#n=1だとsmaller=0->smaller=1のとき必ずjは変化しない
if n==1:
DP[i][1][4]+=DP[i-1][0][4]
DP[i][1][3]+=DP[i-1][0][3]
DP[i][1][2]+=DP[i-1][0][2]
DP[i][1][1]+=DP[i-1][0][1]
DP[i][1][0]+=DP[i-1][0][0]
elif n>=2:
DP[i][1][4]+=DP[i-1][0][4]*n+DP[i-1][0][3]*(n-1)
DP[i][1][3]+=DP[i-1][0][3]+DP[i-1][0][2]*(n-1)
DP[i][1][2]+=DP[i-1][0][2]+DP[i-1][0][1]*(n-1)
DP[i][1][1]+=DP[i-1][0][1]+DP[i-1][0][0]*(n-1)
DP[i][1][0]+=DP[i-1][0][0]
#smaller=0->smaller=0
#n=0だと必ずjは変化しない
if n==0:
DP[i][0][4]+=DP[i-1][0][4]
DP[i][0][3]+=DP[i-1][0][3]
DP[i][0][2]+=DP[i-1][0][2]
DP[i][0][1]+=DP[i-1][0][1]
DP[i][0][0]+=DP[i-1][0][0]
else:
DP[i][0][4]+=DP[i-1][0][4]+DP[i-1][0][3]
DP[i][0][3]+=DP[i-1][0][2]
DP[i][0][2]+=DP[i-1][0][1]
DP[i][0][1]+=DP[i-1][0][0]
print(DP[L][0][K]+DP[L][1][K])
|
import itertools
n = int(input())
p = [[0 for i in range(2)] for j in range(n)]
for i in range(n):
p[i][0],p[i][1] = map(int,input().split())
#print(p)
def dis(a,b):
dis = (a[0]-b[0]) ** 2 + (a[1]-b[1]) **2
return dis ** (1/2)
perm = [i for i in range(n)]
total = 0
num = 0
for v in itertools.permutations(perm,n):
path = 0
for i in range(n-1):
path += dis(p[v[i]],p[v[i+1]])
num += 1
total += path
print(total/num)
| 0 | null | 111,705,530,709,418 | 224 | 280 |
from sys import stdin,stdout
def INPUT():return list(int(i) for i in stdin.readline().split())
def inp():return stdin.readline()
def out(x):return stdout.write(x)
import math
import random
J=int(1e9)+7
###############################################################################\n=17
n=int(input())
A=INPUT()
sum=0
for i in range(n):
sum+=A[i]
sum=sum*sum
s=0
for i in range(n):
s+=A[i]**2
ans=(sum-s)//2
ans%=J
print(ans)
|
while True:
a,b=map(int,input().split())
if a==0 and b==0:break
for i in range (a):
print('#'*b)
print()
| 0 | null | 2,293,852,070,598 | 83 | 49 |
import math
N = int(input())
A = list(map(int, input().split()))
bit = [0] * 60
MOD = 10 ** 9 + 7
for a in A:
i = 0
waru = 1
while a > 0:
if a % (waru * 2) != 0:
a -= waru
bit[i] += 1
waru *= 2
i += 1
answer = 0
for i, b in enumerate(bit):
answer += (2 ** i) * (b * (N-b))
print(answer % MOD)
|
MOD = 1000000007
n = int(input())
aas = list(map(int, input().split()))
KET = 60
arr_0 = [0]*KET
arr_1 = [0]*KET
for i in aas:
bits = format(i,'060b')
for j in reversed(range(KET)):
if bits[j] == '0':
arr_0[KET-j-1] += 1
else:
arr_1[KET-j-1] += 1
res = 0
for i in range(KET):
res += (arr_0[i]%MOD * arr_1[i]%MOD)%MOD * pow(2,i,MOD)
res %= MOD
print(res)
| 1 | 123,376,822,992,850 | null | 263 | 263 |
from sys import stdin
#入力
readline=stdin.readline
N,K=map(int,readline().split())
A=list(map(int,readline().split()))
A.sort()
mod=10**9+7
fact=[1]*(N+1)
finv=[1]*(N+1)
inv=[1]*(N+1)
inv[0]=0
for i in range(2,N+1):
fact[i]=(fact[i-1]*i%mod)
inv[i]=(-inv[mod%i]*(mod//i))%mod
finv[i]=(finv[i-1]*inv[i])%mod
def com(N,K,mod):
if (K<0) or (N<K):
return 0
return fact[N]*finv[K]*finv[N-K]%mod
s=0
for i in range(N-1,K-2,-1):
s+=A[i]*com(i,K-1,mod)
for i in range(N-K+1):
s-=A[i]*com(N-i-1,K-1,mod)
s%=mod
print(s)
|
def power(a,n):
x=1
L=list(format(n,'b'))
l=len(L)
for i in range(l):
if int(L[l-i-1])==1:
x=(x*a)%(10**9+7)
a=(a*a)%(10**9+7)
return x
N,K=map(int,input().split())
A=list(map(int,input().split()))
b=sorted(A)
c=sorted(A,reverse=True)
D=[]
M=0
x=1
y=1
for l in range(K-1):
x=(x*(N-l-1))%(10**9+7)
y=(y*(l+1))%(10**9+7)
y=power(y,10**9+5)
M+=(x*y*(c[0]-b[0]))%(10**9+7)
for i in range(1,N-K+1):
y1=power(N-i,10**9+5)
x=(x*y1)%(10**9+7)
x=(x*(N-K-i+1))%(10**9+7)
m=(x*y*(c[i]-b[i]))
if m>0:
m=m%(10**9+7)
M+=m
M%(10**9+7)
print(M%(10**9+7))
| 1 | 95,842,704,894,180 | null | 242 | 242 |
#!/usr/bin/env python3
def main():
import sys
input = sys.stdin.readline
X = int(input())
cnt = 0
res = 100
while True:
if res >= X:
print(cnt)
break
res += res // 100
cnt += 1
if __name__ == '__main__':
main()
|
def judge(k, N, A):
p = N - 1
t = 0
for i in A:
while p >= 0 and A[p] + i < k:
p -= 1
t += (p + 1)
return t
def main():
N, M = map(int, input().split())
A = list(map(int, input().split()))
A.sort(reverse=True)
t = A[0] * 2
b = 0
X = None
while t - b > 1:
m = (t + b)//2
i = judge(m, N, A)
if i == M:
X = m
break
if i > M:
ip = judge(m + 1, N, A)
if ip == M:
X = m + 1
break
if ip < M:
X = m
break
b = m + 1
if i < M:
im = judge(m - 1, N, A)
if im >= M:
X = m - 1
break
t = m - 1
if X is None:
X = b
r = 0
p = N - 1
k = sum(A)
for i in A:
while p >= 0 and A[p] + i < X :
k -= A[p]
p -= 1
r += i * (p + 1) + k
return r - (judge(X, N, A) - M) * X
print(main())
| 0 | null | 67,219,767,324,602 | 159 | 252 |
a, b, c, d = input().split()
a=int(a)
b=int(b)
c=int(c)
d=int(d)
def m():
if a>=0 and d<=0:
max=a*d
print(max)
elif a>=0 and c>=0:
max=b*d
print(max)
elif b<=0 and c>=0:
max=b*c
print(max)
elif b<=0 and d<=0:
max=a*c
print(max)
elif a<=0 and b>=0 and c<=0 and d>=0:
if a*c>=b*d:
max=a*c
print(max)
else:
max=b*d
print(max)
elif a>=0 and c<=0 and d>=0:
max=b*d
print(max)
elif b<=0 and c<=0 and d>=0:
max=a*c
print(max)
elif a<=0 and b>=0 and c>=0:
max=b*d
print(max)
elif a<=0 and b>=0 and d<=0:
max=a*c
print(max)
m()
|
s = str(input())
num = [int(s[-1])]
for i in range(1, len(s)):
tmp = num[-1] + pow(10, i, 2019) * int(s[-i - 1])
num.append(tmp % 2019)
mod = [1] + [0] * 2018
ans = 0
for i in num:
ans += mod[i]
mod[i] += 1
print(ans)
| 0 | null | 17,043,224,775,260 | 77 | 166 |
n,x,m=map(int,input().split())
f=1
w=[]
d=[0]*(m+2)
t=[0]
chk=n
p=x
for i in range(m+1):
if i!=0: p=p*p%m
if d[p]: break
d[p]=1
w.append(p)
t.append(t[-1]+p)
#f*=2
chk-=1
if chk==0:
print(t[-1])
exit()
ans=0
a=w.index(p)
ans+=t[a]
n-=a
loo=len(w)-a
if n%loo==0:
ans+=(t[-1]-t[a])*(n//loo)
else:
ans+=(t[-1]-t[a])*(n//loo)
ans+=t[a+n%loo]-t[a]
print(ans)
|
def f(x, m):
return x * x % m
def main():
N, X, M = map(int, input().split())
pre = set()
pre.add(X)
cnt = 1
while cnt < N:
X = f(X, M)
if X in pre: break
cnt += 1
pre.add(X)
if cnt == N:
return sum(pre)
ans = sum(pre)
N -= cnt
loop = set()
loop.add(X)
while cnt < N:
X = f(X, M)
if X in loop: break
loop.add(X)
left = N % len(loop)
ans += sum(loop) * (N // len(loop))
for i in range(left):
ans += X
X = f(X, M)
return ans
print(main())
| 1 | 2,820,493,359,180 | null | 75 | 75 |
import math
def main():
n = int(input())
# n, k = map(int, input().split())
# h = list(map(int, input().split()))
# s = input()
# h = [int(input()) for _ in rane(n)]
ans = 0
for i in range(1, n):
ans += (n - 1) // i
print(ans)
if __name__ == '__main__':
main()
|
N = int(input())
A = list(map(int,input().split()))
bunretsu = sum(A) - 1
zanretsu = 1
souwa = 0
for i in range(N+1):
souwa += zanretsu
if A[i] <= zanretsu:
zanretsu -= A[i]
else:
souwa = -1
break
if bunretsu >= 1 and bunretsu <= zanretsu:
zanretsu += bunretsu
bunretsu = 0
elif bunretsu >= 1 and bunretsu > zanretsu:
bunretsu -= zanretsu
zanretsu *= 2
print(souwa)
| 0 | null | 10,741,680,922,060 | 73 | 141 |
from math import ceil
H=int(input())
W=int(input())
N=int(input())
print(min(ceil(N/H),ceil(N/W)))
|
h=int(input())
w=int(input())
n=int(input())
print(min((n+h-1)//h,(n+w-1)//w))
| 1 | 88,919,687,946,080 | null | 236 | 236 |
class Dice():
def __init__(self, label):
self.d = label
def roll(self, drt):
if drt == 'N':
self.d[1], self.d[2], self.d[6], self.d[5] = self.d[2], self.d[6], self.d[5], self.d[1]
elif drt == 'E':
self.d[1], self.d[3], self.d[6], self.d[4] = self.d[4], self.d[1], self.d[3], self.d[6]
elif drt == 'S':
self.d[2], self.d[6], self.d[5], self.d[1] = self.d[1], self.d[2], self.d[6], self.d[5]
elif drt == 'W':
self.d[4], self.d[1], self.d[3], self.d[6] = self.d[1], self.d[3], self.d[6], self.d[4]
def printl(self, lct):
print(self.d[lct])
label = [0]
label.extend(list(map(int, input().split())))
dice1 = Dice(label)
direction = input()
leng = len(direction)
for i in range(leng):
dice1.roll(direction[i])
dice1.printl(1)
|
def main():
N = int(input())
if N <= 1:
print(1)
return
fib = [0]*(N+1)
fib[0], fib[1] = 1, 1
for i in range(2, N+1):
fib[i] = fib[i-1] + fib[i-2]
print(fib[N])
if __name__ == "__main__":
main()
| 0 | null | 117,540,673,962 | 33 | 7 |
import sys
sys.setrecursionlimit(1000000000)
ii = lambda: int(input())
ii0 = lambda: ii() - 1
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
def main():
N,M,L = mis()
from scipy.sparse.csgraph import floyd_warshall
import numpy as np
INF = np.iinfo(np.int64).max
d = np.full((N,N), INF, dtype=np.uint64)
for i in range(N):
d[i,i] = 0
#
for _ in range(M):
a,b,c = mis()
a -= 1
b -= 1
if c <= L:
d[a,b] = c
d[b,a] = c
#
'''
for k in range(N):
for i in range(N):
np.minimum(d[i,:], d[i,k]+d[k,:], out=d[i,:])
'''
d = floyd_warshall(d)
#
d2 = np.full((N,N), INF, dtype=np.uint64)
for i in range(N):
d2[i, i] = 0
for i in range(N):
for j in range(N):
if d[i, j] <= L:
d2[i, j] = 1
#
'''
for k in range(N):
for i in range(N):
np.minimum(d2[i,:], d2[i,k]+d2[k,:], out=d2[i,:])
'''
d2 = floyd_warshall(d2)
#
Q = ii()
for _ in range(Q):
s,t = mis()
s -= 1
t -= 1
dist = d2[s,t]
if dist == INF:
print(-1)
else:
print(int(dist)-1)
main()
|
import sys
INF = 1 << 32 - 1
S = sys.stdin.readlines()
N, M, L = map(int, S[0].split())
dp = [[INF] * N for _ in range(N)]
for i in range(1, M + 1):
A, B, C = map(int, S[i].split())
dp[A - 1][B - 1] = C
dp[B - 1][A - 1] = C
for i in range(N):
dp[i][i] = 0
for k in range(N):
for i in range(N):
for j in range(N):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])
dp2 = [[INF] * N for _ in range(N)]
for i in range(N):
for j in range(N):
if dp[i][j] <= L:
dp2[i][j] = 1
# for i in range(N):
# dp2[i][i] = 0
for k in range(N):
for i in range(N):
for j in range(N):
dp2[i][j] = min(dp2[i][j], dp2[i][k] + dp2[k][j])
Q = int(S[M + 1])
for i in range(M + 2, M + 2 + Q):
s, t = map(int, S[i].split())
refuel = dp2[s - 1][t - 1]
if refuel >= INF:
print(-1)
else:
print(refuel - 1)
| 1 | 173,529,800,777,422 | null | 295 | 295 |
arr = list(map(int, input().split()))
arr.sort()
if (arr[0] == arr[1]) and (arr[2] != arr[1]):
print("Yes")
elif (arr[1] == arr[2]) and (arr[0] != arr[1]):
print("Yes")
else:
print("No")
|
m1,_ = map(int,input().split())
m2,_ = map(int,input().split())
if m1 < m2:
print(1)
else:
print(0)
| 0 | null | 96,428,189,684,820 | 216 | 264 |
def II(): return int(input())
N=II()
d=2
ans=0
while d*d<=N:
if N%d!=0:
d+=1
continue
z=d
while N%z==0:
ans+=1
N//=z
z*=d
while N%d==0:
N//=d
if N!=1:
ans+=1
print(ans)
|
# -*- coding: utf-8 -*-
class Dice:
def __init__(self, n):
self.upper = n[0]
self.backward = n[1]
self.right = n[2]
self.left = n[3]
self.ahead = n[4]
self.bottom = n[5]
def roll_north(self):
self.upper, self.ahead, self.bottom, self.backward = self.backward, self.upper, self.ahead, self.bottom
def roll_south(self):
self.upper, self.ahead, self.bottom, self.backward = self.ahead, self.bottom, self.backward, self.upper
def roll_east(self):
self.upper, self.right, self.bottom, self.left = self.left, self.upper, self.right, self.bottom
def roll_west(self):
self.upper, self.right, self.bottom, self.left = self.right, self.bottom, self.left, self.upper
dice_info = Dice(list(map(int, input().split())))
order = list(input())
for i in range(len(order)):
if 'N' in order[i]:
dice_info.roll_north()
elif 'S' in order[i]:
dice_info.roll_south()
elif 'E' in order[i]:
dice_info.roll_east()
elif'W' in order[i]:
dice_info.roll_west()
print(dice_info.upper)
| 0 | null | 8,583,974,509,252 | 136 | 33 |
a,b=input().split()
c,d=input().split()
b=int(b)
d=int(d)
if d-b==1:
print("0")
else:
print("1")
|
n, k, c = map(int, input().split())
s = input()
left_dp = []
right_dp = []
i = 0
while len(left_dp)<k:
if s[i] == "o":
left_dp.append(i+1)
i += c+1
else: i += 1
i = n-1
while len(right_dp)<k:
if s[i] == "o":
right_dp.append(i+1)
i -= c+1
else: i -= 1
for i in range(k):
if left_dp[i] == right_dp[k-i-1]:
print(left_dp[i])
| 0 | null | 82,768,397,751,208 | 264 | 182 |
a,b,n = map(int,input().split())
k = max(0,(n - b + 1) // b)
k = min(n,k * b + b - 1)
print((a * k) // b - a * (k // b))
|
a,b,n = map(int,input().split())
if b <= n:
k = b-1
else:
k = n
m = int(k*a/b) - a*int(k/b)
print(m)
| 1 | 28,208,463,766,940 | null | 161 | 161 |
N,M = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
MAX = 10**10 + 10
# Ai+Ajを列挙して大きいほうからM番目となるスコアSを求める
# その後S以上となるスコアを加算して合計値を求める
from bisect import bisect_left
def judge(x,key):
# スコアx以上となるのがkey個以上あるか？
num = 0
for i in range(N):
eidx = bisect_left(A,x-A[i])
num += N-eidx
if num >= key:
return True
else:
return False
def meguru(key):
ok = -1
ng = MAX
while (abs(ok-ng)>1):
mid = (ok+ng)//2
if judge(mid,key):
ok = mid
else:
ng = mid
return ok
D = meguru(M)
ans = 0
ruisekiwa = [0]*(N+1)
for i in range(N):
ruisekiwa[i+1] = ruisekiwa[i] + A[i]
num = 0
for i in range(N):
eidx = bisect_left(A,D+0.5-A[i])
ans += A[i] * (N-eidx)
ans += ruisekiwa[N] - ruisekiwa[eidx]
num += N-eidx
if num<M:
ans += (M-num)*D
print(ans)
|
import sys
input = sys.stdin.readline
from bisect import *
def judge(x):
cnt = 0
for Ai in A:
cnt += N-bisect_left(A, x-Ai+1)
return cnt<M
def binary_search():
l, r = 0, 2*max(A)
while l<=r:
m = (l+r)//2
if judge(m):
r = m-1
else:
l = m+1
return l
N, M = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
border = binary_search()
acc = [0]*(N+1)
for i in range(N):
acc[i+1] = acc[i]+A[i]
cnt = 0
ans = 0
for Ai in A:
j = bisect_left(A, border-Ai+1)
cnt += N-j
ans += (N-j)*Ai+acc[N]-acc[j]
ans += (M-cnt)*border
print(ans)
| 1 | 107,682,058,137,430 | null | 252 | 252 |
h,w,m = map(int,input().split())
x = {}
y = {}
dic = {}
for _ in range(m):
a,b = map(int,input().split())
dic[(a,b)] = 1
x[a] = x.get(a,0) + 1
y[b] = y.get(b,0) + 1
p = max(x.values())
q = max(y.values())
cnt = 1
a = [i for i in x if x[i] == p]
b = [j for j in y if y[j] == q]
for i in a:
for j in b:
if dic.get((i,j),-1) == -1:
cnt = 0
break
if not cnt:
break
print(p+q-cnt)
|
num = int(input())
table = list(map(int, input().split()))
table2 = []
for i in range(num):
table2.append(0)
for j in range(len(table)):
table2[table[j]-1] += 1
for k in table2:
print(k)
| 0 | null | 18,610,397,571,680 | 89 | 169 |
def gcd(x, y):
if x == 0:
return y
return gcd(y % x, x)
def lcm(x, y):
return x // gcd(x, y) * y
n, m = map(int, input().split())
a = list(map(int, input().split()))
aa = [e // 2 for e in a]
for i, e in enumerate(aa):
if i == 0:
base = 0
while e % 2 == 0:
e //= 2
base += 1
else:
cnt = 0
while e % 2 == 0:
e //= 2
cnt += 1
if cnt != base:
print(0)
exit()
c = 1
for e in aa:
c = lcm(c, e)
if c > m:
print(0)
exit()
ans = (m - c) // (2 * c) + 1
print(ans)
|
import sys
input = sys.stdin.buffer.readline
def main():
n = int(input())
A = list(map(int, input().split()))
L = [(a, i+1) for i, a in enumerate(A)]
L.sort(reverse=True)
dp = [[-1]*(n+1) for _ in range(n+1)]
dp[0][0] = 0
ans = 0
for i in range(n+1):
for j in range(n+1-i):
a, idx = L[i+j-1]
if i:
dp[i][j] = max(dp[i][j], dp[i-1][j]+a*(idx-i))
if j:
dp[i][j] = max(dp[i][j], dp[i][j-1]+a*(n+1-j-idx))
if i+j == n:
ans = max(ans, dp[i][j])
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 67,729,996,592,256 | 247 | 171 |
n = int(raw_input())
dp = {}
def fib(n):
if n in dp: return dp[n]
if n == 0:
dp[n] = 1
return 1
elif n == 1:
dp[n] = 1
return 1
else:
dp[n] = fib(n-1)+fib(n-2)
return dp[n]
print fib(n)
|
#!/usr/bin/env python3
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
def main():
N, D, A = map(int, input().split())
XH = [None] * N
X = [None] * N
for i in range(N):
XH[i] = tuple(map(int, input().split()))
X[i] = XH[i][0]
XH.sort()
X.sort()
ans = 0
S = [0] * (N+1)# 与えたダメージ
for i in range(N):
if S[i] < XH[i][1]:
# あと何回攻撃する？
need = (XH[i][1]-S[i]+A-1)//A
# 爆弾が届く範囲
j = bisect_right(X,X[i]+2*D)
# imos法
S[i] += need*A
S[j] -= need*A
ans += need
S[i+1] += S[i]
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 40,929,021,375,920 | 7 | 230 |
N=int(input())
S=input()
if N%2==1:print('No')
else:
s1,s2=S[:N//2],S[N//2:]
ok=1
for i in range(N//2):
if s1[i]!=s2[i]:
print('No')
ok=0
break
if ok==1:print('Yes')
|
N = int(input())
ret = False
if N % 2 == 0:
S = input()
if S[:N//2] == S[N//2:]:
ret = True
if ret:
print("Yes")
else:
print("No")
| 1 | 147,051,755,494,908 | null | 279 | 279 |
x = raw_input()
x = int(x)
x = x * x * x
print x
|
a=input()
print a ** 3
| 1 | 284,915,325,820 | null | 35 | 35 |
N = int(input())
A = list(map(int, input().split()))
count = 0
for a in A[0::2]:
if a % 2 == 1:
count = count + 1
print(count)
|
n = int(input())
S = [False for i in range(13)]
D = [False for i in range(13)]
C = [False for i in range(13)]
H = [False for i in range(13)]
for i in range(n):
a,b = input().split()
b = int(b)
if a == "S":
S[b-1] = True
elif a == "D":
D[b-1] = True
elif a == "C":
C[b-1] = True
elif a == "H":
H[b-1] = True
for i in range(13):
if S[i] == False:
print("S "+str(i+1))
for i in range(13):
if H[i] == False:
print("H "+str(i+1))
for i in range(13):
if C[i] == False:
print("C "+str(i+1))
for i in range(13):
if D[i] == False:
print("D "+str(i+1))
| 0 | null | 4,442,120,959,848 | 105 | 54 |
n,x,y = map(int,input().split())
x -= 1
y -= 1
cnt = [0]*n
for i in range(n):
for j in range(i+1,n):
dis = min(j-i,abs(x-i)+1+abs(j-y))
cnt[dis] += 1
for i in range(1,n):
print(cnt[i])
|
from collections import Counter
N, X, Y = map(int, input().split())
ans = []
for i in range(1, N + 1):
for j in range(i + 1, N + 1):
min_dis = min(abs(j - i),
abs(X - i) + 1 + abs(j - Y),
abs(Y - i) + 1 + abs(j - X))
ans.append(min_dis)
c = Counter(ans)
for i in range(1, N):
print(c[i])
| 1 | 44,373,714,322,080 | null | 187 | 187 |
def main():
name = list(map(str,input().split()))
num = list(map(int,input().split()))
n = input()
if n==name[0]:
print(num[0]-1,num[1])
else:
print(num[0],num[1]-1)
main()
|
apple = [1, 2, 3]
apple.remove(int(input()))
apple.remove(int(input()))
print(apple[0])
| 0 | null | 90,886,672,296,474 | 220 | 254 |
# -*- 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])
|
# coding: utf-8
# Your code here!
while(1):
H,W=map(int,input().split(" "))
if H==0 and W==0:
break
else:
for i in range(H):
for j in range(W):
print("#",end="")
print("")
print("")
| 0 | null | 393,007,277,088 | 7 | 49 |
N=int(input())
A=list(map(int,input().split()))
ans=20202020200
sum_A=0
sum_B=sum(A)
for i in range(N):
sum_A+=A[i]
sum_B-=A[i]
tmp=abs(sum_A-sum_B)
if tmp<ans:
ans=tmp
print(ans)
|
# B - Iron Bar Cutting
N = int(input())
A = list(map(int, input().split()))
left = 0
right = sum(A)
ans = right
for a in A:
left += a
right -= a
diff = abs(right - left)
ans = min(ans, diff)
if left > right:
break
print(ans)
| 1 | 141,936,624,522,932 | null | 276 | 276 |
N = int(input())
b = list(map(int, input().split()))
MOD = 1000000007
sum_n = 0
a = []
for i in b:
a.append(i%MOD)
sum_sum = sum(a[1:])
for i in range(N):
sum_n = (sum_n + (a[i] * sum_sum) % MOD) % MOD
if i+1 < N:
sum_sum = sum_sum - a[i+1]
print(sum_n % MOD)
|
x = int(input())
k = 1
while k*x%360:
k += 1
print(k)
| 0 | null | 8,399,413,581,552 | 83 | 125 |
N, K = map(int,input().split())
d_list = []
A_list = []
for i in range(K):
d = int(input())
d_list.append(d)
A = list(map(int, input().split()))
A_list.append(A)
person = [0 for i in range(N)]
for i in range(K):
for j in range(d_list[i]):
person[A_list[i][j]-1] += 1
print(person.count(0))
|
# coding:UTF-8
import sys
from math import factorial
MOD = 10 ** 9 + 7
INF = 10000000000
def main():
# ------ 入力 ------#
n = int(input()) # 数字
# 定数行入力
x = n
dList = [list(map(int, input().split())) for _ in range(x)] # スペース区切り連続数字(行列)
# ------ 処理 ------#
flg = 1
for i in range(n-2):
if dList[i][0] == dList[i][1]:
if dList[i+1][0] == dList[i+1][1]:
if dList[i+2][0] == dList[i+2][1]:
flg = 0
# ------ 出力 ------#
if flg == 0:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| 0 | null | 13,592,072,745,530 | 154 | 72 |
import math
def prime_array(n=1000):
List = [2]
i = 3
while i <= n:
judge = True
for k in List :
if math.sqrt(i) < k :
break
if i%k == 0:
judge = False
break
if judge :
List.append(i)
i += 2
return List
def main():
cnt=0
prime_List=prime_array(10**4)
n=input()
for i in range(n):
a=input()
if a<=10**4:
for j in prime_List:
if a==j:
cnt+=1
break
else:
judge=True
for j in prime_List:
if a%j==0:
judge=False
break
if judge:
cnt+=1
print('%d' % cnt)
if __name__=='__main__':
main()
|
import sys
from io import StringIO
import unittest
import copy
# 検索用タグ、バージョンによる相違点(pypy)
def resolve():
x, y, a, b, c = map(int, input().split())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
r = list(map(int, input().split()))
p.sort(key=lambda xx: -xx)
q.sort(key=lambda xx: -xx)
r.sort(key=lambda xx: -xx)
# 着色を一切行わない場合の値
# pypy3(2.4.0)ではlist.copy()が未実装。copy をインポートする必要がある。
def_red = copy.copy(p[0:x])
def_grren = copy.copy(q[0:y])
# 無職のリンゴに置換していく・・
redcnt = -1
grncnt = -1
def_red_cnt = len(def_red)
def_grren_cnt = len(def_grren)
for i in range(len(r)):
if not (r[i] > def_red[redcnt] or r[i] > def_grren[grncnt]):
continue
if def_red[redcnt] > def_grren[grncnt] and r[i] > def_grren[grncnt]:
# 透明のリンゴを緑に着色して、置き換える。
def_grren[grncnt] = r[i]
if grncnt is not -def_grren_cnt:
grncnt -= 1
else:
# 透明のリンゴを赤に着色して、置き換える。
def_red[redcnt] = r[i]
if redcnt is not -def_red_cnt:
redcnt -= 1
print(sum(def_red) + sum(def_grren))
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """1 2 2 2 1
2 4
5 1
3"""
output = """12"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """2 2 2 2 2
8 6
9 1
2 1"""
output = """25"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """2 2 4 4 4
11 12 13 14
21 22 23 24
1 2 3 4"""
output = """74"""
self.assertIO(input, output)
# def test_自作成_1(self):
# input = """1 1 1 1 1
# 10
# 20
# 90"""
# output = """110"""
# self.assertIO(input, output)
# このパターンで「list index out of range」が発生。
# def test_自作成_2(self):
# input = """1 1 1 1 2
# 10
# 20
# 90 110"""
# output = """200"""
# self.assertIO(input, output)
if __name__ == "__main__":
# unittest.main()
resolve()
| 0 | null | 22,579,043,493,048 | 12 | 188 |
r=map(float,raw_input().split())
x=r[0]-r[2]
y=r[1]-r[3]
if x<0:
x=x*-1
if y<0:
y=y*-1
print (x**2+y**2)**0.5
|
s = input()
print(s[:3])
| 0 | null | 7,532,509,256,180 | 29 | 130 |
A, B = map(int, input().split())
ans = A - B - B
if ans < 0:
ans = 0
print(ans)
|
import math
import sys
from collections import deque
import heapq
import copy
import itertools
from itertools import permutations
def mi() : return map(int,sys.stdin.readline().split())
def ii() : return int(sys.stdin.readline().rstrip())
def i() : return sys.stdin.readline().rstrip()
a,b=mi()
print(max(a-b-b,0))
| 1 | 166,420,456,322,010 | null | 291 | 291 |
i = 1
while True:
n = input()
if n == 0:
break
else:
print "Case %d: %d" % (i, n)
i = i + 1
|
sum = 0
while 1:
x = raw_input()
sum = sum + 1
if x == '0':
break
print 'Case %s: %s' %(sum, x)
| 1 | 477,496,099,768 | null | 42 | 42 |
def main():
n, m = map(int, input().split())
# nは偶数、mは奇数
# n+mから2つ選ぶ選び方は
# n:m = 0:2 和は 偶数、選び方はmC2
# n:m = 1:1 和は 奇数 （今回はこれは含めない）
# n:m = 2:0 和は 偶数、選び方はnC2
cnt = 0
if m >= 2:
cnt += m * (m -1) // 2
if n >=2:
cnt += n * (n -1) // 2
print(cnt)
if __name__ == '__main__':
main()
|
N,M = map(int,input().split())
ki = (N*(N-1))//2
gu = (M*(M-1))//2
print (ki+gu)
| 1 | 45,332,905,182,570 | null | 189 | 189 |
import sys
args = input()
print(args[:3])
|
s=list(input())
t=[]
for i in range(3):
t.append(s[i])
r=''.join(t)
print(r)
| 1 | 14,711,428,242,368 | null | 130 | 130 |
n=int(input())
a=[]
from collections import deque as dq
for i in range(n):
aaa=list(map(int,input().split()))
aa=aaa[2:]
a.append(aa)
dis=[-1]*n
dis[0]=0
queue=dq([0])
while queue:
p=queue.popleft()
for i in range(len(a[p])):
if dis[a[p][i]-1]==-1:
queue.append(a[p][i]-1)
dis[a[p][i]-1]=dis[p]+1
for i in range(n):
print(i+1,dis[i])
|
# coding: utf-8
from queue import Queue
N = int(input())
graph = [None]
for _ in range(N):
graph.append(list(map(int, input().split(" ")))[1:])
class BFSSolver:
def __init__(self, graph):
self.graph = graph
self.queue = Queue()
self.queue.put(1)
self.before_id = 1
self.already_searched = [1]
self.res = [0]
for _ in range(N):
self.res.append(-1)
self.res[1] = 0
self.turn = 0
def next_turn(self):
now_id = self.queue.get()
before_id = now_id
neighbors = self.graph[now_id][1:]
for i in neighbors:
if i not in self.already_searched:
self.turn = self.res[before_id] + 1
self.already_searched.append(i)
self.res[i] = self.turn
self.queue.put(i)
def solve(self):
while not self.queue.empty():
self.next_turn()
for id, i in enumerate(self.res[1:]):
print("{} {}".format(id+1, i))
s = BFSSolver(graph)
s.solve()
| 1 | 4,317,036,868 | null | 9 | 9 |
# Easy Liniear Programming
A,B,C,K = map(int,input().split())
ans = min(A,K)*1 + max(0, K-A)*0 + max(0, K-A-B)*(-1)
print(ans)
|
A, B, C, K = map(int, input().split())
sum = 0
if A > K:
print(K)
elif A + B > K:
print(A)
else:
print(A-(K-A-B)) # =(A+B-(K-(A+B)))
| 1 | 21,883,690,517,612 | null | 148 | 148 |
n,m,k=map(int,input().split())
mod=998244353
MAX_N=n+5
fac = [1,1] + [0]*MAX_N
finv = [1,1] + [0]*MAX_N
inv = [0,1] + [0]*MAX_N
for i in range(2,MAX_N):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod % i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
def nCk(n,k):
if n<k:
return 0
if n<0 or k<0:
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
ans=0
for i in range(k+1):
ans+=nCk(n-1,i)*m*pow(m-1,n-i-1,mod)
ans%=mod
print(ans)
|
K = int(input())
S = input()
m = 1000000007
result = 0
t = pow(26, K, m)
u = pow(26, m - 2, m) * 25 % m
l = len(S)
for i in range(K + 1):
# result += pow(26, K - i, m) * mcomb(len(S) - 1 + i, i) * pow(25, i, m)
result = (result + t) % m
t = (t * u) % m * (l + i) % m * pow(i + 1, m - 2, m) % m
print(result)
| 0 | null | 17,880,186,833,490 | 151 | 124 |
import sys
from itertools import count
H, A = map(int, next(sys.stdin.buffer).split())
for i in count(1):
H -= A
if H <= 0:
break
print(i)
|
N = int(input())
eList = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
n = N
mod = N
numList = []
while n > 0:
n, mod = divmod(n,26)
if mod != 0:
numList.insert(0, mod - 1)
else:
numList.insert(0, 25)
n -= 1
ans =''
for num in numList:
ans += eList[num]
print(ans)
| 0 | null | 44,663,876,742,128 | 225 | 121 |
str = list(input())
q = int(input())
for i in range(q):
s = list(input().split())
s[1] = int(s[1])
s[2] = int(s[2])
if s[0] == 'print':
print(''.join(str[s[1]:s[2]+1]))
elif s[0] == 'reverse':
str[s[1]:s[2]+1] = ''.join(reversed(str[s[1]:s[2]+1]))
elif s[0] == 'replace':
str[s[1]:s[2]+1:1] = s[3]
|
def str_reverse(s, a, b):
s_new = s[0:a]
s_rev = s[a:b+1]
s_rev_len = len(s_rev)
for i in range(s_rev_len):
j = s_rev_len - i - 1
s_new += s_rev[j]
s_new += s[b+1:]
return s_new
def str_replace(s, a, b, new):
s_new = s[0:a]
s_new += new
s_new += s[b+1:]
return s_new
s = input()
n = int(input())
for q in range(n):
line = input()
if line.find('print') == 0:
cmd, a, b = line.split()
a = int(a)
b = int(b)
print(s[a:b+1])
elif line.find('reverse') == 0:
cmd, a, b = line.split()
a = int(a)
b = int(b)
s = str_reverse(s, a, b)
elif line.find('replace') == 0:
cmd, a, b, p = line.split()
a = int(a)
b = int(b)
s = str_replace(s, a, b, p)
| 1 | 2,105,758,710,780 | null | 68 | 68 |
i = 1
while True:
n = input()
if n != 0:
print 'Case %s: %s' % (str(i), str(n))
i = i + 1
else:
break
|
N,M = map(int,input().split())
A = [0]*M
B = [0]*M
for i in range(M):
A[i],B[i] = map(int,input().split())
from collections import deque
links = [[] for _ in range(N+1)]
for i in range(M):
links[A[i]].append(B[i])
links[B[i]].append(A[i])
result = [-1]*(N+1)
q = deque([1])
while q:
i = q.popleft()
for j in links[i]:
if result[j] == -1:
result[j] = i
q.append(j)
print('Yes')
print('\n'.join(str(i) for i in result[2:]))
| 0 | null | 10,582,405,182,844 | 42 | 145 |
MOD = 10**9+7
n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
#print(a)
kai = [1]
gai = []
for i in range(n):
j = (kai[i] * (i+1)) % MOD
kai.append(j)
for i in range(n+1):
j = kai[i]
l = pow(j, MOD-2, MOD)
gai.append(l)
#print(kai)
#print(gai)
ans = 0
for i in range(n):
if i <= (n-k):
#print('xあり')
x = (a[i] * kai[n-i-1] * gai[n-i-k] * gai[k-1]) % MOD
else:
x = 0
#print('xha', x)
if i >= (k-1):
#print('yあり')
y = (a[i] * kai[i] * gai[i-k+1] * gai[k-1]) % MOD
else:
y = 0
#print('yha', y)
ans = (ans + y - x) % MOD
#print(ans)
print(ans)
|
n,k=map(int,input().split())
a=sorted(list(map(int,input().split())))
mod=10**9+7
fac=[1]*n
finv=[1]*n
inv=[0]*n
inv[1]=1
for i in range(2,n):
fac[i]=fac[i-1]*i%mod
inv[i]=mod-inv[mod%i]*(mod//i)%mod
finv[i]=finv[i-1]*inv[i]%mod
def comb(n,k):
if n<k:
return 0
if n<0 or k<0:
return 0
return fac[n]*(finv[k]*finv[n-k]%mod)%mod
ans=0
for i in range(n-k+1):
ans-=a[i]*comb(n-i-1,k-1)%mod
ans%=mod
a=a[::-1]
for i in range(n-k+1):
ans+=a[i]*comb(n-i-1,k-1)%mod
ans%=mod
print(ans%mod)
| 1 | 95,621,123,125,550 | null | 242 | 242 |
t = input()
ans = ""
if t[len(t)-1] == "s":
ans = t + "es"
else:
ans = t + "s"
print(ans)
|
if __name__ == '__main__':
s = str(input())
if s[-1] != 's':
print(f'{s}s')
else:
print(f'{s}es')
| 1 | 2,397,587,686,908 | null | 71 | 71 |
N, M = list(map(int, input().split()))
import math
ans = []
if M == 1:
ans.append((1, 2))
else:
m0 = (1, M+1)
m1 = (M+2, 2*M+1)
for _ in range(math.ceil(M/2)):
if m0[0] < m0[1]:
ans.append(m0)
if m1[0] < m1[1]:
ans.append(m1)
m0 = (m0[0]+1, m0[1]-1)
m1 = (m1[0]+1, m1[1]-1)
for a in ans:
print(a[0], a[1])
|
N , M = map(int,input().split())
ans = 0
ans += N * (N - 1) // 2
ans += M * (M - 1) // 2
print( ans )
| 0 | null | 36,946,226,030,052 | 162 | 189 |
from itertools import accumulate
N, K = map(int, input().split())
MOD = 10**9 + 7
cum = list(accumulate([0]+ list(range(N+1))))
print((sum(cum[N+1] - cum[N+1-k] - cum[k] + 1 for k in range(K,N+2)))%MOD)
|
a=map(int,raw_input().split())
if 0<=a[2]-a[4] and a[2]+a[4]<=a[0] and 0<=a[3]-a[4] and a[3]+a[4]<=a[1]:
print "Yes"
else:
print "No"
| 0 | null | 16,777,363,543,488 | 170 | 41 |
# 問題: https://atcoder.jp/contests/abc144/tasks/abc144_c
import math
n = int(input())
a = int(math.sqrt(n))
b = 0
while b == 0:
if n % a > 0:
a -= 1
continue
b = n / a
res = a + b - 2
print(int(res))
|
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from functools import reduce, lru_cache
import collections, heapq, itertools, bisect
import math, fractions
import sys, copy
sys.setrecursionlimit(1000000)
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 I(): return int(sys.stdin.readline().rstrip())
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def S(): return list(sys.stdin.readline().rstrip())
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)]
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
def divisors(N):
divs = set([1, N])
i = 2
while i ** 2 <= N:
if N % i == 0:
divs.add(i)
divs.add(N//i)
i += 1
return sorted(list(divs))
def is_ok(N, K):
if K <= 1:
return False
while N % K == 0:
N //= K
return N % K == 1
def main():
N = I()
ans = 0
for divisor in divisors(N-1):
if is_ok(N, divisor):
ans += 1
for divisor in divisors(N):
if is_ok(N, divisor):
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 101,445,679,952,440 | 288 | 183 |
N = int(input())
ans = 0
for a in range(1,N,1):
ans = ans + (N-1)//a
print(ans)
|
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()
def resolve():
N = I()
X = SS()
# 一回の操作でnはN以下になる
# 2回目以降の操作はメモ化再帰
# 初回popcountは2種類しかない Xのpopcountから足し引きすればよい
pc_X = X.count('1')
if pc_X == 0:
for i in range(N):
print(1)
elif pc_X == 1:
for i in range(N):
if i == X.index('1'):
print(0)
else:
# 1が2つある場合、最後の位が1の場合、奇数
if i == N - 1 or X.index('1') == N - 1:
print(2)
else:
print(1)
else:
next_X_m1 = 0
next_X_p1 = 0
pc_m1 = pc_X - 1
pc_p1 = pc_X + 1
for i in range(N):
if X[i] == '1':
next_X_m1 += pow(2, N - 1 - i, pc_m1)
next_X_p1 += pow(2, N - 1 - i, pc_p1)
dp = [-1] * N
dp[0] = 0
def dfs(n):
if dp[n] == -1:
dp[n] = 1 + dfs(n % bin(n).count('1'))
return dp[n]
for i in range(N):
next = 0
if X[i] == '0':
next = (next_X_p1 + pow(2, N - 1 - i, pc_p1)) % pc_p1
else:
next = (next_X_m1 - pow(2, N - 1 - i, pc_m1)) % pc_m1
ans = dfs(next) + 1
print(ans)
# print(dp)
if __name__ == '__main__':
resolve()
| 0 | null | 5,487,039,934,210 | 73 | 107 |
S = input()
DAY = ["SUN","MON","TUE","WED","THU","FRI","SAT"]
for num in range(7):
if DAY[num] == S:
print(7-num)
|
print(["SAT","FRI","THU","WED","TUE","MON","SUN"].index(input())+1)
| 1 | 133,269,530,349,286 | null | 270 | 270 |
def main():
k, n = map(int, input().split(" "))
a = list(map(int, input().split(" ")))
d =[min(a)+k-max(a)]
for i in range(n-1):
d.append(a[i+1]-a[i])
print(k-max(d))
if __name__ == "__main__":
main()
|
#!usr/bin/env python3
import math
import sys
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LIR(n):
return [LI() for i in range(n)]
class SegmentTree:
def __init__(self, size, f=lambda x,y : x+y, default=0):
self.size = 2**(size-1).bit_length()
self.default = default
self.dat = [default]*(self.size*2)
self.f = f
def update(self, i, x):
i += self.size
self.dat[i] = x
while i > 0:
i >>= 1
self.dat[i] = self.f(self.dat[i*2], self.dat[i*2+1])
def get(self, a, b=None):
if b is None:
b = a + 1
l, r = a + self.size, b + self.size
lres, rres = self.default, self.default
while l < r:
if l & 1:
lres = self.f(lres, self.dat[l])
l += 1
if r & 1:
r -= 1
rres = self.f(self.dat[r], rres)
l >>= 1
r >>= 1
res = self.f(lres, rres)
return res
def solve():
n,d,a = LI()
g = LIR(n)
g.sort()
X = [i for (i,_) in g]
s = SegmentTree(n)
ans = 0
for i in range(n):
x = g[i][0]
j = bisect.bisect_left(X,x-2*d)
h = g[i][1]-s.get(j,i)
if h <= 0:
continue
k = math.ceil(h/a)
ans += k
s.update(i,k*a)
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| 0 | null | 62,580,465,438,300 | 186 | 230 |
import math
n=int(input())
print( (pow(10,n)-pow(9,n)*2+pow(8,n))%1000000007)
|
from collections import defaultdict
from collections import deque
from collections import Counter
import math
def readInt():
return int(input())
def readInts():
return list(map(int, input().split()))
def readChar():
return input()
def readChars():
return input().split()
n,k = readInts()
a = readInts()
a.sort(reverse=True)
if n==1:
print(math.ceil(a[0]/(k+1)))
exit()
def get(left, right):
l = (right-left)//2+left
ans = 0
for i in a:
ans+=math.ceil(i/l)-1
#print(l, ans, left, right)
return ans,l
def nibu(left,right):
ans,l = get(left, right)
if left<right:
if ans<=k:
return nibu(left,l)
else:
return nibu(l+1, right)
else:
return right
print(nibu(1,a[0]))
| 0 | null | 4,803,766,552,998 | 78 | 99 |
s=input()
t=input()
n=len(s)
if s==t[:n] and len(t)==n+1:
print('Yes')
else:
print('No')
|
name=input()
len_n=len(name)
name2=input()
len_n2=len(name2)
if name==name2[:-1] and len_n+1==len_n2:
print("Yes")
else:
print("No")
| 1 | 21,408,195,814,610 | null | 147 | 147 |
class Dice():
def __init__(self, nums):
self.nums = nums
self.top, self.front, self.right = 0, 1, 2
def move(self, op):
for c in op:
if c == 'N':
self.top, self.front = self.front, 5 - self.top
elif c == 'S':
self.top, self.front = 5 - self.front, self.top
elif c == 'E':
self.top, self.right = 5 - self.right, self.top
else:
self.top, self.right = self.right, 5 - self.top
dice = Dice([int(n) for n in input().split()])
dice.move(input())
print(dice.nums[dice.top])
|
class Dice(object):
def __init__(self,List):
self.face=List
def n_spin(self,List):
temp=List[0]
List[0]=List[1]
List[1]=List[5]
List[5]=List[4]
List[4]=temp
def s_spin(self,List):
temp=List[0]
List[0]=List[4]
List[4]=List[5]
List[5]=List[1]
List[1]=temp
def e_spin(self,List):
temp=List[0]
List[0]=List[3]
List[3]=List[5]
List[5]=List[2]
List[2]=temp
def w_spin(self,List):
temp=List[0]
List[0]=List[2]
List[2]=List[5]
List[5]=List[3]
List[3]=temp
dice = Dice(map(int,raw_input().split()))
command = list(raw_input())
for k in command:
if k=='N':
dice.n_spin(dice.face)
elif k=='S':
dice.s_spin(dice.face)
elif k=='E':
dice.e_spin(dice.face)
else:
dice.w_spin(dice.face)
print dice.face[0]
| 1 | 229,654,269,992 | null | 33 | 33 |
n=int(input())
s=input().split()
q=int(input())
t=input().split()
cnt=0
for i in range(q):
for j in range(n):
if s[j]==t[i]:
cnt+=1
break
print(cnt)
|
n1=int(input())
l1=list(input().split())
n2=int(input())
l2=list(input().split())
cnt=0
for x in l2:
if x in l1:
cnt=cnt+1
print(cnt)
| 1 | 66,837,494,920 | null | 22 | 22 |
n,m,l = [int(x) for x in input().split()]
matrix_a = [[int(x) for x in input().split()] for _ in range(n)]
matrix_b = [[int(x) for x in input().split()] for _ in range(m)]
matrix_ab = [[0 for a in range(l)] for b in range(n)]
for i in range(n):
for j in range(l):
for k in range(m):
matrix_ab[i][j] += matrix_a[i][k]*matrix_b[k][j]
for i in range(n):
for j in range(l):
if j < l-1:
print(matrix_ab[i][j], "", end="")
elif j == l-1:
print(matrix_ab[i][j])
|
rad = int(input())
print (2*3.1415926*rad)
| 0 | null | 16,313,103,884,548 | 60 | 167 |
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, K = map(int, input().split())
sunuke = [1] * N
for i in range(K):
di = int(input())
tmp = map(int, input().split())
for j in tmp:
sunuke[j-1] = 0
print(sum(sunuke))
| 0 | null | 28,657,955,882,060 | 169 | 154 |
H, W, K = map(int, input().split())
ans = [[0 for _ in range(W)] for _ in range(H)]
not_ichigo_row = []
ichigo_row = []
cnt = 0 #イチゴのカウント、フラグが立っていない場合はカウントしない
for i in range(H):
s = list(input())
# print(s)
if "#" not in s:
not_ichigo_row.append(i)
continue
ichigo_row.append(i)
f = 0 #行内の1つめのイチゴか判定
cnt += 1
for j in range(W):
# print(s[j])
if s[j] == "#":
if not f:
f = 1
else:
cnt += 1
# print("cnt", cnt)
ans[i][j] = cnt
# print(not_ichigo_row)
for i in not_ichigo_row:
row = i
f = 0
while row in not_ichigo_row:
if row == H-1:
f = 1
if f:
row -= 1
else:
row += 1
# print(row)
ans[i] = ans[row].copy()
for r in ans:
print(*r)
|
l = 2*10**9
p = -2*10**9
n = int(input())
for _ in range(n):
x = int(input())
p = max(x-l,p)
l = min(x,l)
print(p)
| 0 | null | 72,081,417,612,302 | 277 | 13 |
import numpy as np
from numba import njit
@njit
def update(a):
n = len(a)
b = np.zeros_like(a)
for i,x in enumerate(a):
l = max(0, i-x)
r = min(n-1, i+x)
b[l] += 1
if r+1 < n:
b[r+1] -= 1
b = np.cumsum(b)
return b
n,k = map(int, input().split())
a = np.array(list(map(int, input().split())))
for _ in range(k):
a = update(a)
if np.all(a==n):
break
print(' '.join(map(str, a)))
|
n = int(input())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
ans = 0
for i in range(n):
ans += abs(x[i] - y[i])
print(ans)
ans = 0
for i in range(n):
ans += (x[i] - y[i])**2
print(ans**(1/2))
ans = 0
for i in range(n):
ans += (abs(x[i] - y[i]))**3
print(ans**(1/3))
ans = 0
for i in range(n):
ans = max(ans, abs(x[i] - y[i]))
print(ans)
| 0 | null | 7,852,317,650,300 | 132 | 32 |
MOD = 10**9 + 7
N, K = map(int, input().split())
def getFacts(n, MOD):
facts = [1] * (n+1)
for x in range(2, n+1):
facts[x] = (facts[x-1] * x) % MOD
return facts
facts = getFacts(2*N, MOD)
def getInvFacts(n, MOD):
invFacts = [0] * (n+1)
invFacts[n] = pow(facts[n], MOD-2, MOD)
for x in reversed(range(n)):
invFacts[x] = (invFacts[x+1] * (x+1)) % MOD
return invFacts
invFacts = getInvFacts(2*N, MOD)
def getComb(n, k, MOD):
if n < k:
return 0
return facts[n] * invFacts[k] * invFacts[n-k] % MOD
ans = 0
for x in range(min(K, N-1)+1):
ans += getComb(N, x, MOD) * getComb(N-1, x, MOD)
ans %= MOD
print(ans)
|
N,K=map(int, input().split())
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
n= 2*10 ** 5 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p) 階乗のmod
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, n + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
#0の数
zeros=min(K, N-1)
ans=1
for i in range(1,zeros+1):
ans+=(cmb(N,i,p)*cmb(i+N-i-1, i, p))%p
#print(pow(N-i, i, p))
ans%=p
print(ans)
| 1 | 67,362,170,697,850 | null | 215 | 215 |
def main():
H, W, K = (int(i) for i in input().split())
A = [input() for i in range(H)]
ans = [[-1]*W for _ in range(H)]
p = 1
for h in range(H):
flag = False
cnt = 0
for w in range(W):
if A[h][w] == "#":
flag = True
cnt += 1
upper = p + cnt
if not(flag):
continue
for w in range(W):
ans[h][w] = p
if A[h][w] == "#":
if p + 1 < upper:
p += 1
p = upper
for h in range(H):
for w in range(W):
if ans[h][w] != -1:
continue
if h != 0:
ans[h][w] = ans[h-1][w]
for h in range(H)[::-1]:
for w in range(W):
if ans[h][w] != -1:
continue
if h != H-1:
ans[h][w] = ans[h+1][w]
for a in ans:
print(*a)
if __name__ == '__main__':
main()
|
import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
h, w, k = list(map(int, readline().split()))
a = [list(str(readline().rstrip().decode('utf-8'))) for _ in range(h)]
no = 0
is_f = True
for i in range(h):
if a[i].count("#") != 0:
row_f = True
no += 1
for j in range(w):
if a[i][j] == "#":
if not row_f:
no += 1
else:
row_f = False
a[i][j] = no
if is_f:
is_f = False
if i != 0:
for j in range(i - 1, -1, -1):
for k in range(w):
a[j][k] = a[i][k]
else:
for j in range(w):
a[i][j] = a[i-1][j]
for i in range(h):
print(*a[i])
if __name__ == '__main__':
solve()
| 1 | 143,785,454,469,394 | null | 277 | 277 |
from sys import stdin
from math import pi
r = float(stdin.readline().rstrip())
area = pi*r*r
circumference = 2*pi*r
print("%lf %lf" % (area, circumference))
|
moutain = [0 for i in range(10)]
for i in range(10):
moutain[i] = int(raw_input())
moutain.sort(reverse=True)
for i in range(3):
print moutain[i]
| 0 | null | 320,174,012,082 | 46 | 2 |
H,A=map(int,input().split())
if 1<=H<=10000 and 1<=A<=10000:
print(H//A+1 if H%A!=0 else int(H/A))
|
def main():
n = input()
A = []
for i in xrange(n):
A.append(map(int,raw_input().split()))
c,d = bfs(n,A)
for i in xrange(n):
if c[i] == -1:
print i+1, -1
else:
print i+1, d[i]
def bfs(n,A):
color = [-1]*n
d = [-1]*n
Q = []
d[0] = 0
Q.append(0)
while(True):
if len(Q)==0:
break
u = Q.pop(0)
for i in A[u][2:]:
if color[i-1] == -1:
color[i-1] = 0
d[i-1] = d[u]+1
Q.append(i-1)
color[u] = 1
return color, d
if __name__ == '__main__':
main()
| 0 | null | 38,227,036,382,802 | 225 | 9 |
n, m = map(int, input().split())
a = 1
b = m + 1
while a < b:
print(a, b)
a += 1
b -= 1
a = m + 2
b = 2 * m + 1
while a < b:
print(a, b)
a += 1
b -= 1
|
import bisect
import copy
import heapq
import math
import sys
from collections import *
from itertools import accumulate, combinations, permutations, product
from math import gcd
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
n,m=map(int,input().split())
half=n//2
lst=[]
if n%2==1:
for i in range(m):
lst.append([half-i,half+i+1])
else:
for i in range(m):
if i%2==0:
lst.append([half-i//2,half+i//2+1])
else:
lst.append([1+i//2,n-1-i//2])
for i in range(m):
print(*lst[i])
# dic=defaultdict(int)
# for i in range(m):
# tmp=lst[i]
# dic[tmp[1]-tmp[0]]+=1
# dic[n-tmp[1]+tmp[0]]+=1
# print(dic)
| 1 | 28,579,504,921,510 | null | 162 | 162 |
n,m=map(int,input().split())
c=list(map(int,input().split()))
dp=[10**5 for i in range(50001)]
dp[0]=0
dp[1]=1
for i in range(1,n+1):
for j in range(m):
if i>=c[j]:
dp[i]=min(dp[i-c[j]]+1,dp[i])
print(dp[n])
|
try:
s=[]
while True:
t = input()
s.append(t)
except EOFError:
for i in range(len(s)):
print(len(str(int(s[i].split(' ')[0])+int(s[i].split(' ')[1]))))
| 0 | null | 67,555,792,732 | 28 | 3 |
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect, heapq
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n = int(input())
A = list(map(int,input().split()))
data = [(ai,i) for i,ai in enumerate(A)]
data.sort(reverse = True)
dp = [[0]*(n+1) for i in range(n+1)]
for i in range(n):
for l in range(i+1):
r = i-l
dp[l+1][r] = max(dp[l+1][r], dp[l][r] + data[i][0] * abs(data[i][1] - l))
dp[l][r+1] = max(dp[l][r+1], dp[l][r] + data[i][0] * abs(data[i][1] - (n-1-r)))
ans = 0
for i in range(n):
ans = max(ans,dp[i][n-i])
print(ans)
|
#from collections import deque
#from heapq import heapify, heappop, heappush
#from bisect import insort
#from math import gcd
#from decimal import Decimal
#mod = 1000000007
#mod = 998244353
#N = int(input())
#N, K = map(int, input().split())
#A = list(map(int, input().split()))
#flag = True
#for k in range(N):
#ans = 0
#print(ans)
#print('Yes')
#print('No')
N = int(input())
ans = 0
#N, K = map(int, input().split())
#A = list(map(int, input().split()))
#flag = True
for B in range(1, N+1):
ans += N//B
if N%B == 0:
ans -= 1
#ans = 0
print(ans)
#print('Yes')
#print('No')
| 0 | null | 18,116,816,986,240 | 171 | 73 |
i = count = 0
a = b = c = ''
line = input()
while line[i] != ' ':
a = a + line[i]
i += 1
i += 1
while line[i] != ' ':
b = b + line[i]
i += 1
i += 1
while i < len(line):
c = c + line[i]
i += 1
a = int(a)
b = int(b)
c = int(c)
while a <= b:
if c%a == 0:
count += 1
a += 1
print(count)
|
N = int(input())
S,T = map(str, input().split())
s=[]
for i in S:
s.append(i)
t=[]
for i in T:
t.append(i)
for i in range(N):
print(s[i]+t[i], end="")
| 0 | null | 56,589,462,641,248 | 44 | 255 |
S=list(input())
N=len(S)
x=0
for i in range(int((N-1)/2)):
if S[i]!=S[-(i+1)]:
print("No")
break
elif i==int((N-1)/2)-1:
x+=1
import math
if x==1:
S_l=S[:int((N-1)/2)]
for i in range(int(math.ceil(len(S_l)/2))):
if S_l[i]!=S_l[-(i+1)]:
print("No")
break
elif i==int(math.ceil(len(S_l)/2))-1:
x+=1
if x==2:
S_m=S[int((N+3)/2)-1:N]
for i in range(int(math.ceil(len(S_m)/2))):
if S_m[i]!=S_m[-(i+1)]:
print("No")
break
elif i==int(math.ceil(len(S_m)/2))-1:
print("Yes")
|
MOD = 10**9+7
K = int(input())
S = input()
N = len(S)
n = N+K
fac = [1]*(n+1)
rev = [1]*(n+1)
for i in range(1,n+1):
fac[i] = i*fac[i-1]%MOD
rev[i] = pow(fac[i], MOD-2, MOD)
comb = lambda a,b:(fac[a]*rev[a-b]*rev[b])%MOD
ans = 0
for i in range(K+1):
ans += pow(26, K-i, MOD) * pow(25, i, MOD) * comb(N+i-1, i)
ans %= MOD
print(ans)
| 0 | null | 29,633,690,351,772 | 190 | 124 |
import sys
x = int(raw_input())
print(x*x*x)
|
import sys
x = sys.stdin.readline()
x3 = int(x) ** 3
print x3
| 1 | 280,233,075,044 | null | 35 | 35 |
A, B, M = [int(a) for a in input().split()]
a = [int(ai) for ai in input().split()]
b = [int(bi) for bi in input().split()]
x = []
y = []
c = []
for _ in range(M):
xi, yi, ci = [int(xyc) for xyc in input().split()]
x.append(xi)
y.append(yi)
c.append(ci)
min_price = min(a) + min(b)
for i in range(M):
price = a[x[i]-1] + b[y[i]-1] - c[i]
min_price = min(min_price, price)
print(min_price)
|
x=input()
y=int(x)
print(y*y*y)
| 0 | null | 27,106,443,893,190 | 200 | 35 |
# coding: utf-8
# Your code here!
n=int(input())
flag=0
for i in range(1,10):
if n%i==0:
if 10>n/i:
flag=1
if flag:
print('Yes')
else:
print('No')
|
n, k = map(int, input().split())
mod = 1000000007
b = mod-2
blis = []
c = 0
while b >0:
if b & 1 == 1:
blis.append(c)
c += 1
b >>= 1
def modinv(a):
if a == 1:
return 1
else:
res = 1
li = []
for _ in range(c):
li.append(a%mod)
a = a*a%mod
for item in blis:
res = res *li[item] %mod
return res
if k >=n:
L = 2*n-1
ansbunsi =1
for j in range(n-1):
ansbunsi = ansbunsi*L%mod
L -= 1
ansbunbo = 1
L = n - 1
for j in range(n-1):
ansbunbo = ansbunbo*L%mod
L -= 1
ansbunbo = modinv(ansbunbo)
print(ansbunsi*ansbunbo%mod)
else:
kaijou = [1, 1]
for j in range(2, n):
kaijou.append(kaijou[-1]*j%mod)
ans = 0
for m in range(k+1):
ansbunsi = (kaijou[n-1]**2)*n%mod
ansbunbo = kaijou[n-m-1]*kaijou[m]%mod
ansbunbo = ansbunbo*ansbunbo%mod*(n-m)%mod
ansbunbo = modinv(ansbunbo)
ans += ansbunbo*ansbunsi%mod
ans %= mod
print(ans)
| 0 | null | 113,505,660,867,490 | 287 | 215 |
import numpy as np
h,w=map(int,input().split())
s=[input() for _ in range(h)]
dp=np.zeros((h,w),np.int64)
if s[0][0]=='#':
dp[0,0]=1
for i in range(h):
for j in range(w):
if (i,j)==(0,0):
continue
elif i==0:
if s[i][j-1]=='.' and s[i][j]=='#':
dp[i,j]=dp[i,j-1]+1
else:
dp[i,j]=dp[i,j-1]
elif j==0:
if s[i-1][j]=='.' and s[i][j]=='#':
dp[i,j]=dp[i-1,j]+1
else:
dp[i,j]=dp[i-1,j]
else:
dp[i,j]=min(dp[i,j-1]+1 if s[i][j-1]=='.' and s[i][j]=='#' else dp[i,j-1],dp[i-1,j]+1 if s[i-1][j]=='.' and s[i][j]=='#' else dp[i-1,j])
print(dp[-1,-1])
#print(dp)
|
A,B=map(int,input().split())
for i in range(1,B+1):
if((A*i)%B==0):
print(A*i)
exit()
| 0 | null | 81,418,797,836,950 | 194 | 256 |
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
h,w,k=map(int,input().split())
S=[input() for _ in range(h)]
ANS=[[0]*w for _ in range(h)]
cunt=0
for i,s in enumerate(S):
for j,ss in enumerate(s):
if ss=='#':
cunt+=1
ANS[i][j]=cunt
elif j>=1 and ANS[i][j-1]>0:
ANS[i][j]=ANS[i][j-1]
if ANS[i][-1]!=0:
for j in range(w-2,-1,-1):
if ANS[i][j]==0:
ANS[i][j]=ANS[i][j+1]
for i in range(h-2,-1,-1):
if ANS[i][0]==0:
for j,ans in enumerate(ANS[i+1]):
ANS[i][j]=ans
for i in range(h):
if ANS[i][0]==0:
for j,ans in enumerate(ANS[i-1]):
ANS[i][j]=ans
for ans in ANS:
print(*ans)
if __name__=='__main__':
main()
|
H, W, k = map(int, input().split())
a = [list(input()) for _ in range(H)]
res = [[0] * W for _ in range(H)]
cnt = 0
for h in range(H):
for w in range(W):
if a[h][w] == "#":
cnt += 1
res[h][w] = cnt
for h in range(H):
for w in range(W):
if w > 0 and res[h][w] == 0:
res[h][w] = res[h][w - 1]
for h in range(H):
for w in reversed(range(W)):
if w < W - 1 and res[h][w] == 0:
res[h][w] = res[h][w + 1]
for h in range(H):
for w in range(W):
if h > 0 and res[h][w] == 0:
res[h][w] = res[h - 1][w]
for h in reversed(range(H)):
for w in range(W):
if h < H - 1 and res[h][w] == 0:
res[h][w] = res[h + 1][w]
for i in res:
print(*i)
| 1 | 143,738,847,227,416 | null | 277 | 277 |
import sys
A1,A2,A3 = map(int,input().split())
if not ( 1 <= A1 <= 13 and 1 <= A2 <= 13 and 1 <= A3 <= 13 ): sys.exit()
if not ( isinstance(A1,int) and isinstance(A2,int) and isinstance(A3,int) ): sys.exit()
print('bust') if A1 + A2 + A3 >= 22 else print('win')
|
#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
As = map(int, readline().split())
if sum(As) >= 22:
print('bust')
else:
print('win')
if __name__ == '__main__':
main()
| 1 | 118,679,928,414,018 | null | 260 | 260 |
n,k = map(int, input().split())
ans = 0
while n > 0:
n /= k
n = int(n)
ans += 1
print(ans)
|
#B
N, K = map(int,input().split())
num=[]
while N >= K:
num.append(N%K)
N=N//K
num.append(N)
print(len(num))
| 1 | 64,390,744,944,500 | null | 212 | 212 |
#C
N=int(input())
A=[int(x) for x in input().split()]
P=[0 for i in range(N+1)]
P[N]=[A[N],A[N]]
for i in range(N-1,-1,-1):
MIN,MAX=P[i+1]
mi=int(A[i]+(MIN+MIN%2)/2)
ma=A[i]+MAX
P[i]=[mi,ma]
if P[0][0]==1:
Q=[0 for i in range(N+1)]
Q[0]=1
cnt=1
for i in range(N):
Q[i+1]=min((Q[i]-A[i])*2,P[i+1][1])
cnt+=Q[i+1]
print(cnt)
else:
print("-1")
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
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
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
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 x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = map(int, input().split())
A = [0 for _ in range(M)]
B = [0 for _ in range(M)]
for i in range(M):
A[i] , B[i] = map(int, input().split())
A[i] -= 1
B[i] -= 1
uf = UnionFind(N)
for i in range(M):
uf.union(A[i], B[i])
print(uf.group_count()-1)
| 0 | null | 10,542,079,510,798 | 141 | 70 |
N = int(input())
ans = set()
def check(N, k):
if k<2:
return False
N //= k
while N:
if (N-1)%k==0:
return True
if N%k:
return False
N //= k
for k in range(1, int(N**0.5)+1):
if (N-1)%k==0:
ans.add(k)
ans.add((N-1)//k)
if N%k==0:
if check(N, k):
ans.add(k)
if check(N, N//k):
ans.add(N//k)
ans.remove(1)
print(len(ans))
|
import math
import copy
def prime_factorize(n):
a = [n]
for i in range(2, math.floor(n ** 0.5) + 1):
if n % i == 0:
a.append(i)
if n // i != i:
a.append(n // i)
return a
N = int(input())
prime_n = prime_factorize(N)
prime_n_1 = prime_factorize(N - 1)
ans = 0
for i in prime_n:
n = copy.deepcopy(N)
while (n % i) == 0:
n = n // i
if (n % i) == 1:
ans += 1
ans += len(prime_n_1)
if N > 2:
print(ans)
else:
print(1)
| 1 | 41,047,132,826,062 | null | 183 | 183 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.