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
|
|---|---|---|---|---|---|---|
X = int(input())
K = 0
while ((X * K) % 360 != 0) or (K == 0):
K += 1
print(K)
|
N = int(input())
A = list(map(int,input().split()))
ans =1
mod = 10**9+7
row = [0] *3
for i in range(N):
ans *=row.count(A[i])
ans %=mod
for j in range(3):
if row[j]==A[i]:
row[j]+=1
break
print(ans%mod)
| 0 | null | 71,957,450,355,632 | 125 | 268 |
N=int(input())
import math
print(360//math.gcd(360,N))
|
X = int(input())
t = X
ans = 1
while t%360 != 0:
t += X
ans += 1
print(ans)
| 1 | 13,092,050,063,340 | null | 125 | 125 |
#!/usr/bin/env python3
h, w = list(map(int, input().split()))
ss = [list(str(input())) for _ in range(h)]
dp = [[100*100 for _ in range(w)] for i in range(h)] # dp[h][w]
if ss[0][0] == "#":
dp[0][0] = 1
else:
dp[0][0] = 0
# print(dp)
for h_tmp in range(0, h):
for w_tmp in range(0, w):
if w_tmp > 0:
# print(dp[h_tmp][w_tmp-1])
if ss[h_tmp][w_tmp-1] == "." and ss[h_tmp][w_tmp] == "#":
dp[h_tmp][w_tmp] = min(dp[h_tmp][w_tmp], dp[h_tmp][w_tmp-1]+1)
else:
dp[h_tmp][w_tmp] = min(dp[h_tmp][w_tmp], dp[h_tmp][w_tmp-1])
if h_tmp > 0:
# print(dp[h_tmp][w_tmp-1])
if ss[h_tmp-1][w_tmp] == "." and ss[h_tmp][w_tmp] == "#":
dp[h_tmp][w_tmp] = min(dp[h_tmp][w_tmp], dp[h_tmp-1][w_tmp]+1)
else:
dp[h_tmp][w_tmp] = min(dp[h_tmp][w_tmp], dp[h_tmp-1][w_tmp])
# print(dp)
print(dp[-1][-1])
|
import sys
input = sys.stdin.readline
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
ans=0
N=I()
for a in range(1,N):
for b in range(1,N):
if a*b>=N:
break
ans+=1
print(ans)
main()
| 0 | null | 25,900,692,306,518 | 194 | 73 |
def main():
H, W = (int(i) for i in input().split())
c = [input() for i in range(H)]
dp = [[10**3]*W for _ in range(H)]
if c[0][0] == "#":
dp[0][0] = 1
else:
dp[0][0] = 0
for h in range(H):
for w in range(W):
if c[h][w] == ".":
if w < W-1 and c[h][w+1] == ".":
dp[h][w+1] = min(dp[h][w+1], dp[h][w])
elif w < W-1 and c[h][w+1] == "#":
dp[h][w+1] = min(dp[h][w+1], dp[h][w] + 1)
if h < H-1 and c[h+1][w] == ".":
dp[h+1][w] = min(dp[h+1][w], dp[h][w])
elif h < H-1 and c[h+1][w] == "#":
dp[h+1][w] = min(dp[h+1][w], dp[h][w] + 1)
else:
if w < W-1:
dp[h][w+1] = min(dp[h][w+1], dp[h][w])
if h < H-1:
dp[h+1][w] = min(dp[h+1][w], dp[h][w])
print(dp[H-1][W-1])
# print(*dp, sep="\n")
if __name__ == '__main__':
main()
|
INF = 10**9
H, W = map(int, input().split())
s = [list(input()) for _ in range(H)]
# (i, j)に進むときの色の反転回数の最小値
dp = [[INF for j in range(W)] for i in range(H)]
if s[0][0] == '#':
dp[0][0] = 1
else:
dp[0][0] = 0
for i in range(H):
for j in range(W):
if i == H - 1 and j == W - 1:
break
if i != H - 1:
if s[i][j] == '.' and s[i + 1][j] == '#':
dp[i + 1][j] = min(dp[i][j] + 1, dp[i + 1][j])
else:
dp[i + 1][j] = min(dp[i][j], dp[i + 1][j])
if j != W - 1:
if s[i][j] == '.' and s[i][j + 1] == '#':
dp[i][j + 1] = min(dp[i][j] + 1, dp[i][j + 1])
else:
dp[i][j + 1] = min(dp[i][j], dp[i][j + 1])
print(dp[H-1][W-1])
| 1 | 49,419,139,348,150 | null | 194 | 194 |
import math
h,w = map(int,input().split())
ans = 0
if h == 1 or w ==1 :
ans += 1
else:
#奇数行目+偶数行目
ans += math.ceil(h/2)*math.ceil(w/2)+(h//2)*(w//2)
print(ans)
|
import math
def main():
h,w = map(int, input().split())
if h == 1 or w == 1:
print(1)
else:
print(math.ceil(h*w/2))
if __name__ == "__main__":
main()
| 1 | 50,731,243,737,312 | null | 196 | 196 |
H=int(input())
W=int(input())
N=int(input())
K=H
if K<W: K=W
sum = 0
ans= 0
for i in range(1,K+1):
if sum < N:
sum += K
ans = i
#print(ans, K)
print(ans)
|
class Dice:
def __init__(self):
d = map(int, raw_input().split(" "))
self.c = raw_input()
self.rows = [d[0], d[4], d[5], d[1]]
self.cols = [d[0], d[2], d[5], d[3]]
def __move_next(self, x, y):
temp = y.pop(0)
y.append(temp)
x[0] = y[0]
x[2] = y[2]
def __move_prev(self, x, y):
temp = y.pop(3)
y.insert(0, temp)
x[0] = y[0]
x[2] = y[2]
def execute(self):
for i in self.c:
self.__move(i, self.rows, self.cols)
def __move(self, com, x, y):
if com == "N":
self.__move_prev(y, x)
elif com == "S":
self.__move_next(y, x)
elif com == "E":
self.__move_prev(x, y)
elif com == "W":
self.__move_next(x, y)
def print_top(self):
print self.rows[0]
dice = Dice()
dice.execute()
dice.print_top()
| 0 | null | 44,734,341,285,468 | 236 | 33 |
x=int(input())
if x>=400 and x<600:
print(8)
elif x>=600 and x<800:
print(7)
elif x>=800 and x<1000:
print(6)
elif x>=1000 and x<1200:
print(5)
elif x>=1200 and x<1400:
print(4)
elif x>=1400 and x<1600:
print(3)
elif x>=1600 and x<1800:
print(2)
elif x>=1800 and x<2000:
print(1)
|
[print("{}x{}={}".format(x, y, x*y)) for x in range(1, 10) for y in range(1, 10)]
| 0 | null | 3,329,976,726,048 | 100 | 1 |
def dfs(S):
if len(S) == N:
ans.append(S)
else:
for c in range(max(S) + 2):
dfs(S + [c])
N = int(input())
ans = []
dfs([0])
for li in ans:
print("".join(chr(c + ord("a")) for c in li))
|
n,a,b=map(int,input().split())
def fact(n,p):
a=1
for i in range(1,n+1):
a=(a*i)%p
return a
def bfact(n,x,p):
a=1
for i in range(n-x+1,n+1):
a=(a*i)%p
return a
p=10**9+7
na=bfact(n,a,p)%p
nb=bfact(n,b,p)%p
aa=fact(a,p)%p
bb=fact(b,p)%p
aaa=pow(aa,-1,p)
bbb=pow(bb,-1,p)
ans=pow(2,n,p)-1
ans-=(na*aaa+nb*bbb)
print(ans%p)
| 0 | null | 59,170,224,488,728 | 198 | 214 |
h=[]
for i in range(10):
h.append((int)(input()))
h.sort()
h.reverse()
for i in range(3):
print(h[i])
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
m = []
for i in range(0,10):
m.append(int(input()))
for i in range(0,3):
print(list(reversed(sorted(m)))[i])
| 1 | 41,368,248 | null | 2 | 2 |
#coding: UTF-8
l = raw_input()
a = int(l)
x = 1
while a != 0:
print "Case %d: %d" %(x,a)
x += 1
l = raw_input()
a = int(l)
if l == 0:
print "end"
|
H, W, K = map(int, input().split())
c = []
b_h = [0] * H
b_w = [0] * W
b = 0
for h in range(H):
c.append(input().rstrip())
for w in range(W):
if c[h][w] == "#":
b_h[h] += 1
b_w[w] += 1
b += 1
ans = 0
for hi in range(2 ** H):
for wi in range(2 ** W):
bsum = b
for h in range(H):
if hi & (2 ** h) != 0:
bsum -= b_h[h]
for w in range(W):
if wi & 2 ** w != 0:
if c[h][w] == '#':
bsum += 1
for w in range(W):
if wi & (2 ** w) != 0:
bsum -= b_w[w]
if bsum == K:
ans += 1
print(ans)
| 0 | null | 4,681,626,006,640 | 42 | 110 |
import cmath
cmp_s = cmath.rect(1/3, 0)
cmp_u = cmath.rect(3**(-1/2), cmath.pi / 6)
cmp_t = cmath.rect(2/3, 0)
def koch_curve(p1: complex, p2: complex, n):
if n != 0:
cmp = p2 - p1
s, u, t = [p1 + cmp * c for c in (cmp_s, cmp_u, cmp_t)]
koch_curve(p1, s, n-1)
print('{0:8f} {1:8f}'.format(s.real, s.imag))
koch_curve(s, u, n-1)
print('{0:8f} {1:8f}'.format(u.real, u.imag))
koch_curve(u, t, n-1)
print('{0:8f} {1:8f}'.format(t.real, t.imag))
koch_curve(t, p2, n-1)
def main():
n = int(input())
print('{0:8f} {1:8f}'.format(.0, .0))
koch_curve(complex(.0, .0), complex(100.0, .0), n)
print('{0:8f} {1:8f}'.format(100.0, .0))
if __name__ == '__main__':
main()
|
import math
cos60 = math.cos(math.pi*60/180)
sin60 = math.sin(math.pi*60/180)
#add_triangle
# input: start(x, y) end(x, y)
def add_triangle(start, end):
x1 = (2*start[0] + end[0]) / 3
x3 = (start[0] + 2*end[0]) / 3
y1 = (2*start[1] + end[1]) / 3
y3 = (start[1] + 2*end[1]) / 3
x2 = x1 + (x3-x1)*cos60 - (y3-y1)*sin60
y2 = y1 + (x3-x1)*sin60 + (y3-y1)*cos60
return [(x1,y1), (x2,y2), (x3,y3)]
#koch_recursion
#input list [(x1,y1),(x2,y2),(x3,y3)...]
def koch_recursion(list1):
output = []
for i in range(len(list1)-1):
output.append(list1[i])
output += add_triangle(list1[i], list1[i+1])
output.append(list1[len(list1)-1])
return output
#Koch call koch_recursion(0, 100)
def Koch(start, end, n):
output = [start, end]
for i in range(n):
output = koch_recursion(output)
for x, y in output:
print("{:.8f} {:.8f}".format(x, y))
n = int(input())
Koch((0,0), (100,0), n)
| 1 | 125,473,736,530 | null | 27 | 27 |
import sys
n=int(input())
if n%2:
print(0)
sys.exit()
# 10->50->2500の個数
cnt=0
v=10
while 1:
cnt+=n//v
if n//v==0:
break
v*=5
print(cnt)
|
n, *a = map(int, open(0).read().split())
mita = [0] * -~n
mita[-1] = 3
mod = 10 ** 9 + 7
c = 1
for i in range(n):
c = c * (mita[a[i] - 1] - mita[a[i]]) % mod
mita[a[i]] += 1
print(c)
| 0 | null | 123,107,117,406,730 | 258 | 268 |
n = int(input())
lst = list(input())
cnt = 0
Num = []
for i in range(10):
for j in range(10):
for k in range(10):
s = [str(i),str(j),str(k)]
Num.append(s)
for num in Num:
flag1 = False
flag2 = False
memo1 = 0
memo2 = 0
for x in range(n-2):
if num[0] == lst[x]:
flag1 = True
memo1 = x
break
if flag1:
for y in range(memo1+1,n-1):
if num[1] == lst[y]:
flag2 = True
memo2 = y
break
if flag2:
for z in range(memo2+1,n):
if num[2] == lst[z]:
cnt += 1
break
print(cnt)
|
import sys
import math
#https://atcoder.jp/contests/agc008/submissions/15248942
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
N = ini()
S = input()
ans = 0
for i in range(1000):
V = str(i).zfill(3)
p1 = S.find(V[0])
if p1 != -1:
p2 = S.find(V[1], p1+1)
if p2 != -1:
p3 = S.find(V[2], p2+1)
if p3 != -1:
ans += 1
print(ans)
| 1 | 128,259,386,847,358 | null | 267 | 267 |
import sys
ff = sys.stdin
while True :
a, b = map(int, ff.readline().split())
if (a == 0) & (b == 0) :
break
if a < b : print(a, b)
else : print(b, a)
|
H = int(input())
W = int(input())
N = int(input())
m = max(H, W)
print((N + m - 1) // m)
| 0 | null | 44,853,956,875,772 | 43 | 236 |
import sys
l = []
for i in sys.stdin:
l.append(i)
for i in range(0,len(l)):
if int(l[i]) == 0:
break
count = 0
for j in range(0,len(l[i])-1):
count += int(l[i][j])
print(count)
|
# D - Coloring Edges on Tree
import sys
sys.setrecursionlimit(10 ** 5)
N = int(input())
G = [[] for _ in range(N)]
for i in range(N - 1):
a, b = map(int, input().split())
a, b = a - 1, b - 1
G[a].append((b, i))
G[b].append((a, i))
ans = [-1] * (N - 1)
def dfs(key, color=-1, parent=-1):
k = 1
for i in range(len(G[key])):
if G[key][i][0] == parent:
continue
if color == k:
k += 1
ans[G[key][i][1]] = k
dfs(G[key][i][0], k, key)
k += 1
dfs(0)
print(max(ans))
for a in ans:
print(a)
| 0 | null | 68,741,048,692,140 | 62 | 272 |
S = input()
N = len(S)
count1,count2,count3 = 0,0,0
flg1,flg2,flg3 = False,False,False
for i in range(N):
#print(S[i],S[-1-i])
if S[i] == S[-1-i]:
count1 += 1
if count1 == N:
flg1 = True
#print(count1,flg1)
a = int((N-1)/2)
for i in range(a):
#print(S[i],S[a-1-i])
if S[i] == S[a-1-i]:
count2 += 1
if count2 == int((N-1)/2):
flg2 = True
#print(count2,flg2,a)
b = int((N+3)/2)
#print(b)
for i in range(N-b+1):
#print(S[b+i-1],S[N-1-i])
if S[b+i-1] == S[N-i-1]:
count3 += 1
if count3 == N-b+1 :
flg3 = True
if flg1 == True and flg2 == True and flg3 == True:
print("Yes")
else:
print("No")
|
def is_palindrome(text):
l = len(text)
for i in range(l // 2 if l % 2 == 0 else (l + 1) // 2):
if text[i] != text[l - 1 - i]:
return False
return True
s = input()
q1 = is_palindrome(text=s)
q2 = is_palindrome(text=s[0:(len(s) - 1) // 2])
q3 = is_palindrome(text=s[(len(s) + 3) // 2 - 1:len(s)])
print("Yes" if q1 and q2 and q3 else "No")
| 1 | 46,200,923,799,040 | null | 190 | 190 |
from math import ceil
debt = 100000
n = int(input())
for _ in range(n):
tmp = ceil(debt*1.05)
debt = ceil((tmp/1000))*1000
print(debt)
|
arr = list([input() for _ in range(10)])
arr.sort(reverse=True)
for i in range(3):
print arr[i]
| 0 | null | 504,410,920 | 6 | 2 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
for i in range(0, n - k):
print("Yes" if a[i + k] > a[i] else "No")
|
import math
N = int(input())
#https://qiita.com/jamjamjam888/items/e066b8c7bc85487c0785
xy = [map(int, input().split()) for _ in range(N)]
x, y = [list(i) for i in zip(*xy)]
l = 0
for j in range(N):
for k in range(N):
if j >= k:
continue
l += math.sqrt((x[j] - x[k])**2 + (y[j] - y[k]) ** 2)
print(l * 2/N)
| 0 | null | 78,133,684,141,142 | 102 | 280 |
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))
n = ii()
def get_head(x):
while x:
b = x%10
x //= 10
return b
dp = [[0] * 10 for i in range(10)]
for i in range(1,n+1):
h = get_head(i)
t = i%10
dp[h][t] += 1
for i in range(10):
dp[0][i] = 0
dp[i][0] = 0
ans = 0
for i in range(1,n+1):
h = get_head(i)
t = i%10
ans += dp[t][h]
print(ans)
|
n = input()
if int(n)<10:
print(n)
exit()
matubi=int(n[-1])
sentou=int(n[0])
keta=len(n)
if n[1:keta-1]=="":
aida=0
else:
aida=int(n[1:keta-1])
n=int(n)
def cnt(saisyo,saigo):
kotae=(10**(keta-2)-1)/9
if saisyo<sentou:
kotae+=10**(keta-2)
elif saisyo==sentou:
tmp=saisyo*10**(keta-1)+saigo
while True:
if str(tmp)[0]==str(saisyo) and tmp<=n:
kotae+=1
else:
break
tmp+=10
if saisyo==saigo:
kotae+=1
return kotae
ans=0
import itertools
for seq in itertools.product(range(1,10),range(1,10)):
ans+=cnt(seq[0],seq[1])*cnt(seq[1],seq[0])
print(int(ans))
| 1 | 86,709,066,954,180 | null | 234 | 234 |
#create date: 2020-07-03 10:09
import sys
stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def main():
s = ns()
t = ns()
print("Yes" if s==t[:-1] else "No")
if __name__ == "__main__":
main()
|
s = input()
t = input()
flag = True
for i in range(len(s)):
if s[i] is not t[i]:
flag = False
if flag is True:
print("Yes")
else:
print("No")
| 1 | 21,415,289,380,074 | null | 147 | 147 |
index = 0
inputs = []
while True:
index += 1
x = input()
if x == '0':
break
else:
inputs.append("Case {}: {}".format(index, x))
print("\n".join(inputs))
|
while True:
y,x = [int(i) for i in input().split()]
if y==x==0:
break
print('#'*x)
for i in range(y-2):
print('#'+'.'*(x-2)+'#')
if y > 1:
print('#'*x)
print()
| 0 | null | 675,162,871,120 | 42 | 50 |
n = int(input())
s = list(map(int, input().split()))
q = int(input())
t = list(map(int, input().split()))
c = 0
for num in t:
if num in s:
c += 1
print(c)
|
# エイシング プログラミング コンテスト 2020: B – An Odd Problem
N = int(input())
a = [int(i) for i in input().split()]
num_odd = 0
for idx in range(1, N + 1, 2):
if a[idx -1] % 2 == 1:
num_odd += 1
print(num_odd)
| 0 | null | 3,885,432,966,490 | 22 | 105 |
def main():
N=int(input())
A=[int(_) for _ in input().split()]
left=0
right=sum(A)
ans=right
for i in range(N):
left+=A[i]
right-=A[i]
ans = min(ans, abs(left-right))
print(ans)
main()
|
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
q = int(input())
b = [0] * q
c = [0] * q
for i in range(q):
b[i], c[i] = map(int, input().split())
ans = sum(a)
a_c = Counter(a)
for i in range(q):
b_num = a_c[b[i]]
ans += (c[i] - b[i]) * b_num
a_c[c[i]] += b_num
a_c[b[i]] = 0
print(ans)
| 0 | null | 77,001,541,329,040 | 276 | 122 |
def main():
x_tuple = tuple(map(int, input().split()))
print(x_tuple.index(0) + 1)
if __name__ == '__main__':
main()
|
numbers = input().split(" ")
num = numbers.index("0")
print(num + 1)
| 1 | 13,383,970,692,900 | null | 126 | 126 |
n = int(input())
s = list(map(int, list(input())))
f = [0]*1000
rnum = [0]*10
lnum = [0]*10
for i in s:
rnum[i] += 1
rnum[s[0]] -= 1
lnum[s[0]] += 1
for i in range(1, n-1):
rnum[s[i]] -= 1
for j in range(10):
for k in range(10):
if lnum[j] >= 1 and rnum[k] >= 1:
f[j*100+s[i]*10+k] = 1
lnum[s[i]] += 1
cnt = 0
for i in f:
if i == 1:
cnt += 1
print(cnt)
|
def numtoalpha(n):
if n <= 26:
return chr(96+n)
elif n % 26 == 0:
return numtoalpha(n//26-1) + chr(96+26)
else :
return numtoalpha(n//26) + chr(96+(n%26))
if __name__ == '__main__':
n = int(input())
print(numtoalpha(n))
| 0 | null | 70,220,566,105,642 | 267 | 121 |
n=int(input())
print((n//2)+(n%2))
|
import math
a, b, x = map(int, input().split())
v = a*a*b
if v == x:
print(0)
elif v/2 <= x < v:
h = 2*(v-x)/a**2
ans = math.atan(h/a)
print(math.degrees(ans))
else:
h = 2*x/(b*a)
ans = math.atan(h/b)
print(90-math.degrees(ans))
| 0 | null | 111,284,519,584,840 | 206 | 289 |
s = input()
k = len(s)
ans = ''
if k % 2 == 1:
ans = 'No'
else:
if s == 'hi' * (k // 2):
ans = 'Yes'
else:
ans = 'No'
print(ans)
|
import itertools
N = int(input())
tbl = [0]*N
for x in range(1,N):
for y in range(1,N):
for z in range(1,N):
p = x*x + y*y + z*z + x*y + y*z + z*x
if p > N:
break
tbl[p-1] += 1
for i in range(N):
print(tbl[i])
| 0 | null | 30,481,349,983,590 | 199 | 106 |
import sys
print('Yes' if len(set(sys.stdin.read().strip())) >= 2 else 'No')
|
def sep():
return map(int,input().strip().split(" "))
def lis():
return list(sep())
s=input()
from collections import Counter
c=Counter(s)
if len(c.keys())>=2:
print("Yes")
else:
print("No")
| 1 | 54,784,361,206,778 | null | 201 | 201 |
import sys
from itertools import accumulate
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
import bisect
n,m=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
def hand(x):
cnt=0
for i in range(n):
k=n-bisect.bisect_left(A,x-A[-i-1])
if k==0:
break
cnt+=k
if cnt>=m:
break
return cnt
def main():
l=0
h=2*10**5+1
mid=(l+h)//2
while l+1<h:
mid=(l+h)//2
if hand(mid)<m:
h=mid
else:
l=mid
B = list(accumulate(A[::-1]))[::-1]
ans=0
cnt=0
for i in range(n):
index=bisect.bisect_left(A,l-A[-i-1]+1)
if n==index:
break
else:
ans+=(n-index)*A[-i-1]+B[index]
cnt+=(n-index)
ans+=(m-cnt)*l
print(ans)
if __name__ == "__main__":
main()
|
import sys
#fin = open("test.txt", "r")
fin = sys.stdin
while True:
[m, f, r] = list(map(int, fin.readline().split()))
if m == -1 and f == -1 and r == -1:
break
sum_mf = m + f
if m == -1 or f == -1:
print("F")
elif sum_mf >= 80:
print("A")
elif sum_mf >= 65:
print("B")
elif sum_mf >= 50:
print("C")
elif sum_mf >= 30:
if r >= 50:
print("C")
else:
print("D")
else:
print("F")
| 0 | null | 54,452,279,800,940 | 252 | 57 |
N = int(input())
words = list(input())
ct_R = words.count('R')
ct_W = words.count('W')
a = words[0:ct_R]
W_in_a_count = a.count('W')
print(W_in_a_count)
|
import sys
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return map(int,sys.stdin.readline().rstrip().split())
def solve():
m = a[-1]+1
ava = [0]*m
for rep in a:
ava[rep] += 1
if ava[rep]==1:
for item in range(2*rep,m,rep):
ava[item] += 2
print(ava.count(1))
return
if __name__=='__main__':
n = I()
a = list(IL())
a.sort()
solve()
| 0 | null | 10,373,803,713,072 | 98 | 129 |
import sys
sys.setrecursionlimit(10**9)
def main():
N,M,K = map(int,input().split())
MOD = 998244353
def get_fact(maxim,mod):
maxim += 1
fact = [0]*maxim
fact[0] = 1
for i in range(1,maxim):
fact[i] = fact[i-1] * i % mod
invfact = [0]*maxim
invfact[maxim-1] = pow(fact[maxim-1],mod-2,mod)
for i in reversed(range(maxim-1)):
invfact[i] = invfact[i+1] * (i+1) % mod
return fact, invfact
def powerful_comb(n,r,mod,fact,invfact):
return fact[n] * invfact[r] * invfact[n-r] % mod
ans = 0
fact, invfact = get_fact(N+1,MOD)
for i in range(K+1):
ans += (M*pow(M-1,N-i-1,MOD) * powerful_comb(N-1,i,MOD,fact,invfact)) % MOD
print(ans % MOD)
if __name__ == "__main__":
main()
|
import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
IN=lambda : map(int, input().split())
LIN=lambda : list(IN())
mod=1000000007
#+++++
def main():
#a = int(input())
h,w,k = IN()
ss=0
ret=[]
kv=1
for i in range(h):
wd = input()
if ss >= 0 and wd == '.'*w:
ss+=1
elif wd == '.'*w:
al=ret[-1][:]
ret.append(al)
else:
al=[]
stf=True
for c in wd:
if stf and c == '#':
stf = False
elif c == '#':
kv+=1
al.append(kv)
else:
kv+=1
if ss >= 0:
for i in range(ss+1):
ret.append(al)
ss=-1
else:
ret.append(al)
for l in ret:
print(*l)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| 0 | null | 83,686,948,623,262 | 151 | 277 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
s = 0
B = [0]
C = {0:[0]}
for i, a in enumerate(A):
s = (s+a)%K
n = (s-i-1)%K
B.append(n)
if n not in C: C[n] = []
C[n].append(i+1)
ans = 0
for k, v in C.items():
if len(v)<=1: continue
ans_k = 0
ir=0
for il in range(0,len(v)-1):
l = v[il]
while(ir<len(v) and v[ir]-l<=K-1): ir+=1
ans_k+=(ir-1)-il
ans+=ans_k
print(ans)
|
n=int(input())
d=list(map(int,input().split()))
mx=max(d)
l=[0]*(10**5)
mx=0
for i in range(n):
if (i==0 and d[i]!=0) or (i!=0 and d[i]==0):
print(0)
exit()
l[d[i]]+=1
mx=max(mx,d[i])
t=1
ans=1
for i in range(1,mx+1):
ans *= t**l[i]
t=l[i]
print(ans%998244353)
| 0 | null | 146,889,089,968,380 | 273 | 284 |
for a in range(1,10):
for b in range(1,10):
i = a * b
print(a,"x",b,"=",i,sep="")
|
import sys
def f(x):
p=0
cnt=0
for i in range(n-1,-1,-1):
while p<n and a[i]+a[p]<x:
p+=1
cnt+=n-p
return cnt
n,m=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
l,r=a[0]*2,a[n-1]*2
md=(r+l)//2
while r-l>0:
if r-l<=1:
if f(r)==m: md=r;break
else: md=l;break
md=(r+l)//2
k=f(md)
if k==m: break
elif k>m: l=md
else: r=md
p=0
cnt=0
ans=0
for q in range(n-1,-1,-1):
try:
while p<n and a[q]+a[p]<=md:
p+=1
except:
b=1
while True:
b+=1
if p==n: break
cnt+=n-p
ans+=a[q]*(n-p)*2
ans+=(m-cnt)*md
print(ans)
| 0 | null | 54,035,875,365,472 | 1 | 252 |
N = input().strip()
INFTY = 10**8
dp = [[INFTY for _ in range(2)] for _ in range(len(N)+1)]
a = int(N[-1])
for i in range(10):
if i<a:
dp[1][1] = min(dp[1][1],i+10-a)
else:
dp[1][0] = min(dp[1][0],i+i-a)
for k in range(2,len(N)+1):
a = int(N[-k])
for i in range(10):
if i>=a:
dp[k][0] = min(dp[k][0],dp[k-1][0]+i+i-a)
if i-1>=a:
dp[k][0] = min(dp[k][0],dp[k-1][1]+i+i-1-a)
if i<a:
dp[k][1] = min(dp[k][1],dp[k-1][0]+i+10-a)
if i==0:
dp[k][1] = min(dp[k][1],dp[k-1][1]+9-a)
if 0<=i-1<a:
dp[k][1] = min(dp[k][1],dp[k-1][1]+i+10-a+i-1)
print(min(dp[len(N)][0],dp[len(N)][1]+1))
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = [int(x)-48 for x in read().rstrip()]
ans = 0
dp = [[0]*(len(N)+1) for i in range(2)]
dp[1][0] = 1
dp[0][0] = 0
for i in range(1, len(N)+1):
dp[0][i] = min(dp[0][i-1] + N[i-1],
dp[1][i-1] + (10 - N[i-1]))
dp[1][i] = min(dp[0][i-1] + N[i-1] + 1,
dp[1][i-1] + (10 - (N[i-1] + 1)))
print(dp[0][len(N)])
| 1 | 70,953,770,863,900 | null | 219 | 219 |
# 入力
n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
# ライブラリ
import itertools
l = [i+1 for i in range(n)]
perms = itertools.permutations(l, n)
# 処理
a = 0
b = 0
for i, perm in enumerate(perms):
perm = list(perm)
if perm == p:
a = i
if perm == q:
b = i
import numpy as np
print(np.abs(a-b))
|
import itertools
#h,w=map(int,input().split())
#S=[list(map(int,input().split())) for _ in range(h)]
n=int(input())
P=list(map(int,input().split()))
Q=list(map(int,input().split()))
num=0
numlist=[i for i in range(1,n+1)]
pall=list(itertools.permutations(numlist))
for pp in pall:
if P==list(pp):
pnum=num
if Q==list(pp):
qnum=num
num+=1
print(abs(pnum-qnum))
| 1 | 100,720,398,323,748 | null | 246 | 246 |
X, Y = map(int, input().split())
if Y % 2 == 0 and 0 <= (4 * X - Y) / 2 <= X:
print("Yes")
else:
print("No")
|
import math
n = int(input())
x = list(map(int,input().split()))
y = list(map(int,input().split()))
d=0
for i in range(n):
d += max(x[i],y[i])-min(x[i],y[i])
print(float(d))
d=0
for i in range(n):
d+=(x[i]-y[i])**2
print(math.sqrt(d))
d=0
for i in range(n):
d+=(max(x[i],y[i])-min(x[i],y[i]))**3
print(math.pow(d,1/3))
d=[]
for i in range(n):
d.append(max(x[i],y[i])-min(x[i],y[i]))
print(float(max(d)))
| 0 | null | 7,050,723,868,928 | 127 | 32 |
div = 0
mod = 0
h = int(input())
w = int(input())
n = int(input())
if h > w:
div = n // h
mod = n % h
else:
div = n // w
mod = n % w
if mod > 0:
print(div+1)
else:
print(div)
|
pi = 3.141592653589793
r = float(input())
print('{0:f} {1:f}'.format(r*r*pi, 2 * r * pi))
| 0 | null | 44,960,892,883,790 | 236 | 46 |
n = int(input())
a = list(map(int,input().split()))
ans = {i:0 for i in range(n)}
for i in a:
ans[i-1] += 1
for i in ans.values():
print(i)
|
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
n = I()
s = S()
rgb = [None for _ in range(n)]
rgb_acc = [None for _ in range(n)]
rgb_st = {"R","G","B"}
rgb_lst = ["R","G","B"]
for i, char in enumerate(s):
if char == "R":
rgb[i] = [1,0,0]
elif char == "G":
rgb[i] = [0,1,0]
else:
rgb[i] = [0,0,1]
rgb_acc[0] = rgb[0]
for i in range(1, n):
rgb_acc[i] = rgb_acc[i-1][:]
index = 0 if s[i]=="R" else 1 if s[i]=="G" else 2
rgb_acc[i][index] += 1
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
if s[i]!=s[j]:
ex = rgb_st - {s[i], s[j]}
ex = ex.pop()
index = 0 if ex=="R" else 1 if ex=="G" else 2
cnt = rgb_acc[n-1][index]-rgb_acc[j][index]
if j+1 <= 2*j-i < n:
if s[2*j-i] == ex:
cnt -= 1
ans += cnt
print(ans)
main()
| 0 | null | 34,287,799,745,640 | 169 | 175 |
import math
a,b,c=map(float,input().split())
C=math.radians(c)
D=math.sin(C)*a*b
S=D/2
E=a**2+b**2-2*a*b*math.cos(C)
F=math.sqrt(E)
L=a+b+F
if C<90:
h=b*math.sin(C)
elif C==90:
h=b
else:
h=b*math.sin(180-C)
print(S,L,h)
|
X, K, D = map(int, input().split())
X = abs(X)
if K%2 == 1:
K -= 1
X -= D
K_ = K // 2
min_Y = X - K_ * (2 * D)
if min_Y > 0:
print(min_Y)
else:
min_Y_p = X % (2 * D)
min_Y_m = 2 * D - X % (2 * D)
print(min(min_Y_p, min_Y_m ))
| 0 | null | 2,673,854,243,282 | 30 | 92 |
N, M = map(int, input().split())
S = input()
S = S[::-1]
dp = [-1] * (N+1)
dp[0] = 0
pos = 0
while pos < N:
p = pos
update = False
for i in range(1, M + 1):
if p + i > N:
break
if S[p + i] == "0":
update = True
pos = p + i
dp[pos] = dp[p] + 1
if not update:
break
if dp[N] == -1:
print(-1)
exit()
dp = dp[::-1]
num = dp[0]
ans = []
pos = 0
while num > 0:
for i in range(1, M + 1):
if dp[pos + i] == num - 1:
num -= 1
pos += i
ans.append(str(i))
break
ans = " ".join(ans)
print(ans)
|
N=int(input())
A = list(map(int,input().split()))
val = 0
for i in range(N):
val = val ^ A[i]
ans = []
for i in range(N):
s = val ^ A[i]
ans.append(s)
print(*ans)
| 0 | null | 75,747,291,079,350 | 274 | 123 |
s = input()
ans=0
s=s[::-1]
t=1
ketame=0
amari10=1
kosuu=[1]+[0]*2020
for i in s:
ketame=(ketame+(int(i)*amari10)%2019)%2019
amari10*=10
amari10%=2019
kosuu[ketame]+=1
for i in range(len(kosuu)):
if kosuu[i]>0:
ans+=kosuu[i]*(kosuu[i]-1)/2
print(int(ans))
|
import sys
S = input()[::-1]
c = [0] * 2019
c[0] = 1
num = 0
d = 1
for a in S:
num += int(a) * d
num %= 2019
d *= 10
d %= 2019
c[num] += 1
a = 0
for i in c:
a += i * (i - 1) // 2
print(a)
| 1 | 30,798,605,216,022 | null | 166 | 166 |
(X1,X2,Y1,Y2)=list(map(int,input().split()))
ans=X2*Y2
ans=max(ans,X1*Y1)
ans=max(ans,X1*Y2)
ans=max(ans,X2*Y1)
print (ans)
|
ST = list(map(str, input().split()))
word = ST[::-1]
print("".join(word))
| 0 | null | 53,106,550,983,232 | 77 | 248 |
import sys
X = int(input())
if X >= 30:
print('Yes')
else:
print('No')
print('Yes\nNo', file=sys.stderr)
|
s = int(input())
if s >= 30:
print("Yes")
else:
print("No")
| 1 | 5,749,016,438,490 | null | 95 | 95 |
def solve(N):
if N%2==1:
return 0
N2=(N-N%10)//10
count_zero=N2
x=5
while N2>=x:
count_zero+=N2//x
x*=5
return count_zero
N=int(input())
print(solve(N))
|
n = int(input())
p = 10
a = 0
if n % 2 == 0:
while p <= n:
a += n // p
p *= 5
print(a)
| 1 | 115,961,669,368,128 | null | 258 | 258 |
n = int(input())
a = list(map(int, input().split()))
leaf = sum(a) - 1
now = 1
ans = 0
for i, num in enumerate(a):
ans += now
now -= num
if leaf >= now:
leaf -= now
now *= 2
elif leaf > 0:
now += leaf
leaf = 0
if now < 0:
print(-1)
exit()
print(ans)
|
n= int(input())
a = list(map(int, input().split()))
if n == 0 and a[0]==1:
print(1)
exit(0)
if a[0] != 0:
print(-1)
exit(0)
b=1
count=1
asum =sum(a)
alim = asum
for i in range(n):
if a[i+1] > 2*b:
print(-1)
exit(0)
else:
alim = alim - a[i+1]
b= min(2*b-a[i+1], alim)
count += b
print(count+ asum)
| 1 | 19,002,424,938,360 | null | 141 | 141 |
a = int(input())
b = int(input())
n = int(input())
t = max(a, b)
print((n + t - 1) // t)
|
[n, m] = [int(x) for x in raw_input().split()]
A = []
counter = 0
while counter < n:
A.append([int(x) for x in raw_input().split()])
counter += 1
B = [int(raw_input()) for j in range(m)]
counter = 0
while counter < n:
result = 0
for j in range(m):
result += A[counter][j] * B[j]
print(result)
counter += 1
| 0 | null | 45,169,389,116,260 | 236 | 56 |
A = list(map(int, input().split()))
if sum(A) < 22:
print("win")
else:
print("bust")
|
n = int(input())
c = 0
for _ in range(n):
r = [int(e) for e in input().split(" ")]
if(r[0] == r[1]):
c += 1
else:
c = 0
if(c == 3):
print("Yes")
break
else:
print("No")
| 0 | null | 60,289,146,871,808 | 260 | 72 |
N=int(input())
A=["a"]
if N==1:
print("a")
exit()
else:
S="abcdefghijklmn"
slist=list(S)
for i in range(2,N+1):
temp=[[] for _ in range(N)]
for j in range(i-1):
for w in A[j]:
for u in slist[:j+1]:
temp[j].append(w+u)
temp[j+1].append(w+slist[j+1])
A=temp
B=[]
for j in range(N):
for t in A[j]:
B.append(t)
B.sort()
for i in range(len(B)):
print(B[i])
|
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
# アルファベットと数字の対応
alp_to_num = {chr(i+97): i for i in range(26)}
ALP_to_num = {chr(i+97).upper(): i for i in range(26)}
num_to_alp = {i: chr(i+97) for i in range(26)}
num_to_ALP = {i: chr(i+97).upper() for i in range(26)}
def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]
def main():
N = NI()
ans = []
def dfs(s, i, max_num):
if i == N:
ans.append(s)
return
for n in range(max_num+2):
dfs(s + num_to_alp[n], i+1, max(max_num, n))
dfs("a", 1, 0)
ans.sort()
for a in ans:
print(a)
if __name__ == "__main__":
main()
| 1 | 52,613,534,289,458 | null | 198 | 198 |
def main():
_ = int(input())
num_tuple = tuple(map(int, input().split()))
count = 0
for i, num in enumerate(num_tuple):
if ((i+1)*num) % 2 == 1:
count += 1
print(count)
if __name__ == '__main__':
main()
|
n = int(input())
data = list(map(int, input().split()))
ans = []
for i in range(n):
if (i % 2 == 0) and (data[i] % 2 == 1):
ans.append(data[i])
print(len(ans))
| 1 | 7,693,312,594,588 | null | 105 | 105 |
n,d,a = map(int,input().split())
xh = [list(map(int,input().split())) for _ in range(n)]
xh.sort()
j = 0
cnt = [0] * n
taken = 0
def problem(h):
if h <= 0:return 0
ans = h//a
if h%a :
ans += 1
return ans
for i in range(n):
[x,h] = xh[i]
while xh[j][0] + 2*d < x:
taken -= cnt[j]
j += 1
# if taken * a >= h:
# break
# if not h % a:
# cnt[i] = h//a - taken
# else:
# cnt[i] = h//a - taken + 1
cnt[i] = problem(h - taken * a)
taken += cnt[i]
print(sum(cnt))
|
#coding: utf-8
def GCM(m, n):
while 1:
if n == 0: return m
m -= (m/n)*n
m,n = n,m
while 1:
try:
a,b = map(int, raw_input().split())
x = GCM(a,b)
y = a*b / x
print "%d %d" % (x, y)
except EOFError:
break
| 0 | null | 40,931,945,666,940 | 230 | 5 |
X, Y = map(int, input().split())
x = 2*X-1/2*Y
y = -X + 1/2*Y
if x.is_integer() and y.is_integer() == True:
if x >= 0 and y >= 0:
print('Yes')
else:
print('No')
else:
print('No')
|
S = input()
N = len(S)
flag = [0,0,0]
if S=="".join(reversed(list(S))):
flag[0]=1
if S[:int((N-1)/2)]=="".join(reversed(list(S[:int((N-1)/2)]))):
flag[1]=1
if S[int((N+3)/2)-1:]=="".join(reversed(list(S[int((N+3)/2)-1:]))):
flag[2]=1
print("Yes" if flag==[1,1,1] else "No")
| 0 | null | 30,174,608,816,978 | 127 | 190 |
import math
N = int(input())
divisor_N1=set()
for i in range(1, math.floor(math.sqrt(N-1)) + 1):
if (N - 1) % i == 0:
divisor_N1.add(i)
divisor_N1.add((N-1) // i)
#print(divisor_N1)
divisor_N=set()
for i in range(1, math.floor(math.sqrt(N) + 1)):
if N % i == 0:
divisor_N.add(i)
divisor_N.add(N // i)
#print(divisor_N)
divisor_N.remove(1)
divisor_N1.remove(1)
#print(divisor_N)
#print(divisor_N1)
cnt = len(divisor_N1)
for num in divisor_N:
temp = N
while temp % num == 0:
temp //= num
if temp % num == 1:
cnt += 1
#print(num)
print(cnt)
|
# coding: utf-8
def check_divide(n):
max_v = int(n ** (1/2))
divide_nums = []
for i in range(1,max_v + 1):
if n % i == 0:
divide_nums.append(i)
return divide_nums
def check_divide2(n):
divide_nums = []
for K in range(2,n+1):
tmp = n
while True:
if tmp % K ==0:
tmp = tmp // K
else:break
if tmp % K == 1:
divide_nums.append(K)
return divide_nums
if __name__ == '__main__':
N = int(input())
tmp1 = check_divide(N-1)
if tmp1[-1] ** 2 == N-1:
tmp1 = len(tmp1) * 2 - 2
else:
tmp1 = len(tmp1) * 2 - 1
candidates = check_divide(N)[1:]
tmp2 = [N]
for val in candidates:
N_ = N
while True:
if N_ % val == 0:
N_ = N_ / val
else:break
if N_ % val == 1:
tmp2.append(val)
tmp2 = len(tmp2)
print(tmp1 + tmp2)
| 1 | 41,530,260,028,140 | null | 183 | 183 |
n, m = map(int, input().split())
h = list(map(int, input().split()))
a = [0] * m
b = [0] * m
ok = [True]*n
for i in range(m):
a[i], b[i] = map(int, input().split())
if h[a[i]-1] <= h[b[i]-1]:
ok[a[i]-1] = False
if h[b[i]-1] <= h[a[i]-1]:
ok[b[i]-1] = False
ans = 0
for i in range(n):
if ok[i] == True:
ans += 1
print(ans)
|
n,m=map(int,input().split())
way=[[] for i in range(n)]
H = list(map(int,input().split()))
for i in range(m):
a,b=map(int,input().split())
way[a-1].append(b-1)
way[b-1].append(a-1)
ans=0
for i in range(n):
high=True
for j in way[i]:
if H[i]<=H[j]:
high=0
break
if high:
ans+=1
print(ans)
| 1 | 25,261,291,844,038 | null | 155 | 155 |
from itertools import permutations
from math import sqrt, pow, factorial
N = int(input())
l = [list(map(int, input().split())) for _ in range(N)]
def calc(a, b):
[x1, y1] = a
[x2, y2] = b
return sqrt(pow(x1 - x2, 2) + pow(y1 -y2, 2))
ans = 0
for order in permutations(range(N)):
tmp = 0
for i in range(1, N):
tmp += calc(l[order[i]], l[order[i-1]])
ans += tmp
print(ans/factorial(N))
|
import sys
nyuukyosha = []
for tou in range(4):
nyuukyosha.append([])
for kai in range(3):
nyuukyosha[tou].append([])
for heya in range(10):
nyuukyosha[tou][kai].append(0)
n = int(raw_input())
for i in range(n):
data = map(int, raw_input().split())
a = data[0] - 1
b = data[1] - 1
c = data[2] - 1
nyuukyosha[a][b][c] += data[3]
for tou in range(4):
for kai in range(3):
for heya in range(10):
sys.stdout.write(" {:}".format(nyuukyosha[tou][kai][heya]))
print("")
if tou < 3:
print("####################")
| 0 | null | 74,398,663,847,872 | 280 | 55 |
import math
a, b, c = map(float, input().split(' '))
c = c / 180 * math.pi
s = a * b * math.sin(c) / 2
l = a + b + pow((pow(a, 2) + pow(b, 2) - 2 * a * b * math.cos(c)), 0.5)
h = b * math.sin(c)
print('{0:.8f}'.format(s) + '\n' + '{0:.8f}'.format(l) + '\n' + '{0:.8f}'.format(h))
|
import math, re
a, b, c = [int(n) for n in re.split(r"\s+", input().strip())]
h = b * math.sin(c * math.pi / 180)
S = a * h / 2
L = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c * math.pi / 180)) + a + b
print("%f %f %f" % (S, L, h))
| 1 | 174,354,250,558 | null | 30 | 30 |
K, N = map(int,input().split())
A = [int(a) for a in input().split()]
dif = [A[i+1] - A[i] for i in range(N-1)]
dif.append(K + A[0] - A[N-1])
print(K - max(dif))
|
K, N = map(int, input().split())
A = tuple(map(int, input().split()))
maxd = K - A[-1] + A[0]
for i in range(1, N):
d = A[i] - A[i-1]
maxd = max(maxd, d)
ans = K - maxd
print(ans)
| 1 | 43,351,505,571,348 | null | 186 | 186 |
# 解説を参考に作成
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
def inverse(a, p):
"""逆元"""
a_, p_ = a, p
x, y = 1, 0
while p_:
t = a_ // p_
a_ -= t * p_
a_, p_ = p_, a_
x -= t * y
x, y = y, x
x %= p
return x
# from decorator import stop_watch
#
#
# @stop_watch
def solve(n, k):
mod = 10 ** 9 + 7
ans = 0
p_mod = [1, 1]
for i in range(2, n + 1):
p_mod.append((p_mod[-1] * i) % mod)
for i in range(min(n, k + 1)):
if i == 0:
ans += 1
elif i == 1:
ans += n * (n - 1)
else:
nCi = p_mod[n] * inverse(p_mod[n - i], mod) % mod * inverse(p_mod[i], mod) % mod
nmHi = (p_mod[n - 1] * inverse(p_mod[n - i - 1], mod) % mod) * inverse(p_mod[i], mod) % mod
# ans += cmb2(n, i, mod) * cmb2(n - 1, i, mod)
ans += nCi * nmHi % mod
ans %= mod
print(ans)
if __name__ == '__main__':
# S = input()
# N = int(input())
n, k = map(int, input().split())
# Ai = [int(i) for i in input().split()]
# Bi = [int(i) for i in input().split()]
# ABi = [[int(i) for i in input().split()] for _ in range(N)]
solve(n, k)
# # test
# from random import randint
# from func import random_str
# solve()
|
"""
E
"""
mod=10**9+7
MAX=4*10**5+100
g1=[1,1]
for i in range(2,MAX+1):
num_1=g1[-1]*i%mod
g1.append(num_1)
def cmb(n,r):
return g1[n]*pow(g1[r],mod-2,mod)*pow(g1[n-r],mod-2,mod)%mod
N,K=map(int,input().split())
ans=cmb(2*N-1,N)
if K>=N:
print(ans)
else:
num=cmb(N,N-K-1)
S=0
for i in range(N-K-1,0,-1):
S=(S+cmb(N-1,i-1)*cmb(N,i))%mod
ans=(ans-S)%mod
print(ans)
| 1 | 67,246,786,823,720 | null | 215 | 215 |
k = int(input())
a,b = map(int,input().split())
count = 1
flag = 0
while k * count <= b:
if k * count >= a and k * count <= b:
flag = 1
count += 1
else:
count += 1
if flag == 1:
print("OK")
else:
print("NG")
|
K = int(input())
A,B = map(int,input().split())
for i in range(1,1000):
x = K * i
if A <= x <= B:
print('OK')
exit()
else:
continue
print('NG')
| 1 | 26,580,318,823,268 | null | 158 | 158 |
#!/usr/bin/env python
from sys import stdin, stderr
def main():
S = stdin.readline().strip()
if (len(S) % 2) != 0:
print('No')
return 0
for i in xrange(0, len(S), 2):
if S[i:i+2] != 'hi':
print('No')
return 0
print('Yes')
return 0
if __name__ == '__main__': main()
|
S = input()
flg = True
for i in range(len(S)):
if flg == True and S[i] == "h":
flg = False
continue
elif flg == False and S[i] == "i":
flg = True
continue
else:
print("No")
break
else:
if flg == False:
print("No")
else:
print("Yes")
| 1 | 53,231,561,736,028 | null | 199 | 199 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(input())
lr = [None]*n
for i in range(n):
x,l = map(int, input().split())
lr[i] = (x-l, x+l)
lr.sort(key=lambda x: x[1])
ans = 0
c = -10**10
for l,r in lr:
if c<=l:
ans += 1
c = r
print(ans)
|
def main():
N = int(input())
robot = []
for _ in range(N):
X, L = map(int, input().split())
robot.append([X-L,X+L])
robot.sort(key=lambda x: x[1])
cnt = 1
l = robot[0][1]
for i in range(1,N):
if l <= robot[i][0]:
cnt += 1
l = robot[i][1]
print(cnt)
if __name__ == "__main__":
main()
| 1 | 89,989,666,653,580 | null | 237 | 237 |
n = int(input())
rem = n%1000
if rem!=0:rem = 1000 - rem
print(rem)
|
n = input()
if len(n) < 3:
print(1000 - int(n))
else:
hasuu = n[len(n) - 3:]
if hasuu == '000':
print('0')
else:
print(1000-int(hasuu))
| 1 | 8,482,613,886,542 | null | 108 | 108 |
n = int(input())
d = dict()
for i in range(1, n+1):
t = i
tail = t % 10
while t >= 10: # head, tail nomi miru.
t //= 10
head = t
d[(head, tail)] = d.get((head, tail), 0) + 1
ans = 0
for i in range(1, 10):
for j in range(1, 10):
temp = d.get((i,j), 0) * d.get((j,i), 0)
# print(i, j, temp, d.get((i, j)), d.get((j, i)))
ans += temp
print(ans)
|
import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline ####
int1 = lambda x: int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def printlist(lst, k='\n'): print(k.join(list(map(str, lst))))
INF = float('inf')
def solve():
n = II()
D = [[0]*10 for _ in range(10)]
for i in range(1, n+1):
s = list(str(i))
l = int(s[0])
r = int(s[-1])
# print(s, l, r)
D[l][r] += 1
# print(D)
ans = 0
for i in range(10):
for j in range(10):
ans += D[i][j] * D[j][i]
print(int(ans))
if __name__ == '__main__':
solve()
| 1 | 86,635,057,869,920 | null | 234 | 234 |
from collections import deque
n = int(input())
l = deque()
for _ in range(n):
command = input().split()
if command[0] == "insert":
l.appendleft(command[1])
elif command[0] == "delete":
try:
ind = l.remove(command[1])
except ValueError:
pass
elif command[0] == "deleteFirst":
l.popleft()
elif command[0] == "deleteLast":
l.pop()
print (" ".join(l))
|
def linearSearch(A, key):
i = 0
A.append(key)
while A[i] != key:
i += 1
if i == len(A)-1:
A.pop()
return 'Not_found'
A.pop()
return i
if __name__ == '__main__':
c = 0
n = int(input())
hoge1 = [int(x) for x in input().split()]
q = int(input())
for key in (int(x) for x in input().split()):
if linearSearch(hoge1, key) == 'Not_found':
continue
else:
c += 1
print (c)
| 0 | null | 61,933,345,632 | 20 | 22 |
s=str("ACL")
n=int(input())
print(s*n)
|
n = int(input())
ls = list(map(int, input().split()))
rsw = [0]*1005
for i in ls:
rsw[i] += 1
for i in range(1,1005):
rsw[i] = rsw[i-1] + rsw[i]
res = 0
for i in range(n):
for j in range(i+1,n):
a = ls[i]
b = ls[j]
low = abs(a-b)
high = a+b
tmp = rsw[min(high,1004)-1] - rsw[low]
if low < a < high:
tmp -= 1
if low < b < high:
tmp -= 1
res += tmp
print(res//3)
| 0 | null | 87,132,722,202,560 | 69 | 294 |
sum = 0
num = [0] * (10 ** 5 + 1)
N = int(input())
A = [int(a) for a in input().split()]
for i in range(0, N):
sum += A[i]
num[A[i]] += 1
Q = int(input())
for i in range(0, Q):
B, C = (int(x) for x in input().split())
sum += (C - B) * num[B]
num[C] += num[B]
num[B] = 0
print(sum)
|
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
q = int(input())
C = Counter(a)
ans = sum(a)
for i in range(q):
b, c = map(int, input().split())
ans += (c-b)*C[b]
C[c] += C[b]
C[b] = 0
print(ans)
| 1 | 12,121,932,103,710 | null | 122 | 122 |
N = int(input())
al = list(map(int,input().split()))
sss=0
pss=0
for i in range(1,N):
pss+=al[i-1]
sss+=al[i]*pss
print(sss%1000000007)
|
# -*- coding: utf-8 -*-
import functools
@functools.lru_cache(maxsize=None)
def fib(n):
if n <= 1:
return 1
else:
return fib(n - 1) + fib(n - 2)
if __name__ == '__main__':
n = int(input())
print(fib(n))
| 0 | null | 1,892,808,152,600 | 83 | 7 |
N = int(input())
A = list(map(int, input().split()))
ary = [0]*(N-1)
for i in reversed(range(N-1)):
if i+1 >= (N-1):
ary[i] = A[N-1]
else:
ary[i] = ary[i+1] + A[i+1]
s = 0
for i in range(N-1):
s += A[i]*ary[i]
print(s%(10**9+7))
|
n = int(input())
cl = str(input())
cl_R = cl.count("R")
# print(cl_R)
cl_leftR = cl[:cl_R].count("R")
# print(cl_leftR)
print(cl_R-cl_leftR)
| 0 | null | 5,002,021,317,888 | 83 | 98 |
n = int(input())
Robo = []
for i in range(n):
x, l = map(int, input().split())
Robo.append([x-l, x+l])
Robo.sort(key=lambda x: x[1])
#print(Robo)
biggest_right = 2 * -10**9 - 1
counter = 0
for left, right in Robo:
if biggest_right <= left:
counter += 1
biggest_right = max(right, biggest_right)
print(counter)
|
N = int(input())
table = []
for i in range(N):
X,L = map(int,input().split())
table.append((X-L,X+L))
table = sorted(table, key=lambda x:x[1])
cur = 0
l_cur, r_cur = table[0]
ans = N
for i in range(1,N):
l,r = table[i]
if r_cur > l:
ans -= 1
else:
l_cur, r_cur = l,r
print(ans)
| 1 | 89,978,045,617,948 | null | 237 | 237 |
n=int(input())
a=list(map(int,input().split()))
#R,B,Gの順に埋めていく
#R,B,Gの現在の数を保存する
cnt={'R':0,'B':0,'G':0}
ans=1
for i in range(n):
count=0
edi=0
for j in 'RBG':
if cnt[j]==a[i]:
count+=1
if edi==0:
cnt[j]+=1
edi=1
ans*=count
print(ans%(10**9+7))
|
m = []
f = []
r = []
while(1):
a,b,c = map(int,raw_input().split())
if a == -1 and b == -1 and c == -1:
break
else:
m.append(a)
f.append(b)
r.append(c)
for i in range(len(m)):
if m[i] == -1 or f[i] == -1:
print "F"
elif m[i] + f[i] >= 80:
print "A"
elif m[i] + f[i] >= 65:
print "B"
elif m[i] + f[i] >= 50 or r[i] >= 50:
print "C"
elif m[i] + f[i] >= 30:
print "D"
else:
print "F"
| 0 | null | 65,836,439,098,532 | 268 | 57 |
X = int(input())
if X >= 2100:
print(1)
exit()
for a in range(21):
for b in range(21-a):
for c in range(21-a-b):
for d in range(21-a-b-c):
for e in range(21-a-b-c-d):
for f in range(21-a-b-c-d-e):
if 100*a +101*b +102*c +103*d +104*e + 105*f == X:
print(1)
exit()
print(0)
|
N = int(input())
x = N // 100
y = N % 100
if y <= 5 * x:
print(1)
else:
print(0)
| 1 | 126,808,581,416,818 | null | 266 | 266 |
from math import gcd
def lcm(a, b):
return a // gcd(a, b) * b
N, M = map(int, input().split())
As = list(map(int, input().split()))
rightmostbit = As[0] & -As[0]
for A in As[1:]:
if rightmostbit != A & -A:
print(0)
exit()
lcm_of_half_As = 1
for A in As:
lcm_of_half_As = lcm(lcm_of_half_As, A // 2)
if lcm_of_half_As > M:
break
print((M // lcm_of_half_As + 1) // 2)
|
a, b = map(int, raw_input().split())
def gcd(a,b):
c = a%b
if c==0:
return b
elif c == 1:
return c
else:
return gcd(b, c)
if a > b:
print gcd(a, b)
elif a < b:
print gcd(b, a)
else:
print a
| 0 | null | 51,002,761,265,430 | 247 | 11 |
S = list(input())
print("".join(S[0:3]))
|
a = input()
b = 0
c = ""
for i in a:
c += i
b += 1
if b==3:
break
print(c)
| 1 | 14,671,785,960,250 | null | 130 | 130 |
from sys import stdin
input = stdin.readline
def solve():
Y, X, K = map(int, input().split())
c = [inp for inp in stdin.read().splitlines()]
res = 0
for ymask in range((1<<Y) - 1):
for xmask in range((1<<X) - 1):
cnt = 0
for y in range(Y):
for x in range(X):
if ymask & (1<<y) == 0 and xmask & (1<<x) == 0 and c[y][x] == '#':
cnt += 1
if cnt == K:
res +=1
print(res)
if __name__ == '__main__':
solve()
|
a,b = input().split(" ")
a = int(a)
b = int(b)
print(a*b)
| 0 | null | 12,304,964,723,600 | 110 | 133 |
N, K = map(int, input().split())
ans = 0
mod = 10 ** 9 + 7
for k in range(K, N + 2):
max_range = int(k * (2 * N - k + 1) / 2)
min_range = int((k-1) * k / 2)
tmp = (max_range - min_range + 1) % mod
ans += tmp
ans %= mod
print(ans)
|
import bisect
n,d,a = map(int,input().split())
lst = []
x = []
for i in range(n):
xi,hi = map(int,input().split())
lst.append([xi,hi,0])
x.append(xi)
lst.sort()
x.sort()
count = 0
cur = 0
for i in range(n):
if lst[i][1]-cur > 0:
num = -(-(lst[i][1]-cur)//a)
count += num
damage = a * num
cur += damage
index = bisect.bisect(x,x[i]+2*d)
if index != n:
lst[index-1][2] += damage
cur -= lst[i][2]
print(count)
| 0 | null | 57,797,968,046,500 | 170 | 230 |
S,T = input().split()
A,B = map(int, input().split())
U = input()
ans=0
if U==S:
ans=A-1,B
else:
ans=A,B-1
print(' '.join(map(str,ans)))
|
n=int(input())
s=input()
ans=0
def my_index(l,x,default=-1):
if x in l:
return l.index(x)
else:
return default
for i in range(10**3):
i=str(i).zfill(3)
if my_index(s,i[0])!=-1:
s2=s[my_index(s,i[0])+1:]
if my_index(s2,i[1])!=-1:
s3=s2[my_index(s2,i[1])+1:]
if my_index(s3,i[2])!=-1:
ans+=1
print(ans)
| 0 | null | 100,304,472,759,168 | 220 | 267 |
mylist1 = [2,4,5,7,9]
mylist2 = [0,1,6,8]
N = int(input())
X = N % 10
if X in mylist1:
print('hon')
elif X in mylist2:
print('pon')
else:
print('bon')
|
while(True):
H, W = map(int, input().split())
if(H == W == 0):
break
str = "#." * (W // 2 + 1)
for i in range(H):
if(i % 2 == 0):
print(str[:W:])
else:
print(str[1:W + 1:])
print()
| 0 | null | 10,080,286,405,010 | 142 | 51 |
import numpy as np
N = int(input())
mod = 10**9 + 7
A = np.array(input().split(), int)
ans = 0
for i in range(60):
b = np.count_nonzero(A >> i & 1)
ans += 2**i*(b*(N-b))
ans %= mod
c = np.count_nonzero(A >> i & 1)
print(ans)
|
n=int(input())
p=10**9+7
A=list(map(int,input().split()))
binA=[]
for i in range(n):
binA.append(format(A[i],"060b"))
exp=[1]
for i in range(60):
exp.append((exp[i]*2)%p)
ans=0
for i in range(60):
num0=0
num1=0
for j in range(n):
if binA[j][i]=="0":
num0+=1
else:
num1+=1
ans=(ans+num0*num1*exp[59-i])%p
print(ans)
| 1 | 122,708,552,858,340 | null | 263 | 263 |
l = list(map(int,input().split()))
#print(l)
if l[0]==l[1]!=l[2]:
print('Yes')
elif l[0]!=l[1]==l[2]:
print('Yes')
elif l[0]==l[2]!=l[1]:
print('Yes')
else:
print('No')
|
class Info:
def __init__(self,arg_start,arg_end,arg_S):
self.start = arg_start
self.end = arg_end
self.S = arg_S
POOL = []
LOC = []
cnt = 0
sum_S = 0
line = input()
for c in line:
if c == "\\":
LOC.append(cnt)
elif c == "/":
if len(LOC) == 0:
continue
tmp_start = LOC.pop()
tmp_end = cnt
tmp_S = tmp_end - tmp_start
sum_S += tmp_S
while len(POOL) > 0:
if POOL[-1].start > tmp_start and POOL[-1].end < tmp_end:
tmp_S += POOL[-1].S
POOL.pop()
else:
break
POOL.append(Info(tmp_start,tmp_end,tmp_S))
else:
pass
cnt += 1
lst = [len(POOL)]
for i in range(len(POOL)):
lst.append(POOL[i].S)
print(sum_S)
print(*lst)
| 0 | null | 34,272,778,144,330 | 216 | 21 |
MOD = 10 ** 9 + 7
N, K = map(int, input().split())
lst = [0] * (K + 1)
ans = 0
for i in range(K, 0, -1):
tmp = K // i
tmp = pow(tmp, N, MOD)
for j in range(2 * i, K + 1, i):
tmp -= lst[j]
ans += (i * tmp)
ans %= MOD
lst[i] = tmp
print (ans)
|
n, k = map(int, input().split())
mod = 10**9+7
def power(a, n, mod):
bi=str(format(n,"b")) #2進数
res=1
for i in range(len(bi)):
res=(res*res) %mod
if bi[i]=="1":
res=(res*a) %mod
return res
D = [0]*(k+1)
ans = 0
for i in reversed(range(1, k+1)):
a = k//i
d = power(a, n, mod)
j = 1
while i*j <= k:
d -= D[i*j]
j += 1
D[i] = d
ans += (d*i)%mod
print(ans%mod)
| 1 | 36,754,040,492,092 | null | 176 | 176 |
from math import pi
r = float(input())
print(round(r * r * pi, 7), round(2 * pi * r, 7))
|
from sys import stdin
def ans():
_in = [_.rstrip() for _ in stdin.readlines()]
S = _in[0] # type:str
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
if S[-1] == 's':
S += 'es'
else:
S += 's'
ans = S
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(ans)
def main():
_in = [_.rstrip() for _ in stdin.readlines()]
S = list(_in[0]) # type:str
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
ans = 0
if S[-1] == 's':
S[-1] += 'es'
else:
S[-1] += 's'
ans = ''.join(S)
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(ans)
if __name__ == "__main__":
#main()
ans()
| 0 | null | 1,537,046,182,400 | 46 | 71 |
import math
def fact(n):
ans = 1
for i in range(2, n+1):
ans*= i
return ans
def comb(n, c):
return fact(n)//(fact(n-c)*c)
s,w = map(int, input().split())
if(s >w):
print('safe')
else:
print('unsafe')
|
n,m = map(int,input().split())
c = [int(i) for i in input().split()]
dp = [[float("INF")]*(n+1) for _ in range(m+1)]
dp[0][0] = 0
for i in range(m):
for yen in range(n+1):
if yen - c[i] < 0: dp[i+1][yen] = dp[i][yen]
else: dp[i+1][yen] = min(dp[i][yen],dp[i+1][yen-c[i]]+1)
print(dp[m][n])
| 0 | null | 14,647,412,542,004 | 163 | 28 |
n = int(input())
aaa = [[0 for i in range(10)] for j in range(10)]
for i in range(1, n+1):
aaa[int(str(i)[0])][i%10] += 1
ans = 0
for i in range(1, 10):
for j in range(1, 10):
ans += aaa[i][j]*aaa[j][i]
print(ans)
|
station = input()
print("Yes" if "AB" in station or "BA" in station else "No")
| 0 | null | 70,656,579,420,624 | 234 | 201 |
mod = 1000000007
n = int(input())
ans = pow(10,n,mod) - 2 * pow(9,n,mod) + pow(8,n,mod)
ans = (ans % mod + mod) % mod
print(ans)
|
n = int(input())
print((10**n-2*9**n+8**n)%1000000007)
| 1 | 3,112,114,000,232 | null | 78 | 78 |
import sys
input = sys.stdin.readline
from collections import *
N, P = map(int, input().split())
S = input()[:-1]
if P in [2, 5]:
ans = 0
for i in range(N):
if int(S[i])%P==0:
ans += i+1
print(ans)
exit()
cnt = defaultdict(int)
cnt[0] = 1
now = 0
ans = 0
for i in range(N-1, -1, -1):
now = (int(S[i])*pow(10, N-1-i, P)+now)%P
ans += cnt[now]
cnt[now] += 1
print(ans)
|
def main():
N, P = (int(i) for i in input().split())
L = [int(s) for s in input()][::-1]
ans = 0
if P == 2 or P == 5:
for i, e in enumerate(L):
if e % P == 0:
ans += N-i
else:
A = [0]*N
d = 1
for i, e in enumerate(L):
A[i] = (e*d) % P
d *= 10
d %= P
S = [0]*(N+1)
for i in range(N):
S[i+1] = S[i] + A[i]
S[i+1] %= P
from collections import Counter
c = Counter(S)
for v in c.values():
ans += v*(v-1)//2
print(ans)
if __name__ == '__main__':
main()
| 1 | 58,109,673,818,130 | null | 205 | 205 |
S=input()
if S=='RSR':print(1)
else:print(S.count('R'))
|
N=int(input())
A=list(map(int,input().split()))
for i in range(N):
A[i]=[A[i],i]
A.sort()
for i in range(N):
print(A[i][1]+1,end=' ')
print()
| 0 | null | 92,452,470,648,540 | 90 | 299 |
import sys
from io import StringIO
import unittest
import os
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
# 実装を行う関数
def resolve(test_def_name=""):
h, w, k = map(int, input().split())
s_s = [list(input()) for i in range(h)]
# パターン数分の情報を作成(横に切る = 最大2^10個)
# 全パターンの・・横に切る回数、と切る場所
side = []
for i in range(1 << h - 1):
cut_cnt = 0
point_s = []
# パターンの桁数分ループ
for j in range(h - 1):
# フラグが立つ(bitが1)の場合の処理を以下に記載。
if i & 1 << j:
cut_cnt += 1
point_s.append(j + 1)
point_s.append(h)
# 得た情報をリストに追加
side.append([point_s, cut_cnt])
## 横切り必須にもかかわらず、横木入りしていないパターンを排除できていない・・と思われる。
x_s_s = list(zip(*s_s))
ans = 999999
for side_cut_point_s, cut_cnt in side:
# 横切りを実施した後の塊を取得
cnt_s = [0 for i in range(cut_cnt + 1)]
for x_s in x_s_s:
start = 0
for cnt, side_cut_point in enumerate(side_cut_point_s):
cnt_s[cnt] += x_s[start: side_cut_point].count("1")
start = side_cut_point
# 切る必要がある場合は切る
if max(cnt_s) > k:
cut_cnt += 1
start = 0
for cnt, side_cut_point in enumerate(side_cut_point_s):
cnt_s[cnt] = x_s[start: side_cut_point].count("1")
start = side_cut_point
if max(cnt_s) > k:
cut_cnt += 99999
ans = min(ans, cut_cnt)
print(ans)
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """3 5 4
11100
10001
00111"""
output = """2"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """3 5 8
11100
10001
00111"""
output = """0"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """4 10 4
1110010010
1000101110
0011101001
1101000111"""
output = """3"""
self.assertIO(test_input, output)
# 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
def test_1original_1(self):
test_input = """10 10 1
1000000000
1000000000
1000000000
1000000000
1000000000
1000000000
1000000000
1000000000
1000000000
1000000000"""
output = """9"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
|
n, m = map(int, input().split())
a = list(map(int, input().split()))
dp = [0] + [float('inf')]*(n)
for i in range(m):
for j in range(a[i],n+1):
dp[j] = min(dp[j],dp[j-a[i]]+1)
print(dp[-1])
| 0 | null | 24,350,955,031,480 | 193 | 28 |
import math
f = True
N = int(input())
for i in range(N+1):
if math.floor(i*1.08) == N:
print(i)
f = False
break
if f:
print(":(")
|
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
from collections import Counter
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
N = int(input())
for x in range(1, N + 1):
val = x * 108
val -= val % 100
if val == N * 100:
print(x)
exit()
print(":(")
| 1 | 126,042,164,357,340 | null | 265 | 265 |
a, b = map(int, input().rstrip().split(" "))
if a > b:
A = a
B = b
else:
A = b
B = a
GCD = 1
while True:
A, B = B, A%B
if B == 0:
break
print (str(A))
|
N = input()
K = int(input())
L = len(N)
dp = [[[0]*(K+2) for _ in range(2)] for _ in range(L+1)]
dp[0][0][0] = 1
for i in range(1,L+1):
a = int(N[i-1])
for k in range(K+1):
dp[i][0][k] += dp[i-1][0][k] if a==0 else dp[i-1][0][k-1]
dp[i][1][k] += dp[i-1][1][k-1]*9 + dp[i-1][1][k]
if a>0:
dp[i][1][k] += dp[i-1][0][k-1]*(a-1) + dp[i-1][0][k]
print(dp[L][0][K]+dp[L][1][K])
| 0 | null | 37,846,159,548,530 | 11 | 224 |
from collections import Counter
N = int(input())
S = input()
ctr = Counter(S)
res = 0
for i in range(N - 1):
for j in range(i + 1, N):
k = 2 * j - i
if k < N and (S[i] != S[j] and S[i] != S[k] and S[j] != S[k]):
res += 1
print(ctr["R"] * ctr["G"] * ctr["B"] - res)
|
from collections import Counter
def solve():
N = int(input())
S = list(input())
c = Counter(S)
ans = c['R']*c['G']*c['B']
for i in range(N):
for j in range(i+1,N):
k = j*2-i
if k>N-1:
break
if S[i]!=S[j] and S[j]!=S[k] and S[i]!=S[k]:
ans -= 1
return ans
print(solve())
| 1 | 35,942,785,869,428 | null | 175 | 175 |
# input
N = int(input())
# 約数
def getDivs(n):
divs = [n]
for i in range(2, n):
if i * i > n:
break
if n % i == 0:
divs.append(i)
if i != n//i:
divs.append(n//i)
return divs
# process
if N == 2:
print(1)
else:
pf1 = getDivs(N)
pf2 = getDivs(N-1)
cnt = len(pf2)
for x in pf1:
n = N
while n%x == 0:
n //= x
n %= x
if n == 1:
cnt += 1
# print(pf1)
# print(pf2)
print(cnt)
|
import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
n = int(ipt())
way = [[] for i in range(n+1)]
for i in range(n-1):
a,b = map(int,ipt().split())
way[a].append((b,i))
way[b].append((a,i))
q = queue.Queue()
q.put((1,-1,-1)) #nowplace,pastplace,hen
col = [-1]*(n-1)
while not q.empty():
np,pp,hen = q.get()
nc = 1
for i,wn in way[np]:
if i == pp:
continue
if nc == hen:
nc += 1
col[wn] = nc
q.put((i,np,nc))
nc += 1
print(max(col))
for i in col:
print(i)
return
if __name__ == '__main__':
main()
| 0 | null | 88,705,616,198,968 | 183 | 272 |
import sys
import math
R = int(input())
if not ( 1 <= R <= 100 ): sys.exit()
print((R+R) * math.pi)
|
a=int(input())
print(a*6.283185307178)
| 1 | 31,554,879,880,090 | null | 167 | 167 |
def solve(l, r, i):
if i - l < 1:
return 0
return dp[i - l] - dp[max(i - r - 1, 0)]
n, k = map(int, input().split())
lr = [list(map(int, input().split())) for _ in range(k)]
MOD = 998244353
dp = [0] * (n + 1)
dp[1] = 1
for i in range(2, n + 1):
tmp = 0
for l, r in lr:
tmp += solve(l, r, i)
tmp = tmp % MOD
dp[i] = (dp[i - 1] + tmp) % MOD
print(tmp)
|
def main():
n, k = map(int, input().split())
lr = [list(map(int, input().split())) for _ in range(k)]
dp = [0] * (n + 1)
dp[1] = 1
dpsum = [0] * (n + 1)
dpsum[1] = 1
mod = 998244353
for i in range(2, n + 1):
for j in range(k):
li = max(i - lr[j][1], 1)
ri = i - lr[j][0]
if ri < 0:
continue
dp[i] = (dp[i] + dpsum[ri] - dpsum[li - 1]) % mod
dpsum[i] = dpsum[i - 1] + dp[i]
print(dp[-1] % mod)
if __name__ == "__main__":
main()
| 1 | 2,736,049,904,578 | null | 74 | 74 |
n = int(input())
a = list(map(int, input().split()))
a.sort()
n_sum = a[0]
sum = 0
for i in range(1,n):
sum += a[i] * n_sum
n_sum += a[i]
print(sum % (10**9 + 7))
|
def main():
n = int(input())
# d,t,s = map(int, input().split())
a = list(map(int, input().split()))
# s = input()
mod = 10**9+7
s = sum(a)
sm = 0
for i in a:
s -= i
sm += i * s % mod
print(sm % mod)
if __name__ == '__main__':
main()
| 1 | 3,819,576,996,630 | null | 83 | 83 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
b = [0] * (n + 1)
for i in range(1, n + 1):
b[i] = b[i - 1] + a[i - 1]
for i in range(n + 1):
b[i] -= i
b[i] %= k
d = dict()
for i in range(min(n + 1, k)):
if b[i] in d:
d[b[i]] += 1
else:
d[b[i]] = 1
ans = []
j = min(n + 1, k)
for i in range(n):
ans.append(d[b[i]])
d[b[i]] -= 1
if j <= n:
if b[j] in d:
d[b[j]] += 1
else:
d[b[j]] = 1
j += 1
ans = sum(ans) - n
print(ans)
|
n = int(input())
a = list(map(int,input().split()))
q = int(input())
table = {}
sum = 0
for i in range(n):
sum += a[i]
if a[i] not in table.keys():
table[a[i]] = 1
else:
table[a[i]] += 1
for i in range(q):
b,c = map(int,input().split())
if b in table.keys():
sum -= b * table[b]
sum += c * table[b]
if c not in table.keys():
table[c] = table[b]
else:
table[c] += table[b]
table[b] = 0
print(sum)
| 0 | null | 74,972,829,048,608 | 273 | 122 |
def main():
input_lines_lrd = input()
arrLRD = input_lines_lrd.split(" ")
l = int(arrLRD[0])
r = int(arrLRD[1])
d = int(arrLRD[2])
cnt = 0
for n in range(l, r+1):
if n % d == 0:
cnt = cnt + 1
print(cnt)
if __name__ == "__main__":
main()
|
#import sys
#import numpy as np
import math
#from fractions import Fraction
import itertools
from collections import deque
from collections import Counter
import heapq
#from fractions import gcd
#input=sys.stdin.readline
import bisect
s=input()
if s[-1]=="s":
print(s+"es")
else:
print(s+"s")
| 0 | null | 4,895,000,058,868 | 104 | 71 |
n, m = map(int,input().split())
s = list(input())
s.reverse()
ng = False
c = 0
ans = []
while ng == False and c < n:
for i in range(m, 0, -1):
if c+i < n+1 and s[c+i] == '0':
c += i
ans.append(str(i))
break
elif i == 1:
ng = True
if ng:
print(-1)
else:
ans.reverse()
print(' '.join(ans))
|
import itertools
n=int(input())
ab = []
for _ in range(n):
a, b = (int(x) for x in input().split())
ab.append([a, b])
narabi = [0+i for i in range(n)]
ans = 0
count = 0
for v in itertools.permutations(narabi, n):
count += 1
tmp_len = 0
for i in range(1,n):
x, y = abs(ab[v[i-1]][0]-ab[v[i]][0])**2, abs(ab[v[i-1]][1]-ab[v[i]][1])**2
tmp_len += (x + y)**0.5
ans += tmp_len
print(ans/count)
| 0 | null | 144,105,467,415,470 | 274 | 280 |
m1,d1 = map(int,input().split())
m2,d2 = map(int,input().split())
if m1 in [1,3,5,7,8,10,12] and d1==31:
print(1)
elif m1 in [4,6,9,11] and d1==30:
print(1)
elif m1==2 and d1 in [28,29]:
print(1)
else:
print(0)
|
import math
def f(n):
pop = 0
ntemp = n
for i in range(int(math.log2(n)) + 1):
pop += ntemp % 2
ntemp //= 2
return n % pop
n = int(input())
S = input()
popcount = 0
for i in range(n):
popcount += int(S[i])
# 1が1個しかない場合の例外処理
if popcount == 1:
if S[-1] == 1:
ans = [2] * n
ans[-1] = 0
else:
ans = [1] * n
ans[-1] = 2
for i in range(n):
if S[i] == '1':
ans[i] = 0
for i in range(n):
print(ans[i])
exit()
Sint = int(S, 2)
remminus = Sint % (popcount - 1)
remplus = Sint % (popcount + 1)
# 1,2,4,...の余りのリストを準備
remlistminus = []
remlistplus = []
temp = 1
for i in range(n):
remlistminus.append(temp)
temp = (temp * 2) % (popcount - 1)
temp = 1
for i in range(n):
remlistplus.append(temp)
temp = (temp * 2) % (popcount + 1)
remlistminus.reverse()
remlistplus.reverse()
ans = []
for i in range(n):
count = 1
if S[i] == '0':
rem = (remplus + remlistplus[i]) % (popcount + 1)
while rem > 0:
rem = f(rem)
count += 1
else:
rem = (remminus - remlistminus[i]) % (popcount - 1)
while rem > 0:
rem = f(rem)
count += 1
ans.append(count)
for i in range(n):
print(ans[i])
| 0 | null | 66,239,790,431,168 | 264 | 107 |
A = list(map(int, input().split()))
L = []
for i in A:
if i not in L:
L.append(i)
if len(L) == 2:
print('Yes')
else:
print('No')
|
BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001
while True:
M,F,R = map(int,input().split())
if M == -1 and F == -1 and R == -1:
break
if M == -1 or F == -1:
print("F")
elif M+F >= 80:
print("A")
elif M+F >= 65:
print("B")
elif M+F >= 50:
print("C")
elif M+F >= 30:
if R >= 50:
print("C")
else:
print("D")
else:
print("F")
| 0 | null | 34,584,915,124,450 | 216 | 57 |
n, m, k = map(int, input().split())
aa = list(map(int, input().split()))
bb = list(map(int, input().split()))
asum = [0]
bsum = [0]
for i in range(len(aa)):
asum.append(asum[i]+aa[i])
for i in range(len(bb)):
bsum.append(bsum[i]+bb[i])
j = len(bsum)-1
ans = 0
for i in range(len(asum)):
while j >= 0:
if k >= asum[i] + bsum[j]:
ans = max(ans, i+j)
break
else:
j -= 1
print(ans)
|
import bisect
N, M, K = map(int, input().split())
A = tuple(map(int, input().split()))
B = tuple(map(int, input().split()))
Asums = [0] * (N + 1)
for i, a in enumerate(A):
Asums[i+1] = Asums[i] + a
Bsums = [0] * (M + 1)
for i, b in enumerate(B):
Bsums[i+1] = Bsums[i] + b
ans = 0
for anum in range(N + 1):
t = Asums[anum]
if K < t:
break
bnum = bisect.bisect_right(Bsums, K - t) - 1
ans = max(ans, anum + bnum)
print(ans)
| 1 | 10,753,721,056,100 | null | 117 | 117 |
import sys
input = sys.stdin.buffer.readline
N, K = map(int, input().split())
A = [-1] + list(map(int, input().split()))
I = [-1] * (N + 1)
S = []
idx = 1
while I[idx] == -1:
S.append(idx)
I[idx] = len(S)
idx = A[idx]
# print(f'{S=}, {idx=}, {I[idx]=}')
start_idx = I[idx] - 1
num_circles = len(S) - start_idx
# print(f'{start_idx=}, {num_circles=}')
if K < len(S) - 1:
ans = S[K]
else:
K -= start_idx
div, mod = divmod(K, num_circles)
ans = S[start_idx + mod]
print(ans)
|
from sys import stdin,stdout
from collections import defaultdict
import sys
sys.setrecursionlimit(10**7)
def dfs1(src):
global steps
if steps==rem:return src
steps+=1
return dfs1(g[src][0])
def dfs(src):
global steps,done,boc,nic
vis[src]=1
steps+=1
if steps-1==k:
print(src)
exit(0)
dfn[src]=steps
for neigh in g[src]:
if not vis[neigh]:dfs(neigh)
else:
boc,done,nic=[neigh,steps,steps-dfn[neigh]+1]
# print(done,boc,nic)
return
n,k=list(map(int,stdin.readline().split()))
done,boc,nic=0,0,0
a=list(map(int,stdin.readline().split()))
g=defaultdict(list)
for i in range(1,n+1):
g[i]+=[a[i-1]]
vis=[0]*(n+1)
dfn=[0]*(1+n)
steps=0
dfs(1)
# print(done,boc,nic)
left=k-done
rem=(left%nic)
if rem==0:rem=nic
steps=1
print(dfs1(g[boc][0]))
| 1 | 22,641,966,251,180 | null | 150 | 150 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.