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
|
|---|---|---|---|---|---|---|
roll = {"N": (1, 5, 2, 3, 0, 4),
"S": (4, 0, 2, 3, 5, 1),
"E": (3, 1, 0, 5, 4, 2),
"W": (2, 1, 5, 0, 4, 3)}
dice = input().split()
for direction in input():
dice = [dice[i] for i in roll[direction]]
print(dice[0])
| l = list(map(int, input().split()))
s = input()
for c in s:
if c == "S":
l = [l[4], l[0], l[2], l[3], l[5], l[1]]
elif c == "N":
l = [l[1], l[5], l[2], l[3], l[0], l[4]]
elif c == "E":
l = [l[3], l[1], l[0], l[5], l[4], l[2]]
else:
l = [l[2], l[1], l[5], l[0], l[4], l[3]]
print(l[0])
| 1 | 236,473,840,032 | null | 33 | 33 |
a,b,m=map(int,input().split())
al=list(map(int,input().split()))
bl=list(map(int,input().split()))
xyc=[list(map(int,input().split())) for _ in range(m)]
ans=min(al)+min(bl)
for i in range(m):
tmp=0
tmp=al[xyc[i][0]-1]+bl[xyc[i][1]-1]-xyc[i][2]
ans=min(ans,tmp)
print(ans) | N=int(input())
S,T=input().split()
list=[]
i=0
while i<N:
list.append(S[i])
list.append(T[i])
i=i+1
print(*list, sep='') | 0 | null | 83,266,040,913,120 | 200 | 255 |
import math
def isPrime( x ):
if 2 == x or 3 == x:
return True
if 0 == x&1:
return False
i = 3
limit = math.sqrt( x )
while i <= limit:
if 0 == x%i:
return False
i += 2
return True
n = int( raw_input( ) )
nums = []
i = 0
while i < n:
nums.append( int( raw_input( ) ) )
i += 1
cnt = i = 0
for val in nums:
if isPrime( val ):
cnt += 1
print( cnt ) | s=str(input())
p=str(input())
ss = s*2
hantei = p in ss
if hantei:
print("Yes")
else:
print("No")
| 0 | null | 870,708,679,522 | 12 | 64 |
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
N=I()
cnt=0
flag=0
for _ in range(N):
a,b=MI()
if a==b:
cnt+=1
else:
cnt=0
if cnt==3:
flag=1
break
if flag==1:
print("Yes")
else:
print("No")
main()
| import sys
input = sys.stdin.buffer.readline
def main():
T1,T2 = map(int,input().split())
A1,A2 = map(int,input().split())
B1,B2 = map(int,input().split())
l = (A1-B1)*T1 + (A2-B2)*T2
if l == 0:
print("infinity")
elif l > 0:
if A1 > B1:
print(0)
else:
d = (B1-A1)*T1
if d%l == 0:
ans = 2*(d//l)
else:
ans = 1+2*(d//l)
print(ans)
else:
l *= -1
if B1 > A1:
print(0)
else:
d = (A1-B1)*T1
if d%l == 0:
ans = 2*(d//l)
else:
ans = 1+2*(d//l)
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 66,957,420,341,360 | 72 | 269 |
n = input()
s , t=input().split()
print(*[s + t for s, t in zip(s, t)],sep='') | s = input()
if s == '0':
print(1)
else:
print(0) | 0 | null | 57,397,367,750,688 | 255 | 76 |
a = input().split()
print(' '.join(sorted(a))) | num = input().split()
num.sort()
print(num[0], num[1], num[2]) | 1 | 430,281,361,552 | null | 40 | 40 |
#初期定義
global result
global s_list
result = 0
#アルゴリズム：ソート
def merge(left, mid, right):
global result
n1 = mid - left
n2 = right - mid
inf = 10**9
L_list = s_list[left: mid] + [inf]
R_list = s_list[mid: right] + [inf]
i = 0
j = 0
for k in range(left, right):
result += 1
if L_list[i] <= R_list[j]:
s_list[k] = L_list[i]
i += 1
else:
s_list[k] = R_list[j]
j += 1
#アルゴリズム：マージソート
def mergeSort(left, right):
if (left + 1) < right:
mid = (left + right) // 2
mergeSort(left, mid)
mergeSort(mid, right)
merge(left, mid, right)
#初期値
n = int(input())
s_list = list(map(int, input().split()))
#処理の実行
mergeSort(0, n)
#結果の表示
print(" ".join(map(str, s_list)))
print(result)
| A,B = map(int,input().split())
ans=int(A-B*2)
print(ans if ans >= 0 else 0) | 0 | null | 83,370,816,272,842 | 26 | 291 |
X = int(input())
for i in range(100000//100 +1):
if X >= i*100 and X<= i*105:
print(1)
exit()
print(0)
| N = int(input())
a_list = list(map(int, input().split()))
num = 1
ans = 0
for i in range(N):
if a_list[i] != num:
ans += 1
else:
num += 1
if num == 1:
print(-1)
else:
print(ans) | 0 | null | 120,956,671,770,880 | 266 | 257 |
A=input();print(sum(i!=j for i,j in zip(A,A[::-1]))//2) | list_s = list(input())
count = 0
for i in range(0, len(list_s) // 2):
if list_s[i] == list_s[0 - (i + 1)]:
continue
else: count += 1
print(count) | 1 | 120,421,916,932,042 | null | 261 | 261 |
n = int(input())
A = list(map(int, input().split()))
count = 0
def swap(a, b):
t = a
a = b
b = t
return [a, b]
def selection_sort(l):
global count
for i in range(0, len(l)):
mini = i
for j in range(i, len(l)):
if l[j] < l[mini]:
mini = j
if i != mini:
count += 1
l[i], l[mini] = swap(l[i], l[mini])
return l
l = selection_sort(A)
print(' '.join(str(x) for x in l))
print(count) | def selection_sort(num_list):
list_length = len(num_list)
cnt = 0
for i in range(list_length):
min_element = i
for j in range(i+1,list_length):
if num_list[j] < num_list[min_element]:
min_element = j
if i != min_element:
num_list[i],num_list[min_element] = num_list[min_element],num_list[i]
cnt += 1
return num_list,cnt
n = int(input())
num_list = list(map(int,input().split()))
ans_list,cnt = selection_sort(num_list)
str_ans_list = [str(i) for i in ans_list]
print('{}\n{}'.format(' '.join(str_ans_list),cnt))
| 1 | 20,784,738,632 | null | 15 | 15 |
W = input()
if W.count("R") > 0:
if W == "RRR":
print(3)
elif "RR" in W:
print(2)
else:
print(1)
else:
print(0) | #!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
#%%code
def resolve():
H,W,K=pin()
choco=[list(input()) for _ in range(H)]
#think H<=10:bit full search
ans=H+W #default
#print(choco)
for h in range(1<<(H-1)):#uekara h banme no yoko de waru
tempans=0
see=[]
shiro=[0]
for i in range(H):
see.append(tempans)
if (1<<i)&h:
tempans+=1
shiro.append(0)
#print(see,tempans,bin(h),"sth")
#print(shiro,";")
#yokoni krenai nara donkoku de jituhatokeru
j=0
while(j<W):
f=1
for n,s in enumerate(see):
shiro[s]+=int(choco[n][j])
if shiro[s]>K:#suguhidaride kiru
if j==0:#kirenai kara nasi
f=0
break
tempans+=1
shiro=[0]*len(shiro)
j-=1
break
if f==0:
tempans=H*W
break
j+=1
#print(j,shiro,"tochu")
#print(tempans,"tempans")
ans=min(ans,tempans)
print(ans)
#%%submit!
resolve() | 0 | null | 26,850,258,243,972 | 90 | 193 |
n = int(input())
a = [(_a, i) for i, _a in enumerate(map(int, input().split()))]
a.sort(reverse=True)
dp = [[0]*(n+1) for _ in range(n+1)]
for i, (v, p) in enumerate(a):
# 前にj人いる
dp[i+1][0] = dp[i][0] + v*abs((n-1 - i) - p)
for j in range(1, i+1):
dp[i+1][j] = max(dp[i][j] + v*abs((n-1 - (i-j)) - p),
dp[i][j-1] + v*abs((j-1) - p))
dp[i+1][i+1] = dp[i][i] + v*abs(i - p)
print(max(dp[n]))
| INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp():
'''
一つの整数
'''
return int(input())
def inpl():
'''
一行に複数の整数
'''
return list(map(int, input().split()))
def inpl_str():
'''
一行に複数の文字
'''
return list(input().split())
n=inp()
a = inpl()
sorted_a = sorted(a,reverse=True)
place=dict()
for i in range(n):
if a[i] not in place:
place[a[i]]=[i+1]
else:
place[a[i]].append(i+1)
ans = 0
dp=[[-INF]*(n+1) for i in range(n+1)]
dp[0][0] = 0
for i in range(n):
if i!=0 and sorted_a[i] == sorted_a[i - 1]:
index += 1
else:
index = 0
for j in range(n):
_place = place[sorted_a[i]][index]
#右
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + sorted_a[i] * abs(n - (i - j) - _place))
#左
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + sorted_a[i] * abs(_place - j - 1))
print(max(dp[n]))
| 1 | 33,687,032,619,864 | null | 171 | 171 |
a,b,c,k = map(int,input().split())
print(k if k<a else a if a+b>k else a-(k-a-b))
| import math
r = input()
print '%f %f' % (r * r * math.pi, 2 * r * math.pi) | 0 | null | 11,278,532,733,650 | 148 | 46 |
h,w,k=map(int, input().split())
s=[list(input()) for _ in range(h)]
ans=[[0]*w for i in range(h)]
cnt=1
for i in range(h):
for j in range(w):
if s[i][j]=="#":
ans[i][j]=cnt
cnt+=1
for i in range(h):
for j in range(w):
if ans[i][j]==0:
if j!=0:
ans[i][j]=ans[i][j-1]
for i in range(h):
for j in range(w-1, -1, -1):
if ans[i][j]==0:
if j!=(w-1):
ans[i][j]=ans[i][j+1]
# for i in range(h):
# print(*ans[i])
# print()
for i in range(h):
for j in range(w):
if ans[i][j]==0:
if i!=0:
ans[i][j]=ans[i-1][j]
for i in range(h-1, -1, -1):
for j in range(w):
if ans[i][j]==0:
if i!=(h-1):
ans[i][j]=ans[i+1][j]
for i in range(h):
print(*ans[i])
| h,w,k = map(int, input().split())
s = []
st = 0
zero = [0 for i in range(h)]
z = 0
for i in range(h):
t = input()
st += t.count('#')
zero[i] = t.count('#')
s.append(t)
cake = 0
ans = [[0 for j in range(w)] for i in range(h)]
for i in range(h):
if zero[i] == 0:
continue
cake += 1
t = 0
for j in range(w):
if s[i][j] == '#':
t += 1
if t >= 2:
cake += 1
ans[i][j] = cake
for i in range(h-1):
if zero[i+1] != 0:
continue
if ans[i][0] == 0:
continue
for j in range(w):
ans[i+1][j] = ans[i][j]
for i in range(h-1,0,-1):
if zero[i-1] != 0:
continue
for j in range(w):
ans[i-1][j] = ans[i][j]
for i in range(h):
print (*ans[i]) | 1 | 143,169,040,498,032 | null | 277 | 277 |
S, T = input().split()
A, B = map(int, input().split())
U = input()
print(A-1 if S==U else A)
print(B if S==U else B-1) | import sys
from heapq import heappop, heappush
from scipy.sparse.csgraph import floyd_warshall
input = sys.stdin.readline
def main():
n,w,l = map(int,input().split())
d = [[10**15 for _ in range(n)] for _ in range(n)]
for _ in range(w):
x,y,z = map(int,input().split())
x -= 1
y -= 1
if z > l:
continue
d[x][y] = z
d[y][x] = z
for i in range(n):
d[i][i] = 0
d = floyd_warshall(d)
G = [[10**15 for _ in range(n)] for _ in range(n)]
for i in range(n-1):
for j in range(i+1,n):
if d[i][j] <= l:
G[i][j] = 1
G[j][i] = 1
for i in range(n):
G[i][i] = 0
G = floyd_warshall(G)
q = int(input())
for _ in range(q):
s,t = map(int,input().split())
s -= 1
t -= 1
ans = G[s][t]
if ans == 10**15:
print(-1)
continue
print(int(ans)-1)
if __name__ == "__main__":
main() | 0 | null | 122,819,050,879,462 | 220 | 295 |
from collections import deque
INF = 1000000
N,T,A=map(int,input().split())
T -= 1
A -= 1
G = [ [] for i in range(N) ]
DT = [ INF for _ in range(N) ]
DA = [ INF for _ in range(N) ]
for i in range(N-1):
h1,h2=map(int,input().split())
h1 -= 1
h2 -= 1
G[h1].append(h2);
G[h2].append(h1);
DT[T] = 0
DA[A] = 0
q = deque()
# BFS
q.append(T)
while len(q) > 0:
v = q.popleft()
for nv in G[v]:
if DT[nv] == INF:
DT[nv] = DT[v] + 1
q.append(nv)
q.clear()
q.append(A)
while len(q) > 0:
v = q.popleft()
for nv in G[v]:
if DA[nv] == INF:
DA[nv] = DA[v] + 1
q.append(nv)
max_da = 0
for i in range(N):
#print(i, " T:", DT[i], " A:", DA[i])
if DA[i] - DT[i] >= 1 :
max_da = max(DA[i], max_da)
print(max_da-1)
| n,m = map(int,input().split())
h = list(map(int,input().split()))
r = ['t'] * n
for i in range(m):
x,y = map(int,input().split())
if h[x-1] > h[y-1]:
r[y-1] = 'f'
elif h[x-1] < h[y-1]:
r[x-1] = 'f'
else:
r[y-1] = 'f'
r[x-1] = 'f'
s = 0
for i in range(n):
if r[i] == 't':
s += 1
print(s) | 0 | null | 71,149,278,756,820 | 259 | 155 |
from collections import deque
def main():
d = deque()
for _ in range(int(input())):
command = input()
if command[0] == 'i':
d.appendleft(command[7:])
elif command[6] == ' ':
try:
d.remove(command[7:])
except ValueError:
pass
elif len(command) == 11:
d.popleft()
else:
d.pop()
print(*d)
if __name__ == '__main__':
main()
| money = int(input())
count_div_500, left_after_500 = divmod(money, 500)
count_div_5, left_after_5 = divmod(left_after_500, 5)
print(count_div_500 * 1000 + count_div_5 * 5)
| 0 | null | 21,277,199,330,280 | 20 | 185 |
# import math
# import statistics
a=input()
b=input()
#b,c=int(input()),int(input())
c,d=[],[]
for i in a:
c.append(i)
for i in b:
d.append(i)
#e1,e2 = map(int,input().split())
# f = list(map(int,input().split()))
#g = [input() for _ in range(a)]
# h = []
# for i in range(e1):
# h.append(list(map(int,input().split())))
ma=[]
if b in a:
print(0)
else:
for i in range(len(c)-len(d)+1):
count=0
for k in range(len(d)):
if c[i:len(d)+i][k]!=d[k]:
count+=1
ma.append(count)
print(min(ma)) | S=input()
T=input()
lenS=len(S)
lenT=len(T)
count=[]
for i in range(lenS-lenT+1):
c=0
for j in range(lenT):
if T[j]!=S[i+j]:
c=c+1
j=j+1
count.append(c)
i=i+1
print(min(count)) | 1 | 3,713,570,414,670 | null | 82 | 82 |
from collections import Counter
n = int(input())
s = input()
cnt = Counter(s)
ans = cnt["R"]*cnt["G"]*cnt["B"]
for i in range(n):
for j in range(i+1,n):
k = 2*j-i
if k >= n: continue
if s[i] != s[j] and s[i] != s[k] and s[j] != s[k]: ans -= 1
print(ans) | import itertools
def solve():
N = int(input())
S = input()
l = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
p = itertools.product(l,repeat=3)
count = 0
for v in p:
S_temp = S
dig_0_index = S_temp.find(v[0])
if dig_0_index != -1:
S_temp = S_temp[dig_0_index+1::]
dig_1_index = S_temp.find(v[1])
if dig_1_index != -1:
S_temp = S_temp[dig_1_index+1::]
dig_2_index = S_temp.find(v[2])
if dig_2_index != -1:
count += 1
print(count)
if __name__ == "__main__":
solve() | 0 | null | 82,511,916,753,772 | 175 | 267 |
S = input()
if len(S) % 2 != 0:
print("No")
exit(0)
for i in range(len(S) // 2):
s = S[2 * i: 2 * (i + 1)]
if s != "hi":
print("No")
exit(0)
print("Yes") | S=input();
if(S=="hi" or S=="hihi" or S=="hihihi" or S=="hihihihi" or S=="hihihihihi"):
print("Yes");
else:
print("No"); | 1 | 53,288,227,599,490 | null | 199 | 199 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce, lru_cache
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = 10**6#float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
#from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N = INT()
D = [LIST() for _ in range(N)]
cnt = 0
for x, y in D:
if x == y:
cnt += 1
if cnt == 3:
print("Yes")
break
else:
cnt = 0
else:
print("No") | import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
A = list(map(int, readline().split()))
if sum(A) >= 22:
print("bust")
else:
print("win")
if __name__ == '__main__':
main()
| 0 | null | 60,477,332,739,742 | 72 | 260 |
n = int(raw_input())
S = map(int, raw_input().split())
q = int(raw_input())
T = map(int, raw_input().split())
ans = 0
for i in T:
if i in S:
ans += 1
print ans | N = int(input())
A = list(map(int,input().split()))
S = [0] * (N+1)
total = 0
for i in A:
S[i] =S[i]+ 1
for i in S:
total = i * (i - 1) // 2 + total
for i in A:
#print(i,S[i])
a=total-S[i]+1
print(a) | 0 | null | 24,061,058,996,998 | 22 | 192 |
s = list(input())
t = list(input())
cnt = 0
for (s1,t1) in zip(s,t):
if s1 != t1:
cnt += 1
print(cnt) | mojiretsua=input()
mojiretsub=input()
count=0
for i in range(len(mojiretsua)):
if mojiretsua[i] != mojiretsub[i]:
count=count+1
print(count) | 1 | 10,519,745,118,630 | null | 116 | 116 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
n = I()
ab = [LI() for _ in range(n)]
aa = sorted(map(lambda x: x[0], ab))
ba = sorted(map(lambda x: x[1], ab))
if n % 2 == 1:
a = aa[n//2]
b = ba[n//2]
return b - a + 1
a1 = aa[n//2-1]
a2 = aa[n//2]
b1 = ba[n//2-1]
b2 = ba[n//2]
r = b2 - a2
r += b1 - a1
return r + 1
print(main())
| import sys
def input(): return sys.stdin.readline().rstrip()
def main():
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(reverse=True)
q.sort(reverse=True)
r.sort(reverse=True)
p=[10**10]+p[:x]
q=[10**10]+q[:y]
r+=[0]*(a+b)
ans=sum(p)+sum(q)-2*10**10
pcnt,qcnt=0,0
for i in range(x+y):
if p[-1-pcnt] >= r[i] and q[-1-qcnt] >= r[i]:
break
elif p[-1-pcnt] > q[-1-qcnt]:
ans += -q[-1-qcnt] + r[i]
qcnt +=1
else:
ans += -p[-1-pcnt] + r[i]
pcnt +=1
print(ans)
if __name__ == '__main__':
main() | 0 | null | 31,091,635,851,012 | 137 | 188 |
H,V,M=map(int,input().split())
h=[0 for i in range(M)]
w=[0 for i in range(M)]
for i in range(M):
h[i],w[i]=map(int,input().split())
Dh=dict()
Dw=dict()
for i in range(M):
if h[i] in Dh:
Dh[h[i]]+=1
else:
Dh[h[i]]=1
if w[i] in Dw:
Dw[w[i]]+=1
else:
Dw[w[i]]=1
Hmax=0
Wmax=0
for i in Dh:
if Dh[i]>Hmax:
Hmax=Dh[i]
for i in Dw:
if Dw[i]>Wmax:
Wmax=Dw[i]
A=0
B=0
for i in Dh:
if Dh[i]==Hmax:
A+=1
for i in Dw:
if Dw[i]==Wmax:
B+=1
tmp=0
for i in range(M):
if Dh[h[i]]==Hmax and Dw[w[i]]==Wmax:
tmp+=1
if A*B>tmp:
print(Hmax+Wmax)
else:
print(Hmax+Wmax-1)
| def main():
H, W, M = (int(i) for i in input().split())
hc = [0]*(H+1)
wc = [0]*(W+1)
maps = set()
for _ in range(M):
h, w = (int(i) for i in input().split())
hc[h] += 1
wc[w] += 1
maps.add((h, w))
mah = max(hc)
maw = max(wc)
ans = mah+maw
hmaps = []
wmaps = []
for i, h in enumerate(hc):
if mah == h:
hmaps.append(i)
for i, w in enumerate(wc):
if maw == w:
wmaps.append(i)
if M < len(hmaps) * len(wmaps):
# 爆破対象の合計が最大になるマスがM個より多ければ，
# 必ず爆破対象がないマスに爆弾を置くことができる
# 逆にM個以下なら3*10^5のループにしかならないので
# このようにif文で分けなくても，必ずO(M)になるのでelse節のforを回してよい
print(ans)
else:
for h in hmaps:
for w in wmaps:
if (h, w) not in maps:
print(ans)
return
else:
print(ans-1)
if __name__ == '__main__':
main()
| 1 | 4,719,090,049,412 | null | 89 | 89 |
from collections import deque
h,w = map(int,input().split())
maze = []
for _ in range(h):
maze.append(input())
ans = 0
move = [[1,0],[-1,0],[0,1],[0,-1]]
for i in range(h):
for j in range(w):
if(maze[i][j]=="."):
dist = [ [99999999]*w for _ in range(h) ]
dq = deque()
y=i
x=j
d=0
dist[y][x]=0
dq.append((y,x,d))
while(len(dq)):
y,x,d = dq.popleft()
for m in move:
if((0<=x+m[0]<w) and (0<=y+m[1]<h) and
(dist[y+m[1]][x+m[0]] > d+1) and
(maze[y+m[1]][x+m[0]] == ".")):
dist[y+m[1]][x+m[0]]=d+1
dq.append((y+m[1],x+m[0],d+1))
ans = max(ans,d)
# print(d,i,j)
print(ans) | h,w=map(int,input().split())
g=[[*input()] for _ in range(h)]
from collections import *
a=0
for sx in range(h):
for sy in range(w):
if g[sx][sy]=='#': continue
d=[[-1]*w for _ in range(h)]
d[sx][sy]=0
q=deque([(sx,sy)])
while q:
x,y=q.popleft()
t=d[x][y]+1
for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:
nx,ny=x+dx,y+dy
if 0<=nx<h and 0<=ny<w and g[nx][ny]=='.' and d[nx][ny]<0:
d[nx][ny]=t
q.append((nx,ny))
a=max(a,t)
print(a) | 1 | 94,468,044,754,888 | null | 241 | 241 |
def solve(n, k):
ans = 0
mod = int(1e9 + 7)
for i in range(k, n + 2):
lb = (i - 1) * i // 2
ub = (n + n - i + 1) * i // 2
ans += ub - lb + 1
ans %= mod
# print(ub-lb+1, ub, lb, i)
return ans
def main():
# print(solve(3, 2))
# print(solve(200000, 200001))
# print(solve(141421, 35623))
print(solve(*[int(v) for v in input().split()]))
if __name__ == '__main__':
main()
| from itertools import accumulate
# k個選んだ時の最小値と最大値が分かれば、個数が分かる？？
n,k = list(map(int, input().split()))
cumsum = list(accumulate(range(n+1)))
cumsum_r = list(accumulate(range(n+1)[::-1]))
MOD = 10**9 + 7
ans = 0
for i in range(k, n+2):
_min, _max = cumsum[i-1], cumsum_r[i-1]
ans = (ans + _max - _min + 1) % MOD
print(ans) | 1 | 32,952,661,605,600 | null | 170 | 170 |
#基本1つ飛ばしだが、パスも使える。
#奇数ならパス2回、偶数ならパス1回。
N = int(input())
A = [int(hoge) for hoge in input().split()]
DP = [[0]*3 for n in range(N)] #DP[n][y] = n桁目までみて、パスをy回使ったときの最大値
DP[0][0] = A[0]
for n in range(1,N):#n桁目までみる。
#「選ぶ」か「パスを使う」かの2択。
DP[n][0] = DP[n-2][0] + A[n]
DP[n][1] = max((DP[n-2][1]+A[n],DP[n-1][0]))
DP[n][2] = max((DP[n-2][2]+A[n],DP[n-1][1]))
if N%2:
print(DP[n][2])
else:
print(DP[n][1]) | def atc_160b(X: int) -> int:
return X // 500 * 1000 + X % 500 // 5 * 5
X_input = int(input())
print(atc_160b(X_input))
| 0 | null | 39,881,782,045,952 | 177 | 185 |
def resolve():
N = int(input())
A = list(map(int, input().split()))
mp = dict()
ans = 0
for i in range(N):
x = i - A[i]
ans += mp.get(x, 0)
y = A[i] + i
mp[y] = mp.get(y, 0) + 1
print(ans)
if __name__ == "__main__":
resolve() | from collections import defaultdict
n = int(input())
A = list(map(int, input().split()))
cnt = defaultdict(int)
ans = 0
for i, a in enumerate(A):
ans += cnt[i+1 - a]
cnt[i+1 + a] += 1
print(ans) | 1 | 25,940,846,416,492 | null | 157 | 157 |
print(float(input()) * 2.0 * 3.141592653589) | import sys
import math
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inl = lambda: [int(x) for x in sys.stdin.readline().split()]
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
def solve():
a, b, h, m = inl()
t2 = 2 * math.pi * m / 60.0
t1 = 2 * math.pi * (h * 60.0 + m) / (12 * 60.0)
return math.sqrt(a * a + b * b - 2 * a * b * math.cos(t1 - t2))
print(solve())
| 0 | null | 25,668,310,471,412 | 167 | 144 |
N = int(input())
c = [[0 for _ in range(10)] for __ in range(10)]
for x in range(1, N+1):
check = str(x)
it = int(check[0])
jt = int(check[-1])
c[it][jt] += 1
ans = 0
for i in range(0,10):
for j in range(0,10):
ans += c[i][j] * c[j][i]
print(ans)
| import math
import numpy as np
N = int(input())
tb = [[0]*10]*10
tb = np.array(tb)
for i in range(1,N+1):
s = str(i)
tb[int(s[0])][int(s[-1])] =tb[int(s[0])][int(s[-1])] +1
point =0
for i in range(0,10):
for j in range(0,10):
point += tb[i][j] * tb[j][i]
print(point) | 1 | 86,476,018,718,508 | null | 234 | 234 |
n, m = map(int,input().split())
sum = n * (n - 1) / 2 + m * (m - 1) / 2
print(int(sum))
| n,m = map(int,input().split())
ans = 0
if n > 1:
ans += n * (n -1) / 2
if m > 1:
ans += m *(m - 1) / 2
print(int(ans)) | 1 | 45,523,373,835,680 | null | 189 | 189 |
import re
S = input()
rds = list(map(lambda x: len(x), re.findall('R{1,}', S)))
print(max(rds)) if rds else print(0)
| from sys import stdin
def main():
x, y, a, b, c = map(int, stdin.readline().split())
p = list(map(int, stdin.readline().split()))
q = list(map(int, stdin.readline().split()))
r = list(map(int, stdin.readline().split()))
pqr = []
for pi in p:
pqr.append([pi, 0])
for qi in q:
pqr.append([qi, 1])
for ri in r:
pqr.append([ri, 2])
pqr.sort(reverse=True)
ans = 0
c_a = 0
c_b = 0
c_c = 0
for pqri in pqr:
if pqri[1] == 0 and c_a < x:
ans += pqri[0]
c_a += 1
elif pqri[1] == 1 and c_b < y:
ans += pqri[0]
c_b += 1
elif pqri[1] == 2 and (c_a < x or c_b < y) and c_a + c_b + c_c < x + y:
ans += pqri[0]
c_c += 1
if c_a + c_b + c_c == x + y:
print(ans)
exit()
if __name__ == "__main__":
main()
| 0 | null | 24,845,063,536,668 | 90 | 188 |
import math
X = int(input())
for k in range(1, 361):
if (k * X) % 360 == 0:
print(k)
break | from math import gcd
from sys import stdin
N = int(stdin.readline().rstrip())
print(360//gcd(N, 360)) | 1 | 13,053,251,686,912 | null | 125 | 125 |
def gcd(m, n):
x = max(m, n)
y = min(m, n)
if x % y == 0:
return y
else:
while x % y != 0:
z = x % y
x = y
y = z
return z
def lcm(m, n):
return (m * n) // gcd(m, n)
# input
A, B = map(int, input().split())
# lcm
snack = lcm(A, B)
print(snack)
| import math
H = int(input())
W = int(input())
N = int(input())
ans = max([H,W])
fa = N/ans
print(math.ceil(fa)) | 0 | null | 100,699,492,394,170 | 256 | 236 |
import sys
# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
import heapq
import decimal
# import statistics
import queue
# import numpy as np
# sys.setrecursionlimit(10000001)
INF = 10 ** 16
# MOD = 10 ** 9 + 7
MOD = 998244353
def ni(): return int(sys.stdin.readline())
def ns(): return map(int, sys.stdin.readline().split())
def na(): return list(map(int, sys.stdin.readline().split()))
# ===CODE===
class ModCombination:
# https://atcoder.jp/contests/abc167/submissions/13058694
# https://ikatakos.com/pot/programming_algorithm/number_theory/mod_combination
def __init__(self, maxN, MOD):
self._maxN = maxN
self._MOD = MOD
self.facts = [1]
self.invs = [1]*(self._maxN+1)
fact = 1
for i in range(1, self._maxN+1):
fact *= i
fact %= self._MOD
self.facts.append(fact)
inv = pow(fact, self._MOD-2, self._MOD)
self.invs[self._maxN] = inv
for i in range(self._maxN, 1, -1):
inv *= i
inv %= self._MOD
self.invs[i-1] = inv
def nCr(self, n, r):
return self.facts[n]*self.invs[r]*self.invs[n-r] % self._MOD
def main():
n, m, k = ns()
mc = ModCombination(n, MOD)
result = 0
for ki in range(k + 1):
ans = 1
ans *= m % MOD
ans *= pow(m - 1, n - 1 - ki, MOD)
ans %= MOD
ans *= mc.nCr(n-1, ki)
ans %= MOD
result += ans
result %= MOD
print(result)
if __name__ == '__main__':
main()
| n=int(input())
lst={}
for i in range(n):
lst[input()]=1
print(len(lst)) | 0 | null | 26,729,582,235,600 | 151 | 165 |
def solve():
X = [int(i) for i in input().split()]
for i in range(len(X)):
if X[i] == 0:
print(i+1)
break
if __name__ == "__main__":
solve() | import math
N = int(input())
XY = [list(map(int, input().split())) for _ in range(N)]
count = N * (N - 1) // 2
t = 0.0
for i in range(N):
for j in range(i + 1, N):
x1 = XY[i][0]
y1 = XY[i][1]
x2 = XY[j][0]
y2 = XY[j][1]
t += math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
print(t / count * (N - 1)) | 0 | null | 81,289,022,910,208 | 126 | 280 |
N = int(input())
A_list = list(map(int, input().split()))
if A_list[0] > 1:
print(-1)
exit()
elif A_list[0] == 1:
if N == 0:
print(1)
else:
print(-1)
exit()
sumA = sum(A_list)
node = 1
count = 1
for i in range(len(A_list) - 1):
temp = min([node * 2, sumA])
count += temp
node = temp - A_list[i + 1]
if node < 0:
print(-1)
exit()
sumA -= A_list[i + 1]
print(count) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def solve():
def min2(x, y): return x if x <= y else y
N = int(input())
As = list(map(int, input().split()))
if N == 0:
if As[0] == 1:
return 1
else:
return -1
pow2 = 1
pow2s = [pow2]
for d in range(61):
pow2 *= 2
pow2s.append(pow2)
pow2s += [pow2] * N
# print('pow2s:', pow2s)
maxV = min2(1, 1-As[0])
maxVs = [maxV]
for d in range(1, N+1):
maxV = min2(maxV*2, pow2s[d]) - As[d]
maxVs.append(maxV)
# print('maxVs:', maxVs)
numVs = [0] * (N+1)
numVs[N] = As[N]
for d in reversed(range(N)):
# print('\n##### d:', d)
numC2 = -(-numVs[d+1] // 2)
# print('numC2:', numC2)
if maxVs[d] < numC2:
return -1
num = min2(maxVs[d], numVs[d+1])
numVs[d] = As[d] + num
# print('As[d]:', As[d], '/ num:', num, '/ numVs[d]:', numVs[d])
if numVs[d] > pow2s[d]:
return -1
# print('numVs:', numVs)
return sum(numVs)
ans = solve()
print(ans)
| 1 | 18,806,570,232,350 | null | 141 | 141 |
s = input()
t = input()
if (len(t)-len(s)==1) and (t[:-1]==s):
print("Yes")
else:
print("No") | s = list(input())
t = list(input())
t.pop(-1)
for i in range(len(t)):
if s[i] != t[i]:
print('No')
exit()
print('Yes') | 1 | 21,277,215,428,078 | null | 147 | 147 |
import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
import sys
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
C =_S()
#H,N= LI()
#AB = [LI() for _ in range(N)]
#A,B = zip(*AB)
#Ap = np.array(A)
#C = np.zeros(N + 1)
print(chr(ord(C)+1))
# if ans:
# print('Yes')
# else:
# print('No') | num = int(input())
data = list()
for i in range(1,10):
for j in range(1, 10):
data.append(i*j)
if num in data:
print('Yes')
else:
print('No') | 0 | null | 125,794,752,706,910 | 239 | 287 |
l = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
s = input()
for i, day in enumerate(l):
if day == s:
if i == 0:
print(7)
else:
print(7-i) | import sys
card = [ list(map(int,input().split())) for a in range(3) ]
N = int(input())
point = [ int(input()) for a in range(N) ]
# cut holes
for I in point:
for J in card:
if I in J:
J.index(I)
J[J.index(I)] = "H"
# vertical check
for K in range(3):
check = set([ x[K] for x in card ])
if len(check) == 1 and list(check)[0] == "H":
print('Yes')
sys.exit()
# horizon check
for L in card:
check = set(L)
if len(check) == 1 and list(check)[0] == "H":
print('Yes')
sys.exit()
# diagonal check
LtoR = set([ card[M][M] for M in range(3)])
RtoL = set([ card[M][-M-1] for M in range(3)])
if len(LtoR) == 1 and list(LtoR)[0] == "H" or len(RtoL) == 1 and list(RtoL)[0] == "H":
print('Yes')
sys.exit()
print('No') | 0 | null | 96,463,247,515,644 | 270 | 207 |
data = []
while 1:
H, W = map(int, raw_input().split())
if H == 0 and W == 0:
break
data.append([H, W])
for h, w in data:
for i in xrange(h):
print '#' * w
print | while True:
H,W = (int(x) for x in input().split())
if H == 0 and W == 0:
break
i = 0
while i < H:
j = 0
while j < W:
print ("#", end='')
j += 1
print ('')
i += 1
print ('')
| 1 | 780,564,759,820 | null | 49 | 49 |
#それぞれの桁を考えた時にその桁を一つ多めに払うのかちょうどで払うのかで場合分けする
n=[int(x) for x in list(input())]#それぞれの桁にアクセスするためにイテラブルにする
k=len(n)
#それぞれの桁を見ていくが、そのままと一つ多い状態から引く場合と二つあることに注意
dp=[[-1,-1] for _ in range(k)]
dp[0]=[min(1+(10-n[0]),n[0]),min(1+(10-n[0]-1),n[0]+1)]
for i in range(1,k):
dp[i]=[min(dp[i-1][1]+(10-n[i]),dp[i-1][0]+n[i]),min(dp[i-1][1]+(10-n[i]-1),dp[i-1][0]+n[i]+1)]
print(dp[k-1][0]) | def main():
N = list(map(int, list(input())))
N = N[::-1] + [0]
ans = 0
for i in range(len(N)-1):
if N[i] < 5:
ans += N[i]
elif N[i] > 5:
ans += 10 - N[i]
N[i+1] += 1
else:
ans += 5
if N[i+1] >= 5:
N[i+1] += 1
print(ans + N[len(N)-1])
main() | 1 | 70,876,318,283,020 | null | 219 | 219 |
while True:
m,f,r=map(int,input().split())
p=m+f
if m+f+r==-3:
break
if m==-1 or f==-1:
print("F")
elif p>=80:
print("A")
elif 65<=p and p<80:
print("B")
elif 50<=p and p<65:
print("C")
elif 30<=p and p<50:
if r>=50:
print("C")
else:
print("D")
else:
print("F") | K=int(input())
L=len(input())
from numba import*
@njit(cache=1)
def f():
m=10**9+7
max_n=2*10**6
fac=[1]*(max_n+1)
inv=[1]*(max_n+1)
ifac=[1]*(max_n+1)
for n in range(2,max_n+1):
fac[n]=(fac[n-1]*n)%m
inv[n]=m-inv[m%n]*(m//n)%m
ifac[n]=(ifac[n-1]*inv[n])%m
d=[1]*(K+1)
d2=[1]*(K+1)
for i in range(K):
d[i+1]=d[i]*25%m
d2[i+1]=d2[i]*26%m
a=0
for i in range(K+1):
a=(a+fac[L+i-1]*ifac[i]%m*ifac[L-1]%m*d[i]%m*d2[K-i]%m)%m
return a
print(f()) | 0 | null | 6,993,540,626,472 | 57 | 124 |
N = int(input())
S = []
T = []
for _ in range(N):
s, t = input().split()
S.append(s)
T.append(int(t))
ind = S.index(input())
ans = sum(T[ind+1:])
print(ans)
| N=int(input())
S=["a"]*N
T=[0]*N
for i in range(N):
S[i],T[i]=input().split()
X=input()
flag=0
x=0
for i in range(N):
if flag==1:
x+=int(T[i])
elif X==S[i]:
flag=1
print(x)
| 1 | 97,298,223,631,248 | null | 243 | 243 |
def report(k, r):
print('{} x {}'.format(k, r[k]))
ans = {'AC': 0, 'WA': 0, 'TLE': 0, 'RE': 0}
N = int(input().rstrip())
for i in range(N):
S = input().rstrip()
ans[S] += 1
report('AC', ans)
report('WA', ans)
report('TLE', ans)
report('RE', ans)
| from collections import deque
def init_tree(x, par):
for i in range(x + 1):
par[i] = i
def find(x, par):
q = deque()
q.append(x)
while len(q) > 0:
v = q.pop()
if v == par[v]:
return v
q.append(par[v])
def union(x, y, par, rank):
px, py = find(x, par), find(y, par)
if px == py:
return
if rank[px] < rank[py]:
par[px] = py
return
elif rank[px] == rank[py]:
rank[px] += 1
par[py] = px
n, m, k = map(int, input().split())
par = [0] * (n + 1)
rank = [0] * (n + 1)
init_tree(n, par)
eg = [[] for _ in range(n + 1)]
for _ in range(m):
a, b = map(int, input().split())
union(a, b, par, rank)
eg[a].append(b)
eg[b].append(a)
for _ in range(k):
a, b = map(int, input().split())
eg[a].append(b)
eg[b].append(a)
xs = [0] * (n + 1)
ys = [0] * (n + 1)
for i in range(1, n + 1):
p = find(i, par)
xs[p] += 1
for v in eg[i]:
if p == find(v, par):
ys[i] += 1
ans = [-1] * (n + 1)
for i in range(1, n + 1):
ans[i] += xs[find(i, par)] - ys[i]
ans = [-1] * (n + 1)
for i in range(1, n + 1):
ans[i] += xs[find(i, par)] - ys[i]
print(*ans[1:])
| 0 | null | 35,199,325,348,880 | 109 | 209 |
from math import pi
r = float(input())
circle_squre = r * r * pi
circle_length = (r*2) * pi
print('{}'.format(circle_squre),'{}'.format(circle_length)) | import math
r = input()
print("%f %f" % (math.pi*r**2, 2*math.pi*r)) | 1 | 636,694,230,432 | null | 46 | 46 |
from collections import deque
que = deque()
l = input()
S = 0
S2 = []
for j in range(len(l)):
i = l[j]
if i == '\\':
que.append(j)
continue
elif i == '/':
if len(que) == 0:
continue
k = que.pop()
pond_sum = j-k
S += pond_sum
while S2 and S2[-1][0] > k:
pond_sum += S2[-1][1]
S2.pop()
S2.append([k,pond_sum])
elif i == '_':
continue
data = [i for j,i in S2]
print(S)
print(len(S2),*data)
| import math
def main():
R = input_int()
print(R * 2 * math.pi)
def input_int():
return int(input())
def input_ints():
return map(int, input().split())
def input_int_list_in_line():
return list(map(int, input().split()))
def input_int_tuple_list(n: int, q: int):
return [tuple(map(int, input().split())) for _ in range(n)]
main()
| 0 | null | 15,714,555,105,640 | 21 | 167 |
def solve(N):
N = [0] + N
k = 0 # 繰り上がり
ans = 0
for d, d_next in zip(N[::-1], N[-2::-1]):
d += k
if d <= 4 or (d==5 and d_next<5):
k = 0
ans += d
else:
k = 1
ans += 10 - d
if k:
ans += 1
return ans
def test(N, ans):
for i in range(N, 10000):
rem = i - N
if sum(map(int, str(i))) + sum(map(int, str(rem))) < ans:
print(f"!!! N={N}, ans={ans}, trueans={i, rem}")
def main():
N = list(map(int, input()))
print(solve(N))
# for i in range(1, 10000):
# ans = solve(list(map(int, str(i))))
# test(i, ans)
main()
| cards = [[0 for i in range(13)] for j in range(4)]
n = int(input())
for i in range(n):
card = list(input().split())
card[1] = int(card[1])
if card[0] == 'S':
suit = 0
elif card[0] == 'H':
suit = 1
elif card[0] == 'C':
suit = 2
elif card[0] == 'D':
suit = 3
cards[suit][card[1]-1] = 1
for i in range(4):
if i == 0:
suit = 'S'
elif i == 1:
suit = 'H'
elif i == 2:
suit = 'C'
elif i == 3:
suit = 'D'
for j in range(13):
if not(cards[i][j]):
print(suit, j+1) | 0 | null | 35,778,250,376,960 | 219 | 54 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
plus = []
minus = []
for i in a:
if i >= 0: plus.append(i)
if i < 0: minus.append(-i)
plus.sort(reverse=True)
minus.sort(reverse=True)
ans = 1
if k == n:
for x in a:
ans = (ans * x) % mod
elif n == len(plus):
for x in plus[:k]:
ans = (ans * x) % mod
elif n == len(minus):
if k % 2 == 1:
ans = -1
minus.sort()
for x in minus[:k]:
ans = (ans * x) % mod
else:
i, j = 0, 0
if k % 2 == 1:
ans = plus[0]
i += 1
while i + j != k:
x_p = plus[i] * plus[i + 1] if i < len(plus) - 1 else 0
x_m = minus[j] * minus[j + 1] if j < len(minus) - 1 else 0
if x_p > x_m:
ans = (ans * x_p) % mod
i += 2
else:
ans = (ans * x_m) % mod
j += 2
print(ans) | #!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
"""
N, K = LI()
A = LI()
def abssort(A):
return sorted(A, key = lambda x:abs(x), reverse= True)
tmps = []
A_abs = abssort(A)
cnt = 0
while len(tmps) > K:
# for i in range(K):
if A_abs[cnt] != 0:
tmps.append(A_abs[i])
cnt += 1
cnt = 0
for i in range(K):
if tmps[i] < 0:
cnt += 1
if cnt % 2 == 0:
ans = 1
for i in range(K):
ans *= tmps[i]
ans = ans % mod
print(ans)
sys.exit()
else:
tmp_1 = copy.deepcopy(tmps)
tmp_2 = copy.deepcopy(tmps)
tmp_1.reverse()
tmp_2.reverse()
tmp_2_ = 0
tmp_1_ = 0
# -を一つ消す
for i in range(K):
if tmp_1[i] < 0:
tmp_1.remove(tmp_1[i])
break
# + を一つたす
for i in range(K, N):
if A_abs[i] > 0:
tmp_1.append(A_abs[i])
tmp_1_ = 1
break
else:
# +がなかった時
tmp_1 = []
tmp_1_ = -1
A_abs.reverse()
for i in range(K):
tmp_1.append(A_abs[i])
# +を消して-を追加
cnt = 0
for i in range(K):
if tmp_2[i] > 0:
tmp_2.remove(tmp_2[i])
cnt += 1
break
if cnt == 1:
for i in range(K, N):
if A_abs[i] < 0:
tmp_2.append(A_abs[i])
tmp_2_ = 1
break
else:
tmp_2_ = 0
else:
tmp_2_ = -1
# print(tmp_1, tmp_2)
tmp_1_m = 1
tmp_2_m = 1
for i in range(K):
tmp_1_m *= tmp_1[i]
tmp_1_m = tmp_1_m % mod
if tmp_2_ == 0:
pass
else:
for i in range(K):
tmp_2_m *= tmp_2[i]
tmp_2_m = tmp_2_m % mod
# print(tmp_1_, tmp_2_)
if tmp_2_ == 0:
print(tmp_1_m)
elif tmp_1_ == 1 and tmp_2_ == -1:
print(tmp_1_m)
elif tmp_1_ == -1 and tmp_2_ == 1:
print(tmp_2_m)
elif tmp_1_ == 1 and tmp_2_ == 1:
for i in range(K):
if tmp_1[i] == tmp_2[i]:
pass
elif abs(tmp_1[i]) > abs(tmp_2[i]):
print(tmp_2_m)
sys.exit()
else:
print(tmp_1_m)
sys.exit()
else:
print(tmp_1_m)
# for i in range(K):
# if tmp_1[i] == tmp_2[i]:
# pass
# elif abs(tmp_1[i]) > abs(tmp_2[i]):
# print(tmp_2_m)
# sys.exit()
# else:
# print(tmp_1_m)
# sys.exit()
"""
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
# 正負に関係なくsort
A_abs = sorted(A, key = lambda x:abs(x))
A_p = [] # plusを入れる
A_n = [] # -を入れる
for i in range(N):
if A[i] < 0:
A_n.append(A[i])
else:
A_p.append(A[i])
A_n.sort()
A_p.sort(reverse = True)
ok = True
if len(A_p) > 0:
# 正の数が存在している
if N == K:
# 選択肢がない時
ok = (len(A_n) % 2 == 0)
# 負の数が偶数個
else:
ok = True
else:
ok = (K % 2 == 0)
ans = 1
if ok == False:
for i in range(K):
ans *= A_abs[i]
ans = ans % mod
else:
if K % 2 == 1:
# 奇数個選ぶ
ans *= A_p[0]
ans = ans % mod
A_p = A_p[1:]
position = 0
pairs = []
cnt_p = len(A_p)
cnt_n = len(A_n)
while cnt_p - position > 1:
pairs.append(A_p[position] * A_p[position + 1])
position += 2
position = 0
while cnt_n - position > 1:
pairs.append(A_n[position] * A_n[position + 1])
position += 2
pairs.sort(reverse=True)
for i in range(K // 2):
ans *= pairs[i]
ans = ans % mod
print(ans)
| 1 | 9,415,001,811,918 | null | 112 | 112 |
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
ans = [0] * N
for a_i in A:
ans[a_i-1] += 1
for a in ans:
print(a) | N = int(input())
result = [0] * (N + 1)
for i in list(map(int, input().split())):
result[i] += 1
result.pop(0)
for r in result:
print(r)
| 1 | 32,642,730,468,700 | null | 169 | 169 |
def num2alpha(num):
if num<=26:
return chr(64+num)
elif num%26==0:
return num2alpha(num//26-1)+chr(90)
else:
return num2alpha(num//26)+chr(64+num%26)
print(num2alpha(int(input())).lower()) | def num2alpha(num):
if num<=26:
return chr(64+num)
elif num%26==0:
return num2alpha(num//26-1)+chr(90)
else:
return num2alpha(num//26)+chr(64+num%26)
n = int(input())
ans = num2alpha(n)
print(ans.lower()) | 1 | 11,895,960,269,550 | null | 121 | 121 |
n=int(input())
a=list(map(int,input().split()))
m=max(a)
b=[0]
b*=m
for i in range(n):
b[a[i]-1]+=1
c=[]
for i in range(m):
if b[i]>=2:
c.append(int(b[i]*(b[i]-1)/2))
else:
c.append(0)
d=sum(c)
for i in range(n):
if c[a[i]-1]>=1:
e=c[a[i]-1]-int((b[a[i]-1]-1)*(b[a[i]-1]-2)/2)
print(d-e)
else:
print(d)
| def resolve():
N = int(input())
A = list(map(int, input().split()))
import collections
counter = collections.Counter(A)
total = 0
for k, v in counter.items():
total += v*(v-1)//2
for a in A:
cnt = counter[a]
cntm1 = cnt - 1
print(total - cnt*(cnt-1)//2 + cntm1*(cntm1-1)//2)
if '__main__' == __name__:
resolve() | 1 | 47,875,346,166,560 | null | 192 | 192 |
import collections
N = int(input())
L = [input() for i in range(N)]
c = collections.Counter(L)
max_L = max(list(c.values()))
keys = [k for k, v in c.items() if v == max_L]
keys.sort()
for key in keys:
print(key)
| print(*sorted([int(input()) for _ in [0]*10])[:6:-1], sep="\n") | 0 | null | 35,094,261,086,428 | 218 | 2 |
def main():
S = list(input())
cnt = 0
for i in range(int(len(S) / 2)):
if S[i] != S[-i - 1]:
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| S = str(input())
N = len(S)
half = (N+1) // 2
ans = 0
for i in range(half):
if S[i] != S[N-1-i]:
ans += 1
print(ans) | 1 | 120,237,640,046,132 | null | 261 | 261 |
H = int(input())
i=0
count=0
while(H>0):
H=H//2
count += 2**i
i+=1
print(count) | c= int(input())
ans =0
s = 0
while c >1:
c = c//2
ans += 1
for i in range(1,ans+1):
s += 2**i
print(s+1) | 1 | 80,168,563,945,234 | null | 228 | 228 |
N = int(input())
XY = []
points = []
for i in range(N):
points.append(i)
x, y = list(map(int, input().split()))
XY.append((x, y))
import math
import itertools
count = math.factorial(N)
line = 0
for pp in itertools.permutations(points, N):
i = 0
while i < N - 1:
i1, i2 = pp[i], pp[i + 1]
t = ((XY[i1][0] - XY[i2][0]) ** 2 + (XY[i1][1] - XY[i2][1]) ** 2) ** 0.5
line += t
i += 1
ans = line / count
print(ans)
| while True:
h, w = map(int, raw_input().split())
if (h == 0) & (w == 0):
break
line = ""
for j in range(w):
line += "#"
for i in range(h):
print line
print "" | 0 | null | 74,279,151,602,252 | 280 | 49 |
N, *A = map(int, open(0).read().split())
mod = 10**9 + 7
ans = 0
for i in range(60):
mask = 1 << i
cnt = 0
for a in A:
if a & mask:
cnt += 1
x = cnt * (N-cnt)
x *= mask % mod
ans += x
ans %= mod
print(ans)
| N=str(input())
NN=0
for i in range(len(N)):
NN=NN+int(N[i])
if NN%9==0:print('Yes')
else:print('No') | 0 | null | 64,027,553,057,230 | 263 | 87 |
n = list(map(int, list(input())))
n_sum = sum(n)
print("Yes" if n_sum % 9 == 0 else "No") | n=int(input())
s=0
for i in str(n):
s+=int(i)
if(s%9==0):
print("Yes")
else:
print("No") | 1 | 4,413,379,263,902 | null | 87 | 87 |
x=int(input())
for i in range(1001):
for j in range(100*i,105*i+1):
if x==j:
print(1)
exit(0)
print(0) | class Cmb:
def __init__(self, N, mod=10**9+7):
self.fact = [1,1]
self.fact_inv = [1,1]
self.inv = [0,1]
""" 階乗を保存する配列を作成 """
for i in range(2, N+1):
self.fact.append((self.fact[-1]*i) % mod)
self.inv.append((-self.inv[mod%i] * (mod//i))%mod)
self.fact_inv.append((self.fact_inv[-1]*self.inv[i])%mod)
""" 関数として使えるように、callで定義 """
def __call__(self, n, r, mod=10**9+7):
if (r<0) or (n<r):
return 0
r = min(r, n-r)
return self.fact[n] * self.fact_inv[r] * self.fact_inv[n-r] % mod
n,k = map(int,input().split())
mod = 10**9+7
c = Cmb(N=n)
ans = 0
for l in range(min(k+1, n)):
tmp = c(n,l)*c(n-1, n-l-1)
ans += tmp%mod
print(ans%mod) | 0 | null | 97,388,405,532,010 | 266 | 215 |
from collections import deque
n = int(input())
answer = deque()
for i in range(n):
command = input()
if " " in command:
command, key = command.split()
if command == "insert":
answer.appendleft(key)
elif command == "delete":
if key in answer:
answer.remove(key)
elif command == "deleteFirst":
answer.popleft()
elif command == "deleteLast":
answer.pop()
print(*answer)
| from collections import deque
n = int(input())
dll = deque([])
for _ in range(n):
p = input().split()
if p[0] == "insert":
dll.appendleft(p[1])
elif p[0] == "delete":
try:
dll.remove(p[1])
except:
pass
elif p[0] == "deleteFirst":
dll.popleft()
else:
dll.pop()
print(" ".join(dll))
| 1 | 52,981,939,010 | null | 20 | 20 |
# ABC152
a, b = map(int, input().split())
print(min(str(a)*b, str(b)*a))
| input_line=input().rstrip().split()
num1 = int(input_line[0])
num2 = int(input_line[1])
if (num1 > num2):
print(str(num2)*num1)
elif (num1 < num2):
print(str(num1)*num2)
elif (num1 == num2):
print(str(num1)*num2) | 1 | 84,455,678,452,262 | null | 232 | 232 |
a,b,c=input().split()
if a==b and a!=c:
print("Yes")
elif a==c and a!=b:
print("Yes")
elif b==c and a!=b:
print("Yes")
else:
print("No") | print('Yes' if len(set(map(int, input().split()))) == 2 else 'No')
| 1 | 68,027,828,781,572 | null | 216 | 216 |
S = input()
bb = 'x'*len(S)
print(bb)
| import os, sys, re, math
(N, K) = [int(n) for n in input().split()]
d = 0
a = K ** 0
while a <= N:
d += 1
a *= K
print(d)
| 0 | null | 68,537,984,189,248 | 221 | 212 |
def gcd(a,b):
a,b=max(a,b),min(a,b)
return a if b==0 else gcd(b,a%b)
x=int(input())
g=gcd(360,x)
print(360//g) | X=int(input())
for i in range(1,180):
if (i*360%X==0):
print((i*360)//X)
exit() | 1 | 13,214,215,796,968 | null | 125 | 125 |
#
import sys
input=sys.stdin.readline
def main():
N=input().strip("\n")
K=int(input())
# dp[i][j][k]=i桁目 j: nonzero数 k:N以下確定か
dp=[[[0]*(2) for i in range(K+1)] for j in range(len(N))]
dp[0][0][1]=1
dp[0][1][1]=int(N[0])-1
dp[0][1][0]=1
for i in range(len(N)):
dp[i][0][1]=1
for i in range(1,len(N)):
d=int(N[i])
for j in range(1,K+1):
if d!=0:
dp[i][j][1]=dp[i-1][j-1][1]*9+dp[i-1][j-1][0]*(d-1)
# nonzeroを使う場合i-1で既にN以下確定なら好き勝手できる*9
dp[i][j][1]+=dp[i-1][j][1]+dp[i-1][j][0]
# zeroを使う場合
dp[i][j][0]=dp[i-1][j-1][0]
# d未満とったら確定するため。
else:
dp[i][j][1]=dp[i-1][j-1][1]*9+dp[i-1][j][1]
dp[i][j][0]=dp[i-1][j][0]
print(sum(dp[len(N)-1][K]))
if __name__=="__main__":
main()
| N = input()
K = int(input())
# K = 1の時の組み合わせを求める関数
def func_1(N):
Nm = int(N[0])
return Nm + 9 * (len(N) - 1)
# K = 2の時の組み合わせを求める関数
def func_2(N):
#NはStringなので
#print(N[0])
Nm = int(N[0])
m = len(N)
#if m == 1:
# print("0")
#print((Nm-1)*(m-1)*9)
#print((m - 1) * (m - 2) * 9 * 9 / 2)
x = int(N) - Nm * pow(10, m-1)
#print(x)
#print(1)
#print(func_1(str(x)))
return int((Nm-1)*(m-1)*9+(m-1)*(m-2)*9*9/2+func_1(str(x)))
def func_3(N):
#print("OK")
Nm = int(N[0])
m = len(N)
# if m == 1 or m == 2:
# print("0")
return int(pow(9,3)*(m-1)*(m-2)*(m-3)/6+(Nm-1)*(m-1)*(m-2)*9*9/2+func_2(str(int(N)-Nm*(10**(m-1)))))
if K == 1:
print(func_1(N))
elif K == 2:
print(func_2(N))
elif K == 3:
print(func_3(N)) | 1 | 76,202,083,101,138 | null | 224 | 224 |
n = int(input())
ans = 0
ans += n // 500 * 1000
n %= 500
ans += n // 5 * 5
print(ans)
| x=int(input())
y=x//500*1000+(x%500)//5*5
print(y) | 1 | 42,909,683,397,892 | null | 185 | 185 |
def main(S, T):
if len(S)+1 == len(T) and S == T[:-1]:
return 'Yes'
else:
return 'No'
if __name__ == '__main__':
S = input()
T = input()
ans = main(S, T)
print(ans)
| A,B,M=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
m=10**6
for i in range(M):
x,y,z=map(int,input().split())
m=min(a[x-1]+b[y-1]-z,m)
print(min(m,min(a)+min(b))) | 0 | null | 37,838,730,128,472 | 147 | 200 |
a,b,*cc = map(int, open(0).read().split())
if sum(cc) >= a:
print('Yes')
else:
print('No') | H, N = map(int, input().split())
A = list(map(int, input().split()))
if H - sum(A) <= 0:
print("Yes")
else:
print("No") | 1 | 77,982,346,387,892 | null | 226 | 226 |
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 998244353
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, K = LI()
LR = [LI() for _ in range(K)]
dp = [0] * (N + 1)
dp[0] = 1
a = [0] * (N + 1)
a[0] = 1
a[1] = -1
for i in range(N):
for l, r in LR:
left = min(i + l, N)
right = min(i + r + 1, N)
a[left] += dp[i]
a[right] -= dp[i]
dp[i+1] += dp[i] + a[i+1]
dp[i+1] %= MOD
# print(a)
# print(dp)
print(dp[-2])
if __name__ == '__main__':
resolve()
| def kaibun(moji):
n = len(moji)
for i in range(0,int(n/2)):
if s[i]!=s[n-1-i]:
return False
return True
s = str(input())
n = len(s)
moji1 = int((n - 1) / 2)
moji2 = int((n + 3) / 2)
#print(s[:moji1])
#print(s[moji2-1:])
if kaibun(s) and kaibun(s[:moji1]) and kaibun(s[moji2-1:]):
print('Yes')
else:
print('No') | 0 | null | 24,536,036,458,472 | 74 | 190 |
def maximumProfit(A, N):
minR = A[0]
minP = A[1] - A[0]
for i in range(1, N):
R = A[i] - minR
if R > minP:
minP = R
if A[i] < minR:
minR = A[i]
return minP
if __name__ == "__main__":
N = input()
A = []
for i in range(N):
A.append(input())
print maximumProfit(A, N) | N=int(input())
A=sorted(list(map(int,input().split())))
m=A[-1]
dp=[True]*m
ans,p,q=0,0,False
for a in A:
if p==a and q:
ans-=1
q=False
if dp[a-1]:
p,q=a,True
ans+=1
aa=a
while m>=aa:
dp[aa-1]=False
aa+=a
print(ans) | 0 | null | 7,246,406,515,190 | 13 | 129 |
list1 = range(1,10)
list2 = list1
for i in list1 :
for j in list2 :
print str(i) + "x" + str(j) + "=" + str(i*j) | for x in range(1, 10):
for y in range(1, 10):
print('%dx%d=%d' % (x,y,x*y)) | 1 | 1,157,732 | null | 1 | 1 |
from math import tan, pi, degrees
a, b, x = map(int, input().split())
def solve(isOK):
ng, ok = pi/2, 0
while abs(ok-ng) > 10**-12:
mid = (ng+ok) / 2
if isOK(mid):
ok = mid
else:
ng = mid
# print('ok:', ok)
print(degrees(ok))
def isOK1(theta):
return a*a*tan(theta)/2 + x/a <= a*b
def isOK2(theta):
return b*b/tan(theta)/2 >= x/a
if x/a >= a*b/2:
solve(isOK1)
else:
solve(isOK2)
| #input
X, N = map(int, input().split())
p = list(map(int, input().split()))
if len(p) == 0 or X < min(p) or X > max(p):
print(X)
exit()
min = X
max = X
while True:
if min not in p:
print(min)
break
elif max not in p:
print(max)
break
else:
min -= 1
max += 1
| 0 | null | 88,811,628,766,042 | 289 | 128 |
MOD = 998244353
N, M, K = map(int, input().split())
fac = [1] * N
for i in range(1, N):
fac[i] = (fac[i - 1] * i) % MOD
pow_mmm = [1] * N
for i in range(1, N):
pow_mmm[i] = (pow_mmm[i - 1] * (M - 1)) % MOD
ans = 0
for i in range(K + 1):
t = (M * pow_mmm[N - 1 - i]) % MOD
comb = (fac[N - 1] * pow(fac[N - 1 - i], MOD - 2, MOD) * pow(fac[i], MOD - 2, MOD)) % MOD
t = (t * comb) % MOD
ans = (ans + t) % MOD
print(ans) | def combs_mod(n,k,mod):
#nC0からnCkまで
inv = [1]*(k+1)
for i in range(1,k+1):
inv[i] = pow(i,mod-2,mod)
ans = [1]*(k+1)
for i in range(1,k+1):
ans[i] = ans[i-1]*(n+1-i)*inv[i]%mod
return ans
def solve():
ans = 0
mod = 998244353
N, M, K = map(int, input().split())
top = min(K,N-1)
combs = combs_mod(N-1,top,mod)
for k in range(top+1):
ans += M*combs[k]*pow(M-1,N-1-k,mod)
ans %= mod
return ans
print(solve()) | 1 | 23,218,935,483,068 | null | 151 | 151 |
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))
from collections import Counter
h,w,m=nii()
h_bomb=[0 for i in range(h)]
w_bomb=[0 for i in range(w)]
l=set()
for i in range(m):
th,tw=nii()
th-=1
tw-=1
h_bomb[th]+=1
w_bomb[tw]+=1
l.add((th,tw))
h_max=max(h_bomb)
w_max=max(w_bomb)
h_cand=[]
w_cand=[]
for i in range(len(h_bomb)):
if h_bomb[i]==h_max:
h_cand.append(i)
for i in range(len(w_bomb)):
if w_bomb[i]==w_max:
w_cand.append(i)
for i in h_cand:
for j in w_cand:
if (i,j) not in l:
print(h_max+w_max)
exit()
print(h_max+w_max-1)
| H,W,M=map(int,input().split())
nh=[0]*H
nw=[0]*W
boms=set()
for _ in range(M):
h,w=map(int,input().split())
nh[h-1] += 1
nw[w-1] += 1
boms.add((h-1, w-1))
maxh = max(nh)
maxw = max(nw)
i_indexes=[]
for i in range(H):
if nh[i] == maxh:
i_indexes.append(i)
j_indexes=[]
for j in range(W):
if nw[j] == maxw:
j_indexes.append(j)
for i in i_indexes:
for j in j_indexes:
if (i,j) in boms:
continue
print(maxh + maxw)
exit()
print(maxh + maxw - 1) | 1 | 4,690,502,646,284 | null | 89 | 89 |
s=input()
t=input()
if len(s)+1 == len(t):
if s==t[:len(s)]:
print("Yes")
exit()
print("No") | #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() | 1 | 21,326,592,473,302 | null | 147 | 147 |
# -*- coding: utf-8 -*-
def bubbleSort(num_list):
flag = True
length = len(num_list)
count = 0
while flag:
flag = False
for j in range(length-1, 0, -1):
if num_list[j] < num_list[j-1]:
num_list[j], num_list[j-1] = num_list[j-1], num_list[j]
flag = True
count += 1
return num_list, count
input_num = int(input())
num_list = [int(i) for i in input().split()]
bubble_list, swap_num = bubbleSort(num_list)
for i in range(len(num_list)):
if i > 0:
print(" ", end="")
print(num_list[i], end="")
print()
print(swap_num) | n = input()
a, b = input().split(" ")
output = ""
for s, t in zip(a, b):
output += s
output += t
print(output) | 0 | null | 56,168,501,687,720 | 14 | 255 |
#!/usr/bin/env python3
import collections as cl
import sys
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def main():
_a, _b = input().split()
a = _a * int(_b)
b = _b * int(_a)
print(a if a < b else b)
main()
| import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N = int(input())
As = [[0]*10 for _ in range(10)]
for i in range(1, N+1):
s = str(i)
first = int(s[0])
end = int(s[-1])
As[first][end] += 1
ans = 0
for i in range(10):
for j in range(10):
a = As[i][j]
b = As[j][i]
ans += a*b
print(ans) | 0 | null | 85,761,121,147,740 | 232 | 234 |
n = int(input())
ans = float('inf')
for i in range(1, int(n**0.5)+1):
if n%i == 0:
j = n//i
ans = min(ans, i-1+j-1)
print(ans) | s=input()
print('YNeos'[s[2]!=s[3] or s[4]!=s[5]::2]) | 0 | null | 102,097,798,280,060 | 288 | 184 |
from bisect import bisect_left,insort_left
n=int(input())
s=list(input())
lindex=[[] for _ in range(26)]
for i in range(n):
lindex[ord(s[i])-97].append(i)
q=int(input())
for i in range(q):
q1,q2,q3=input().split()
if q1=='1':
q2=int(q2)-1
idx=bisect_left(lindex[ord(s[q2])-97],q2)
if s[q2]!=q3:
del lindex[ord(s[q2])-97][idx]
insort_left(lindex[ord(q3)-97],q2)
s[q2]=q3
else:
l=int(q2)-1
r=int(q3)-1
cnt=0
for j in range(26):
if len(lindex[j])==0:
continue
idx=bisect_left(lindex[j],l)
if len(lindex[j])>idx and lindex[j][idx]<=r:
cnt+=1
print(cnt) | def main():
t1,t2=map(int,input().split())
a1,a2=map(int,input().split())
b1,b2=map(int,input().split())
if a1<b1:
a1,b1,a2,b2 = b1,a1,b2,a2
d1 = a1*t1
d2 = b1*t1
dd1 = d1 - d2
d1 += a2*t2
d2 += b2*t2
if d1 == d2:
return "infinity"
dd2 = d1 - d2
if dd1 * dd2 > 0:
return 0
else:
d1 += a1*t1
d2 += b1*t1
dd3 = d1 - d2
if dd2 * dd3 > 0:
return 1
else:
d1 += a2*t2
d2 += b2*t2
dd4 = d1 - d2
if dd3 * dd4 > 0:
return 2
else:
if dd1 > dd3:
if dd1 % (dd1-dd3) == 0:
return (dd1 // (dd1-dd3) )*2
else:
return (dd1 // (dd1-dd3) )*2+1
else:
if dd2 % (dd2-dd4) == 0:
return (dd2 // (dd2-dd4) )*2 +1
else:
return (dd2 // (dd2-dd4) )*2+2
print(main()) | 0 | null | 96,845,074,174,680 | 210 | 269 |
N = int(input())
X = input()
n1 = X.count("1")
Xn = int(X, 2)
Xms = (Xn % (n1 - 1)) if n1 > 1 else 0
Xml = Xn % (n1 + 1)
def f(n):
if n == 0:
return 0
return f(n % bin(n).count("1")) + 1
dp = [0] * ((10 ** 5) * 2 + 1)
for i in range(1, len(dp)):
dp[i] = f(i)
for i in range(N):
cnt = 0
Xim = 0
if X[i] == "1" and n1 == 1:
print(cnt)
elif X[i] == "1":
print(dp[(Xms - pow(2, N - i - 1, n1 - 1)) % (n1 - 1)] + 1)
else:
print(dp[(Xml + pow(2, N - i - 1, n1 + 1)) % (n1 + 1)] + 1)
| n = int(input())
a = list(map(int, input().split()))
a.sort()
ls = [1] * (10 ** 6 + 1)
cnt = [0] * (10 ** 6 + 1)
for i in range(n):
cnt[a[i]] += 1
if cnt[a[i]] == 1:
if ls[a[i]] == 1:
for j in range(a[i] * 2, 10 ** 6 + 1, a[i]):
ls[j] = 0
ans = 0
for i in range(n):
if ls[a[i]] == 1 and cnt[a[i]] == 1:
ans += 1
print(ans)
| 0 | null | 11,276,761,818,752 | 107 | 129 |
from fractions import gcd
from functools import reduce
def lcm(a,b): # lcmは標準ライブラリには存在しない
return a * b // gcd(a,b)
def ls_lcm(A): # リストを引数に取れる
return reduce(lcm ,A)
def ls_gcd(A): # リストを引数に取れる
return reduce (gcd, A)
def count_two(n): # 2で割れる回数を取得
cnt = 0
while(n & 1 == 0): # 最下位ビットが0かどうか
cnt += 1
n = n >> 1 # 右ビットシフト
return cnt
N, M = map(int, input().split())
A = list(map(int, input().split()))
if len(set([count_two(a) for a in A])) != 1:
print (0)
exit()
A = [a//2 for a in A] # a_k/2 を考える
lc = ls_lcm(A)
print ((M + lc) // (2*lc)) # 最小公倍数を奇数倍したものが条件を満たす
| import math
import collections
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 LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
n,m=MI()
A=LI()
def num2(x):
ans=0
while x%2==0:
x=x//2
ans+=1
return ans
mod=2**(num2(A[0]))
for i in range(1,n):
if A[i]%mod!=0:
print(0)
sys.exit()
if A[i]%mod==0 and (A[i]//mod)%2==0:
print(0)
sys.exit()
#print(A)
for i in range(n):
A[i]//=2
#print(A)
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a // gcd(a, b) * b
L=A[0]
for i in range(1,n):
L=lcm(L,A[i])
#print(L)
if L>m:
an=0
else:
an=int(((m/L)-1)/2)+1
print(an)
| 1 | 101,911,614,341,668 | null | 247 | 247 |
inp = input()
a = inp.split()
a[0] = int(a[0])
a[1] = int(a[1])
a[2] = int(a[2])
c = 0
for i in range(a[0],a[1]+1):
if a[2] % i == 0:
c += 1
print(c)
| def q_d():
n = int(input())
a = list(map(int, input().split()))
break_num = 0
current_index = 1
for i in range(n):
if a[i] == current_index:
current_index += 1
else:
break_num += 1
if break_num == n:
print(-1)
else:
print(break_num)
if __name__ == '__main__':
q_d()
| 0 | null | 57,437,215,911,936 | 44 | 257 |
N,M=map(int,input().split())
H=list(map(int,input().split()))
G={i+1 for i in range(N)}
for _ in range(M):
a,b=map(int,input().split())
if H[a-1]>H[b-1]:
G-={b}
elif H[b-1]>H[a-1]:
G-={a}
else:
G-={a,b}
print(len(G)) | import itertools
import functools
import math
from collections import Counter
from itertools import combinations
N,M=map(int,input().split())
ans = 0
if N >= 2:
ans += len(list(itertools.combinations(range(N), 2)))
if M >= 2:
ans += len(list(itertools.combinations(range(M), 2)))
print(ans)
| 0 | null | 35,340,254,045,360 | 155 | 189 |
import os
import sys
import numpy as np
def solve(N, U, V, AB):
G = [[0]*0 for _ in range(N+1)]
for idx_ab in range(len(AB)):
a, b = AB[idx_ab]
G[a].append(b)
G[b].append(a)
P1 = np.zeros(N+1, dtype=np.int64)
def dfs1(u):
st = [u]
while st:
v = st.pop()
p = P1[v]
for u in G[v]:
if p != u:
st.append(u)
P1[u] = v
dfs1(U)
path_u2v = [U]
v = V
while v != U:
v = P1[v]
path_u2v.append(v)
path_u2v.reverse()
l = len(path_u2v)
half = (l-2) // 2
c = path_u2v[half]
ng = path_u2v[half+1]
Depth = np.zeros(N+1, dtype=np.int64)
def dfs2(c):
st = [c]
P = np.zeros(N+1, dtype=np.int64)
while st:
v = st.pop()
p = P[v]
d = Depth[v]
for u in G[v]:
if p != u and u != ng:
st.append(u)
P[u] = v
Depth[u] = d + 1
dfs2(c)
c_ = path_u2v[l-1-half]
v = c_
while v != c:
Depth[v] = 0
v = P1[v]
d = l%2
ans = max(Depth) + half + d
return ans
# >>> numba compile >>>
numba_config = [
[solve, "i8(i8,i8,i8,i8[:,:])"],
]
if sys.argv[-1] == "ONLINE_JUDGE":
from numba import njit
from numba.pycc import CC
cc = CC("my_module")
for func, signature in numba_config:
vars()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
exit()
elif os.name == "posix":
exec(f"from my_module import {','.join(func.__name__ for func, _ in numba_config)}")
else:
from numba import njit
for func, signature in numba_config:
vars()[func.__name__] = njit(signature, cache=True)(func)
print("compiled!", file=sys.stderr)
# <<< numba compile <<<
def main():
N, u, v = map(int, input().split())
if N==2:
print(0)
return
AB = np.array(sys.stdin.read().split(), dtype=np.int64).reshape(N-1, 2)
ans = solve(N, u, v, AB)
print(ans)
main()
| n = int(input())
A = list(map(int, input().split()))
mod = 10**9+7
ans = 0
for i in range(61):
cnt0 = 0
cnt1 = 0
for a in A:
if (a>>i) & 1 == 0:
cnt0 += 1
else:
cnt1 += 1
ans += cnt0 * cnt1 * (2 ** i)
ans %= mod
print(ans) | 0 | null | 120,050,861,682,820 | 259 | 263 |
def check(h):
if h > 1:
return 2*(check(h//2))+1
elif h==1:
return 1
print(check(int(input()))) | h = int(input())
num = 0
t = 0
while h != 1:
h = h//2
num += 2**t
t += 1
num += 2**t
print(num) | 1 | 80,323,121,473,418 | null | 228 | 228 |
N = int(input())
A = [int(c) for c in input().split()]
l = [0]*N
for i in range(N):
l[A[i]-1] = i+1
print(' '.join(map(str, l)))
| N = int(input())
list = input().split()
answer = [0] * N
for i in range(N):
answer[int(list[i]) - 1] = str(i + 1)
print(' '.join(answer))
| 1 | 180,803,190,887,438 | null | 299 | 299 |
import math
k = 1
x = float(input())
while x*k%360 != 0:
k += 1
print(k) | x = int(input())
while True:
for i in range(2,x):
if x % i == 0:
break
else:
print(x)
exit()
x += 1
| 0 | null | 59,119,736,632,420 | 125 | 250 |
a, b=map(int, input().split())
s=a*b
m=a+a+b+b
print(s, m)
| def main():
n = int(input())
a = list(map(int, input().split()))
dp = [[[-float("inf")]*2 for j in range(3)] for i in range(n+1)]
#dp[index][i//2+j個選んだ][直前の値を採用したか否か]
dp[0][0][0] = 0
for i in range(n):
x = a[i]
if i%2 == 0:
for j in range(-1, 2):
dp[i+1][j][0] = max(dp[i][j][0], dp[i][j][1])
for j in range(-1, 1):
dp[i+1][j+1][1] = dp[i][j][0] + x
else:
for j in range(-1, 1):
dp[i+1][j][0] = max(dp[i][j+1][0], dp[i][j+1][1])
for j in range(-1, 2):
dp[i+1][j][1] = dp[i][j][0] + x
print(max(dp[n][0][0], dp[n][0][1]))
if __name__ == "__main__":
main() | 0 | null | 18,705,931,092,640 | 36 | 177 |
n = int(input())
MOD = 10 ** 9 + 7
ans = (pow(10, n, MOD) - 2 * pow(9, n, MOD) + pow(8, n, MOD))%MOD
print(ans) | N=int(input())
MOD=10**9+7
in_9=10**N-9**N
in_0=10**N-9**N
nine_and_zero=10**N-8**N
ans=int(int(in_0+in_9-nine_and_zero)%MOD)
print(ans) | 1 | 3,193,031,264,500 | null | 78 | 78 |
n,k=map(int,input().split())
r,s,p=map(int,input().split())
t=list(input())
rsp={"r":p,"s":r,"p":s}
sumt=0
chk=[1]*n
for i in range(len(t)):
sumt+=rsp[t[i]]
if i>=k and t[i]==t[i-k]:
chk[i]=chk[i-k]+1
chk[i-k]=1
ans=sumt
for i in range(len(chk)):
if chk[i]!=1:
chg=chk[i]//2
ans-=(rsp[t[i]])*chg
print(ans) | # import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(N, K, R, S, P, T):
k_list = [[] for _ in range(K)]
for i in range(len(T)):
k_list[i % K].append(T[i])
ans = 0
for kl in k_list:
dp = [[0, 0, 0] for _ in range(len(kl) + 1)]
for i in range(len(kl)):
# rock
dp[i + 1][0] = max(dp[i][1], dp[i][2])
dp[i + 1][0] += R if kl[i] == 's' else 0
# scissors
dp[i + 1][1] = max(dp[i][0], dp[i][2])
dp[i + 1][1] += S if kl[i] == 'p' else 0
# paper
dp[i + 1][2] = max(dp[i][0], dp[i][1])
dp[i + 1][2] += P if kl[i] == 'r' else 0
ans += max(dp[-1])
print(ans)
if __name__ == '__main__':
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()
# N, K = 10 ** 5, 10 ** 3
# R, S, P = 100, 90, 5
# T = 'r' * 10 ** 5
solve(N, K, R, S, P, T)
| 1 | 106,875,649,636,768 | null | 251 | 251 |
N = int(input())
M = [[0]*10 for _ in range(10)]
for n in range(1,N+1):
head = int(str(n)[0])
tail = int(str(n)[-1])
M[head][tail] += 1
ans = 0
for i in range(10):
for j in range(i+1,10):
ans += M[i][j]*M[j][i]*2
ans += M[i][i]**2
print(ans)
| ##未完成
N = int(input())
K = str(N)
l = len(str(N))
ans = 0
def tp(i,j,p):
tmp = 0
if p >= 2:
if l == p:
if i == int(K[0]):
if j > int(K[l-1]):
tmp = (N-int(K[0])*10**(l-1)-int(K[l-1]))//10
else:
tmp = (N-int(K[0])*10**(l-1)-int(K[l-1]))//10+1
elif i >= int(K[0]):
tmp = 0
else:
tmp = 10**(p-2)
elif l > p:
tmp = 10**(p-2)
return tmp
else:
if i == j and i <= N:
return 1
else:
return 0
for i in range(1,10):
for j in range(1,10):
for p in range(1,l+1):
for q in range(1,l+1):
ans += tp(i,j,p)*tp(j,i,q)
print(ans) | 1 | 86,561,043,942,880 | null | 234 | 234 |
alp=list("abcdefghijklmnopqrstuvwxyz")
print(alp[alp.index(input())+1]) | n = int(input())
a = [list(map(int, input().split())) for i in range(n)]
for i in range(n):
temp = 0 if a[i][0] - a[i][1] < 0 else a[i][0] - a[i][1]
a[i][1] = a[i][0]+a[i][1]
a[i][0] = temp
a.sort(key = lambda x:x[1])
ans = n
right = 0
for j in a:
if right > j[0]:
ans -= 1
else:
right = j[1]
print(ans) | 0 | null | 91,005,468,467,342 | 239 | 237 |
n = int(raw_input())
A = map(int, raw_input().split(" "))
def printElem(B):
string = ""
for elem in B:
string += str(elem) + " "
print(string[:len(string)-1])
printElem(A)
for i in range(1, n):
key = A[i]
j = i - 1
while j >= 0 and A[j] > key:
A[j+1] = A[j]
j -= 1
A[j+1] = key
printElem(A) | K = int(input())
A,B = map(int, input().split())
target = 0
target = B - B % K
if A <= target:
print('OK')
else:
print('NG') | 0 | null | 13,349,104,160,700 | 10 | 158 |
M = 10**9 + 7
n = int(input())
a = [int(i) for i in input().split()] #; print(a)
counter = [0] * (n+1) ; counter[0] = 3
ans = 1
for i in range(n):
ans *= counter[a[i] - 1 +1] - counter[a[i] +1]
ans = ans % M
counter[a[i] +1] += 1
print(ans) | import sys,queue,math,copy
input = sys.stdin.readline
MOD = 10**9 + 7
LI = lambda : [int(x) for x in input().split()]
N = int(input())
A = LI()
c =[0,0,0]
cnt = [0 for _ in range(N)]
for i in range(N):
cnt[i] = c.count(A[i])
if cnt[i] == 0: break
c[c.index(A[i])] += 1
ans = 1
for i in range(N):
ans = (ans * cnt[i]) % MOD
print (ans) | 1 | 130,172,184,687,850 | null | 268 | 268 |
h, n = map(int,input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
for v in a:
h -= v
if h <= 0:
print('Yes')
break
else:
print('No') | def main():
from collections import deque
import sys
input = sys.stdin.readline
N,M = map(int,input().split())
to = [[] for _ in range(N)]
for _ in range(M):
a,b = map(int,input().split())
a -= 1
b -= 1
to[a].append(b)
to[b].append(a)
# print(to)
guide = [0] * N
guide[0] = 1
q = deque()
q.append(0)
while len(q) > 0:
u = q.popleft()
for v in to[u]:
# print(guide)
if guide[v] != 0:
continue
guide[v] = u+1
q.append(v)
print("Yes")
for g in guide[1:]:
print(g)
if __name__ == '__main__':
main()
| 0 | null | 49,357,985,837,908 | 226 | 145 |
S = input()
T = input()
list_s = []
list_t = []
counter = 0
for i in range(0, len(S)):
list_s.append(S[i])
list_t.append(T[i])
if S[i] != T[i]:
list_s[i] = list_t[i]
counter += 1
print(counter) | s = [input() for i in range(2)]
count=0
for item1, item2 in zip(s[0], s[1]):
if (item1 != item2):
count +=1
print(count) | 1 | 10,553,328,593,072 | null | 116 | 116 |
from collections import deque
N = int(input())
p = 1
for i in range(2,int(N ** (1/2)+1)):
if N % i == 0:
p = i
print(int(p+N/p)-2)
| import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n = int(input())
d1_0, d2_0 = -1, -2
d1_1, d2_1 = -1, -2
d1_2, d2_2 = -1, -2
for i in range(n):
d1_2, d2_2 = d1_1, d2_1
d1_1, d2_1 = d1_0, d2_0
d1_0, d2_0 = map(int,input().split())
if d1_0 == d2_0 and d1_1 == d2_1 and d1_2 == d2_2:
print("Yes")
sys.exit()
print("No")
if __name__=='__main__':
main() | 0 | null | 82,146,011,876,050 | 288 | 72 |
n,k=map(int,input().split())
i=1
while True:
if n>=k**i:
i+=1
else:
break
print(i) | from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import product, combinations,permutations
from copy import deepcopy
import sys
sys.setrecursionlimit(4100000)
if __name__ == '__main__':
N, K = map(int, input().split())
cnt = 0
while N!=0:
N //= K
cnt += 1
print(cnt) | 1 | 64,066,468,402,300 | null | 212 | 212 |
n = int(input())
a = [int(i) for i in input().split()]
#import numpy as np
#n = 100
#a = np.random.randint(1, 100, n)
a = sorted(a)
minsum = float('inf')
for i in range(a[0], a[-1]+1):
cnt = 0
for ai in a:
cnt += (ai - i)**2
if cnt <= minsum:
minsum = cnt
print(minsum) | n=int(input())
x = [int(x) for x in input().split()]
heikin=(sum(x)/n)
if abs(int(heikin)-heikin)<abs(int(heikin+1)-heikin):
kaisai=int(heikin)
else:
kaisai=int(heikin+1)
ans=0
for i in x:
ans+=(i-kaisai)**2
print(ans) | 1 | 65,364,156,147,112 | null | 213 | 213 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.