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
|
|---|---|---|---|---|---|---|
import math
x1, y1, x2, y2 = list(map(float, input().split()))
x = x2 - x1
y = y2 - y1
ans = math.sqrt(pow(x, 2) + pow(y, 2))
print(ans)
| n = int(input())
a = [int(x) for x in input().split()]
res = 0
for i in range(n):
for j in range(i+1,n):
res += a[i] * a[j]
print(res) | 0 | null | 84,504,811,163,668 | 29 | 292 |
a, b = list(map(int, input().split()))
if a <= b:
my_result = 'unsafe'
else:
my_result = 'safe'
print(my_result) | s,w=map(int,input().split())
if s>w: print("safe")
else: print("unsafe") | 1 | 29,164,729,549,340 | null | 163 | 163 |
# -*- coding: utf-8 -*-
n = input()
l = map(int, raw_input().split())
for i in range(n-1):
print l[n-i-1],
print l[0] | A,B,C,D = list(map(int,input().split()))
Takahashi = C//B
if C%B != 0 :
Takahashi += 1
Aoki = A//D
if A%D != 0 :
Aoki += 1
# print(Takahashi,Aoki)
ans='No'
if Takahashi <= Aoki:
ans = 'Yes'
print(ans) | 0 | null | 15,359,692,574,642 | 53 | 164 |
import itertools
def is_triangle(list_L):
if (list_L[0] + list_L[1] > list_L[2]) and (list_L[1] + list_L[2] > list_L[0]) and (list_L[2] + list_L[0] > list_L[1]) :
return True
else :
return False
def is_uniqueL(list_L):
return len(list_L) == len(set(list_L))
N = int(input())
L = map(int,input().split())
comb_L = list(itertools.combinations(L, 3))
sum = 0
for a_comb_L in comb_L :
if is_uniqueL(a_comb_L) == True and is_triangle(a_comb_L) == True:
sum += 1
print(sum) | x, n = map(int, input().split())
p = set(map(int, input().split()))
ans = 1000
ans = min(abs(x-i) for i in range(102) if i not in p)
print(x + ans if x - ans in p else x - ans)
| 0 | null | 9,622,800,360,384 | 91 | 128 |
K = int(input())
A, B = map(int, input().split())
i = A
while (i % K != 0) and (i <= B):
i += 1
if i == B+1:
print("NG")
else:
print("OK") | K = int(input())
A, B = map(int, input().split())
for i in range(1000):
C = K * i
if A <= C and C <= B:
print('OK')
exit()
print('NG') | 1 | 26,508,011,387,958 | null | 158 | 158 |
n = int(input())
for i in range(1,n+1):
if i % 3 == 0 or i % 10 == 3:
print(" {}".format(i), end='')
else:
x = i
while True:
x = x // 10
if x == 0:
break
elif x % 10 == 3:
print(" {}".format(i), end='')
break
print("") |
import collections,sys
def s():
d = collections.deque()
input()
for e in sys.stdin:
if "i"==e[0]: d.appendleft(e[7:-1])
else:
if " "==e[6]:
m = e[7:0-1]
if m in d: d.remove(m)
elif "i"==e[7]: d.popleft()
else: d.pop()
print(*d)
s()
| 0 | null | 495,012,840,890 | 52 | 20 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def main():
N = int(input())
A = [(i, v) for i, v in enumerate(map(int, input().split()))]
values = [[0] * (N + 1) for _ in range(N + 1)]
A.sort(key=lambda x:-x[1])
for i, (p, v) in enumerate(A):
for j in range(i + 1):
left = abs((p - j) * v)
right = abs((N - 1 - (i - j) - p) * v)
values[i + 1][j + 1] = max(values[i][j] + left, values[i + 1][j + 1])
values[i + 1][j] = max(values[i][j] + right, values[i + 1][j])
print(max(values[-1]))
if __name__ == '__main__':
main()
| import decimal
d = int(input())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
D_1 = 0
for i in range(d):
L_i = abs(x[i] - y[i])
D_1 += L_i
D_2 = 0
for i in range(d):
L_i = abs(x[i]-y[i])**2
D_2 += L_i
D_2 = (D_2) **(1/2)
D_3 = 0
for i in range(d):
L_i = abs(x[i]-y[i])**3
D_3 += L_i
D_3 = (D_3) ** (1/3)
L =[]
for i in range(d):
L.append(abs(x[i]-y[i]))
D_ = max(L)
print('{:.8f}'.format(D_1))
print('{:.8f}'.format(D_2))
print('{:.8f}'.format(D_3))
print('{:.8f}'.format(D_))
| 0 | null | 16,857,624,123,484 | 171 | 32 |
# coding: utf-8
# Here your code !
import collections
s=int(input())
deq =collections.deque()
for i in range(s):
n=input().split()
if n[0]=="insert":
deq.appendleft(n[1])
elif n[0]=="delete":
try:
deq.remove(n[1])
except ValueError:
pass
elif n[0]=="deleteFirst":
deq.popleft()
elif n[0]=="deleteLast":
deq.pop()
print(" ".join(list(deq))) | # ALDS1_3_C: Doubly Linked List
# collections.deque
# https://docs.python.org/3.8/library/collections.html#collections.deque
#n = 7
#A = [('insert', 5), ('insert', 2), ('insert', 3), ('insert', 1),
# ('delete', 3), ('insert', 6), ('delete', 5),]
from collections import deque
n = int(input())
mylist = deque()
for i in range(n):
myinput = input().split()
if len(myinput) == 1:
order = myinput[0]
x = 0
else:
order, x = myinput
#print(order, x)
if order == 'insert':
mylist.appendleft(x)
elif order == 'delete':
try:
mylist.remove(x)
except:
pass
elif order == 'deleteFirst':
#mylist.remove(mylist[0])
mylist.popleft()
elif order == 'deleteLast':
mylist.pop()
#print(mylist)
print(" ".join(map(str, mylist)))
| 1 | 50,400,130,352 | null | 20 | 20 |
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())
w = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
s = {}
s["a"] = 0
ans = [s]
for i in range(2, n+1):
new_s = {}
for t in s.items():
for j in range(1, i):
if t[0][-1] == w[j-1]:
for k in range(t[1] + 2):
new_s[t[0] + w[k]] = max(t[1], k)
ans.append(new_s)
s = new_s
answer = sorted(ans[n-1].keys())
for x in answer:
print(x)
| 1 | 52,449,260,589,280 | null | 198 | 198 |
N = int(input())
ans = N//2 + N%2
print(ans) | W,H,x,y,r=map(int,input().split())
a = x-r
b = x+r
c = y-r
d = y+r
if a>=0 and b<=W and c>=0 and d<=H:
print("Yes")
else:
print("No")
| 0 | null | 29,757,429,485,710 | 206 | 41 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
h, w = na()
m = []
m = [ns() for _ in range(h)]
dp = [[inf] * w for _ in range(h)]
dp[0][0] = int(m[0][0] == '#')
for x in range(1, w):
dp[0][x] = dp[0][x-1] + (int(m[0][x]=="#") if m[0][x-1]=="." else 0)
for y in range(1, h):
dp[y][0] = dp[y-1][0] + (int(m[y][0]=="#") if m[y-1][0]=="." else 0)
for x in range(1, w):
dp[y][x] = min(
dp[y][x-1] + (int(m[y][x]=="#") if m[y][x-1]=="." else 0),
dp[y-1][x] + (int(m[y][x]=="#") if m[y-1][x]=="." else 0)
)
print(dp[-1][-1]) | 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():
h,w = LI()
aa = [[0 if c == '.' else 1 for c in S()] for _ in range(h)]
dp = [[[inf]*2 for _ in range(w)] for __ in range(h)]
dp[0][0][aa[0][0]] = aa[0][0]
for i in range(h):
for j in range(w):
k = aa[i][j]
if i > 0:
dp[i][j][k] = min(dp[i][j][k], dp[i-1][j][k])
dp[i][j][k] = min(dp[i][j][k], dp[i-1][j][1-k]+1)
if j > 0:
dp[i][j][k] = min(dp[i][j][k], dp[i][j-1][k])
dp[i][j][k] = min(dp[i][j][k], dp[i][j-1][1-k]+1)
return min(dp[-1][-1][0] + 1, dp[-1][-1][1] + 2) // 2
print(main())
| 1 | 49,472,763,388,138 | null | 194 | 194 |
import math
n = int(input())
if n==0:
a=100000
else:
c = int(100)
for i in range(n):
num = c*1.05
c = math.ceil(num)
a = c*1000
print(a)
| N, M, X = map(int, input().split())
I = [list(map(int, input().split())) for i in range(N)]
C = [0] * N
A = [[0] * M] * N
for i in range(N):
C[i] = I[i][0]
A[i] = I[i][1:]
ans = -1
anslist = []
for i in range(2**N):
flag = 0
c = 0
total = [0] * M
for j in range(N):
if ((i >> j) & 1):
c += C[j]
for k in range(M):
total[k] += A[j][k]
for k in range(M):
if total[k] < X:
flag = 1
break
if flag == 1:
continue
anslist.append(c)
if len(anslist) != 0:
anslist.sort()
ans = anslist[0]
print(ans) | 0 | null | 11,224,955,951,760 | 6 | 149 |
#!usr/bin/env python3
import sys
def string_to_list_spliter():
h, w = [int(i) for i in sys.stdin.readline().split()]
return h, w
def generate_ractangle(h, w):
rect = ''
for i in range(h):
for j in range(w):
rect += '#'
rect += '\n'
return rect
def main():
while True:
h, w = string_to_list_spliter()
if h == 0 and w == 0:
break
print(generate_ractangle(h, w))
if __name__ == '__main__':
main() | while True:
s = input().rstrip().split(" ")
h=int(s[0])
w=int(s[1])
if (h == 0) & (w == 0):
break
for i in range(h):
print("#"*w)
print() | 1 | 775,969,468,520 | null | 49 | 49 |
a,b,c = [int(x) for x in input().split( )]
div = []
for x in range(1,c+1):
if c % x == 0:
div.append(x)
r = []
for x in range(a,b+1):
r.append(x)
answer = 0
for x in div:
for y in r:
if x == y:
answer += 1
print(answer)
| #!usr/bin/env python3
def string_two_numbers_spliter():
a, b, c = [int(i) for i in input().split()]
return a, b, c
def count_nums_of_divisors_of_c_in_a_and_b(a, b, c):
count = 0
for i in range(1, c+1):
if (c % i == 0):
if i >= a and i <= b:
count += 1
return count
def main():
a, b, c = string_two_numbers_spliter()
print(count_nums_of_divisors_of_c_in_a_and_b(a, b, c))
if __name__ == '__main__':
main() | 1 | 566,027,354,628 | null | 44 | 44 |
import math
N = int(input())
def mass_search(x):
divisor = 0
limit = math.floor(math.sqrt(x))
for i in range(1,limit+1):
if N % i == 0:
divisor = max(divisor, i)
x = divisor
y = N//divisor
return x+y-2
print(mass_search(N)) | n = int(input())
A = list(map(int, input().split( )))
mod = 10**9 + 7
#Aたちの最小公倍数をMとすれば
#答えはsum_{i}M/A_{i} (mod 10**9 + 7)
def lcm(X,Y):
x=X
y=Y
if y>x:
x,y=y,x
while x%y!=0:
x,y=y,x%y
return X*Y//y
#(A,B,C)の最小公倍数 =(A,B)の最小公倍数とCの最小公倍数を利用すれば簡単そう.
a = 1
c = 0
s = 0
for i in range(n):
q = lcm(a,A[i])
s*=q//a
a = q
s+=q//A[i]
print(s%mod)
| 0 | null | 124,776,166,993,380 | 288 | 235 |
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def main():
N = I()
a = LI()
dp = [0] * N
dp[1] = max(a[0], a[1])
c = a[0]
for i in range(2, N):
if i % 2 == 0:
c += a[i]
dp[i] = max(dp[i-2] + a[i], dp[i-1])
else:
dp[i] = max(dp[i-2] + a[i], c)
print(dp[-1])
if __name__ == '__main__':
main()
| #!/usr/bin/env python
# coding: utf-8
# In[21]:
N,K = map(int, input().split())
R,S,P = map(int,input().split())
T = input()
# In[22]:
points = {}
points["r"] = P
points["s"] = R
points["p"] = S
ans = 0
mylist = []
for i in range(N):
mylist.append(T[i])
if i >= K:
if T[i] == mylist[-K-1]:
mylist[-1] = "x"
else:
ans += points[T[i]]
else:
ans += points[T[i]]
print(ans)
# In[ ]:
| 0 | null | 71,922,383,803,388 | 177 | 251 |
class UnionFind():
def __init__(self, n):
self.r = [-1 for _ in range(n)]
def root(self, x):
if self.r[x] < 0:
return x
self.r[x] = self.root(self.r[x])
return self.r[x]
def unite(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.r[x] > self.r[y]:
x, y = y, x
self.r[x] += self.r[y]
self.r[y] = x
return True
def size(self, x):
return -self.r[self.root(x)]
n, m = map(int, input().split())
uf = UnionFind(n)
for _ in range(m):
a, b = map(int, input().split())
uf.unite(a - 1, b - 1)
max_friend = -min(uf.r)
print(max_friend) | a,b,c,k=map(int,open(0).read().split())
#while k:k-=1;t=a<b;b*=2-t;c*=1+t
while k:k-=1;exec(f'{"bc"[a<b]}*=2')
#while k:k-=1;exec('%c*=2'%'bc'[a<b])
#while k:k-=1;vars()['bc'[a<b]]*=2
print('NYoe s'[b<c::2]) | 0 | null | 5,460,254,674,068 | 84 | 101 |
import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from functools import reduce
# from math import *
from fractions import *
N, M = map(int, readline().split())
A = list(map(lambda x: int(x) // 2, readline().split()))
def f(n):
cnt = 0
while n % 2 == 0:
n //= 2
cnt += 1
return cnt
t = f(A[0])
for i in range(N):
if f(A[i]) != t:
print(0)
exit(0)
A[i] >>= t
M >>= t
lcm = reduce(lambda a, b: (a * b) // gcd(a, b), A)
if lcm > M:
print(0)
exit(0)
print((M // lcm + 1) // 2)
| import sys
import itertools
import fractions
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
def frac2(p):
return p//2
N,M=nm()
A=nl()
A=list(map(frac2,A))
min_bai=A[0]
for i in range(1,N):
min_bai=min_bai*A[i]//fractions.gcd(min_bai,A[i])
for i in range(N):
if((min_bai//A[i])%2==0):
print(0)
sys.exit(0)
tmp=M//min_bai
if(tmp%2==0):
tmp-=1
print((tmp+1)//2) | 1 | 101,993,858,685,638 | null | 247 | 247 |
def main():
a,b,c = map(int,input().split())
k = int(input())
i = 0
while a >= b:
b *= 2
i += 1
while b >= c:
c *= 2
i += 1
print("Yes" if i <= k else "No")
if __name__ == '__main__':
main() | import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N, M = [int(x) for x in input().split()]
ans = [[] for j in range(M)]
if N % 2:
for i in range(M):
ans[i].append(i + 1)
ans[i].append(N - i - 1)
else:
memo = 0
f = False
for i in range(M):
memo = i
if (i + 1) * 4 >= N:
f = True
break
ans[i].append(i + 1)
ans[i].append(N - i - 1)
if f:
for j in range(memo, M):
ans[j].append(j + 1)
ans[j].append(N - j - 2)
for a in ans:
print(*a)
if __name__ == '__main__':
main()
| 0 | null | 17,765,933,902,508 | 101 | 162 |
import sys
import fractions
def lcm(a,b):
return int(a*b/fractions.gcd(a,b))
if __name__ == '__main__':
for line in sys.stdin:
a,b = map(int,line.split())
print(int(fractions.gcd(a,b)),lcm(a,b)) | while True:
try:
a, b = map(int, input().split())
if a < b:
b, a = a, b
x, y = a, b
while b: a, b = b, a%b
gcd = a
lcm = (x*y)//gcd
print(gcd, lcm)
except:
break | 1 | 586,843,872 | null | 5 | 5 |
N = int(input())
A = list(map(int, input().split()))
B = [0]*60
mod = 10 ** 9 + 7
for x in A:
temp = bin(x)[2:]
for i in range(len(temp)):
if temp[-1-i] == "1":
B[i] += 1
ans = 0
for i in range(60):
ans += (N-B[i])*B[i]*pow(2, i, mod)
ans %= mod
print(ans)
| n = int(input())
alist = list(map(int,input().split()))
syain = [0]*n
for i in range(n-1):
syain[alist[i]-1] += 1
for i in range(n):
print(syain[i]) | 0 | null | 77,959,659,397,828 | 263 | 169 |
n = int(input())
ns = list(map(int, input().split()))
print(min(ns), max(ns), sum(ns))
| n= int(input())
l= list(map(int,input().split()))
s= 0
for i in range(n):
if(l[i]<l[0]):
l[0],l[i]= l[i],l[0]
for j in range(n):
if(l[n-1]<l[j]):
l[n-1],l[j]= l[j],l[n-1]
for k in range(n):
s+= l[k]
print(l[0],l[n-1],s) | 1 | 734,585,763,512 | null | 48 | 48 |
import sys
N,X,Y = map(int, input().split())
d = [0]*(N-1)
for i in range(N-1):
for j in range(i+1,N):
d[min(j-i,abs((X-1)-i)+1+abs((Y-1)-j))-1] += 1
#print(i,j,min(j-i,abs((X-1)-i)+1+abs((Y-1)-j))-1)
for i in range(len(d)):
print(d[i]) |
from collections import defaultdict
N, X, Y = map(int, input().split())
ctr = defaultdict(int)
for i in range(1, N + 1):
for j in range(i + 1, N + 1):
d = min(j - i, abs(i - X) + 1 + abs(j - Y))
ctr[d] += 1
for i in range(1, N):
print(ctr[i])
| 1 | 43,847,582,289,928 | null | 187 | 187 |
k = int(input())
acl = "ACL"
print(acl*k) | N = int(input())
print("ACL"*N)
| 1 | 2,186,437,540,870 | null | 69 | 69 |
# -*- coding: utf-8 -*-
def selection_sort(seq, l):
cnt = 0
for head_i in range(l):
flag = False
min_i = head_i
for target_i in range(head_i+1, l):
if seq[target_i] < seq[min_i]:
min_i = target_i
flag = True
if flag:
seq[head_i], seq[min_i] = seq[min_i], seq[head_i]
cnt += 1
print(' '.join([str(n) for n in seq]))
print(cnt)
def to_int(v):
return int(v)
def to_seq(v):
return [int(c) for c in v.split()]
if __name__ == '__main__':
l = to_int(input())
seq = to_seq(input())
selection_sort(seq, l) | N = int(raw_input())
A = map(int, raw_input().split())
def selectionSort(A, N):
count = 0
for i in range(0, N):
minj = i
for j in range(i, N):
if A[j] < A[minj]:
minj = j
if i != minj:
temp = A[i]
A[i] = A[minj]
A[minj] = temp
count += 1
return count
count = selectionSort(A, N)
print " ".join(map(str, A))
print count | 1 | 19,904,618,358 | null | 15 | 15 |
n,t=map(int,input().split())
ab=[list(map(int,input().split())) for _ in range(n)]
ab.sort(key=lambda x:x[0])
import numpy as np
ans=0
dp=np.zeros(t,np.int64)
# dp[i]:時間合計i以内に食べれる料理のおいしさ総和の最大
for i in range(n):
a,b=ab[i]
ans=max(ans,dp[-1]+b)
dp[a:]=np.maximum(dp[a:],dp[:-a]+b)
print(ans)
| from collections import deque
n = int(input())
a = deque()
for i in range(n):
c = input()
if c == "deleteFirst":
a.popleft()
elif c == "deleteLast":
a.pop()
else:
c, v = c.split()
if c == "insert":
a.appendleft(v)
else:
try:
a.remove(v)
except:
pass
print(" ".join(a))
| 0 | null | 76,136,159,826,008 | 282 | 20 |
# 入力
N, X, T = input().split()
N = int(N)
X = int(X)
T = int(T)
if N % X == 0:
cnt = int(N / X)
else:
cnt = int(N / X + 1)
print(cnt * T) | NXT= [int(i) for i in input().split(' ')]
i=NXT[0]
count=0
while i>0:
i -= NXT[1];count +=1
print(int(NXT[2]*count)) | 1 | 4,264,495,452,964 | null | 86 | 86 |
n, k, s = map(int, input().split())
a = [s] * n
if s == 1:
s = 2
else:
s -=1
for i in range(k, n):
a[i] = s
print(a[0], end = "")
for i in a[1:]:
print("", i, end = "")
print()
| n = int(input())
lis=[]
for _ in range(n):
x,l = map(int,input().split())
lis.append([x+l,x-l])
lis.sort()
m = -(10**9+7)
ans = 0
for i in range(n):
a ,b = lis[i]
if m <= b:
ans += 1
m = a
print(ans)
| 0 | null | 90,528,377,822,620 | 238 | 237 |
N = int(input())
X = []
for i in range(N):
X.append(input().split())
S = input()
flg = False
ans = 0
for x in X:
if flg:
ans += int(x[1])
if S == x[0]:
flg = True
print(ans) | 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,099,040,615,318 | null | 243 | 243 |
a,b=map(int,input().split())
dic={1:3*10**5,2:2*10**5,3:1*10**5}
c=0
if a in dic and b in dic:
if a==1 and b==1:
c+=dic[a]+dic[b]+4*10**5
print(c)
else:
c+=dic[a]+dic[b]
print(c)
elif a in dic and b not in dic:
c+=dic[a]
print(c)
elif b in dic and a not in dic:
c+=dic[b]
print(c)
else:
print(c)
| x, y = map(int,input().split())
print((max(4-x, 0) + max(4-y, 0) + 4*max(3-x-y, 0)) * 100000) | 1 | 140,414,656,100,024 | null | 275 | 275 |
def print_arr(arr):
arr_str = ''
for i in range(len(arr)):
arr_str += str(arr[i])
if i != len(arr) - 1:
arr_str += ' '
print(arr_str)
n = int(input())
arr = list(map(int, input().split()))
swap_count = 0
for i in range(n):
mini = i
for j in range(i, n):
if arr[j] < arr[mini]:
mini = j
if mini != i:
temp = arr[i]
arr[i] = arr[mini]
arr[mini] = temp
swap_count += 1
print_arr(arr)
print(swap_count)
| def ssort(a,n):
count = 0
for i in range(n):
mini = i
for j in range(i, n):
if a[mini]>a[j]:
mini = j
if i!=mini:
a[i], a[mini] = a[mini], a[i]
count+=1
print(*a)
print(count)
n= int(input())
a = [int(x) for x in input().split()]
ssort(a,n)
| 1 | 20,920,920,732 | null | 15 | 15 |
def main():
n, r = map(int, input().split())
if n < 10:
r += 100 * (10 - n)
print(r)
main()
| H, W = map(int, input().split())
h = H // 2
w = W // 2
if H == 1 or W == 1:
print(1)
exit()
if W % 2 == 1:
w += 1
if H % 2 == 1:
print(h * W + w)
else:
print(h * W) | 0 | null | 57,122,296,666,388 | 211 | 196 |
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
from collections import defaultdict
def get_sieve_of_eratosthenes(n, D):
limit = int(n ** 0.5) + 1
cnt_list = [0] * (n + 1)
for i in range(2, limit + 1):
if cnt_list[i] == 0:
k = n // i
for j in range(1, k + 1):
s = i * j
if cnt_list[s] == 0:
D[s] = i
cnt_list[s] = 1
for l in range(limit, n + 1):
if cnt_list[l] == 0:
D[l] = l
cnt_list[l] = 1
return D
N = I()
A = LI()
D = defaultdict()
max_a = max(A)
num_list = [0] * (max_a + 1)
if max_a == 1:
print("pairwise coprime")
exit()
g = A[0]
for a in A:
g = math.gcd(g, a)
if g > 1:
print('not coprime')
exit()
A_ = set(A)
A_.discard(1)
if len(A_) >= 90000:
print('setwise coprime')
exit()
D = get_sieve_of_eratosthenes(max_a, D)
for a in A:
P_list = defaultdict(int)
while a != 1:
x = D[a]
P_list[x] += 1
a //= x
for key in P_list.keys():
if num_list[key] != 0:
print('setwise coprime')
exit()
num_list[key] = 1
print('pairwise coprime')
if __name__ == "__main__":
main()
| n = int(input())
A = list(map(int,input().split()))
def factorize(n):
fct = [] # prime factor
b, e = 2, 0 # base, exponent
while b * b <= n:
while n % b == 0:
n = n // b
e = e + 1
if e > 0:
fct.append((b, e))
b, e = b + 1, 0
if n > 1:
fct.append((n, 1))
return fct
def gcd(a, b):
while b:
a, b = b, a % b
return a
pc = True
fac = [0]*(10**6+1)
for a in A:
lst = factorize(a)
for p in lst:
if not fac[p[0]]:
fac[p[0]] = 1
else:
pc = False
break
if not pc:
break
if pc:
print('pairwise coprime')
else:
g = A[0]
for i in range(1,n):
g = gcd(g, A[i])
if g == 1:
print('setwise coprime')
else:
print('not coprime') | 1 | 4,130,272,888,408 | null | 85 | 85 |
from sys import setrecursionlimit
setrecursionlimit(10 ** 6)
N = int(input())
Gb = [ [] for _ in range(N) ]
Gu = [ [] for _ in range(N) ]
Es = {}
for n in range(N - 1):
a, b = map(lambda x: int(x) - 1, input().split())
Es[f'{a:06}{b:06}'] = None
Gb[a].append(b)
Gb[b].append(a)
Gu[a].append(b)
colors = list(range(max(map(len, Gb))))
def dfs(base_node, edge_color):
global Es
valid_colors = filter(lambda color: color != edge_color, colors)
for child_node, color in zip(Gu[base_node], valid_colors):
Es[f'{base_node:06}{child_node:06}'] = color + 1
dfs(child_node, color)
print(len(colors))
dfs(0, None)
for color in Es.values():
print(color) | from collections import deque
n=int(input())
g=[[] for _ in range(n+1)]
e=[]
for i in range(n-1):
a,b=map(int,input().split())
g[a-1].append(b-1)
e.append(b-1)
q=deque([0])
color=[0 for _ in range(n)]
while(len(q)>0):
ei=q.popleft()
c=1
for x in g[ei]:
if c == color[ei]:
c+=1
color[x]=c
c+=1
q.append(x)
print(max(color))
for i in e:
print(color[i]) | 1 | 135,869,585,071,340 | null | 272 | 272 |
import numpy as np
from numpy.fft import rfft,irfft
import sys
sys.setrecursionlimit(10**9)
def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))
INF=10**20
class Polynomial:
def __init__(self,coefficient=None,dim=0,const=1):
if coefficient == None:
self.coefficient = np.zeros(dim+1, np.int64)
self.coefficient[dim] = const
else:
self.coefficient = coefficient
def __add__(self,other): # +
f,g = self.coefficient, other.coefficient
if len(f) > len(g): f,g = g,f
h = Polynomial(dim=len(g)-1,const=0)
h.coefficient[len(f):] += g[len(f):]
h.coefficient[:len(f)] += f + g[:len(f)]
return h
def __iadd__(self,other): # +=
h = self.__add__(other)
self.coefficient = h.coefficient
return self
def __mul__(self,other): # *
f = self.coefficient
g = other.coefficient
h = Polynomial()
h.coefficient = self.fft(f,g)[:len(f)+len(g)-1]
return h
def __len__(self):
return len(self.coefficient)
def __getitem__(self,key):
return self.coefficient[key]
def get_coefficient(self,x):
return self.coefficient[x]
def fft(self,A,B,fft_len=1<<18):
x = irfft(rfft(A,fft_len) * rfft(B,fft_len))
return np.rint(x).astype(np.int64)
def main():
N,M=mi()
A=list(mi())
coefficient = [0] * (2*10**5+10)
for a in A:
coefficient[a] += 1
f = Polynomial(coefficient=coefficient)
g = f * f
ans = 0
handshake = M
for x in range(len(g)-1,1,-1):
count = g[x]
if count <= 0: continue
if count > handshake:
ans += handshake * x
else:
ans += count * x
handshake = max(handshake-count,0)
if handshake == 0:
break
print(ans)
if __name__ == "__main__":
main()
| from bisect import bisect_left
def main():
n, m = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
L, R = 0, 2 * 10**5 + 1
while L+1 < R:
P = (L+R)//2
cnt = 0
for v in a:
x = P - v
cnt += n - bisect_left(a, x)
if cnt >= m:
L = P
else:
R = P
csum = [0]
for v in a:
csum.append(v)
for i in range(n):
csum[i+1] += csum[i]
ans = 0
cnt = 0
for v in a:
x = L - v
idx = bisect_left(a, x)
cnt += n-idx
ans += csum[-1] - csum[idx]
ans += v * (n - idx)
ans -= (cnt - m) * L
print(ans)
if __name__ == "__main__":
main() | 1 | 108,372,599,912,378 | null | 252 | 252 |
n,m=map(int,input().split())
for i in range(m):
if n%2==0 and 2*m-i-i-1>=n//2:
print(i+1,2*m-i+1)
else:
print(i+1,2*m-i) | # -*- coding: utf-8 -*-
n, m= [int(i) for i in input().split()]
for i in range(0,m):
if n-2*i-1>n/2 or n%2==1:
print(i+1,n-i)
else:
print(i+1,n-i-1) | 1 | 28,574,036,838,940 | null | 162 | 162 |
from collections import defaultdict
import itertools
N = int(input())
L = list(map(int, input().split()))
dic = defaultdict(int)
for num in L:
dic[num] += 1
set_L = set(L)
comb = list(itertools.combinations(set_L, 3))
ans = 0
for a,b,c in comb:
if a+b <= c or b+c<=a or c+a <= b: continue
ans += dic[a] * dic[b] * dic[c]
print(ans)
| def check(a,b,c):
if a == b:
return False
if b == c:
return False
if c == a:
return False
m = max(a,b,c)
if m >= (a+b+c)-m:
return False
return True
N = int(input())
L = list(map(int,input().split()))
ans = 0
if N >= 3:
for i in range(0,N-2):
for j in range(i+1,N-1):
for k in range(j+1,N):
if check(L[i],L[j],L[k]):
ans += 1
print(ans) | 1 | 5,051,483,294,844 | null | 91 | 91 |
# coding=utf-8
inputs = raw_input().rstrip().split()
a, b, c = [int(x) for x in inputs]
if a < b < c:
print 'Yes'
else:
print 'No' | in_str = input().split(" ")
a = int(in_str[0])
b = int(in_str[1])
c = int(in_str[2])
if a < b:
if b < c:
print("Yes")
else:
print("No")
else:
print("No") | 1 | 395,144,154,496 | null | 39 | 39 |
from decimal import *
getcontext().prec = 1000
a, b, c = map(lambda x: Decimal(x), input().split())
if a.sqrt() + b.sqrt() + Decimal('0.00000000000000000000000000000000000000000000000000000000000000000001') < c.sqrt():
print('Yes')
else:
print('No')
| #hは時間,mは60未満の分,sは60未満の秒
S=int(input())
h=int(S/3600)
m=int(S%3600/60)
s=int(S%3600%60)
print(str(h)+":"+str(m)+":"+str(s))
| 0 | null | 26,026,458,247,800 | 197 | 37 |
#from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7
#R = 998244353
def ddprint(x):
if DBG:
print(x)
n = inn()
a = inl()
acc = [0]*(n+1)
for i in range(n-1,-1,-1):
acc[i] = acc[i+1]+a[i]
#ddprint(acc)
x = 0
for i in range(n-1):
#ddprint(f"{x=} {i=} {acc[i+1]}")
x = (x+a[i]*acc[i+1])%R
print(x)
| n = int(input())
a = list(map(int, input().split()))
s, mod = sum(a)-a[0], 1000000007
ans = a[0]*s
for i in range(1, n):
s -= a[i]
ans = (ans % mod + ((s % mod) * a[i]) % mod) % mod
print(ans % mod)
| 1 | 3,819,934,778,150 | null | 83 | 83 |
s=[]
p=s.pop
for e in input().split():
s+=[e if e.isdigit() else str(eval(p(-2)+e+p()))]
print(*s) | ops = [op for op in input().split(" ")]
stack = []
for op in ops:
if op == "+":
stack = stack[:-2]+[stack[-2]+stack[-1]]
elif op == "-":
stack = stack[:-2]+[stack[-2]-stack[-1]]
elif op == "*":
stack = stack[:-2]+[stack[-2]*stack[-1]]
else:
stack.append(int(op))
print(stack[0]) | 1 | 36,745,565,600 | null | 18 | 18 |
#!/usr/bin/env python3
while(True):
try:
a,b=map(int, input().split())
except EOFError:
break
#euclidian algorithm
r=a%b
x,y=a,b
while(r>0):
x=y
y=r
r=x%y
gcd=y
lcm=int(a*b/gcd)
print("{0} {1}".format(gcd, lcm)) | 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 s(): 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")
p = L()
a,b = I()
u = s()
if u == p[0]:
a -=1
else:
b-=1
print("{} {}".format(a,b))
| 0 | null | 36,032,160,572,496 | 5 | 220 |
#!/usr/bin/env python3
import sys
from itertools import chain
# form bisect import bisect_left, bisect_right, insort_left, insort_right
# from collections import Counter
# import numpy as np
def solve(N: int, K: int, p: "List[int]"):
p = sorted(p)
return sum(p[:K])
def main():
tokens = chain(*(line.split() for line in sys.stdin))
# N, K, p = map(int, line.split())
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
p = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
answer = solve(N, K, p)
print(answer)
if __name__ == "__main__":
main()
| N = int(raw_input())
nums = map(int, raw_input().split(" "))
count = 0
for i in range(0, len(nums)):
for j in range(len(nums)-1, i, -1):
if nums[j-1] > nums[j]:
temp = nums[j-1]
nums[j-1] = nums[j]
nums[j] = temp
count += 1
nums = map(str, nums)
print(" ".join(nums))
print(count) | 0 | null | 5,861,126,834,954 | 120 | 14 |
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) | number = int(input())
word = input()
answer = word.count('ABC')
print(answer) | 1 | 99,242,261,456,508 | null | 245 | 245 |
S = input()
arr = [0]*(len(S) + 1)
cn = 0
for i in range(len(S)):
if S[i] == "<":
cn += 1
else:
cn = 0
arr[i+1] = cn
cn = 0
for i in range(len(S)-1, -1, -1):
if S[i] == ">":
cn += 1
else:
cn = 0
arr[i] = max(arr[i], cn)
# print(arr)
print(sum(arr)) | n=int(input())
s=[]
t=[]
for i in range(n):
st,tt=input().split()
s.append(st)
t.append(int(tt))
x=str(input())
temp=0
ans=sum(t)
for i in range(n):
temp=temp+t[i]
if s[i]==x:
break
print(ans-temp) | 0 | null | 126,891,042,764,040 | 285 | 243 |
a,b = map(int,input().split())
print(-1) if a > 9 or b > 9 else print(a*b) | value = int(input())
print(value ** 3) | 0 | null | 79,202,253,549,090 | 286 | 35 |
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions 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
#
#
#
# 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
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()
def yaku(m):
ans = []
i = 1
while i*i <= m:
if m % i == 0:
j = m // i
ans.append(i)
i += 1
ans = sorted(ans)
return ans
a = yaku(n)
#print(a)
ans = float('inf')
for v in a:
ans = min(ans, (v-1)+(n//v)-1)
print(ans)
| from collections import Counter
N=int(input())
S=input()
c=Counter(S+'RGB')
ans = (c['R']-1)*(c['G']-1)*(c['B']-1)
max_d = (N-3)//2+1
for d in range(1,max_d+1):
for i in range(N-2):
j = i+d
k = j+d
if k > N-1:break
if len(set([S[i],S[j],S[k]]))==3:
ans -= 1
print(ans) | 0 | null | 98,974,952,190,972 | 288 | 175 |
def main():
_, *S = open(0)
print(len(set(S)))
if __name__ == "__main__":
main() | def main():
n = int(input())
s_dict = dict()
for _ in range(n):
s = input()
if s in s_dict:
continue
else:
s_dict[s] = 1
print(sum(s_dict.values()))
if __name__ == "__main__":
main()
| 1 | 30,281,746,726,660 | null | 165 | 165 |
import math
def main():
N = int(input())
if N % 2 == 0:
print("{:.11f}".format((N / 2) / N))
else:
print("{:.11f}".format(math.ceil(N / 2) / N))
if __name__ == "__main__":
main()
| N = int(input())
ans = (N - (N//2)) / N
print(ans) | 1 | 177,140,829,442,938 | null | 297 | 297 |
import math
import cmath
def check(inp):
if inp==2:
return True
for num in xrange(2,int(math.sqrt(inp)+1)):
if inp%num==0:
return False
return True
st=set()
while True:
try:
str=raw_input().strip()
except EOFError:
break
#print str
num=int(str)
st.add(num)
sum=0
for nm in st:
if check(nm):
sum+=1
print sum
| x = int(input())
def check(input):
one = 1800
two = 1999
kyu = 1
while one >= 400:
if one <= input <= two:
return kyu
kyu += 1
one -= 200
two -= 200
print(check(x))
| 0 | null | 3,374,336,065,998 | 12 | 100 |
import sys
read = sys.stdin.read
INF = 1 << 60
def main():
H, N, *AB = map(int, read().split())
dp = [INF] * (H + 1)
dp[0] = 0
for a, b in zip(*[iter(AB)] * 2):
for i in range(H + 1):
if i >= a:
if dp[i] > dp[i - a] + b:
dp[i] = dp[i - a] + b
else:
if dp[i] > dp[0] + b:
dp[i] = dp[0] + b
print(dp[H])
return
if __name__ == '__main__':
main()
| HP, n = map(int, input().split())
AB = [list(map(int,input().split())) for _ in range(n)]
# DP
## DP[i]は、モンスターにダメージ量iを与えるのに必要な魔力の最小コスト
## DPの初期化
DP = [float('inf')] * (HP+1); DP[0] = 0
## HP分だけDPを回す.
for now_hp in range(HP):
## 全ての魔法について以下を試す.
for damage, cost in AB:
### 与えるダメージは、現在のダメージ量＋魔法のダメージか体力の小さい方
next_hp = min(now_hp+damage, HP)
### 今の魔法で与えるダメージ量に必要な最小コストは、->
####->現在わかっている値か今のHPまでの最小コスト＋今の魔法コストの小さい方
DP[next_hp] = min(DP[next_hp], DP[now_hp]+cost)
print(DP[-1]) | 1 | 81,248,595,801,070 | null | 229 | 229 |
n = int(input())
A = list(map(int, input().split()))
print(' '.join(list(map(str, 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
print(' '.join(list(map(str, A)))) | def insertionSort(R, n):
for i in range(1, n):
Now = R[i]
j = i - 1
while j >= 0 and R[j] > Now:
R[j + 1] = R[j]
j = j - 1
R[j + 1] = Now
trace(R, n)
def trace(R, n):
for i in range(n):
print R[i],
print
n = input()
R = map(int, raw_input().split())
trace(R, n)
insertionSort(R, n) | 1 | 6,271,711,292 | null | 10 | 10 |
m = input()
c = m[-1]
if c == 's':
print(m+'es')
else:
print(m+'s') | while True:
x, y = list(map(int, input().split()))
if (x == 0 and y == 0) :
break
if (x < y) :
print(str(x) + " " + str(y))
else :
print(str(y) + " " + str(x)) | 0 | null | 1,434,600,467,630 | 71 | 43 |
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
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 LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
inf=10**9
h,w=MI()
ss=[SI() for _ in range(h)]
cc=[[0]*w for _ in range(h)]
if ss[0][0]=="#":cc[0][0]=1
for i in range(h):
for j in range(w):
if (i,j)==(0,0):continue
u=l=inf
if i-1>=0:
u=cc[i-1][j]
if ss[i][j]=="#" and ss[i-1][j]==".":u+=1
if j-1>=0:
l=cc[i][j-1]
if ss[i][j]=="#" and ss[i][j-1]==".":l+=1
cc[i][j]=min(u,l)
print(cc[h-1][w-1])
main() | def resolve():
base = 998244353
N, K = map(int, input().split(" "))
LRs = []
for _ in range(K):
(L, R) = map(int, input().split(" "))
LRs.append((L, R))
dp = [0] * (N+1)
dp_sum = [0] * (N+1)
dp[1] = 1
dp_sum[1] = 1
for i in range(2, N+1):
for lr in LRs:
left = max(i - lr[1] - 1, 0)
right = max(i - lr[0], 0)
dp[i] += dp_sum[right] - dp_sum[left]
if dp[i] >= base:
dp[i] %= base
dp_sum[i] = dp_sum[i-1] + dp[i]
print(dp[-1])
if __name__ == "__main__":
resolve() | 0 | null | 25,927,832,142,648 | 194 | 74 |
#!/usr/bin/env python3
import sys
import math
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N = int(readline())
print(math.ceil(N / 2) / N)
if __name__ == '__main__':
main()
| n=int(input())
print((n//2+n%2)/n)
| 1 | 177,654,162,904,444 | null | 297 | 297 |
#入力の高速化
import sys
input = sys.stdin.readline
# ユニオンファインド
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m= map(int, input().split())
g= [list(map(int, input().split())) for i in range(m)]
UF=UnionFind(n)
for a,b in g:
a-=1
b-=1
UF.union(a,b)
ans=UF.group_count()-1
print(ans)
| import sys
data = sys.stdin.read()
letters = 'abcdefghijklmnopqrstuvwxyz'
for letter in letters:
count = 0
for d in data:
if letter == d.lower():
count += 1
print(f'{letter} : {count}')
| 0 | null | 1,981,274,506,400 | 70 | 63 |
from collections import Counter
S = list(map(int, list(input())))
A = [0]
for i, s in enumerate(S[::-1]):
A.append((A[-1] + s * pow(10, i, 2019)) % 2019)
print(sum([v * (v - 1) // 2 for v in Counter(A).values()]))
| s = input()
s = s[::-1]
L = [0]
cnt = 1
for i in range(len(s)):
L.append((L[-1]+(int(s[i])*cnt))%2019)
cnt *= 10
cnt %= 2019
D = dict()
for j in L:
if j in D:
D[j] += 1
else:
D[j] = 1
ans = 0
for k in D.values():
ans += k * (k-1) //2
print(ans) | 1 | 30,883,987,176,908 | null | 166 | 166 |
H, W = list(map(int, input().split()))
### 片方だけ奇数のマスには行くことができない
### Hが偶数、Wが偶数の場合 → H*W // 2
### Hが奇数、Wが偶数の場合 → H*W // 2 (Wが奇数の場合も同様)
### Hが奇数、Wが奇数の場合 → H*W // 2 + 1
if H == 1 or W == 1:
print(1)
elif H % 2 != 0 and W % 2 != 0:
print(int(H * W // 2) + 1)
else:
print(int(H * W // 2)) | h,w = [int(i) for i in input().split()]
if h == 1 or w == 1:
print(1)
elif h % 2 == 1 and w % 2 == 1:
print(int(h*w/2) + 1)
else:
print(int(h*w/2)) | 1 | 50,650,883,549,386 | null | 196 | 196 |
"""AtCoder."""
n = int(input()[-1])
s = None
if n in (2, 4, 5, 7, 9):
s = 'hon'
elif n in (0, 1, 6, 8):
s = 'pon'
elif n in (3,):
s = 'bon'
print(s)
| n=list(map(int,input()))
if n[-1] in [2,4,5,7,9]:
print('hon')
elif n[-1] in [0,1,6,8]:
print('pon')
else:
print('bon') | 1 | 19,312,648,567,850 | null | 142 | 142 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N, X, T = map(int, readline().split())
p = (N//X)*T
if N%X == 0:
print(p)
else:
print(p+T)
if __name__ == '__main__':
main()
| N,X,T=map(int,input().split())
count = 0
ans = 0
while count < N:
count += X
ans +=T
print(ans) | 1 | 4,239,198,485,122 | null | 86 | 86 |
n = int(input())
p = list(map(int, input().split()))
count = 0
for i in range(n) :
if i == 0 :
mn = p[i]
count += 1
else :
if mn > p[i] :
mn = p[i]
count += 1
print(count)
| import os, sys, re, math
N = int(input())
D = [int(n) for n in input().split()]
value = 0
for i in range(len(D) - 1):
for j in range(i + 1, len(D)):
value += D[i] * D[j]
print(value)
| 0 | null | 127,181,001,263,218 | 233 | 292 |
import sys
mapin = lambda: map(int, sys.stdin.readline().split())
listin = lambda: list(map(int, sys.stdin.readline().split()))
inp = lambda: sys.stdin.readline()
N = int(inp())
mp = {}
for i in range(N):
S = inp()
S = S[:-1]
if S in mp:
mp[S] += 1
else:
mp[S] = 1
ans = 0
vec = []
for i in mp.values():
if ans < i:
ans = i
for i in mp.keys():
if mp[i] == ans:
vec.append(i)
vec.sort()
for i in vec:
print(i) | n = int(input())
s = []
for i in range(n):
s.append(input())
s.sort()
# print(s)
m = 1
cnt = [1]
ans = []
for i in range(1,n):
if s[i] == s[i-1]:
cnt[-1] += 1
else:
if cnt[-1] > m:
ans = [s[i-1]]
elif cnt[-1] == m:
ans.append(s[i-1])
m = max(m, cnt[-1])
cnt.append(1)
if i == n-1 and cnt[-1] > m:
ans = [s[i]]
elif i == n-1 and cnt[-1] == m:
ans.append(s[i])
print('\n'.join(ans)) | 1 | 70,072,961,251,828 | null | 218 | 218 |
def main():
n = int(input())
a = list(map(int, input().split()))
dp = [-10**15]*(n+1)
dp[2] = max(a[0], a[1])
if n > 2:
dp[3] = max(a[:3])
aa = a[0]+a[2]
for i in range(4, n+1):
if i%2:
aa += a[i-1]
dp[i] = max(dp[i-1], dp[i-2]+a[i-1])
else:
dp[i] = max(aa, dp[i-2]+a[i-1])
print(dp[n])
if __name__ == "__main__":
main() | def main():
INF = 10 ** 18
N = int(input())
A = list(map(int, input().split(' ')))
K = 1 + N % 2 # 余分な×を入れられる個数
# dp[i][j]: i個目までの要素で余分な×をj個使った際の最大値
dp = [[- INF for _ in range(K + 1)] for _ in range(N + 1)]
dp[0][0] = 0
for i in range(N):
for j in range(K + 1):
if j < K:
# 余分な×を使う場合
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j])
# 余分な×を使わない場合
now = dp[i][j]
if (i + j) % 2 == 0:
# 基本はi % 2 == 0の時にA[i]を足していく
# ただ、余分な×がj個入っていると、その分ずれる
now += A[i]
dp[i + 1][j] = max(dp[i + 1][j], now)
print(dp[N][K])
if __name__ == '__main__':
main()
| 1 | 37,513,093,280,142 | null | 177 | 177 |
import sys
input = sys.stdin.buffer.readline
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A = sorted(A)
F = sorted(F)[::-1]
left = -1
right = max(A) * max(F)
while left + 1 < right:
mid = (left + right) // 2
tmp = 0
for i in range(N):
a, f = A[i], F[i]
if a * f > mid:
tmp += -(-(a * f - mid) // f)
if tmp <= K:
right = mid
else:
left = mid
print(right) | import math
N,K = map(int,input().split())
A = list(map(int,input().split()))
F = list(map(int,input().split()))
if sum(A) <= K:
print(0)
exit()
A.sort()
F.sort(reverse=True)
l,r = -1,10**12+1
while r-l > 1:
m = (l+r)//2
k = 0
for i in range(N):
a,f = A[i], F[i]
k += max(0,a-(m//f))
if k <= K:
r = m
else:
l = m
print(r) | 1 | 164,580,346,787,264 | null | 290 | 290 |
def insertionSort(A,n,g,count):
for i in range(g,N):
v = A[i]
j = i-g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j -= g
count += 1
A[j+g] = v
return count
def shellSort(A,n):
count = 0
m = 0
G = []
while (3**(m+1)-1)//2 <= n:
m += 1
G.append((3**m-1)//2)
for i in range(m):
count = insertionSort(A,n,G[-1-i],count)
return m,G,count
import sys
input = sys.stdin.readline
N = int(input())
A = [int(input()) for _ in range(N)]
m,G,count = shellSort(A,N)
print(m)
print(*G[::-1])
print(count)
print('\n'.join(map(str,A)))
| N = int(input())
XYS = [list(map(int, input().split())) for _ in range(N)]
s = 0
def perm(ns):
acc = []
def fill(ms, remains):
if remains:
for m in remains:
fill(ms + [m], [x for x in remains if x != m])
else:
acc.append(ms)
fill([], ns)
return acc
s = 0
for indexes in perm(list(range(N))):
xys = [XYS[i] for i in indexes]
x0, y0 = xys[0]
for x1, y1 in xys:
s += ((x0 - x1)**2 + (y0 - y1)**2) ** 0.5
x0 = x1
y0 = y1
nf = 1
for i in range(1, N+1):
nf *= i
ans = s / nf
print(ans) | 0 | null | 73,881,752,592,608 | 17 | 280 |
S = list(map(str,input()))
for i in range(len(S)):
S[i] = 'x'
print(''.join(map(str,S))) | s=input()
n=len(s)
ans='x'*n
print(ans) | 1 | 73,152,410,046,718 | null | 221 | 221 |
while True:
x = input().split()
a = int(x[0])
b = int(x[1])
if a == 0 and b == 0:
break
elif a > b:
print('{0} {1}'.format(b, a))
else:
print('{0} {1}'.format(a, b)) | n=int(input())
lst={}
for i in range(n):
lst[input()]=1
print(len(lst)) | 0 | null | 15,475,933,394,672 | 43 | 165 |
import sys
dice = [int(i) for i in sys.stdin.readline().split()]
command = sys.stdin.readline().strip()
for c in command:
if c == "N":
dice = (dice[1], dice[5], dice[2], dice[3], dice[0], dice[4])
elif c == "S":
dice = (dice[4], dice[0], dice[2], dice[3], dice[5], dice[1])
elif c == "W":
dice = (dice[2], dice[1], dice[5], dice[0], dice[4], dice[3])
elif c == "E":
dice = (dice[3], dice[1], dice[0], dice[5], dice[4], dice[2])
print(dice[0]) | class Dice():
def __init__(self, *n):
self.rolls = n
def spin(self, order):
if order == "N":
self.rolls = [
self.rolls[1],
self.rolls[5],
self.rolls[2],
self.rolls[3],
self.rolls[0],
self.rolls[4]
]
if order == "E":
self.rolls = [
self.rolls[3],
self.rolls[1],
self.rolls[0],
self.rolls[5],
self.rolls[4],
self.rolls[2]
]
if order == "S":
self.rolls = [
self.rolls[4],
self.rolls[0],
self.rolls[2],
self.rolls[3],
self.rolls[5],
self.rolls[1]
]
if order == "W":
self.rolls = [
self.rolls[2],
self.rolls[1],
self.rolls[5],
self.rolls[0],
self.rolls[4],
self.rolls[3]
]
return self.rolls[0]
d = Dice(*[int(i) for i in input().split()])
for order in list(input()):
l = d.spin(order)
print(l) | 1 | 225,924,066,976 | null | 33 | 33 |
K = int(input())#asking lenght of string wanted to be shorted
S = input()#asking string
if len(S)>K:##set that S must be greater than K
print (S[:K], "...",sep="")# to print only the K number of the string
else:
print (S) | K=int(input())
S=input()
list1=[]
if len(S)<=K:
print(S)
else:
for i in range(K):
list1.append(S[i])
list1.append("...")
S2="".join(list1)
print(S2) | 1 | 19,829,684,346,318 | null | 143 | 143 |
#単位元を設定
ide = 0
class SegmentTree:
def __init__(self,n):
#セグ木の頂点はindex == 1から。index == 0は無視すること。
#つまり、STtable[0]は無視。頂点はSTtable[1]。
self.n = n
tmp = 0
while True:
if 2 ** tmp >= self.n:
break
tmp += 1
self.STtable = [ide] * (2*2**tmp)
self.STtable_size = len(self.STtable)
def update(self,i,a):
#更新のためのインデックスの指定は0_indexedで。
a_bit = 1 << ord(a)-97
i += self.STtable_size//2
self.STtable[i] = a_bit
while i > 0:
i //= 2
self.STtable[i] = self.STtable[i*2] | self.STtable[i*2+1]
def find(self,a,b,k=1,l=0,r=None):
#kは頂点番号。初期値は1にすること。
#[a,b)の最小を返す。
#[l,r)からです。
#初期値のrは、self.STtable_size//2にすると、ちょうど要素数と同じ値になって[l,r)のrになる。
#問題に適するように範囲を指定するように注意。大体[l,r]で指定されている。
if r == None:
r = self.STtable_size//2
if a >= r or b <= l:
return ide
elif a <= l and b >= r:
return self.STtable[k]
else:
mid = (l+r)//2
if b <= mid:
return self.find(a,b,2*k,l,mid)
elif a >= mid:
return self.find(a,b,2*k+1,mid,r)
else:
v1 = self.find(a,mid,2*k,l,mid)
v2 = self.find(mid,b,2*k+1,mid,r)
return v1 | v2
N = int(input())
solve = SegmentTree(N)
S = input()
for i in range(N):
solve.update(i,S[i])
Q = int(input())
ans = []
for _ in range(Q):
a,b,c = map(str, input().split())
if a == '1':
solve.update(int(b)-1,c)
else:
tmp = solve.find(int(b)-1,int(c))
cnt = 0
for i in range(26):
if tmp >> i & 1 == 1:
cnt += 1
ans.append(cnt)
for a in ans:
print(a)
|
N = int(input())
S = [x for x in input()]
Q = int(input())
#A1 ... AnのBIT(1-indexed)
BIT = [[0] * (N + 1) for _ in range(26)]
#A1 ~ Aiまでの和 O(logN)
def BIT_query(input_BIT, idx):
res_sum = 0
while idx > 0:
res_sum += input_BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(input_BIT,idx,x):
while idx <= N:
input_BIT[idx] += x
idx += (idx&(-idx))
return
for i, c in enumerate(S):
BIT_update(BIT[ord(c)-ord('a')], i+1, 1)
for _ in range(Q):
a, b, c = input().rstrip().split()
if int(a) == 1:
BIT_update(BIT[ord(S[int(b)-1])-ord('a')], int(b), -1)
BIT_update(BIT[ord(c)-ord('a')], int(b), 1)
S[int(b)-1] = c
else:
count = 0
for i in range(26):
if BIT_query(BIT[i], int(b)-1) != BIT_query(BIT[i], int(c)):
count += 1
print(count) | 1 | 62,529,644,208,102 | null | 210 | 210 |
s = len(input())
print('x'*s)
| n = input()
print(n.replace(n,'x'*len(n))) | 1 | 72,855,559,913,602 | null | 221 | 221 |
def sieve_of_eratosthenes(N):
N += 1
sieve = [0] * N
for p in range(2, N):
if sieve[p]:
continue
for i in range(p, N, p):
sieve[i] = p
return sieve
def lcm_with_sieve(numbers, N):
sieve = sieve_of_eratosthenes(N)
lcm = dict()
for n in numbers:
d = dict()
while n > 1:
factor = sieve[n]
n //= factor
d[factor] = d.get(factor, 0) + 1
for factor, power in d.items():
lcm[factor] = max(lcm.get(factor, 0), power)
return lcm
def main():
MOD = 10 ** 9 + 7
_, *A = map(int, open(0).read().split())
lcm = 1
for factor, power in lcm_with_sieve(A, 10 ** 6).items():
lcm = lcm * pow(factor, power, MOD) % MOD
total = 0
for a in A:
total = (total + lcm * pow(a, MOD - 2, MOD)) % MOD
print(total)
main() | from collections import Counter
N = int(input())
A = list(map(int,input().split()))
memo = []
for i in range(N):
tmp = []
a = A[i]
d = 2
while d*d <= a:
while a%d == 0:
tmp.append(d)
a //= d
d += 1
if a!=1:
tmp.append(a)
memo.append(Counter(tmp))
lcm = Counter([])
for count in memo:
for k,v in count.items():
if k not in lcm:
lcm[k] = v
else:
lcm[k] = max(lcm[k],v)
mod = 10**9 +7
LCM = 1
for k,v in lcm.items():
LCM = LCM*pow(k,v)%mod
ans = 0
for a in A:
ans = (ans + LCM*pow(a,mod-2,mod))%mod
print(int(ans)) | 1 | 87,463,101,521,956 | null | 235 | 235 |
import math
def possible(l, a, k):
for x in a:
k -= math.ceil(x/l)-1
return k>=0
n, k = map(int, input().split())
a = [int(x) for x in input().split()]
mini = 1
maxi = 10**9+7
while(mini!=maxi):
mid = (mini+maxi)//2
if possible(mid, a, k):
maxi = mid
else:
mini = mid + 1
print(mini)
| n,k=list(map(int,input().split()))
alst=list(map(int,input().split()))
ok=max(alst)
ng=0
while abs(ok-ng)>1:
cen=(ok+ng)//2
cnt=0
for a in alst:
cnt+=(a+cen-1)//cen-1
if cnt<=k:
ok=cen
else:
ng=cen
print(ok) | 1 | 6,488,203,632,108 | null | 99 | 99 |
from collections import defaultdict
N, u, v = map(int, input().split())
d = defaultdict(list)
for _ in range(N-1):
A, B = map(int, input().split())
d[A].append(B)
d[B].append(A)
def get_dist(s):
dist = [-1]*(N+1)
dist[s] = 0
q = [s]
while q:
a = q.pop()
for b in d[a]:
if dist[b]!=-1:
continue
dist[b] = dist[a] + 1
q.append(b)
return dist
du, dv = get_dist(u), get_dist(v)
ds = [(i,j[0], j[1]) for i,j in enumerate(zip(du, dv)) if j[0]<j[1]]
ds.sort(key=lambda x:-x[2])
a, b, c = ds[0]
print(c-1) | import sys
sys.setrecursionlimit(10**9)
N, u, v = map(int, input().split())
u, v = u-1, v-1
edge = [[] for _ in range(N)]
for i in range(N-1):
a, b = map(int, input().split())
a, b = a-1, b-1
edge[a].append(b)
edge[b].append(a)
taka = [0] * N
aoki = [0] * N
def dfs(v, pre, cost, i):
for e in edge[v]:
if e == pre:
continue
cost = dfs(e, v, cost, i+1)
cost[v] = i
return cost
taka = dfs(u, -1, [0] * N, 0)
aoki = dfs(v, -1, [0] * N, 0)
m = 0
for i in range(N):
if taka[i] < aoki[i]:
m = max(m, aoki[i])
print(m-1)
| 1 | 117,311,037,125,500 | null | 259 | 259 |
N,K=map(int,input().split())
H=list(map(int,input().split()))
H.sort()
m=0
if K<N:
for i in range(N-K):
m+=H[i]
print(m) | N, K = map(int, input().split())
A = list(map(int, input().split()))
A = sorted(A, reverse = True)
for i in range(min(K, N)):
A[i] = 0
ans = sum(A)
print(ans) | 1 | 78,930,965,827,810 | null | 227 | 227 |
N = int(input())
A, B = [], []
for i in range(N):
a, b = map(int, input().split())
A += [a]
B += [b]
A.sort()
B.sort()
if N%2 == 1:
med_minimum = A[(N-1)//2]
med_maximum = B[(N-1)//2]
else:
med_minimum = (A[(N-2)//2] + A[(N-2)//2+1])
med_maximum = (B[(N-2)//2] + B[(N-2)//2+1])
print(med_maximum - med_minimum + 1)
| ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
n=ni()
mins=[]
maxs=[]
for i in range(n):
a,b=nm()
mins.append(a)
maxs.append(b)
smn = sorted(mins)
smx = sorted(maxs)
if n%2==1:
mn = smn[(n+1)//2-1]
mx = smx[(n+1)//2-1]
print(round((mx-mn)+1))
else:
mn = (smn[n//2-1]+smn[n//2])/2.0
mx = (smx[n//2-1]+smx[n//2])/2.0
print(round((mx-mn)*2+1))
| 1 | 17,333,898,092,988 | null | 137 | 137 |
n,k = map(int,input().split())
# Function of Combination mod M
# set n >= max p expected
M = 10**9+7
if k >= n-1:
fac = [1]+[0]*(2*n-1)
for i in range(1,2*n): fac[i] = fac[i-1]*i %M
comb = lambda p,q:(fac[p]*pow(fac[q],M-2,M)*pow(fac[p-q],M-2,M))%M
y = comb(2*n-1,n-1)
else:
y = 1
c1,c2=1,1
for i in range(1,k+1):
p = pow(i,M-2,M)
c1 = c1*(n+1-i)*p%M
c2 = c2*(n-i)*p%M
y += c1*c2%M
# y = (y+c1*c2)%M
print(y%M)
| n, k = map(int, input().split())
mod = 10**9+7
k = min([k, n-1])
ans = 0
key = 1
for i in range(k+1):
ans += key
ans %= mod
key = (((key*(n-i)%mod)*(n-i-1)%mod)*pow(pow(i+1, mod-2, mod), 2, mod))%mod
print(ans) | 1 | 66,946,899,348,392 | null | 215 | 215 |
s = []
n = int(input())
for i in range(n):
s.append(input())
print("AC x " + str(s.count("AC")))
print("WA x " + str(s.count("WA")))
print("TLE x " + str(s.count("TLE")))
print("RE x " + str(s.count("RE"))) | n,*a = map(int,open(0).read().split())
all = 0
for i in a:
all^=i
print(*[all^i for i in a]) | 0 | null | 10,634,731,620,788 | 109 | 123 |
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
N = int(input())
A = list(map(int, input().split()))
def get_primenumber(number): # エラトステネスの篩
prime_list = []
search_list = list(range(2, number + 1))
# search_listの先頭の値が√nの値を超えたら終了
while search_list[0] <= math.sqrt(number):
# search_listの先頭の値が√nの値を超えたら終了
# search_listの先頭をprime_listに入れて、先頭をリストに追加して削除
head_num = search_list.pop(0)
prime_list.append(head_num)
# head_numの倍数を除去
search_list = [num for num in search_list if num % head_num != 0]
# prime_listにsearch_listを結合
prime_list.extend(search_list)
return prime_list
def prime_factor_table(n):
table = [0] * (n + 1)
for i in range(2, n + 1):
if table[i] == 0:
for j in range(i + i, n + 1, i):
table[j] = i
return table
def prime_factor(n, prime_factor_table):
prime_count = collections.Counter()
while prime_factor_table[n] != 0:
prime_count[prime_factor_table[n]] += 1
n //= prime_factor_table[n]
prime_count[n] += 1
return prime_count
table = prime_factor_table(10**6+10)
numset = set()
for i in A:
thedic = prime_factor(i, table)
for l in thedic.keys():
flag = True
if l in numset and l != 1:
flag = False
break
if flag:
tmpset = set(thedic.keys())
numset |= tmpset
else:
break
if flag:
print('pairwise coprime')
sys.exit()
else:
flag = True
theset = set(prime_factor(A[0], table).keys())
for i in A[1:]:
thedic = prime_factor(i, table)
theset = theset & set(thedic.keys())
if len(theset) == 0:
print('setwise coprime')
flag = False
break
if flag:
print('not coprime')
if __name__ == '__main__':
solve() | import sys
def gcd(a, b):
while b:
a, b = b, a % b
return a
def is_prime_MR(n):
d = n - 1
d = d // (d & -d)
L = [2, 7, 61] if n < 1 << 32 else [
2, 3, 5, 7, 11, 13, 17
] if n < 1 << 48 else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
for a in L:
t = d
y = pow(a, t, n)
if y == 1:
continue
while y != n - 1:
y = y * y % n
if y == 1 or t == n - 1:
return 0
t <<= 1
return 1
def find_factor_rho(n):
m = 1 << n.bit_length() // 8
for c in range(1, 99):
def f(x):
return (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if is_prime_MR(g):
return g
elif is_prime_MR(n // g):
return n // g
return find_factor_rho(g)
def prime_factor(n):
i = 2
ret = {}
rhoFlg = 0
while i * i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k:
ret[i] = k
i += i % 2 + (3 if i % 3 == 1 else 1)
if i == 101 and n >= 2**20:
while n > 1:
if is_prime_MR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = find_factor_rho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1:
ret[n] = 1
if rhoFlg:
ret = {x: ret[x] for x in sorted(ret)}
return ret
input = sys.stdin.buffer.readline
N = int(input())
A = list(map(int, input().split()))
g = 0
for a in A:
g = gcd(g, a)
if g > 1:
print('not coprime')
exit()
X = [0] * 1001001
for a in A:
for p in prime_factor(a):
if X[p]:
print('setwise coprime')
exit()
X[p] = 1
print('pairwise coprime')
| 1 | 4,119,192,703,758 | null | 85 | 85 |
s = input()
ans = s[0:3]
print(ans) | from os.path import split
def main():
X, Y, Z = map(int, input().split())
print(Z, X, Y)
if __name__ == '__main__':
main()
| 0 | null | 26,575,168,035,872 | 130 | 178 |
N = int(input())
A = list(map(int, input().split()))
ans = 1
A.sort()
ans = 1
for a in A:
ans *= a
if ans == 0:
break
if ans > 10 ** 18:
ans = -1
break
print(ans)
| x = input()
y = x.split(" ")
y[0] = int(y[0])
y[1] = int(y[1])
if y[0] < y[1]:
print("a < b")
elif y[0] > y[1]:
print("a > b")
else:
print("a == b") | 0 | null | 8,278,415,061,804 | 134 | 38 |
# ABC150 D
from math import gcd
N,M=map(int,input().split())
A=list(map(int,input().split()))
g=A[0]
check=g&-g
for a in A:
if check!=a&-a:
check=-1
break
g=g*a//gcd(a,g)
if check>=0:
g//=2
print((M//g+1)//2)
else:
print(0) | S = list(input())
N = len(S)
K = int(input())
old = S[0]
a = 0
c = 1
for i in range(1,N):
if S[i] == old:
c += 1
else:
a += c // 2
old = S[i]
c = 1
b = 0
a += c // 2
for i in range(N):
if S[i] == old:
b += 1
else:
break
ans = a * K + ((b + c) // 2 - b // 2 - c // 2) * (K - 1)
if c == N:
ans = N * K // 2
print(ans) | 0 | null | 138,731,358,658,702 | 247 | 296 |
A,B,C,K=map(int,input().split())
if K<=A:
print(K)
elif K<=A+B:
print(A)
else:
m=K-(A+B)
print(A-m) | a, b, c, k = map(int, input().split())
ans = 0
if k <= a:
ans = k
elif k <= a+b:
ans = a
else:
ans = 2*a +b - k
print(ans) | 1 | 21,780,282,140,358 | null | 148 | 148 |
N = int(input())
S = list(map(int,input().split()))
ans = 0
for i in range(N-1):
add = max(S[i] - S[i+1],0)
S[i+1] += add
ans += add
print(ans)
| import math
from itertools import combinations
from itertools import combinations_with_replacement
from itertools import product
from collections import defaultdict
from collections import deque
from collections import Counter
import heapq
def input_li():
return list(map(int, input().split()))
N = int(input())
A_LI = input_li()
max_h = A_LI[0]
ans = 0
for i in range(1, N):
if A_LI[i] < max_h:
ans += max_h - A_LI[i]
else:
max_h = max(max_h, A_LI[i])
print(ans)
| 1 | 4,584,343,438,620 | null | 88 | 88 |
import os
import sys
import numpy as np
def solve(inp):
def bitree_sum(bit, t, i):
s = 0
while i > 0:
s += bit[t, i]
i ^= i & -i
return s
def bitree_add(bit, n, t, i, x):
while i <= n:
bit[t, i] += x
i += i & -i
def bitree_lower_bound(bit, n, d, t, x):
sum_ = 0
pos = 0
for i in range(d, -1, -1):
k = pos + (1 << i)
if k <= n and sum_ + bit[t, k] < x:
sum_ += bit[t, k]
pos += 1 << i
return pos + 1
def initial_score(d, ccc, sss):
bit_n = d + 3
bit = np.zeros((26, bit_n), dtype=np.int64)
INF = 10 ** 18
for t in range(26):
bitree_add(bit, bit_n, t, bit_n - 1, INF)
ttt = np.zeros(d, dtype=np.int64)
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
best_t = 0
best_diff = -INF
costs = ccc * (i - last)
costs_sum = costs.sum()
for t in range(26):
tmp_diff = sss[i, t] - costs_sum + costs[t]
if best_diff < tmp_diff:
best_t = t
best_diff = tmp_diff
ttt[i] = best_t
last[best_t] = i
score += best_diff
bitree_add(bit, bit_n, best_t, i + 2, 1)
return bit, score, ttt
def calculate_score(d, ccc, sss, ttt):
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
t = ttt[i]
last[t] = i
score += sss[i, t] - (ccc * (i - last)).sum()
return score
def pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
cd = np.random.randint(0, d)
ct = np.random.randint(0, 26)
while ttt[cd] == ct:
ct = np.random.randint(0, 26)
diff = 0
t = ttt[cd]
k = bitree_sum(bit, t, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, t, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, t, k + 1) - 2
b = ccc[t]
diff -= b * (cd - c) * (e - cd)
diff -= sss[cd, t]
k = bitree_sum(bit, ct, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct, k) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct, k + 1) - 2
b = ccc[ct]
diff += b * (cd - c) * (e - cd)
diff += sss[cd, ct]
if diff > permissible:
bitree_add(bit, bit_n, t, cd + 2, -1)
bitree_add(bit, bit_n, ct, cd + 2, 1)
ttt[cd] = ct
else:
diff = 0
return diff
def swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
dd = np.random.randint(1, 14)
cd1 = np.random.randint(0, d - dd)
cd2 = cd1 + dd
ct1 = ttt[cd1]
ct2 = ttt[cd2]
if ct1 == ct2:
return 0
diff = 0
k = bitree_sum(bit, ct1, cd1 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct1, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct1, k + 1) - 2
diff += ccc[ct1] * (e + c - cd1 - cd2)
k = bitree_sum(bit, ct2, cd2 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct2, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct2, k + 1) - 2
diff -= ccc[ct2] * (e + c - cd1 - cd2)
diff -= sss[cd1, ct1] + sss[cd2, ct2]
diff += sss[cd1, ct2] + sss[cd2, ct1]
if diff > permissible:
bitree_add(bit, bit_n, ct1, cd1 + 2, -1)
bitree_add(bit, bit_n, ct1, cd2 + 2, 1)
bitree_add(bit, bit_n, ct2, cd1 + 2, 1)
bitree_add(bit, bit_n, ct2, cd2 + 2, -1)
ttt[cd1] = ct2
ttt[cd2] = ct1
else:
diff = 0
return diff
d = inp[0]
ccc = inp[1:27]
sss = np.zeros((d, 26), dtype=np.int64)
for r in range(d):
sss[r] = inp[27 + r * 26:27 + (r + 1) * 26]
bit, score, ttt = initial_score(d, ccc, sss)
bit_n = d + 3
bit_d = int(np.log2(bit_n))
loop = 5 * 10 ** 6
permissible_min = -2000.0
method_border = 0.8
best_score = score
best_ttt = ttt.copy()
for lp in range(loop):
permissible = (1 - lp / loop) * permissible_min
if np.random.random() < method_border:
diff = pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
else:
diff = swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
score += diff
# print(lp, score, calculate_score(d, ccc, sss, ttt))
if score > best_score:
best_score = score
best_ttt = ttt.copy()
return best_ttt + 1
if sys.argv[-1] == 'ONLINE_JUDGE':
from numba.pycc import CC
cc = CC('my_module')
cc.export('solve', '(i8[:],)')(solve)
cc.compile()
exit()
if os.name == 'posix':
# noinspection PyUnresolvedReferences
from my_module import solve
else:
from numba import njit
solve = njit('(i8[:],)', cache=True)(solve)
print('compiled', file=sys.stderr)
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print('\n'.join(map(str, ans)))
| from copy import copy
import random
import math
import sys
input = sys.stdin.readline
D = int(input())
c = list(map(int,input().split()))
s = [list(map(int,input().split())) for _ in range(D)]
last = [0]*26
ans = [0]*D
score = 0
for i in range(D):
ps = [0]*26
for j in range(26):
pl = copy(last)
pl[j] = i+1
ps[j] += s[i][j]
for k in range(26):
ps[j] -= c[k]*(i+1-pl[k])
idx = ps.index(max(ps))
last[idx] = i+1
ans[i] = idx+1
score += max(ps)
for k in range(1,40001):
na = copy(ans)
x = random.randint(1,365)
y = random.randint(1,365)
na[x-1] = na[y-1]
last = [0]*26
ns = 0
for i in range(D):
last[na[i]-1] = i+1
ns += s[i][na[i]-1]
for j in range(26):
ns -= c[j]*(i+1-last[j])
if k%100 == 1:
T = 80-(79*k/40000)
p = pow(math.e,-abs(ns-score)/T)
if ns > score or random.random() < p:
ans = na
score = ns
for a in ans:
print(a) | 1 | 9,777,529,587,352 | null | 113 | 113 |
n=int(input())
a=list(map(int,input().split()))
d={}
for v in a:
if v not in d:
d[v]=0
d[v]+=1
for x in range(n):
if x+1 not in d:
print(0)
else:
print(d[x+1]) | n = int(input())
list_ = [0]*n
joshi_list = list(map(int, input().split()))[::-1]
for i,num in enumerate(joshi_list):
list_[num-1]+=1
for num in list_:
print(num) | 1 | 32,633,054,682,708 | null | 169 | 169 |
r=input().split()
a=int(r[0])
b=int(r[1])
if a>=b:
ans=""
for i in range(a):
ans+=str(b)
print(int(ans))
else:
ans=""
for i in range(b):
ans+=str(a)
print(int(ans)) | n=int(input())
a=list(map(int,input().split()))
mod=10**9+7
def eucrid(a,b):
a,b=max(a,b),min(a,b)
while True:
if a%b==0:
return b
else:
a,b=b,a%b
m=a[0]
for i in range(n):
m=m//eucrid(m,a[i])*a[i]
b=0
m=m%mod
for i in a:
b+=m*pow(i,mod-2,mod)%mod
print(b%mod) | 0 | null | 85,875,318,350,400 | 232 | 235 |
s,t = map(int,input().split())
print('Yes' if s*2 <= t <= s*4 and t%2 == 0 else 'No') | a,b=map(int, input().split())
if a <= 9 :
c = b + 100*(10-a)
else:
c = b
print(c) | 0 | null | 38,780,152,293,760 | 127 | 211 |
n, m, l = map(int, input().split())
A, B = [list(map(int, input().split())) for r in range(n)], [list(map(int, input().split())) for r in range(m)]
for i in range(n):
for j in range(l):
Cij = 0
for k in range(m):
Cij += A[i][k]*B[k][j]
if j < l-1:
print('%d' %(Cij), end=' ')
else:
print('%d' % (Cij)) | a = []
b = []
n, m, l = [int(n) for n in input().split()]
c = [[0 for i in range(l)] for j in range(n)]
for i in range(n):
a.append([int(n) for n in input().split()])
for i in range(m):
b.append([int(n) for n in input().split()])
for i in range(n):
for j in range(l):
for k in range(m):
c[i][j] += a[i][k] * b[k][j]
for num in c:
print(' '.join(str(n) for n in num)) | 1 | 1,456,787,636,330 | null | 60 | 60 |
data = raw_input()
while data.count('-1') < 3:
m,f,r = map(int,data.split(" "))
if m+f < 30 or m == -1 or f == -1:
print 'F'
elif m+f >=80:
print 'A'
elif m+f >= 65:
print 'B'
elif m+f >= 50 or (m+f >=30 and r>= 50):
print 'C'
elif m+f >= 30:
print 'D'
elif m+f <30:
print 'F'
data = raw_input() | n=int(input())
a=[int(k) for k in input().split()]
sum=0;
max=a[0];
for aa in a:
if aa<max:
sum=sum+max-aa
else:
max=aa
print(sum) | 0 | null | 2,898,925,738,378 | 57 | 88 |
n = int(input())
l = list(map(int, input().split()))
l.sort()
cnt = 0
for i in range(n):
for j in range(i+1, n):
for k in range(j+1, n):
if l[i]!=l[j] and l[j]!=l[k] and l[k]!=l[i] and l[k]-l[j]<l[i]:
cnt +=1
print(cnt) | def solve():
N = int(input())
L = list(map(int, input().split()))
count = 0
for i in range(N):
for j in range(i+1, N):
for k in range(j+1, N):
if(L[i] != L[j] and L[j] != L[k] and L[k] != L[i]):
if(L[i]+L[j] > L[k] and L[j]+L[k] > L[i] and L[k]+L[i] > L[j]):
count += 1
print(count)
if __name__ == "__main__":
solve() | 1 | 5,016,129,061,096 | null | 91 | 91 |
def main():
import itertools
n,m,q = map(int,input().split())
Q = []
for i in range(q):
Q.append(list(map(int,input().split())))
cmb = [i for i in range(1,m+1)]
ans = 0
for que in itertools.combinations_with_replacement(cmb,n):
m = 0
for i in range(q):
[a,b,c,d] = Q[i]
if que[b-1]-que[a-1]==c:
m += d
if m>ans:
ans = m
print(ans)
if __name__ == "__main__":
main()
| import sys
INF = 10**60
inint = lambda: int(sys.stdin.readline())
inintm = lambda: map(int, sys.stdin.readline().split())
inintl = lambda: list(inm())
instr = lambda: sys.stdin.readline()
instrm = lambda: map(str, sys.stdin.readline().split())
instrl = lambda: list(instrm())
n = inint()
min_sum = INF
i = 0
j = 0
for k in range(1,n):
if k > n**0.5:
break
if n/k % 1 != 0:
continue
i = k
j = n/k
if i+j < min_sum:
min_sum = i+j
print(int(min_sum - 2))
| 0 | null | 94,403,748,654,082 | 160 | 288 |
r,c=list(map(int,input().split()))
s=[0 for i in range(c+1)]
for i in range(r):
l=list(map(int,input().split()))
l.append(sum(l))
print(' '.join(map(str,l)))
s=[s[i]+l[i] for i in range(c+1)]
print(' '.join(map(str,s))) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N, M, K = map(int, input().split())
uf = UnionFind(N)
friends = [0 for _ in range(N)]
for _ in range(M):
a, b = map(int, input().split())
a, b = a - 1, b - 1
uf.union(a, b)
friends[a] += 1
friends[b] += 1
blocks = [0 for _ in range(N)]
for _ in range(K):
c, d = map(int, input().split())
c, d = c - 1, d - 1
if uf.same(c, d):
blocks[c] += 1
blocks[d] += 1
for i in range(N - 1):
ans = uf.size(i) - 1 - friends[i] - blocks[i]
print(str(ans) + " ", end="")
ans = uf.size(N - 1) - 1 - friends[N - 1] - blocks[N - 1]
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 31,420,410,490,092 | 59 | 209 |
N = int(input())
S = input()
plus = N % 26
result = ''
for c in S:
next = ord(c) + plus
result += chr(next - 26) if next > 90 else chr(next)
print(result)
| N = int(input())
S = input()
ret = ''
for s in S:
o = ord(s) - ord('A') + N
ret += chr(ord('A') + o % 26)
print(ret) | 1 | 134,541,049,169,660 | null | 271 | 271 |
def resolve():
N = int(input())
pow = list(map(int, input().split()))
ans = 0
for i in range(N):
for j in range(N):
if i != j:
ans += pow[i]*pow[j]
print(ans//2)
resolve() | mod = 1e9+7
def add(a, b):
c = a + b
if c >= mod:
c -= mod
return c
def main():
N, R = [int(x) for x in raw_input().split()]
if N >= 10:
print(R)
else:
print(R + ((10 - N) * 100))
main() | 0 | null | 115,432,606,403,480 | 292 | 211 |
class Combination:
def __init__(self, mod, max_num):
self.mod = mod
self.fac = [0] * max_num
self.finv = [0] * max_num
self.inv = [0] * max_num
self.fac[0], self.fac[1] = 1, 1
self.finv[0], self.finv[1] = 1, 1
self.inv[1] = 1
for i in range(2, max_num):
self.fac[i] = self.fac[i-1] * i % mod
self.inv[i] = mod - self.inv[mod % i] * (mod // i) % mod
self.finv[i] = self.finv[i - 1] * self.inv[i] % mod
def calc(self, n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return self.fac[n] * (
self.finv[k] * self.finv[n - k] % self.mod) % self.mod
n, k = map(int, input().split())
com = Combination(1000000007, 500000)
ret = 1
min_val = min(n, k)
for i in range(1, min_val+1):
if i != n:
ret += com.calc(n, i) * com.calc(n-1, i)
ret %= 10 ** 9 + 7
else:
ret += 0
print(ret)
| N,K=map(int,input().split())
mod=10**9+7
def cmb(n,r):
global mod
if r<0 or r>n:
return 0
return (g1[n]*g2[r]*g2[n-r])%mod
g1=[1,1]
g2=[1,1]
inv=[0,1]
for i in range(2,1000003):
g1.append((g1[-1]*i)%mod)
inv.append((-inv[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inv[-1])%mod)
P=0
for i in range(min(N,K+1)):
P=(P+cmb(N,i)*cmb(N-1,i))%mod
print(P) | 1 | 67,131,049,444,140 | null | 215 | 215 |
while True:
n = list(map(int,input().split()))
if(n[0] == n[1] == 0):break
print(" ".join(map(str,sorted(n)))) | while True:
a,b = map(int,raw_input().split())
if a == 0:
if b==0:
break
elif b>0:
print a,b
else:
print b,a
elif a>=b:
print b,a
else:
print a,b | 1 | 523,431,095,990 | null | 43 | 43 |
def dfs():
tt = 0
for u in range(N):
if colors[u] == WHITE:
tt = dfs_visit(u, tt)
def dfs_visit(u, tt):
tt += 1
colors[u] = GLAY
d[u] = tt
for v in range(N):
if adjacency_list[u][v] == 1 and colors[v] == WHITE:
tt = dfs_visit(v, tt)
tt += 1
colors[u] = BLACK
f[u] = tt
return tt
N = int(input())
adjacency_list = [[0 for j in range(N)] for i in range(N)]
for _ in range(N):
u, k, *v = map(int, input().split())
for i in v:
adjacency_list[u-1][i-1] = 1
WHITE = 0
GLAY = 1
BLACK = 2
colors = [WHITE for _ in range(N)]
d = [0 for _ in range(N)]
f = [0 for _ in range(N)]
dfs()
for i in range(N):
print("{} {} {}".format(i+1, d[i], f[i]))
| s=input()[::-1]
n=len(s)
cnts=[0]*2019
cnts[0]=1
num=0
for i in range(n):
num+=int(s[i])*pow(10,i,2019)
num%=2019
cnts[num]+=1
ans=0
for cnt in cnts:
ans+=cnt*(cnt-1)//2
print(ans)
| 0 | null | 15,411,910,184,582 | 8 | 166 |
l=raw_input()
k=l.split()
H=int(k[0])
W=int(k[1])
while True:
if H+W==0:
break
else:
for i in range(H):
print "#"*W
print ""
l=raw_input()
k=l.split()
H=int(k[0])
W=int(k[1]) | while True:
h,w = tuple([int(x) for x in raw_input().split(" ")])
if h==0 and w==0: break
for _h in range(h):
print "#" * w
print "" | 1 | 765,846,877,740 | null | 49 | 49 |
h,n=map(int,input().split())
A=list(map(int,input().split()))
attack=0
for i in range(n):
attack+=A[i]
if attack>=h:
print("Yes")
else:
print("No") | from decimal import *
import math
a, b = map(str, input().split())
print(math.floor(Decimal(a)*Decimal(b))) | 0 | null | 47,583,332,052,300 | 226 | 135 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.