code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
from collections import deque
n , d , a = map(int,input().split())
mon = [tuple(map(int,input().split())) for i in range(n)]
mon.sort()
p = deque(mon)
baku = deque()
cou = 0
ans = 0
while p:
nowx , nowh = p.popleft()
while baku:
bx , bh = baku.popleft()
if bx >= nowx:
baku.appendleft((bx,bh))
break
elif bx < nowx:
cou -= bh
if nowh <= cou:
continue
elif nowh > cou:
k = -((-nowh+cou)//a)
ans += k
cou += a*k
baku.append((nowx+2*d,a*k))
print(ans) | def bubble(A, N):
c = 0
flag = True
while flag:
flag = False
for j in range(N-1, 0, -1):
if A[j] < A[j-1]:
A[j], A[j-1] = A[j-1], A[j]
c += 1
flag = True
return A, c
if __name__ == "__main__":
N = int(input())
A = [int(i) for i in input().split()]
A, c = bubble(A, N)
print (*A)
print (c) | 0 | null | 41,311,092,590,810 | 230 | 14 |
import sys
i=1
for line in sys.stdin:
a=int(line)
if a == 0:
break
else:
print 'Case {0}: {1}'.format(i, a)
i+=1 | i=0
while 1:
a = int(input())
if a == 0 : break
i+=1
print "Case %d: %d" % (i, a) | 1 | 480,802,557,840 | null | 42 | 42 |
n = int(input())
s = input()
ans = 0
for i in range(n - 2):
a = s[i:i + 3]
if a == "ABC":
ans += 1
print(ans) | r = int(input())
print(2 * r * 3.1415926535897932) | 0 | null | 65,304,748,887,690 | 245 | 167 |
def is_good(mid, key):
ret = 0
for i in range(N):
ret += max(0, A[i] - mid // F[i])
return ret <= key
def binary_search(key):
bad, good = -1, 10 ** 18
while good - bad > 1:
mid = (bad + good) // 2
if is_good(mid, key):
good = mid
else:
bad = mid
return good
N, K = map(int, input().split())
A = sorted(map(int, input().split()))
F = sorted(map(int, input().split()), reverse=True)
print(binary_search(K))
| a = []
while True:
b = list(map(int,input().split()))
if b[0] == 0 and b[1]==0:
break
b.sort()
a.append(b)
for i in a:
print(i[0],i[1]) | 0 | null | 82,441,565,650,448 | 290 | 43 |
n = int(input())
l = [list(map(int, input().split())) for i in range(n)]
#print(l[0][0])
#print(l[0][1])
ans = n-2
ans1 = 0
for m in range(ans):
if l[m][0] == l[m][1] and l[m+1][0] == l[m+1][1] and l[m+2][0] == l[m+2][1]:
ans1 += 1
if ans1 >= 1:
print("Yes")
else:
print("No") | # coding:UTF-8
import sys
from math import factorial
MOD = 10 ** 9 + 7
INF = 10000000000
def main():
# ------ 入力 ------#
n = int(input()) # 数字
# 定数行入力
x = n
dList = [list(map(int, input().split())) for _ in range(x)] # スペース区切り連続数字(行列)
# ------ 処理 ------#
flg = 1
for i in range(n-2):
if dList[i][0] == dList[i][1]:
if dList[i+1][0] == dList[i+1][1]:
if dList[i+2][0] == dList[i+2][1]:
flg = 0
# ------ 出力 ------#
if flg == 0:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| 1 | 2,473,910,655,440 | null | 72 | 72 |
a, b, c, k = map(int,input().split())
ans = 0
if a > k:
print(k)
elif a+b > k:
print(a)
else:
print(a-(k-a-b))
| N, M = map(int, input().split())
A = list(map(int, input().split()))
for Ai in A:
N -= Ai
if N < 0:
print(-1)
break
if N >= 0:
print(N) | 0 | null | 26,826,089,008,054 | 148 | 168 |
N,K,C=map(int,input().split())
S=input()
def check0(S0):
count=0
index=0
out=[0]*K
while count<K and index<N:
if S0[index]=='o':
out[count]=index
count+=1
index+=(C+1)
else:
index+=1
if count==K:
return 1,out
return 0,out
def checkend(S0):
count=0
index=N-1
out=[0]*K
while count<K and index>=0:
if S0[index]=='o':
out[K-1-count]=index
count+=1
index-=(C+1)
else:
index-=1
if count==K:
return 1,out
return 0,out
flag0,out0=check0(S)
flagend,outend=checkend(S)
if flag0==1:
for i in range(K):
if out0[i]==outend[i]:
print(out0[i]+1) | s = input()
ls = ['SUN','MON','TUE','WED','THU','FRI','SAT']
for i, x in enumerate(ls):
if s == x:
print(7-i)
| 0 | null | 86,997,716,331,968 | 182 | 270 |
N, K = list(map(int, input().rstrip().split()))
r = 0
while 0 < N:
r += 1
N = int(N / K)
print(r)
| import sys
# sys.setrecursionlimit(100000)
from collections import deque
from collections import defaultdict
def input():
return sys.stdin.readline().strip()
def input_int():
return int(input())
def input_int_list():
return [int(i) for i in input().split()]
def main():
# 各ノードで幅優先探索を行う
# 計算量(O(n^2))
n, x, y = input_int_list()
g = defaultdict(list)
g[x].append(y)
g[y].append(x)
for i in range(1, n):
g[i].append(i + 1)
g[i + 1].append(i)
ans = [0] * (n + 1)
for i in range(1, n + 1):
# 幅優先探索
seen = set()
dq = deque()
dq.append((i, 0)) # node,depth
while dq:
p, d = dq.popleft()
if p > i: # 整数の組(i,j) (1 <= i <= j <= N)
ans[d] += 1
for q in g[p]:
if q not in seen:
dq.append((q, d + 1))
seen.add(q)
for i in range(1, n):
print(ans[i])
return
if __name__ == "__main__":
main()
| 0 | null | 54,237,493,923,860 | 212 | 187 |
A = input().split(" ")
B = input().split(" ")
if A[0] == B[0]:
print("0")
else:
print("1")
| n = input()
for ni in n:
if ni == '7':
print('Yes')
exit()
print('No') | 0 | null | 79,591,731,288,860 | 264 | 172 |
import sys
import math
# import bisect
# import numpy as np
# from decimal import Decimal
# from numba import njit, i8, u1, b1 #JIT compiler
# from itertools import combinations, product
# from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return map(int, sys.stdin.readline().strip().split())
def read_ints2(x): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)
def Main():
n, m = read_ints()
a = read_int_list()
a = [x // 2 for x in a]
lcm = 1
for x in a:
lcm *= x // math.gcd(lcm, x)
for x in a:
if lcm // x % 2 == 0:
print(0)
exit()
print(math.ceil((m // lcm) / 2))
if __name__ == '__main__':
Main() | from math import gcd
n, m = (int(x) for x in input().split())
A = list(int(x) for x in input().split())
B = [a // 2 for a in set(A)]
lcm = 1
div2_count = -1
for b in B:
lcm = lcm * b // gcd(lcm, b)
if lcm > m:
print(0)
exit()
count = 0
while b % 2 == 0:
b //= 2
count += 1
if div2_count == -1 or div2_count == count:
div2_count = count
else:
print(0)
exit()
limit = m // lcm
ans = (limit + 1) // 2
print(ans) | 1 | 101,622,848,314,328 | null | 247 | 247 |
n = int(input())
d = set()
for _ in range(n):
c, s = input().split()
if c == 'insert':
d.add(s)
else:
print('yes' if s in d else 'no')
| MOD = 10**9 + 7
class modint():
def __init__(self, value):
self.value = value % MOD
def __int__(self):
return int(self.value)
def __float__(self):
return float(self.value)
def __str__(self):
return str(self.value)
def __repr__(self):
return str(self.value)
def __add__(self, other):
return (modint(self.value + other.value) if isinstance(other, modint)
else modint(self.value + other))
def __sub__(self, other):
return (modint(self.value - other.value) if isinstance(other, modint)
else modint(self.value - other))
def __mul__(self, other):
return (modint(self.value * other.value) if isinstance(other, modint)
else modint(self.value * other))
def __truediv__(self, other):
return (modint(self.value * pow(other.value, MOD - 2, MOD))
if isinstance(other, modint)
else modint(self.value * pow(other, MOD - 2, MOD)))
def __pow__(self, other):
return (modint(pow(self.value, other.value, MOD))
if isinstance(other, modint)
else modint(pow(self.value, other, MOD)))
def __eq__(self, other):
return (self.value == other.value if isinstance(other, modint)
else self.value == (other % MOD))
def __ne__(self, other):
return (self.value == other.value if isinstance(other, modint)
else self.value == (other % MOD))
def __radd__(self, other):
return (modint(other.value + self.value) if isinstance(other, modint)
else modint(other + self.value))
def __rsub__(self, other):
return (modint(other.value - self.value) if isinstance(other, modint)
else modint(other - self.value))
def __rmul__(self, other):
return (modint(other.value * self.value) if isinstance(other, modint)
else modint(other * self.value))
def __rtruediv__(self, other):
return (modint(other.value * pow(self.value, MOD - 2, MOD))
if isinstance(other, modint)
else modint(other * pow(self.value, MOD - 2, MOD)))
def __rpow__(self, other):
return (modint(pow(other.value, self.value, MOD))
if isinstance(other, modint)
else modint(pow(other, self.value, MOD)))
def modinv(self):
return modint(pow(self.value, MOD - 2, MOD))
def main():
import sys
input = sys.stdin.buffer.readline
N = int(input())
A = [int(i) for i in input().split()]
def gcd(x, y):
if y == 0:
return x
while y != 0:
x, y = y, x % y
return x
def lcm(x, y):
return x*y//gcd(x, y)
num = 1
for a in A:
num = lcm(num, a)
n = modint(num)
ans = 0
for i, a in enumerate(A):
ans += n/a
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 44,021,273,627,708 | 23 | 235 |
import math
N=int(input())
if N==2:
print(1)
exit()
def yaku(n):
a=set()
s=int(math.sqrt(n))
for i in range(2,s+1):
if n%i==0:
a.add(i)
a.add(n//i)
return a
ans=len(yaku(N-1))+1
a=yaku(N)
for i in a:
n=N
while n%i==0:
n=n//i
if n%i==1:
ans+=1
print(ans+1) | import math
N = int(input())
N_d = []
N1_d = []
answer = set()
for i in range(1,math.ceil(N**0.5)+1):
if N%i == 0:
N_d.append(i)
N_d.append(N//i)
for i in range(len(N_d)):
temp = N
while temp % N_d[i] == 0:
temp = temp//N_d[i]
if N_d[i] == 1:
break
if temp % N_d[i] == 1:
answer.add(N_d[i])
for i in range(1,math.ceil((N-1)**0.5)+1):
if (N-1) %i == 0:
answer.add(i)
answer.add((N-1)//i)
answer.remove(1)
print(len(answer)) | 1 | 41,360,513,111,160 | null | 183 | 183 |
a=int(input())
print(a*6.283185307178) | #!/usr/bin/env python
# coding: utf-8
# In[8]:
S = input()
K = int(input())
# In[10]:
cnt = 0
ans = 0
tmp = S[0]
fcnt = 0
for s in S:
if tmp == s:
cnt += 1
tmp = s
else:
ans += cnt//2
if fcnt == 0:
fcnt = cnt
cnt = 1
tmp = s
if fcnt == 0:
fcnt = cnt
ans += cnt//2
ans *= K
if len(S) == fcnt:
ans = (len(S)*K)//2
elif S[0] == S[-1]:
ans -= (fcnt//2 + cnt//2 - (fcnt+cnt)//2) * (K-1)
print(ans)
# In[ ]:
| 0 | null | 103,352,498,647,230 | 167 | 296 |
bb = []
input()
aa = [ int(i) for i in input().split()]
for kk in aa[::-1]:
bb.append(kk)
print(' '.join(map(str, bb))) #map(func, iterable) | n = int(input())
ns = [int(i) for i in input().split()]
ns.reverse()
if len(ns) > n:
del ns[:(len(ns) - n)]
for i in ns:
if i != ns[-1]:
print(i,end=' ')
else:
print(i,end='')
print() | 1 | 970,248,940,220 | null | 53 | 53 |
import collections
n = int(input())
words = []
for i in range(n):
words.append(input())
c = collections.Counter(words)
values, counts = zip(*c.most_common())
nums = counts.count(max(counts))
xs = (list(values))[:nums]
xs.sort()
for x in xs:
print(x) | import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
n = k()
ss = [v() for i in range(n)]
c = Counter(ss)
a = list(c.most_common())
maxc = a[0][1]
Ans = []
for i in a:
if i[1] == maxc:
Ans.append(i)
Ans.sort()
for i in Ans:
print(i[0]) | 1 | 69,903,370,561,308 | null | 218 | 218 |
n,d=map(int,input().split());print(sum([d**2>=a**2+b**2 for a,b in [list(map(int,input().split())) for _ in range(n)]])) | from itertools import accumulate
from collections import defaultdict
N,K = map(int,input().split())
A = list(map(int,input().split()))
S = [0] + list(accumulate(A))
S = [ s%K for s in S ]
ans = 0
counter = defaultdict(int)
queue = []
for i,s in enumerate(S):
t = (s-i) % K
ans += counter[t]
counter[t] += 1
queue.append(t)
if len(queue) >= K:
counter[queue[0]] -= 1
queue.pop(0)
print(ans) | 0 | null | 72,120,598,873,752 | 96 | 273 |
n, k, c = map(int, input().split())
s = input()
bound_to_work = [0] * n
def get_days(s):
days = [0] * n
changes = [0] * n
last_day = -1
ndays = 0
for i in range(n):
if (last_day == -1 or i - last_day > c) and s[i] == 'o':
ndays += 1
last_day = i
changes[i] = 1
days[i] = ndays
return days
ldays = get_days(s)
rdays = get_days(s[::-1])[::-1]
for i in range(n):
lchanges = (i > 0 and ldays[i] != ldays[i - 1] or i == 0)
rchanges = i == n - 1 or rdays[i + 1] != rdays[i]
if lchanges and rchanges and ldays[i] + rdays[i] == k + 1:
bound_to_work[i] = 1
for i, f in enumerate(bound_to_work):
if f:
print(i + 1)
| import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
tin=lambda : map(int, input().split())
lin=lambda : list(tin())
mod=1000000007
#+++++
def main():
#a = int(input())
n, k, c_yutori = tin()
if n == 1:
return 1
s = input()
can_work = [0]*n
can_work[0] = 1 if s[0]=='o' else 0
yn = c_yutori if s[0]=='o' else 0
for i, c in enumerate( list(s)[1:],1):
if yn == 0 and c == 'o':
can_work[i] = can_work[i-1]+1
yn = c_yutori
else:
can_work[i] = can_work[i-1]
yn = max(0, yn - 1)
need_to_work = [k]*n
if s[-1]=='o':
need_to_work[-1] = k-1
yn = c_yutori
else:
need_to_work[-1]=k
yn=0
for i, c in enumerate(list(s)[-2::-1],1):
pos = n-i-1
if yn == 0 and c == 'o':
need_to_work[pos] = need_to_work[pos+1]-1
yn = c_yutori
else:
need_to_work[pos]=need_to_work[pos+1]
yn = max(0, yn-1)
#pa(can_work)
#pa(need_to_work)
if need_to_work[1] == 1:
print(1)
for i in range(1, n-1):
if can_work[i-1] < need_to_work[i+1]:
print(i+1)
if can_work[-2]==k-1:
print(n)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | 1 | 40,657,660,123,960 | null | 182 | 182 |
n = input()
n = int(n)
l = []
for i in range(1, n+1):
if i % 3 == 0:
l.append(i)
else:
j = i
while j > 0:
if j % 10 == 3:
l.append(i)
break
else:
j //= 10
for p in l:
print(" " + str(p), end="")
print()
| a, b = map(int, input().split())
print("a", a < b and "<" or a > b and ">" or "==", "b")
| 0 | null | 632,400,742,400 | 52 | 38 |
s=input()
l=input().split()
m=[int(i) for i in l]
print("{} {} {}".format(min(m),max(m),sum(m)))
| import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
A = []
for _ in range(int(input())):
x, l = map(int, input().split())
A.append((x - l, x + l))
A.sort(key = lambda x : x[1])
ans = 0
now = -INF
for l, r in A:
if now <= l:
now = r
ans += 1
print(ans)
resolve() | 0 | null | 45,389,752,447,322 | 48 | 237 |
a = int(input())
ans = a >= 30 and 'Yes' or 'No'
print(ans) | input()
xs = list(map(int, input().split()))
print(' '.join(map(str,[f(xs) for f in [min,max,sum]]))) | 0 | null | 3,240,163,042,990 | 95 | 48 |
from collections import Counter
N, P = map(int, input().split())
S = input()
def check(n):
ans = 0
for i in range(1, N+1):
v = int(S[-i])
if v%n==0:
ans += N-(i-1)
return ans
ans = 0
if P==2:
ans = check(2)
elif P==5:
ans = check(5)
else:
ac = [0]*(N+1)
for i in range(1, N+1):
ac[i] = (ac[i-1]+int(S[-i])*pow(10, i-1, P))%P
c = Counter(ac)
for i in c.values():
ans += i*(i-1)//2
print(ans) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import Counter
N, P = map(int, readline().split())
S = list(map(int, read().rstrip().decode()))
def solve_2(S):
ind = (i for i, x in enumerate(S, 1) if x % 2 == 0)
return sum(ind)
def solve_5(S):
ind = (i for i, x in enumerate(S, 1) if x % 5 == 0)
return sum(ind)
def solve(S,P):
if P == 2:
return solve_2(S)
if P == 5:
return solve_5(S)
S = S[::-1]
T = [0] * len(S)
T[0] = S[0] % P
power = 1
for i in range(1, len(S)):
power *= 10
power %= P
T[i] = T[i-1] + power * S[i]
T[i] %= P
counter = Counter(T)
return sum(x * (x - 1) // 2 for x in counter.values()) + counter[0]
print(solve(S,P))
| 1 | 58,126,762,209,540 | null | 205 | 205 |
def counter(a, b, c):
count = 0
for n in range(a, b+1):
if c % n == 0:
count += 1
print(count)
a, b, c = list(map(int, input().split()))
counter(a, b, c) | i = count = 0
a = b = c = ''
line = input()
while line[i] != ' ':
a = a + line[i]
i += 1
i += 1
while line[i] != ' ':
b = b + line[i]
i += 1
i += 1
while i < len(line):
c = c + line[i]
i += 1
a = int(a)
b = int(b)
c = int(c)
while a <= b:
if c%a == 0:
count += 1
a += 1
print(count) | 1 | 570,587,028,388 | null | 44 | 44 |
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from math import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
#mod = 998244353
INF = float('inf')
from sys import stdin
readline = stdin.readline
def readInts():
return list(map(int,readline().split()))
def readTuples():
return tuple(map(int,readline().split()))
def I():
return int(readline())
n = I()
A = readInts()
cum = list(accumulate(A))
ans = 0
for i in range(n-1):
ans += A[i] * (cum[n-1]-cum[i])
ans%=mod
print(ans%mod)
| n = int(input())
a_list = [int(x) for x in input().split()]
a_sum = sum(a_list)
m = 10 ** 9 + 7
ans = 0
for i in range(n - 1):
a_sum -= a_list[i]
ans = (ans + a_list[i] * a_sum) % m
print(ans) | 1 | 3,795,760,789,500 | null | 83 | 83 |
(L,R,d) = map(int, input().split())
out=int(R/d)-int(L/d)+1
if ( L%d == 0):
print (out)
else:
print(out-1) | L, R, d = list(map(int, input().split(" ")))
diff=R//d - (L-1)//d
print(diff) | 1 | 7,466,506,741,668 | null | 104 | 104 |
import bisect
N=int(input())
arr=list(map(int,input().split()))
arr.sort()
ans=0
for i in range(N-2):
for j in range(i+1,N-1):
k=bisect.bisect_left(arr,arr[i]+arr[j])
if k>j:
ans+=k-j-1
else:
pass
print(ans) | '''
問題：
高橋君は金色の硬貨が好きです。
自分が持っている 500円硬貨 1枚につき 1000、
5円硬貨 1枚につき 5の嬉しさ を得ます。
高橋君は X 円を持っています。
これを高橋君の嬉しさが最大になるように両替したとき、高橋君の嬉しさはいくらになりますか？
(なお、利用できる硬貨は 500 円玉、100 円玉、50 円玉、10 円玉、5円玉、1 円玉の 6 種類とします。)
'''
'''
Xは整数
0 ≦ X ≦ 1,000,000,000
'''
class Yorokobi:
def __init__(self, money, yorokobi):
self.money = money
self.yorokobi = yorokobi
def calc_yorokobi(self, credit): # credit （残金？）を入力として受け取り、喜びを計算して返す
return (credit // self.money) * self.yorokobi
# 標準入力から X の値を取得する
input_x = int(input())
yorokobi_500 = Yorokobi(500, 1000)
yorokobi_5 = Yorokobi(5, 5)
result = 0 # 結果格納用
if input_x >= 500:
result += yorokobi_500.calc_yorokobi(input_x) # 高橋君 500円の喜び
result += yorokobi_5.calc_yorokobi(input_x % 500) # 高橋君 5円の喜び
else:
result += yorokobi_5.calc_yorokobi(input_x)
print(result)
# ret1 = input_x // 500 # 500円で割った商
# ret2 = ret1 * 1000 # 高橋君 500円の喜び
# ret3 = input_x - (ret1 * 500) # X円から500円の枚数分を引いたお金
# ret4 = ret3 // 5 # （X円から500円の枚数分を引いたお金）÷ 5
# ret5 = ret4 * 5 # 高橋君 5円の喜び
# print(ret2 + ret5)
| 0 | null | 107,526,419,739,332 | 294 | 185 |
n=int(input())
a=list(map(int,input().split()))
thing={}
ans=0
for i in range(n):
if i-a[i] in thing:
ans+=thing[i-a[i]]
if i+a[i] in thing:
thing[i+a[i]]+=1
else:
thing[i+a[i]]=1
print(ans) | import sys
from collections import deque
input = sys.stdin.readline
def bfs(S, sh, sw, dist):
dist[sh][sw] = 0
queue = deque([(sh, sw)])
while queue:
h, w = queue.popleft()
for i, j in ((0, 1), (0, -1), (1, 0), (-1, 0)):
y, x = h + i, w + j
if S[y][x] == "#":
continue
if dist[y][x] == -1:
dist[y][x] = dist[h][w] + 1
queue.append((y, x))
def main():
H, W = map(int, input().split())
S = [None] * (H + 2)
S[0] = S[-1] = "#" * (W + 2)
for i in range(1, H + 1):
S[i] = "".join(["#", input().rstrip(), "#"])
ans = 0
for sh in range(1, H + 1):
for sw in range(1, W + 1):
if S[sh][sw] == "#":
continue
dist = [[-1] * (W + 2) for _ in range(H + 2)]
bfs(S, sh, sw, dist)
max_dist = max(map(max, dist))
ans = max(ans, max_dist)
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 60,117,961,771,872 | 157 | 241 |
n = int(input())
def dfs(n, s, idx):
l = len(s)
if n == l:
print(s)
return
alpha = "abcdefghijklmnopqrstuvwxyz"
i = 0
while i < idx + 1:
if i == idx:
dfs(n, s + alpha[i], idx + 1)
else:
dfs(n, s + alpha[i], idx)
i += 1
dfs(n, "", 0)
| n=int(input())
lis=[[[1,"a"]]]
for i in range(n-1):
lisi=[]
for j in lis[i]:
for k in range(j[0]):
lisi.append([j[0],j[1]+chr(ord("a")+k)])
lisi.append([j[0]+1,j[1]+chr(ord("a")+j[0])])
lis.append(lisi)
for i in lis[n-1]:
print(i[1]) | 1 | 52,523,630,836,896 | null | 198 | 198 |
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
from collections import defaultdict
def resolve():
N = ir()
A = sorted([[i+1, d] for i, d in enumerate(lr())], key=lambda x: x[1])[::-1]
dp = defaultdict(lambda: -float('inf'))
dp[0, 0] = 0
for x in range(N):
for y in range(N-x):
i, d = A[x+y]
dp[x+1, y] = max(dp[x, y]+d*(i-x-1), dp[x+1, y])
dp[x, y+1] = max(dp[x, y]+d*(N-y-i), dp[x, y+1])
ans = 0
for i in range(N+1):
ans = max(ans, dp[i, N-i])
print(ans)
resolve() | n,a=int(input()),sorted(list(map(int,input().split())))
m=a[-1]+1
s=[0]*m
for i in a:
s[i]+=1
for i in set(a):
if s[i]:
for j in range(i*2,m,i):
s[j]=0
print(s.count(1)) | 0 | null | 24,173,722,325,090 | 171 | 129 |
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
c1 = T1*A1-T1*B1
c2 = T2*A2-T2*B2
if c1 > 0:
c1 *= -1
c2 *= -1
power = c1+c2
if power == 0:
print('infinity')
elif power < 0:
print(0)
else:
ans = 2*(-c1//power)+(c1%power > 0)
print(ans) | a, b = map(int, input().split())
c = str(a)*b
d = str(b)*a
my_list = [c, d]
my_list.sort()
print(my_list[0]) | 0 | null | 108,148,031,909,960 | 269 | 232 |
def az8():
xs = map(int,raw_input().split())
a,b = xs[0],xs[1]
print (a/b),(a%b), "%5f"%(float(a)/b)
az8() | a, b = map(int, raw_input().split())
print("%d %d %f" % (a//b, a%b, a/float(b))) | 1 | 601,113,523,748 | null | 45 | 45 |
Ss, Ts = input().split()
A, B = map(int, input().split())
Us = input().rstrip()
if Ss == Us:
A -= 1
elif Ts == Us:
B -= 1
print(A, B)
| S,T=input().split()
A,B=map(int,input().split())
U=input()
if S==U:
print('{} {}'.format(A-1,B))
else:
print('{} {}'.format(A,B-1)) | 1 | 72,027,777,371,638 | null | 220 | 220 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
n, m, k = map(int, input().split())
fr = UnionFind(n)
bl = [[] for _ in range(n)]
for _ in range(m):
a, b = map(int, input().split())
bl[a-1].append(b-1)
bl[b-1].append(a-1)
fr.union(a-1, b-1)
for _ in range(k):
c, d = map(int, input().split())
if fr.same(c-1, d-1):
bl[c-1].append(d-1)
bl[d-1].append(c-1)
ans = []
for i in range(n):
s = fr.size(i) - len(bl[i]) - 1
ans.append(s)
print(*ans) | import sys
sys.setrecursionlimit(10**9)
n, m, k = map(int, input().split())
F = [[] for i in range(n)]
B = [[] for i in range(n)]
l = [0]*n
for i in range(m):
a, b = map(int, input().split())
F[a - 1].append(b - 1)
F[b - 1].append(a - 1)
for i in range(k):
c, d = map(int, input().split())
B[c - 1].append(d - 1)
B[d - 1].append(c - 1)
seen = [0]*n
cnt = 0
r = []
def dfs(x):
if seen[x] == 0:
r[cnt].add(x)
seen[x] = 1
for i in F[x]:
dfs(i)
for i in range(n):
if seen[i] == 0:
r.append(set())
dfs(i)
cnt += 1
ans = [0]*n
for i in r:
lr = len(i)
for j in i:
ans[j] = lr - len(F[j]) - len(i & set(B[j])) - 1
print(*ans) | 1 | 61,576,355,729,692 | null | 209 | 209 |
def main():
n = int(input())
mod = 10**9+7
print((pow(10, n, mod)-pow(9, n, mod)*2+pow(8, n, mod))%mod)
if __name__ == "__main__":
main() | import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
sys.setrecursionlimit(10**7)
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
def modpow(n, p, m):
if p == 0:
return 1
if p % 2 == 0:
t = modpow(n, p // 2, m)
return t * t % m
return n * modpow(n, p - 1, m) % m
n = ni()
A = modpow(9, n, mod)
B = A
C = modpow(8, n, mod)
D = modpow(10, n, mod)
ans = (D - A - B + C) % mod
print(ans) | 1 | 3,149,445,933,732 | null | 78 | 78 |
N=input()
L=len(N)
ans=[[0 for e in range(2)] for f in range(L)]
k=int(N[L-1])
ans[0][0]=k
ans[0][1]=10-k
if L>1:
for i in range(1,L):
k=int(N[L-1-i])
ans[i][0]=min(ans[i-1][0]+k,ans[i-1][1]+k+1)
ans[i][1]=min(ans[i-1][0]+10-k,ans[i-1][1]+10-k-1)
print(min(ans[L-1][0],ans[L-1][1]+1))
| import numpy as np
from numba import njit
N = np.array([int(_) for _ in input()])
dp = np.array([[0, 0] for _ in range(len(N))])
@njit
def solve(N, dp):
dp[0, 0] = min(N[0], 11 - N[0])
dp[0, 1] = min(N[0] + 1, 10 - N[0])
for i in range(1, len(N)):
dp[i, 0] = min(dp[i - 1, 0] + N[i], dp[i - 1, 1] + 10 - N[i])
dp[i, 1] = min(dp[i - 1, 0] + N[i] + 1, dp[i - 1, 1] + 9 - N[i])
print(dp[-1][0])
solve(N, dp)
| 1 | 70,827,236,969,110 | null | 219 | 219 |
import math
import numpy as np
import sys
import os
from operator import mul
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))
if os.getenv("LOCAL"):
inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
sys.stdin = open(inputFile, "r")
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
X = I()
for a in range(1,120):
for b in range(-119,119):
if a**5-b**5==X:
print(a,b)
exit() | X=int(input())
a=True
while a==True:
for i in range(-1000,1001):
for j in range(i,1001):
if j**5-i**5==X:
print(j,i)
exit()
| 1 | 25,676,835,989,960 | null | 156 | 156 |
n = int(input())
s = input()
A = list(map(int,s.split()))
flag = 1
cnt = 0
#####################################
for i in range(0,n):
minj = i
for j in range(i,n):
if A[j] < A[minj]:
minj = j
if(A[i] != A[minj]):
tmp = A[i]
A[i] = A[minj]
A[minj] = tmp
cnt += 1
#####################################
for k in range(0,len(A)-1):
print(A[k],end=" ")
print(A[len(A)-1])
print (cnt) | import math
h , w = map(int , input().strip().split())
if h != 1 and w != 1:
print(math.ceil(h * w / 2))
else:
print(1)
| 0 | null | 25,472,045,516,056 | 15 | 196 |
import sys
x,n = map(int,input().split())
p = list(map(int,input().split()))
s = 100
min_i = -1
if x not in p:
print(x)
sys.exit()
for i in range(-1,102):
if i not in p and abs(i-x) < s:
s = abs(i-x)
min_i = i
print(min_i)
| import sys
lines = sys.stdin.readlines()
l = map(int, lines[1].split())
print min(l),max(l),sum(l) | 0 | null | 7,454,313,942,820 | 128 | 48 |
x,y,z = map(int,input().split())
tmp = x
x = y
y = tmp
tmp = x
x = z
z = tmp
print(x,y,z) | import collections
hoge = collections.defaultdict(lambda: 'no')
num = int(input())
for _ in range(num):
command, key = input().split()
if command == 'insert':
hoge[key] = 'yes'
else:
print(hoge[key])
| 0 | null | 18,958,073,707,314 | 178 | 23 |
def dfs(s):
global ans
if len(s) == n:
cnt = 0
for i in range(q):
if s[abcd[i][1]-1]-s[abcd[i][0]-1] == abcd[i][2]:
cnt += abcd[i][3]
ans = max(ans, cnt)
return
last = 1
if len(s) > 0:
last = s[-1]
for i in range(last, m+1):
dfs(s+[i])
return
n, m, q = map(int, input().split())
abcd = [list(map(int, input().split())) for i in range(q)]
ans = 0
dfs([])
print(ans) | N, M, Q = map(int, input().split())
res = 0
def dfs(L: list):
global res
A = L[::]
if len(A) == N + 1:
now = 0
for i in range(Q):
if A[b[i]] - A[a[i]] == c[i]:
now += d[i]
res = max(res, now)
# print(A, now)
return
A.append(A[-1])
while A[-1] <= M:
dfs(A)
A[-1] += 1
a, b, c, d = [], [], [], []
for _ in range(Q):
_a, _b, _c, _d = map(int, input().split())
a.append(_a)
b.append(_b)
c.append(_c)
d.append(_d)
dfs([1])
print(res)
| 1 | 27,570,421,723,080 | null | 160 | 160 |
N = int(input())
a_list = list(map(int, input().split()))
a_list.reverse()
partial_sum = 0
sum_ = 0
for i in range(1, N):
partial_sum += a_list[i-1]
sum_ += a_list[i] * partial_sum
print(sum_ % (10 ** 9 + 7)) | N = int(input())
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
sum = sum(A) ** 2
squ = 0
for i in range(N):
squ += A[i] ** 2
answer = int(((sum - squ) // 2 ) % mod)
print(answer) | 1 | 3,873,529,613,340 | null | 83 | 83 |
S = int(input())
h = S//3600
m = (S%3600)//60
s = S%60
print(h,":",m,":",s,sep='')
| n=int(input())
ans=0
for i in range(1000):
ans=n+i
if ans%1000==0:
print(i)
break | 0 | null | 4,419,679,045,532 | 37 | 108 |
S = raw_input()
areas = []
stack = []
for i,c in enumerate(S):
if c == "\\":
stack.append(i)
elif c == "/":
if len(stack) > 0:
j = stack.pop()
area = i-j
while len(areas) > 0:
p,a = areas.pop()
if j < p:
area += a
else:
areas.append((p, a))
break
areas.append((j, area))
A = map(lambda x:x[1], areas)
print sum(A)
if len(A) == 0:
print "0"
else:
print len(A), " ".join(map(str, A))
| # coding: utf-8
s = list(input().rstrip())
ht = []
ponds=[]
for i, ch in enumerate(s):
if ch == "\\":
ht.append(i)
elif ch == "/":
if ht:
b = ht.pop()
ap = i - b
if not ponds:
ponds.append([b, ap])
else:
while ponds:
p = ponds.pop()
if p[0] > b:
ap += p[1]
else:
ponds.append([p[0],p[1]])
break
ponds.append([b,ap])
else:
pass
ans = ""
area = 0
for point, ar in ponds:
area += ar
ans += " "
ans += str(ar)
print(area)
print(str(len(ponds)) + ans)
| 1 | 56,477,161,860 | null | 21 | 21 |
from itertools import permutations as p
N = int(input())
P = tuple(map(int,input().split()))
Q = tuple(map(int,input().split()))
j = 0
for i in p(range(1, N + 1)):
j += 1
if i == P: a = j
if i == Q: b = j
if a - b >= 0: print(a - b)
else: print(b - a) | def main():
n = input()
A = map(int,raw_input().split())
c = mergeSort(A,0,n)
for i in range(n-1):
print A[i],
print A[-1]
print c
def merge(A,left,mid,right):
n1 = mid - left
n2 = right - mid
L = [A[left+i] for i in range(n1)]
L += [float("inf")]
R = [A[mid+i] for i in range(n2)]
R += [float("inf")]
i = 0
j = 0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
return i+j
def mergeSort(A,left,right):
if left+1 < right:
mid = (left+right)/2
k1 = mergeSort(A,left,mid)
k2 = mergeSort(A,mid,right)
k3 = merge(A,left,mid,right)
return k1+k2+k3
else:
return 0
if __name__ == "__main__":
main() | 0 | null | 50,325,122,137,652 | 246 | 26 |
class Proc:
def __init__(self, name, time):
self.name = name
self.time = time
n, q = map(int, input().split(' '))
procs = []
for i in range(0, n):
name, time = input().split(' ')
time = int(time)
procs.append(Proc(name, time))
elapsed = 0
while len(procs) > 0:
proc = procs.pop(0)
if proc.time > q:
proc.time -= q
elapsed += q
procs.append(proc)
else:
elapsed += proc.time
print(proc.name, elapsed) | X,Y = list(map(int,input().split()))
MAXN = 2*(10**6)+10
p = 10**9+7
f = [1]
for i in range(MAXN):
f.append(f[-1] * (i+1) % p)
def nCr(n, r, mod=p):
return f[n] * pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod
Z = (X+Y)//3
if Z*3!=X+Y:
print(0)
else:
P,Q = X-Z, Y-Z
if P<0 or Q<0:
print(0)
else:
print(nCr(Z,P))
| 0 | null | 75,179,964,192,704 | 19 | 281 |
li = list(map(int,input().split()))
n = 1
for i in li:
if i == 0:
print(n)
n += 1 | def main():
x=list(map(int,input().split()))
for i in range(5):
if x[i] == 0:
print(i+1)
main() | 1 | 13,501,690,990,558 | null | 126 | 126 |
i=1
while True :
x,y=map(int,input().split());
if (x,y) == (0,0) :
break
else :
if x < y :
print(x,y)
else :
print(y,x)
| H = int(input())
W = int(input())
N = int(input())
A_div, A_mod = divmod(N, H)
if A_mod != 0:
A_div += 1
B_div, B_mod = divmod(N, W)
if B_mod != 0:
B_div += 1
print(min(A_div, B_div)) | 0 | null | 44,416,545,905,600 | 43 | 236 |
word=input()
last_letter=word[int(len(word))-1]
if last_letter=="s":
print(word+"es")
else:
print(word+"s") | n=input().strip()
if n[-1]=='s':
print(n+'es')
else:
print(n+'s') | 1 | 2,418,965,673,882 | null | 71 | 71 |
def circle(n):
return n * n
if __name__ == "__main__":
n = int(input())
print(circle(n)) | r = int(input())
n = (r*r) / 3.14
print(int(n / (1/3.14))) | 1 | 144,867,178,357,860 | null | 278 | 278 |
import sys
import math
input = sys.stdin.readline
def warshall_floyd(d):
for k in range(len(d)):
for i in range(len(d)):
for j in range(len(d)):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
N, M, L = map(int, input().split())
d = [[math.inf] * N for _ in range(N)]
for i in range(N):
d[i][i] = 0
for _ in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
d[a][b] = c
d[b][a] = c
warshall_floyd(d)
for i in range(N):
for j in range(N):
d[i][j] = 1 if d[i][j] <= L else math.inf
for i in range(N):
d[i][i] = 0
warshall_floyd(d)
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if s == t:
print(0)
elif d[s][t] == math.inf:
print(-1)
else:
print(d[s][t]-1)
| from collections import deque
def bfs(g, source):
n = len(g)
d = [float('inf') for _ in range(n)]
d[0] = 0
queue = deque()
queue.append(0)
while len(queue) > 0:
cur = queue.popleft()
for next in g[cur]:
if d[cur] + 1 < d[next]:
d[next] = d[cur] + 1
queue.append(next)
return d
def main():
n = int(input())
g = [[] for _ in range(n)]
for _ in range(n):
inp = list(map(int, input().split()))
m = inp[0] - 1
k = inp[1]
for i in range(k):
g[m].append(inp[i+2] - 1)
d = bfs(g, 0)
for i in range(n):
if d[i] == float('inf'):
d[i] = -1
print(i+1, d[i])
if __name__ == '__main__':
main()
| 0 | null | 86,787,514,582,296 | 295 | 9 |
n,k = map(int,input().split())
h = list(map(int,input().split()))
h.sort(reverse=True)
for i in range(min(n,k)):
h[i] = 0
print(sum(h))
| import sys
import bisect
N = int(input())
L = list(map(int, input().split()))
LS = sorted(L)
ans = 0
for i in range(N):
for j in range(N):
if i < j:
index = bisect.bisect_left(LS,LS[i]+LS[j])
ans += index-j-1
print(ans) | 0 | null | 125,133,833,420,700 | 227 | 294 |
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
X, Y = LI()
print(X * Y)
| print(eval(input().replace(' ','*'))) | 1 | 15,840,086,866,108 | null | 133 | 133 |
a = input()
if(a[-1] == 's'):
print(a+'es')
else:
print(a+'s') | def main():
A, B, K = map(int, input().split())
r = max(0, A + B - K)
a = min(r, B)
t = r - a
print(t, a)
if __name__ == '__main__':
main()
| 0 | null | 53,119,941,532,460 | 71 | 249 |
N = int(input())
S = [input() for n in range(N)]
assert len(S) == N
counts = {'AC': 0, 'WA': 0, 'TLE': 0, 'RE': 0}
for s in S:
counts[s] += 1
for key in ['AC', 'WA', 'TLE', 'RE']:
print('{} x {}'.format(key, counts[key])) | def main():
from sys import stdin
readline = stdin.readline
N = int(readline().rstrip())
c0 , c1 , c2 , c3 = 0 , 0 , 0 , 0
for i in range(N):
test = readline().rstrip()
if test == "AC":
c0 += 1
elif test == "WA":
c1 += 1
elif test == "TLE":
c2 += 1
elif test == "RE":
c3 += 1
c0 = "AC x " + str(c0)
c1 = "WA x " + str(c1)
c2 = "TLE x " + str(c2)
c3 = "RE x " + str(c3)
print(c0 + "\n" + c1 + "\n" + c2 + "\n" + c3)
main() | 1 | 8,630,445,500,602 | null | 109 | 109 |
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 7 15:49:02 2020
@author: liang
"""
N, X, Y = map(int, input().split())
ans = [0]*(N-1)
for i in range(1,N+1):
for j in range(i+1, N+1):
#print(i,j)
res = min(abs(i-j), abs(X-i) + 1 + abs(Y-j))
#print(i, j, res)
ans[res-1] += 1
for i in ans:
print(i) | n,x,y = map(int,input().split())
x -= 1
y -= 1
cnt = [0]*n
for i in range(n):
for j in range(i+1,n):
dis = min(j-i,abs(x-i)+1+abs(j-y))
cnt[dis] += 1
for i in range(1,n):
print(cnt[i]) | 1 | 44,283,807,650,978 | null | 187 | 187 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
class UnionFind:
def __init__(self, n):
# 負 : 根であることを示す。絶対値はランクを示す
# 非負: 根でないことを示す。値は親を示す
self.table = [-1] * n
self.size = [1] * n
# self.group_num = n
def root(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.root(self.table[x])
return self.table[x]
def get_size(self, x):
r = self.root(x)
return self.size[r]
def is_same(self, x, y):
return self.root(x) == self.root(y)
def union(self, x, y):
r1 = self.root(x)
r2 = self.root(y)
if r1 == r2:
return
# ランクの取得
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.size[r1] += self.size[r2]
if d1 == d2:
self.table[r1] -= 1
else:
self.table[r1] = r2
self.size[r2] += self.size[r1]
# self.group_num -= 1
n, k = LI()
P = LI()
C = LI()
U = UnionFind(n)
for i in range(n):
U.union(P[i] - 1, i)
D = defaultdict(int)
for i in range(n):
D[U.root(i)] += C[i]
ans = -INF
k -= 1
for j in range(n):
now = P[j] - 1
r = D[U.root(now)]
m = U.get_size(now)
ret = C[now]
ans = max(ans, ret)
if k // m and r >= 0:
ret += k // m * r
ans = max(ans, ret)
for l in range(k % m):
now = P[now] - 1
ret += C[now]
ans = max(ans, ret)
ret = C[now]
for l in range(min(m, k)):
now = P[now] - 1
ret += C[now]
ans = max(ans, ret)
print(ans)
| n,x,y=map(int,input().split())
a=[0]*n
for i in range(1,n+1):
for j in range(i,n+1):
b=min(abs(i-j),abs(i-x)+1+abs(y-j),abs(x-j)+1+abs(y-i))
a[b]+=1
print(*a[1:],sep="\n") | 0 | null | 24,759,751,933,380 | 93 | 187 |
n = int(input())
a = [int(i) for i in input().split()]
a.sort(reverse=True)
i = 1
ans = a[0]
c = 1
while c < n - 1:
k = min(2, n - 1 - c)
c += k
ans += a[i] * k
i += 1
print(ans)
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, r = map(int, input().split())
diff = 100 * (max(0, 10 - n))
print(r + diff)
if __name__ == '__main__':
resolve()
| 0 | null | 36,239,060,155,760 | 111 | 211 |
from math import pi # 円周率
# 浮動小数点数で読む
r = float(input())
area = r * r * pi
cir =(r+r) * pi
print(f'{(area):.6f} {(cir):.6f}')
| def main():
num = list(map(int,input().split()))
if num[0]*500>=num[1]:
print("Yes")
else:
print("No")
main() | 0 | null | 49,384,788,859,108 | 46 | 244 |
n = int(input())
numbers = list(map(int, input().split()))
print(' '.join(str(x) for x in numbers))
for i in range(1, n):
key = numbers[i]
j = i - 1
while 0 <= j and key < numbers[j]:
numbers[j+1] = numbers[j]
j -= 1
numbers[j+1] = key
print(' '.join(str(x) for x in numbers)) | def ins(A,N):
for i in range(N):
v=A[i]
j=i-1
while j>=0 and A[j]>v:
A[j+1]=A[j]
j-=1
A[j+1]=v
for k in range(len(A)):
if k==len(A)-1:
print(A[k])
else:
print(A[k],end=" ")
N=int(input())
A=list(map(int,input().split(" ")))
ins(A,N) | 1 | 5,195,285,618 | null | 10 | 10 |
import sys
def main():
k = int(input())
a =7%k
if a == 0:
print(1)
sys.exit()
for i in range(2,10**7):
a = (10*a+7) % k
if a == 0:
print(i)
sys.exit()
print(-1)
main() | hon=[2,4,5,7,9]
pon=[0,1,6,8]
bon=[3]
N=int(input())
if N%10 in hon:
print('hon')
elif N%10 in pon:
print('pon')
else:
print('bon') | 0 | null | 12,563,923,383,414 | 97 | 142 |
s = input()
prev = s[0]
for i in range(1, 3):
if s[i] != prev:
print('Yes')
break
else:
print('No')
| S = input()
if S == 'AAA' or S== 'BBB':
print("No")
else:
print("Yes") | 1 | 55,089,954,445,438 | null | 201 | 201 |
from math import ceil
A_HP, A_ATK, B_HP, B_ATK = map(int, input().split())
print('Yes' if ceil(A_HP / B_ATK) >= ceil(B_HP / A_ATK) else 'No') | import sys
import bisect
def input():
return sys.stdin.readline().rstrip()
def main():
N = int(input())
A = []
B = []
for i in range(N):
a, b = map(int, input().split())
A.append(a)
B.append(b)
pass
A.sort()
B.sort()
if N % 2 == 0:
n = N // 2
mini = (A[n]+A[n-1]) /2
maxi = (B[n]+B[n-1]) /2
print(int((maxi-mini)*2)+1)
else:
n = N//2
mini = A[n]
maxi = B[n]
print(maxi-mini+1)
if __name__ == "__main__":
main()
| 0 | null | 23,378,121,245,260 | 164 | 137 |
counter = 0
def merge(A, left, mid, right):
m = mid - left
n = right - mid
L = [None] * (m+1)
R = [None] * (n+2)
for i in range(m):
L[i] = A[left + i]
for i in range(n):
R[i] = A[mid + i]
L[m], R[n] = float("inf"), float("inf") # stoper
i, j = 0, 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
global counter
counter += right - left
return
def merge_sort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
return A
def main():
_ = input()
A = [int(i) for i in input().strip().split()]
merge_sort(A, 0, len(A))
print(" ".join([str(i) for i in A]))
if __name__ == "__main__":
counter = 0
main()
print(counter)
| a, b, c = map(int, input().split())
if(a < b & b < c) :
print("Yes")
else :
print("No")
| 0 | null | 246,950,982,432 | 26 | 39 |
n = int(input())
s = input()
l = []
for i in s:
l.append(chr((ord(i) - 65 + n) % 26 + 65))
print(*l, sep="") | N = int(input())
S = input()
A = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
ans = ''
for s in S:
ans += A[(A.index(s)+N)%26]
print(ans) | 1 | 134,695,029,886,930 | null | 271 | 271 |
s = input()
for _ in range(int(input())):
o = input().split()
a, b = map(int, o[1:3])
b += 1
c = o[0][2]
if c == 'p':
s = s[:a]+o[3]+s[b:]
elif c == 'i':
print(s[a:b])
elif c == 'v':
s = s[:a]+s[a:b][::-1]+s[b:]
| word = input()
n = int(input())
for _ in range(n):
meirei = input().split()
if meirei[0] == "print":
print(word[int(meirei[1]):int(meirei[2])+1])
elif meirei[0] == "reverse":
word = word[:int(meirei[1])] + word[int(meirei[1]):int(meirei[2])+1][::-1] + word[int(meirei[2])+1:]
elif meirei[0] == "replace":
word = word[:int(meirei[1])] + meirei[3] + word[int(meirei[2])+1:]
| 1 | 2,077,259,597,348 | null | 68 | 68 |
n = int(input())
title = []
length = []
for i in range(n):
a,b = map(str, input().split())
title.append(a)
length.append(int(b))
x = input()
ind = title.index(x)
print(sum(length[ind+1:])) | n=int(input())
s=[0]*n
t=[0]*n
for i in range(n):
s[i],t[i]=input().split()
t[i]=int(t[i])
print(sum(t[s.index(input())+1:])) | 1 | 97,047,303,273,012 | null | 243 | 243 |
n=input()
count=0
while 1 :
x=[i for i in input().split()]
if x[0]=="END_OF_TEXT":
break
for i in range(len(x)):
if x[i].lower()==n.lower():
count=count+1
print(count) | s=list(input());print(sum([1 for i,j in list(zip(s[:(len(s)//2)],s[len(s)//2:][::-1])) if i!=j])) | 0 | null | 61,198,797,898,812 | 65 | 261 |
i = int(input())
k = 1000
while k < i:
k += 1000
if k > i:
print(k - i)
elif k == i:
print(0) | import sys
input = sys.stdin.readline
class SegmentTree():
def __init__(self, S, n):
self.size = n
self.array = [set()] * (2**(self.size + 1) - 1)
for i, c in enumerate(S):
self.array[i + 2**self.size - 1] = {c}
for i in range(2**self.size - 1)[::-1]:
self.array[i] = self.array[2 * i + 1] | self.array[2 * i + 2]
def subquery(self, l, r, k, i, j):
if j <= l or r <= i:
return set()
elif l <= i and j <= r:
return self.array[k]
else:
l_set = self.subquery(l, r, 2 * k + 1, i, (i + j) // 2)
r_set = self.subquery(l, r, 2 * k + 2, (i + j) // 2, j)
return l_set | r_set
def query(self, l, r):
return len(self.subquery(l, r, 0, 0, 2**self.size))
def update(self, i, c):
tmp = i + 2**self.size - 1
self.array[tmp] = {c}
while tmp > 0:
tmp = (tmp - 1) // 2
self.array[tmp] = self.array[2 * tmp + 1] | self.array[2 * tmp + 2]
n = int(input())
S = [ord(c) for c in list(input())]
segtree = SegmentTree(S, 19)
for _ in range(int(input())):
t, i, c = input().split()
if t == '1':
segtree.update(int(i)-1, ord(c))
if t == '2':
print(segtree.query(int(i)-1, int(c)))
| 0 | null | 35,446,156,734,700 | 108 | 210 |
def cin():
in_ = list(map(int,input().split()))
if len(in_) == 1: return in_[0]
else: return in_
N = cin()
A = cin()
INF = 10 ** 9 + 7
res = [0 for _ in range(65)]
for i in range(65):
c0, c1 = 0, 0
for j in range(N):
if bool(A[j] & (1 << i)): c1 += 1
else: c0 += 1
res[i] = c0 * c1
ans = 0
for i in range(65): ans = (ans + (1 << i) * res[i]) % INF
print(ans) | mod = 10**9 + 7
n = int(input())
dat = list(map(int, input().split()))
cnt0 = [0] * 64
cnt1 = [0] * 64
for i in range(n):
for j in range(62):
if ((dat[i] >> j) & 1) == 1:
cnt1[j] += 1
else:
cnt0[j] += 1
#print(cnt0)
#print(cnt1)
res = 0
for i in range(62):
res += (cnt0[i] * cnt1[i]) << i
res %= mod
print(res) | 1 | 122,782,948,922,810 | null | 263 | 263 |
print int(raw_input("")) ** 3 | def cube(x):
return x**3
def main():
x = int(input())
ans = cube(x)
print(ans)
if __name__=='__main__':
main() | 1 | 277,839,149,182 | null | 35 | 35 |
N = int(input())
#リスト内包表記
Ss = [input() for _ in range(N)]
Ss_set = set(Ss)
print(len(Ss_set)) | N = int(input())
b=[]
c=[]
for j in range(N):
a = input()
b.append(a)
c = set(b)
print(len(c)) | 1 | 30,253,996,663,372 | null | 165 | 165 |
r=range(1,int(input())+1)
from math import gcd
print(sum(gcd(gcd(a,b),c) for a in r for b in r for c in r)) | K=int(input())
def gcd(p,q):
if p%q==0:
return q
return gcd(q,p%q)
S=0
for i in range(K):
for j in range(K):
for k in range(K):
S+=gcd(i+1,gcd(j+1,k+1))
print(S) | 1 | 35,610,286,087,850 | null | 174 | 174 |
#coding: UTF-8
l = raw_input().split()
a = int(l[0])
b = int(l[1])
if 1 <= a and b <= 1000000000:
d = a / b
r = a % b
f = float (a )/ b
print "%d %d %f" %(d, r, f) | a, b = map(int, input().split())
# a/bだとeやらEやら（名称忘れた）も出力されてしまうので小数点以下をフォーマットした
print(a//b, a % b, format(a/b, '.10f'))
| 1 | 602,898,862,410 | null | 45 | 45 |
T = input()
T = ['D' if c == '?' else c for c in T]
print(*T, sep='') | d=int(input())
a=[0 for i in range(26)]
c=list(map(int,input().split()))
l=[]
for i in range(d):
l.append(list(map(int,input().split())))
#print(c.index(max(c))+1)
p=[0]
for i in range(1,d+1):
t=int(input())-1
a[t]=i
k=0
for j in range(26):
k+=c[j]*(i-a[j])
p.append(p[i-1]+l[i-1][t]-k)
print(*p[1:],sep='\n') | 0 | null | 14,276,666,432,500 | 140 | 114 |
# coding:utf-8
import math
a,b,C=list(map(float,input().split()))
h=b*math.sin(math.radians(C))
S=a*h/2
c=math.sqrt(a**2+b**2-2*a*b*math.cos(math.radians(C)))
L=a+b+c
print('%.6f'%S)
print('%.6f'%L)
print('%.6f'%h) | # https://atcoder.jp/contests/abc157/tasks/abc157_e
import sys
input = sys.stdin.readline
class SegmentTree:
def __init__(self, n, op, e):
"""
:param n: 要素数
:param op: 二項演算
:param e: 単位減
例) 区間最小値 SegmentTree(n, lambda a, b : a if a < b else b, 10 ** 18)
区間和 SegmentTree(n, lambda a, b : a + b, 0)
"""
self.n = n
self.op = op
self.e = e
self.size = 1 << (self.n - 1).bit_length() # st[self.size + i] = array[i]
self.tree = [self.e] * (self.size << 1)
def built(self, array):
"""arrayを初期値とするセグメント木を構築"""
for i in range(self.n):
self.tree[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.tree[i] = self.op(self.tree[i << 1], self.tree[(i << 1) + 1])
def update(self, i, x):
"""i 番目の要素を x に更新"""
i += self.size
self.tree[i] = x
while i > 1:
i >>= 1
self.tree[i] = self.op(self.tree[i << 1], self.tree[(i << 1) + 1])
def get_val(self, l, r):
"""[l, r)の畳み込みの結果を返す"""
l, r = l + self.size, r + self.size
res = self.e
while l < r:
if l & 1:
res = self.op(self.tree[l], res)
l += 1
if r & 1:
r -= 1
res = self.op(self.tree[r], res)
l, r = l >> 1, r >> 1
return res
##################################################################################################################
def popcount(x):
return bin(x).count("1")
N = int(input())
st = SegmentTree(N, lambda a, b: a | b, 0)
S = input().strip()
data = []
for s in S:
data.append(1 << (ord(s) - ord("a")))
st.built(data)
Q = int(input())
for _ in range(Q):
q, a, b = input().split()
if q == "1":
st.update(int(a)-1, 1 << (ord(b) - ord("a")))
if q == "2":
a = int(a) - 1
b = int(b)
print(popcount(st.get_val(a, b))) | 0 | null | 31,536,819,432,690 | 30 | 210 |
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
MOD = 10 ** 9 + 7
N, K = map(int, readline().split())
d = [0] * (K+1)
for i in range(K,0,-1):
t = K // i
cnt = pow(t,N,MOD)
for j in range(2,t+1):
cnt -= d[i*j]
cnt %= MOD
d[i] = cnt
ans = 0
for num,cnt in enumerate(d):
ans += num * cnt
ans %= MOD
print(ans) | N,K=map(int,input().split())
MOD=int(1e9)+7
dp=[0]*(K+1)
for i in range(K):
j=K-i
dp[j]+=pow(K//j, N, MOD)
k=2*j
while k<=K:
dp[j]=(dp[j]-dp[k]+MOD) % MOD
k+=j
ans=0
for i in range(1,K+1):
ans+=dp[i]*i
ans%=MOD
print(ans) | 1 | 36,971,216,774,468 | null | 176 | 176 |
from math import log2
print(2 ** int(log2(int(input())) + 1) - 1) | h = int(input())
p = 1
i = 1
while h > 1:
h = h // 2
p += 2 ** i
i += 1
print(p) | 1 | 80,221,126,570,630 | null | 228 | 228 |
import sys
class Node:
def __init__(self, x):
self.x = x
def set_prev(self, prev):
self.prev = prev
def set_next(self, next):
self.next = next
class DoublelyLinkedList:
def __init__(self):
self.nil = Node(None)
self.nil.set_next(self.nil)
self.nil.set_prev(self.nil)
def insert(self, x):
new_elem = Node(x)
new_elem.set_next(self.nil.next)
new_elem.set_prev(self.nil)
self.nil.next.set_prev(new_elem)
self.nil.set_next(new_elem)
def list_search(self, x):
cur = self.nil.next
while cur != self.nil and cur.x != x:
cur = cur.next
return cur
def _delete(self, node):
node.prev.set_next(node.next)
node.next.set_prev(node.prev)
def delete_first(self):
self._delete(self.nil.next)
def delete_last(self):
self._delete(self.nil.prev)
def delete(self, x):
del_node = self.list_search(x)
if del_node.x is not None:
self._delete(del_node)
def main():
d_linked_list = DoublelyLinkedList()
for i in sys.stdin:
if 'insert' in i:
x = i[7:-1]
d_linked_list.insert(x)
elif 'deleteFirst' in i:
d_linked_list.delete_first()
elif 'deleteLast' in i:
d_linked_list.delete_last()
elif 'delete' in i:
x = i[7:-1]
d_linked_list.delete(x)
else:
pass
results = []
cur = d_linked_list.nil.next
while cur.x is not None:
results.append(cur.x)
cur = cur.next
print(*results)
if __name__ == "__main__":
main()
| from collections import defaultdict
def main():
n = int(input())
s =defaultdict(lambda:0)
for i in range(n):
s[input()] += 1
max_s = max(s.values())
for key, value in sorted(s.items()):
if value == max_s:
print(key)
if __name__ == "__main__":
main() | 0 | null | 34,915,941,780,290 | 20 | 218 |
n = input()
list = []
list = map(str, raw_input().split())
list.reverse()
print " ".join(list) | N = int(input())
A = list(map(int,input().split()))
Q = int(input())
M = list(map(int,input().split()))
def bitsearch():
nums = [0] * (2 ** N)
for i in range(2 ** N):
num = 0
for j in range(N):
if (i >> j) & 1:
num += A[j]
nums[i] = num
for q in range(Q):
if M[q] in nums:
print("yes")
else:
print("no")
bitsearch()
| 0 | null | 536,736,379,486 | 53 | 25 |
# N=4
# G=[[2],[4],[],[3]]
import sys
sys.setrecursionlimit(1000000)
N=int(input())
G=[list(map(int, input().split()))[2:] for _ in range(N)]
v=[False]*N
d=[0]*N
f=[0]*N
timecount=1
def dfs(i):
global timecount
if v[i] : return
v[i] = True
d[i] = timecount
# print("D",i+1,timecount)
timecount += 1
for p in G[i]:
dfs(p-1)
# print("F",i+1,timecount)
f[i] = timecount
timecount += 1
return
for i in range(N):
if v[i]==0: dfs(i)
for i in range(N):
print(i+1, d[i], f[i])
| from collections import deque
import copy
H,W=map(int,input().split())
MAP=[list(input()) for y in range(H)]
def Maze(_x, _y):
MAP2=copy.deepcopy(MAP)
q=deque([[_x,_y]])
MAP2[_y][_x]=0
while q:
xy=q.popleft()
for d in [(0,-1),(-1,0),(0,1),(1,0)]:
x2,y2=xy[0]+d[0],xy[1]+d[1]
if x2<0 or y2<0 or x2>=W or y2>=H:
continue
if MAP2[y2][x2]=='.':
q.append([x2,y2])
MAP2[y2][x2]=MAP2[xy[1]][xy[0]]+1
maxM=0
for y in range(H):
for x in range(W):
if type(MAP2[y][x])==int:
maxM=max(maxM, MAP2[y][x])
return maxM
ans=0
for y in range(H):
for x in range(W):
if MAP[y][x]=='.':
ans=max(ans, Maze(x,y))
print(ans) | 0 | null | 47,384,638,840,242 | 8 | 241 |
import queue
h,w,m = ( int(x) for x in input().split() )
h_array = [ 0 for i in range(h) ]
w_array = [ 0 for i in range(w) ]
ps = set()
for i in range(m):
hi,wi = ( int(x)-1 for x in input().split() )
h_array[hi] += 1
w_array[wi] += 1
ps.add( (hi,wi) )
h_great = max(h_array)
w_great = max(w_array)
h_greats = list()
w_greats = list()
for i in range( h ):
if h_array[i] == h_great:
h_greats.append(i)
for i in range( w ):
if w_array[i] == w_great:
w_greats.append(i)
ans = h_great + w_great - 1
escaper = False
for i in range( len(h_greats) ):
hi = h_greats[i]
for j in range( len(w_greats) ):
wi = w_greats[j]
if (hi,wi) not in ps:
ans += 1
escaper = True
break
if escaper:
break
print(ans) | h,w,m = ( int(x) for x in input().split() )
h_array = [ 0 for i in range(h) ]
w_array = [ 0 for i in range(w) ]
ps = set()
for i in range(m):
hi,wi = ( int(x)-1 for x in input().split() )
h_array[hi] += 1
w_array[wi] += 1
ps.add( (hi,wi) )
h_great = max(h_array)
w_great = max(w_array)
h_greats = list()
w_greats = list()
for i , hi in enumerate(h_array):
if hi == h_great:
h_greats.append(i)
for i , wi in enumerate(w_array):
if wi == w_great:
w_greats.append(i)
ans = h_great + w_great
for _h in h_greats:
for _w in w_greats:
if (_h,_w) in ps:
continue
print(ans)
exit()
print(ans-1) | 1 | 4,728,163,334,232 | null | 89 | 89 |
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
n = int(input())
A = get_nums_l()
# スキップできる回数
p = 1 if n%2==0 else 2
# log(p)
# dp[i][j][k] i==1なら次取れる スキップ回数をj回残してk個目まで見たときの最大和
dp = [ [ [0]*(n+1) for _ in range(p+1) ] for _ in range(2) ]
dp[0][0][0] = -999999999999999999
dp[0][1][0] = -999999999999999999
dp[1][0][0] = -999999999999999999
if p == 2:
dp[0][2][0] = -999999999999999999
dp[1][1][0] = -999999999999999999
# log(dp)
for k in range(n):
dp[0][0][k+1] = dp[1][0][k] + A[k]
dp[0][1][k+1] = dp[1][1][k] + A[k]
dp[1][0][k+1] = max(dp[1][1][k], dp[0][0][k])
dp[1][1][k+1] = dp[0][1][k]
if p == 2:
dp[0][2][k+1] = dp[1][2][k] + A[k]
dp[1][2][k+1] = dp[0][2][k]
#dp[1][0][k+1] = max(dp[1][0][k+1], dp[1][1][k])
dp[1][1][k+1] = max(dp[1][1][k+1], dp[1][2][k])
# for a in dp:
# for b in a:
# log(b)
ans = [dp[0][0][n], dp[0][1][n], dp[1][0][n], dp[1][1][n]]
if p == 2:
# ans.append(dp[0][2][n])
ans.append(dp[1][2][n])
print(max(ans))
| import copy
n = int(input())
a = list(map(int, input().split()))
k = 1 + n%2
INF = 10**18
dp = [[-INF]*4 for i in range(n+5)]
dp[0][0] = 0
for i in range(n):
for j in range(k+1):
dp[i+1][j+1] = max(dp[i+1][j+1], dp[i][j])
now = copy.deepcopy(dp[i][j])
if (i+j) % 2 == 0:
now += a[i]
dp[i+1][j] = max(dp[i+1][j], now)
print(dp[n][k])
| 1 | 37,477,188,362,234 | null | 177 | 177 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
x, n, *p = map(int, read().split())
sa = 10000
r = 10000
for i1 in range(-101, 202):
if i1 not in p:
if abs(x - i1) < sa:
sa = abs(x - i1)
r = i1
print(r)
if __name__ == '__main__':
main()
| import math
#入力
x = int(input())
x_upper = (x+1) / 1.08
x_lower = x / 1.08
x_candidate = math.ceil(x_lower)
if x_lower <= x_candidate < x_upper:
print(x_candidate)
else:
print(":(") | 0 | null | 70,101,523,716,080 | 128 | 265 |
import copy as cp
n = int(input())
A = [str(x) for x in input().split()]
AS = cp.copy(A)
def bubble(X):
for i in range(n):
X[i] = list(X[i])
X[i][1] = int(X[i][1])
for i in range(n):
for j in range(n-1):
if (X[j+1][1] < X[j][1]):
X[j],X[j+1] = X[j+1],X[j]
for i in range(n):
X[i][1] = str(X[i][1])
X[i] = "".join(X[i])
return(X)
BA = bubble(A)
def minsort():
for i in range(n):
AS[i] = list(AS[i])
AS[i][1] = int(AS[i][1])
for i in range(n):
minj = i
for j in range(i,n):
if (AS[j][1] < AS[minj][1]):
minj = j
if (minj != i):
AS[i],AS[minj] = AS[minj],AS[i]
for i in range(n):
AS[i][1] = str(AS[i][1])
AS[i] = "".join(AS[i])
return(AS)
MA = minsort()
for k in range(n-1):
print(str(BA[k])+" ",end = "")
print(str(BA[n-1]))
print("Stable")
for k in range(n-1):
print(str(MA[k])+" ",end = "")
print(str(MA[n-1]))
if (BA == MA):
print("Stable")
else :
print("Not stable")
| #! python3
# stable_sort.py
import copy
def num_from_card(card):
return int(card[1:])
def bubble_sort(A, N):
A_ = copy.copy(A)
flag = True
while flag:
flag = False
for i in range(N-1, 0, -1):
if num_from_card(A_[i]) < num_from_card(A_[i-1]):
A_[i-1], A_[i] = A_[i], A_[i-1]
flag = True
return A_
def selection_sort(A, N):
A_ = copy.copy(A)
for i in range(N-1):
minj = i
for j in range(i, N):
if num_from_card(A_[j]) < num_from_card(A_[minj]):
minj = j
if i != minj:
A_[i], A_[minj] = A_[minj], A_[i]
return A_
def is_stable(A, sorted_A, N):
A_nums = [int(x[1:]) for x in A]
same_num = [x for x in set(A_nums) if A_nums.count(x) > 1]
A_symbols, sorted_A_symbols = [], []
flag = 'Stable'
for num in same_num:
if [card[0] for card in A if int(card[1:]) == num] != [card[0] for card in sorted_A if int(card[1:]) == num]:
flag = 'Not stable'
break
return flag
N = int(input())
cards = [x for x in input().split(' ')]
bubble_sorted = bubble_sort(cards, N)
selection_sorted = selection_sort(cards, N)
print(' '.join(bubble_sorted))
print(is_stable(cards, bubble_sorted, N))
print(' '.join(selection_sorted))
print(is_stable(cards, selection_sorted, N))
| 1 | 25,659,031,474 | null | 16 | 16 |
def main():
x, n = list(map(int, input().split()))
if n > 0:
p_list = list(map(int, input().split()))
else:
return x
ans = 0
diff = abs(p_list[0]-x)
for i in range(n):
diff_new = abs(p_list[i] - x)
if diff_new < diff:
ans =i
diff=diff_new
#print(p_list[ans])
for i in range(200):
if p_list[ans] - i not in p_list:
return p_list[ans] - i
break
elif p_list[ans] + i not in p_list:
return p_list[ans] + i
break
if __name__=='__main__':
print(main()) | import sys
x,n = map(int,input().split())
p = list(map(int,input().split()))
s = 100
min_i = -1
if x not in p:
print(x)
sys.exit()
for i in range(-1,102):
if i not in p and abs(i-x) < s:
s = abs(i-x)
min_i = i
print(min_i)
| 1 | 14,076,621,994,272 | null | 128 | 128 |
n = int(input())
s = str(input())
if n % 2 == 1:
print("No")
exit()
if s[:n // 2] == s[n // 2:]:
print("Yes")
exit()
print("No") | #!/usr/bin/env python3
import sys
import string
l = [c for c in string.ascii_lowercase]
def f(N: int):
N -= 1
if N // 26:
return f(N//26) + l[N%26]
else:
return l[N%26]
def solve(N):
print(f(N))
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
solve(N)
if __name__ == '__main__':
main()
| 0 | null | 79,230,061,635,192 | 279 | 121 |
n, m, l = map(int, input().split())
a = []
b = []
c = []
for i in range(n):
ai = list(map(int, input().split()))
a.append(ai)
for i in range(m):
bi = list(map(int, input().split()))
b.append(bi)
for i in range(n):
ci = []
for j in range(l):
cij = 0
for k in range(m):
cij += a[i][k] * b[k][j]
ci.append(cij)
c.append(ci)
for i in range(n):
print(" ".join(list(map(str, c[i])))) | n, m, l = map(int,input().split())
a = list()
for i in range(n):
a.append(list(map(int,input().split())))
b = list()
for i in range(m):
b.append(list(map(int,input().split())))
for i in range(n):
line = list()
for j in range(l):
c = 0
for k in range(m):
c += a[i][k] * b[k][j]
line.append(str(c))
print(' '.join(line))
| 1 | 1,407,807,487,538 | null | 60 | 60 |
import sys
input = sys.stdin.readline
def main():
s = input().rstrip('\n')
if s[-1] == 's':
s += 'es'
else:
s += 's'
print(s)
if __name__ == '__main__':
main() | a=input()
e=a[len(a)-1:len(a)]
if e == "s":
print(a+"es")
else:
print(a+"s") | 1 | 2,408,437,457,020 | null | 71 | 71 |
nag = int(input())
def dfs(rootlist,deep,n):
global nag
if len(rootlist) != nag:
for i in range(n+1):
nextroot = rootlist[:]
nextroot.append(i)
if i < n:
dfs(nextroot,deep+1,n)
else:
dfs(nextroot,deep+1,n+1)
else:
answer = ''
wordlist = ['a','b','c','d','e','f','g','h','i','j']
for index in rootlist:
answer += wordlist[index]
print(answer)
dfs([0],0,1)
| from collections import deque
def scan(que, ps, way):
Li = 0
pp = ps
while len(que) > 0:
if way==0:
p = que.popleft()
else:
p = que.pop()
if p < ps:
Li += ps - p
else:
break
pp = p
return Li
if __name__=='__main__':
D = input()
que = deque()
p = 0
for c in D:
que.append(p)
if c == "\\" : p += -1
elif c == "/" : p += 1
que.append(p)
Ll = []
Lr = []
ls = que.popleft()
if len(que) > 0: rs = que.pop()
while len(que) > 0:
while len(que) > 0:
if que[0] < ls:
break
else:
ls = que.popleft()
while len(que) > 0:
if que[-1] < rs:
break
else:
rs = que.pop()
if len(que) > 0:
if ls < rs: Ll.append(scan(que,ls,0))
else : Lr.insert(0,scan(que,rs,1))
L = Ll + Lr
if len(L) > 0:
print(sum(L))
print(len(L), *L)
else:
print(0)
print(0) | 0 | null | 26,193,628,711,702 | 198 | 21 |
s=input()
res=""
for t in s:
if t.islower()==True:
res+=t.upper()
else:
res+=t.lower()
print(res)
| lit=input()
print(lit.swapcase())
| 1 | 1,512,734,844,678 | null | 61 | 61 |
'''
問題：
高橋君と青木君がモンスターを闘わせます。
高橋君のモンスターは体力が A で攻撃力が B です。
青木君のモンスターは体力が C で攻撃力が D です。
高橋君→青木君→高橋君→青木君→... の順に攻撃を行います。
攻撃とは、相手のモンスターの体力の値を自分のモンスターの攻撃力のぶんだけ減らすことをいいます。
このことをどちらかのモンスターの体力が 0 以下になるまで続けたとき、
先に自分のモンスターの体力が 0 以下になった方の負け、そうでない方の勝ちです。
高橋君が勝つなら Yes、負けるなら No を出力してください。
'''
'''
制約：
1 ≦ A, B, C, D ≦ 100
入力は全て整数である
'''
class Monster:
def __init__(self, hp, power):
self.hp = hp
self.power = power
def fight(self, power) -> int:
self.hp -= power
return self.hp
def is_loser(self) -> bool:
return self.hp <= 0
# 標準入力から A, B, C, D を取得する
a, b, c, d = map(int, input().split())
takahashi_monster = Monster(a, b) # 高橋モンスター
aoki_monster = Monster(c, d) # 青木モンスター
result = "ret"
while True:
aoki_monster.fight(b) # 高橋の攻撃
if aoki_monster.is_loser():
result = "Yes"
break
takahashi_monster.fight(d) # 青木の攻撃
if takahashi_monster.is_loser():
result = "No"
break
print(result)
| a, b, c, d = map(int, input().split())
i = 0
i1 = 0
while a > 0:
a -= d
i += 1
while c > 0:
c -= b
i1 += 1
if i >= i1:
print('Yes')
else:
print('No')
| 1 | 29,683,450,369,700 | null | 164 | 164 |
import sys
def Ii():return int(sys.stdin.buffer.readline())
def Mi():return map(int,sys.stdin.buffer.readline().split())
def Li():return list(map(int,sys.stdin.buffer.readline().split()))
k = Ii()
a,b = Mi()
for i in range(a,b+1):
if i%k == 0:
print('OK')
exit(0)
print('NG') | N,M = map(int,input().split())
print( 'No' if M < N else 'Yes') | 0 | null | 54,979,940,327,260 | 158 | 231 |
n,*a=map(int,open(0).read().split())
dp=[[0]*n for _ in range(3)]
for i in range(n):
if i%2:
dp[1][i]=max(dp[2][i-3]+a[i],dp[1][i-2]+a[i])
elif i>1:
dp[0][i]=max(dp[0][i-2]+a[i],dp[1][i-3]+a[i],dp[2][i-4]+a[i])
dp[2][i]=dp[2][i-2]+a[i]
else:
dp[2][i]=dp[2][i-2]+a[i]
print(max(dp[2][-3],dp[1][-2],dp[0][-1]) if n%2 else max(dp[1][-1],dp[2][-2])) | s=[0]*26
try:
while True:
n=str(input())
n=n.lower()
#print(n)
for i in range(len(n)):
if 97<=ord(n[i])<=122:
s[ord(n[i])-97]+=1
except EOFError:pass
for j in range(26):
print(chr(j+97),':',s[j])
| 0 | null | 19,391,701,278,652 | 177 | 63 |
r, c = map(int, input().split())
arr = []
for i in range(r):
arr.append(list(map(int, input().split())))
for line in arr:
line.append(sum(line))
arr.append([sum([line[i] for line in arr]) for i in range(c + 1)])
for line in arr:
print(*line) | #!/usr/bin/python3
cmdvar_numlist=input()
cmdvar_spritd=cmdvar_numlist.split()
D,T,S=list(map(int,cmdvar_spritd))
if D/S<=T:
print("Yes")
else:
print("No") | 0 | null | 2,438,110,166,048 | 59 | 81 |
import fractions
N = int(input())
A = list(map(int,input().split()))
MOD = 10** 9 + 7
lcm = 1
for a in A:
lcm = a // fractions.gcd(a,lcm) * lcm
print(sum(lcm//a for a in A)%MOD) | h = int(input())
w = int(input())
n = int(input())
lines = 0
act = 0
if h <= w:
# print('w long')
lines = h
act = w
else:
# print('h long')
lines = w
act = h
# print(lines)
# print(act)
draw = 0
for i in range(lines):
if n <= (i + 1) * act:
print(i + 1)
break | 0 | null | 88,452,206,790,610 | 235 | 236 |
def main():
n = int(input())
A = [int(x) for x in input().split()]
ans = 0
mod = 10 ** 9 + 7
for d in range(60):
# d桁目ごとに考える
x = 0
for a in A:
if (a >> d) & 1:
x += 1
ans += x * (n-x) * 2**d
ans %= mod
print(ans)
if __name__ == '__main__':
main() | import numpy as np
data = np.array([int(x) for x in str(input())])
if data.sum() % 9 == 0:
print("Yes")
else:
print("No")
| 0 | null | 63,749,261,945,152 | 263 | 87 |
N=int(input())
P=list(map(int,input().split()))
count=0
min=2*10**5
for i in range(N):
if P[i]<=min:
min=P[i]
count+=1
print(count)
| n = int(input())
for i in range(1, n+1):
if i % 3 == 0:
print(" " + str(i), end = "")
elif "3" in str(i):
print(" " + str(i), end = "")
print() | 0 | null | 43,036,245,428,280 | 233 | 52 |
from __future__ import print_function
import sys
from functools import reduce
input = sys.stdin.readline
def eprint(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
return
def solve02():
n = int(input().strip())
L = []
Xmin, Ymin, Xmax, Ymax = (sys.maxsize, sys.maxsize, -100, -100)
for i in range(n):
a, b = map(int, input().strip().split())
L.append((a, b))
Xmin, Ymin, Xmax, Ymax = (min(Xmin, a), min(Ymin, b), max(Xmax, a), max(Ymax, b))
A, B, C, D = ((Xmin, Ymax), (Xmin, Ymin), (Xmax, Ymin), (Xmax, Ymax))
# 対角線ACについて
d_MinDistFromA = sys.maxsize # 点Aからの距離が最小であるような，その最小の距離の値を求める
d_MinDistFromC = sys.maxsize # 点Cからの距離が最小であるような，その最小の距離の値を求める
# 対角線BDについて
d_MinDistFromB = sys.maxsize # 点Bからの距離が最小であるような，その最小の距離の値を求める
d_MinDistFromD = sys.maxsize # 点Dからの距離が最小であるような，その最小の距離の値を求める
for a, b in L:
d_MinDistFromA = min(d_MinDistFromA, abs(a - Xmin) + abs(b - Ymax))
d_MinDistFromC = min(d_MinDistFromC, abs(a - Xmax) + abs(b - Ymin))
d_MinDistFromB = min(d_MinDistFromB, abs(a - Xmin) + abs(b - Ymin))
d_MinDistFromD = min(d_MinDistFromD, abs(a - Xmax) + abs(b - Ymax))
# 出力
ans1 = abs(A[0] - C[0]) + abs(A[1] - C[1]) - (d_MinDistFromA + d_MinDistFromC)
ans2 = abs(B[0] - D[0]) + abs(B[1] - D[1]) - (d_MinDistFromB + d_MinDistFromD)
print(max(ans1, ans2))
def main():
solve02()
if __name__ == '__main__':
main() | n = int(input())
xy = [list(map(int, input().split())) for _i in range(n)]
x = [i+j for i, j in xy]
y = [i-j for i, j in xy]
x.sort()
y.sort()
print(max(abs(x[0]-x[-1]), abs(y[0]-y[-1]))) | 1 | 3,399,291,658,620 | null | 80 | 80 |
n, m = map(int, raw_input().split())
a, b, result = list(), list(), list()
for _ in range(n):
a.append(map(int, raw_input().split()))
for _ in range(m):
b.append(int(raw_input()))
for i in range(n):
temp = 0
for j in range(m):
temp += a[i][j] * b[j]
result.append(temp)
for i in result:
print(i) | N = int(input())
xyss = [[] for _ in range(N)]
for i in range(N):
A = int(input())
for _ in range(A):
x, y = map(int, input().split())
xyss[i].append((x-1, y))
ans = 0
for ptn in range(1<<N):
conflict = False
for i in range(N):
if (ptn>>i) & 1:
for x, y in xyss[i]:
if (ptn>>x) & 1 != y:
conflict = True
break
if conflict:
break
else:
num1 = bin(ptn).count('1')
if num1 > ans:
ans = num1
print(ans)
| 0 | null | 61,672,286,012,452 | 56 | 262 |
def ALDS1_5A():
n, A, q = int(input()), list(map(int, input().split())), int(input())
S=[False for i in range(2001)]
for a in A:
for i in range(2001-a, 0, -1):
if S[i]: S[i+a] = True
S[a] = True
for mi in input().split():
if S[int(mi)]:
print('yes')
else:
print('no')
if __name__ == '__main__':
ALDS1_5A() | H, W, M = map(int, input().split())
R = [0]*H #各行にある爆弾の個数
C = [0]*W #各列にある爆弾の個数
bombs = []
for _ in range(M):
h, w = map(lambda x: int(x)-1, input().split())
R[h] += 1
C[w] += 1
bombs.append((h, w))
R_max = max(R)
C_max = max(C)
### Rが最大かつCが最大な座標であって、
# そこに爆弾がない場合があれば
# 答えがR_max+C_max
# なければR_max+C_max-1
count = 0 # 爆弾がある座標であって、Rが最大かつCが最大の組の個数
for bx, by in bombs:
if R[bx] == R_max and C[by] == C_max:
count += 1
count_R = R.count(R_max)
count_C = C.count(C_max)
if count >= count_R*count_C:
ans = R_max + C_max - 1
else:
ans = R_max + C_max
print(ans) | 0 | null | 2,441,249,294,848 | 25 | 89 |
# A**5 = X + B**5
X = int(input())
l = []
for i in range(-300, 300):
l.append(i**5)
for b, b_5 in enumerate(l, start=-300):
# print(b, b_5, X)
if X+b_5 in l:
a_5 = X+b_5
a = l.index(a_5)-300
print(a, b)
break | K=int(input())
def gcd(p,q):
if p%q==0:
return q
return gcd(q,p%q)
S=0
for i in range(K):
for j in range(K):
for k in range(K):
S+=gcd(i+1,gcd(j+1,k+1))
print(S) | 0 | null | 30,567,794,033,480 | 156 | 174 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.