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
|
|---|---|---|---|---|---|---|
class itp1_3b:
def out(self,i,x):
print "Case "+str(i)+": "+str(x)
if __name__=="__main__":
run=itp1_3b()
i=1
while(True):
x=input()
if x==0:
break
run.out(i,x)
i+=1
|
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))
from collections import Counter
n=int(input())
l=lnii()
def eratosthenes(lim):
num=[1 for i in range(lim)]
for i in set(l):
if num[i]:
for j in range(i+i,lim,i):
num[j]=0
return num
lim=10**6+5
num=eratosthenes(lim)
count=Counter(l)
ans=0
for i in l:
if num[i]==1 and count[i]==1:
ans+=1
print(ans)
| 0 | null | 7,465,837,618,746 | 42 | 129 |
def main():
K = int(input())
S = input()
if len(S) <= K:
return S
return S[:K] + '...'
if __name__ == '__main__':
print(main())
|
import sys
K = int(input())
S = input()
if not ( 1 <= K <= 100 and isinstance(K,int) and S.islower() and 1 <= len(S) <= 100): sys.exit()
print(S) if len(S) <= K else print(S[:K]+"...")
| 1 | 19,712,184,639,718 | null | 143 | 143 |
a, b = map(int, input().split())
ans = 0
if a >= b:
for i in range(a):
ans += b * 10**i
else:
for i in range(b):
ans += a * 10**i
print(ans)
|
a, b = map(int, input().split())
x = str(a) * b
y = str(b) * a
x, y = sorted([x, y])
print(x)
| 1 | 84,208,591,112,002 | null | 232 | 232 |
N, K = map(int, input().split())
nums = list(map(int, input().split()))
expect = 0
answer = 0
for i in range(N):
if i < K:
expect += (nums[i]+1)/2
else:
expect += (nums[i]+1)/2 - (nums[i-K]+1)/2
answer = max(answer, expect)
print(answer)
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
s = sum(p[:k])
ret = s
for i in range(k, n):
s += p[i] - p[i - k]
ret = max(ret, s)
print((ret + k) / 2.0)
| 1 | 74,945,457,076,854 | null | 223 | 223 |
w = input()
r = ''
for i in range(len(w)):
c = str(w[i])
if (w[i].islower()):
c = w[i].upper()
elif (w[i].isupper()):
c = w[i].lower()
r = r + c
print(r)
|
import sys
def gcd(a, b):
if b == 0: return a
return gcd(b, a%b)
for line in sys.stdin:
a, b= map(int, line.split())
if a < b:
a, b = b, a
g = gcd(a,b)
print g, a*b/g
| 0 | null | 740,568,051,632 | 61 | 5 |
n,m = map(int,input().split())
v1 = [ input().split() for _ in range(n) ]
v2 = [ int(input()) for _ in range(m) ]
l = [sum(map(lambda x,y:int(x)*y,v,v2)) for v in v1 ]
print(*l,sep="\n")
|
n,m=list(map(int,input().split()))
mA=[list(map(int,input().split())) for i in range(n)]
mB=[int(input()) for j in range(m)]
for ma in mA:
print(sum([a*b for a, b in zip(ma,mB)]))
| 1 | 1,137,397,840,580 | null | 56 | 56 |
N = int(input())
S = input()
if N % 2 != 0:
print('No')
exit()
print('Yes') if S[:N//2] == S[N//2:] else print('No')
|
n=int(input())
s=str(input())
ans="Yes"
if len(s)%2==1:
ans="No"
for i in range(len(s)//2):
if s[i]!=s[len(s)//2+i]:
ans="No"
break
print(ans)
| 1 | 147,015,208,765,780 | null | 279 | 279 |
s=input()
a,b,c,d=0,0,0,0
for i in range(len(s)):
if s[i]==">":
c=0;b+=1
if b<=d:a+=b-1
else:a+=b
else:b=0;c+=1;a+=c;d=c
print(a)
|
s = input()
de_num = 0
le_num = 0
ans = [0]*(len(s)+1)
for i in range(len(s)):
if s[i] == "<":
de_num += 1
else:
de_num = 0
ans[i+1] = de_num
s = s[::-1]
ans.reverse()
for i in range(len(s)):
if s[i] == ">":
le_num += 1
else:
le_num = 0
ans[i+1] = max(le_num,ans[i+1])
print(sum(ans))
| 1 | 156,751,052,412,060 | null | 285 | 285 |
n = input()
if int(n)%1000 == 0:
print(0)
elif int(n) < 1000:
print(1000-int(n))
else:
print(1000-int(n[-3:]))
|
n = int(input())
print(0 if n % 1000 == 0 else 1000 - n % 1000)
| 1 | 8,395,659,307,112 | null | 108 | 108 |
i = int(input())
while (i > 0):
i -= 1000
print(abs(i))
|
n = int(input())
a = 10000
ans = (a - n) % 1000
print(ans)
| 1 | 8,451,547,898,460 | null | 108 | 108 |
N = int(input())
S,T = input().split()
ans = ["a"]*(N*2)
for i in range(N) :
ans[2*i] = S[i]
ans[2*i+1] = T[i]
print(''.join(ans))
|
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = inp()
s,t = input().split()
print(''.join([s[i] + t[i] for i in range(n)]))
| 1 | 111,977,070,934,368 | null | 255 | 255 |
INF = 1<<60
def resolve():
def judge(j):
for i in range(group):
cnt_Wchoco[i] += div_G[i][j]
if cnt_Wchoco[i] > K:
return False
return True
H, W, K = map(int, input().split())
G = [list(map(int, input())) for _ in range(H)]
ans = INF
for bit in range(1<<(H-1)):
group = 0 # 分かれたブロック数
row = [0]*H
for i in range(H):
# 分割ライン
row[i] = group
if bit>>i & 1:
group += 1
group += 1 # 1つ折ったら2つに分かれるのでプラス1, 折らなかったら1つ
# 分割したブロックを列方向で見る
div_G = [[0] * W for _ in range(group)]
for i in range(H):
for j in range(W):
div_G[row[i]][j] += G[i][j]
num = group-1
cnt_Wchoco = [0]*group
for j in range(W):
if not judge(j):
num += 1
cnt_Wchoco = [0] * group
if not judge(j):
num = INF
break
ans = min(ans, num)
print(ans)
if __name__ == "__main__":
resolve()
|
import sys
n,x,m = map(int,input().split())
lst_sum = [0,x]
loop = [0]*(10**5)
loop[x] = 1
s = 1
for i in range(2,n+1):
y = ((lst_sum[-1] - lst_sum[-2])**2)%m
if loop[y] != 0:
l = i-loop[y]
d = (n-loop[y]+1) // l
q = (n-loop[y]+1) % l
sum_loop = lst_sum[-1]-lst_sum[loop[y]-1]
sum_first = lst_sum[loop[y]-1]
if q == 0:
sum_rest = 0
else:
sum_rest = lst_sum[loop[y] + q-1] - lst_sum[loop[y]-1]
print(sum_first+d*sum_loop+sum_rest)
sys.exit()
else:
s += 1
loop[y] = s
lst_sum.append(lst_sum[-1] + y)
print(lst_sum[-1])
| 0 | null | 25,520,576,788,250 | 193 | 75 |
def plus(x):
yen = 0
if x < 4:
yen = yen + 100000
if x < 3:
yen = yen + 100000
if x < 2:
yen = yen + 100000
return yen
x, y = map(int, input().split())
res = plus(x) + plus(y)
if x == 1 and y == 1:
res = res + 400000
print(res)
|
def p(n):
if n == 1:
return 300000
elif n == 2:
return 200000
elif n == 3:
return 100000
else:
return 0
x, y = map(int, input().split())
ans = 0
if x == y == 1:
ans += 400000
ans += p(x) + p(y)
print(ans)
| 1 | 140,333,094,439,890 | null | 275 | 275 |
n,k=map(int,input().split())
R,S,P=map(int,input().split())
T=input()
t=""
count=0
for i in range(n):
if i>k-1:
if T[i]=="r":
if t[i-k]!="p":
t=t+"p"
count+=P
else:
t=t+" "
if T[i]=="s":
if t[i-k]!="r":
t=t+"r"
count+=R
else:
t=t+" "
if T[i]=="p":
if t[i-k]!="s":
t=t+"s"
count+=S
else:
t=t+" "
else:
if T[i]=="r":
t=t+"p"
count+=P
if T[i]=="p":
t=t+"s"
count+=S
if T[i]=="s":
t=t+"r"
count+=R
print(count)
|
N,K = map(int,input().split())
R,S,P = map(int,input().split())
T = input()
d = []
for i in range(N):
if T[i] == "r":
if i < K or d[i-K] != "p":
d.append("p")
else:
d.append("a")
elif T[i] == "s":
if i < K or d[i-K] != "r":
d.append("r")
else:
d.append("a")
else:
if i < K or d[i-K] != "s":
d.append("s")
else:
d.append("a")
ans = d.count("r") * R + d.count("s") * S + d.count("p") * P
print(ans)
| 1 | 106,795,126,371,080 | null | 251 | 251 |
h, w, k = map(int, input().split())
s = [list(map(int, input())) for _ in range(h)]
ans = float("inf")
for sep in range(1 << (h-1)):
g_id = [0] * h
cur = 0
for i in range(h-1):
g_id[i] = cur
if sep >> i & 1: cur += 1
g_id[h-1] = cur
g_num = cur+1
ng = False
for i in range(w):
tmp = [0] * g_num
for j in range(h): tmp[g_id[j]] += s[j][i]
if any([x > k for x in tmp]): ng = True; break
if ng: continue
res = g_num-1
gs = [0] * g_num
for i in range(h):
gs[g_id[i]] += s[i][0]
for i in range(1, w):
tmp = gs[::]
for j in range(h):
tmp[g_id[j]] += s[j][i]
if any([x > k for x in tmp]):
res += 1
gs = [0] * g_num
for j in range(h): gs[g_id[j]] += s[j][i]
ans = min(ans, res)
print(ans)
|
import sys
from collections import defaultdict
read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
X, Y = map(int, readline().split())
ans = 0
if X==1:
ans += 300000
elif X==2:
ans += 200000
elif X==3:
ans += 100000
else:
pass
if Y==1:
ans += 300000
elif Y==2:
ans += 200000
elif Y==3:
ans += 100000
else:
pass
if X==Y==1:
ans += 400000
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 94,597,602,971,622 | 193 | 275 |
S = list(input())
q = int(input())
for i in range(q):
cmd, a, b, *c = input().split()
a = int(a)
b = int(b)
if cmd == "replace":
S[a:b+1] = c[0]
elif cmd == "reverse":
S[a:b+1] = reversed(S[a:b+1])
else:
print(*S[a:b+1], sep='')
|
from itertools import starmap
print("".join(starmap(lambda c: c.lower() if 'A' <= c <= 'Z' else c.upper(), input())))
| 0 | null | 1,817,371,411,076 | 68 | 61 |
n = int(input())
print(input().count("ABC"))
|
n=int(input())
s=input().split("ABC")
print(len(s)-1)
| 1 | 99,440,978,591,576 | null | 245 | 245 |
from operator import itemgetter
from bisect import bisect_right
n, d, a = map(int, input().split())
monster = [tuple(map(int, input().split())) for _ in range(n)]
monster.sort(key=itemgetter(0))
xx = [xi for xi, hi in monster]
ans = 0
imos = [0] * (n + 1)
for i, (xi, hi) in enumerate(monster):
hi -= imos[i]
if hi > 0:
c = (hi + a - 1) // a
ans += c
idx = bisect_right(xx, xi + 2 * d)
imos[i] += c * a
imos[idx] -= c * a
# update imos
imos[i + 1] += imos[i]
print(ans)
|
n = int(input())
graph = [[] for _ in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
graph[a - 1].append((b - 1, i))
graph[b - 1].append((a - 1, i))
ans = [0] * (n - 1)
from collections import deque
d = deque()
d.append([0, -1])
while d:
point, prev = d.popleft()
color = 1 if prev != 1 else 2
for a, index in graph[point]:
if ans[index] == 0:
ans[index] = color
d.append([a, color])
color += 1 if prev != color + 1 else 2
print(max(ans))
print(*ans, sep='\n')
| 0 | null | 109,457,047,989,102 | 230 | 272 |
N = int(input())
MOD = 10**9 + 7
a1, a2, a3 = 1, 1, 1
for _ in range(N):
a1 *= 10
a1 %= MOD
for _ in range(N):
a2 *= 9
a2 %= MOD
a2 *= 2
a2 %= MOD
for _ in range(N):
a3 *= 8
a3 %= MOD
ans = a1 - a2 + a3
ans %= MOD
print(ans)
|
n = int(input())
MOD = 1000000007
ans = pow(10,n,MOD) - pow(9,n,MOD) - pow(9,n,MOD) + pow(8,n,MOD)
print((ans+MOD)%MOD)
| 1 | 3,198,767,769,752 | null | 78 | 78 |
def solve():
N = int(input())
ans = 0
for i in range(1, N+1):
if i%3 != 0 and i%5 != 0:
ans += i
print(ans)
if __name__ == "__main__":
solve()
|
import sys
from math import log10, floor
print('\n'.join(map(str, [floor(log10(sum(map(int, ab.split())))) + 1 for ab in sys.stdin])))
| 0 | null | 17,466,760,055,712 | 173 | 3 |
input()
a = list(input().split())
print(*a[::-1])
|
import sys
n = input()
a = map(int, raw_input().split())
for i in range(n):
sys.stdout.write(str(a[n-i-1]))
if(i != n-1):
sys.stdout.write(" ")
print
| 1 | 980,847,888,908 | null | 53 | 53 |
import sys
#list = sys.stdin.readlines()
#i=0
list = []
for line in sys.stdin.readlines():
list = line.split(" ")
print str(len(str(int(list[0]) + int(list[1]))))
|
while True:
try:
a=map(int,raw_input().split())
print len(str(a[0]+a[1]))
except:
break
| 1 | 68,042,592 | null | 3 | 3 |
import sys
def ISI(): return map(int, sys.stdin.readline().rstrip().split())
n, r = ISI()
if n<10:
r+=100*(10-n)
print(r)
|
n, m = map(int, input().split())
num = [-1 for _ in range(n)]
for _ in range(m):
s, c = map(int, input().split())
s -= 1
if n >= 2 and s == 0 and c == 0:
print(-1)
exit()
elif num[s] != -1 and num[s] != c:
print(-1)
exit()
else:
num[s] = c
if num[0] == -1 and n != 1:
num[0] = 1
elif num[0] == -1 and n == 1:
num[0] = 0
num = ["0" if n == -1 else str(n) for n in num]
print("".join(num))
| 0 | null | 61,820,538,239,400 | 211 | 208 |
from itertools import accumulate
N, K = map(int, input().split())
P = tuple(accumulate(map(int, input().split())))
ans = P[K - 1]
for i in range(N - K):
ans = max(P[i + K] - P[i], ans)
print((ans + K) / 2)
|
N,K = map(int,input().split())
p = list(map(int,input().split()))
ans = sum(p[0:K])
s = ans
for i in range(1,N-K+1):
s += p[i+K-1]-p[i-1]
ans = max(ans,s)
print((K+ans)/2)
| 1 | 74,922,085,679,560 | null | 223 | 223 |
n,m = map(int, input().split())
a = [[] for x in range(0, n)]
b = [0 for x in range(0, m)]
for x in range(0, n):
a[x] = list(map(int, input().split()))
for x in range(0, m):
b[x] = int(input())
for i in range(0, n):
c = 0
for j in range(0, m):
c += a[i][j] * b[j]
print(c)
|
matrix = []
vector = []
n, m = [int(x) for x in input().split()]
for i in range(n):
matrix.append([int(x) for x in input().split()])
for i in range(m):
vector.append(int(input()))
for i in range(n):
sum = 0
for j in range(m):
sum += matrix[i][j] * vector[j]
print(sum)
| 1 | 1,150,276,105,440 | null | 56 | 56 |
N, M = map(int, input().split())
A = map(int, input().split())
A_sum = sum(A)
if (N - A_sum) >= 0:
print(N - A_sum)
else:
print(-1)
|
n, m = map(int,input().split())
lst = list(map(int,input().split()))
x = 0
for i in range(m):
x = x + lst[i]
if (x > n):
print("-1")
else:
print(n - x)
| 1 | 31,876,660,869,440 | null | 168 | 168 |
input_list = list(map(str, input().split()))
stack_list = []
for i in input_list:
if i not in ['+', '-', '*']:
stack_list.append(i)
else:
a = stack_list.pop()
b = stack_list.pop()
stack_list.append(str(eval(b + i + a)))
print(stack_list[0])
|
def arg(operator):
try:
return elements.index(operator)
except:
return 100000000000000
elements = [elem if elem in ['+', '-', '*']
else int(elem) for elem in input().split()]
while len(elements) != 1:
if arg('+') or arg('-') or arg('*'):
i = arg('+')
i = min(i, arg('-'))
i = min(i, arg('*'))
if elements[i] == '+': r = elements[i-2] + elements[i-1]
elif elements[i] == '-': r = elements[i-2] - elements[i-1]
elif elements[i] == '*': r = elements[i-2] * elements[i-1]
# i, i-1, i-2 -> one element
elements = elements[:i-2] + [r] + elements[i+1:]
else:
break
print(elements[0])
| 1 | 34,487,317,178 | null | 18 | 18 |
def main():
n = int(input())
while True:
try:
num_list = [int(i) for i in input().split()]
num_list = sorted(num_list)
a,b,c = num_list[0],num_list[1],num_list[2]
if (a**2 + b**2) == c**2:
print("YES")
else:
print("NO")
except EOFError:
break
return None
if __name__ == '__main__':
main()
|
A, B, C, K = map(int, input().split())
D = A + B
if D >= K:
print(min(K,A))
else:
K -= D
print(A-K)
| 0 | null | 10,876,330,523,022 | 4 | 148 |
import sys
for line in sys.stdin:
a,b = [int(i) for i in line.split()]
print(len(str(a+b)))
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys
for line in sys.stdin:
a,b = line.split(' ')
value = int(a) + int(b)
print( len('{}'.format(value)) )
| 1 | 74,538,112 | null | 3 | 3 |
n = int(input())
a = list(map(int, input().split()))
def judge(x, y):
if x > y:
return(x-y)
else:
return(0)
ans = 0
for i in range(n - 1):
xy = judge(a[i], a[i+1])
a[i+1] += xy
ans += xy
print(ans)
|
class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
N, K = map(int, input().split())
K = min(K, N)
MOD = 10**9 + 7
comb = Combination(N + 100)
ans = 0
for k in range(K + 1):
ans += comb.ncr(N, k) * comb.nhr(N - k, k)
ans %= MOD
print(ans)
| 0 | null | 35,725,027,685,620 | 88 | 215 |
N, M = map(int, input().split())
coins = map(int, input().split())
dp = [0] + [50001 for i in range(N)]
for coin in coins:
for index in range(N-coin+1):
dp[index+coin] = min(dp[index+coin], dp[index]+1)
print(dp[N])
|
a, b, c, d = map(int, input().split())
if c%b==0:
x = c//b
else:
x = c//b+1
if a%d==0:
y = a//d
else:
y = a//d+1
if x<=y:
print("Yes")
else:
print("No")
| 0 | null | 14,905,589,966,388 | 28 | 164 |
n = int(input())
s = input()
prev = ""
ans = ""
for i in range(n):
if s[i] == prev:
continue
prev = s[i]
ans += s[i]
print(len(ans))
|
n = int(input())
s = str(input())
s_new = s[0]
for i in range(1,len(s)):
if s_new[-1] != s[i]:
s_new = s_new + s[i]
print(len(s_new))
| 1 | 169,637,248,894,172 | null | 293 | 293 |
N = input()
N = int(N)
for a in range(0,100):
n = N-10*a
if n <=9:
break;
if n == 2 or n == 4 or n == 5 or n == 7 or n == 9:
print('hon')
elif n == 0 or n == 1 or n == 6 or n == 8:
print('pon')
elif n == 3:
print('bon')
|
r, c = map(int, raw_input().split(" "))
table1 = [[0 for j in range(c)] for i in range(r)]
for i in range(r):
table1[i] = map(int, raw_input().split(" "))
table2 = [0 for j in range(c+1)]
ans = ""
for i in range(r):
tmp = 0
for j in range(c):
ans += str(table1[i][j]) + " "
tmp += table1[i][j]
table2[j] += table1[i][j]
ans += str(tmp) + "\n"
for j in range(c+1):
ans += str(table2[j])
table2[c] += table2[j]
if j!=c:
ans += " "
print ans
| 0 | null | 10,357,006,516,962 | 142 | 59 |
n = int(input()[-1])
if n in [2,4,5,7,9]:
print("hon")
elif n in [0,1,6,8]:
print("pon")
else:
print("bon")
|
# -*- coding: utf-8 -*-
def judge(m, f, r):
if m==-1 or f==-1: return "F"
ttl = m + f
if ttl >= 80: return "A"
elif ttl >= 65: return "B"
elif ttl >= 50: return "C"
elif ttl >= 30:
return "C" if r>=50 else "D"
else: return "F"
if __name__ == "__main__":
while True:
m, f, r = map(int, raw_input().split())
if m==-1 and f==-1 and r==-1: break
print judge(m, f, r)
| 0 | null | 10,249,169,904,800 | 142 | 57 |
n=int(input())
s=input()
c=0
for i in range(n-2):
if s[i]=="A":
if s[i+1]=="B":
if s[i+2]=="C":
c+=1
else:
pass
else:
pass
else:
pass
print(c)
|
mod = 10 ** 9 + 7
x, y = map(int, input().split())
if (x + y) % 3 != 0 or x * 2 < y or y * 2 < x:
print(0)
exit()
l = [1]
for i in range(1, (x + y) // 3 + 100):
l.append(l[-1] * i % mod)
def comb(n, r, m):
return l[n] * pow(l[r], m - 2, m) * pow(l[n - r], m - 2, m) % m
a, b = y - (x + y) // 3, x - (x + y) // 3
print(comb(a + b, a, mod) % mod)
| 0 | null | 124,730,692,210,112 | 245 | 281 |
from itertools import repeat
print(sum((lambda a, b, c: map(lambda r, n: n % r == 0,
range(a, b+1), repeat(c))
)(*map(int, input().split()))))
|
N = int(raw_input())
A = raw_input().split(" ")
count = 0
flag = 1
i = 0
while flag == 1:
flag = 0
for j in reversed(range(i+1, N)):
if int(A[j]) < int(A[j-1]):
temp = A[j]
A[j] = A[j-1]
A[j-1] = temp
count += 1
flag = 1
i += 1
print " ".join(A)
print count
| 0 | null | 288,553,653,648 | 44 | 14 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
X, N = mapint()
A = set(range(1000))
Ps = list(mapint())
Ps = sorted(list(A-set(Ps)))
mi = 10**18
ans = 0
for p in Ps:
if abs(X-p)<mi:
ans = p
mi = abs(X-p)
print(ans)
|
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())
| 1 | 13,957,642,214,880 | null | 128 | 128 |
import math
N = int(input())
a = list(map(int,input().split()))
m = max(a)
c = [0] * (m+1)
for i in a:
c[i] += 1
pairwise = True
for i in range(2, m+1, 1):
cnt = 0
for j in range(i, m+1, i):
cnt += c[j]
if cnt > 1:
pairwise = False
break
if pairwise:
print("pairwise coprime")
exit()
g = 0
for i in range(N):
g = math.gcd(g, a[i])
if g == 1:
print("setwise coprime")
exit()
print("not coprime")
|
import sys
printf = sys.stdout.write
bilt1 = [0] * 30
bilt2 = [0] * 30
bilt3 = [0] * 30
bilt4 = [0] * 30
sha = "#" * 20
count = 0;
x = input()
for i in range(x):
b,f,r,v =map(int, raw_input().split())
if b == 1:
bilt1[((f - 1) * 10) + (r - 1)] = bilt1[((f - 1) * 10) + (r - 1)] + v
elif b == 2:
bilt2[((f - 1) * 10) + (r - 1)] = bilt2[((f - 1) * 10) + (r - 1)] + v
elif b == 3:
bilt3[((f - 1) * 10) + (r - 1)] = bilt3[((f - 1) * 10) + (r - 1)] + v
else:
bilt4[((f - 1) * 10) + (r - 1)] = bilt4[((f - 1) * 10) + (r - 1)] + v
for i in range(3):
for j in range(10):
print " ",
printf(str(bilt1[(i * 10) + j]))
print ""
print sha
for i in range(3):
for j in range(10):
print " ",
printf(str(bilt2[(i * 10) + j]))
print ""
print sha
for i in range(3):
for j in range(10):
print " ",
printf(str(bilt3[(i * 10) + j]))
print ""
print sha
for i in range(3):
for j in range(10):
print " ",
printf(str(bilt4[(i * 10) + j]))
print ""
| 0 | null | 2,636,977,647,620 | 85 | 55 |
# -*- coding: utf-8 -*-
N, X, M = map(int, input().split())
mod_check_list = [False for _ in range(M)]
mod_list = [(X ** 2) % M]
counter = 1
mod_sum = (X ** 2) % M
last_mod = 0
for i in range(M):
now_mod = (mod_list[-1] ** 2) % M
if mod_check_list[now_mod]:
last_mod = now_mod
break
mod_check_list[now_mod] = True
mod_list.append(now_mod)
counter += 1
mod_sum += now_mod
loop_start_idx = 0
for i in range(counter):
if last_mod == mod_list[i]:
loop_start_idx = i
break
loop_list = mod_list[loop_start_idx:]
loop_num = counter - loop_start_idx
ans = 0
if (N - 1) <= counter:
ans = X + sum(mod_list[:N - 1])
else:
ans += X + mod_sum
N -= (counter + 1)
ans += sum(loop_list) * (N // loop_num) + sum(loop_list[:N % loop_num])
print(ans)
|
N=int(input())
x=input()
def popcount(X,ones,count):
#print(count,bin(X),X,ones)
if ones==0:
return count
else:
X=X%ones
count+=1
ones=str(bin(X)).count("1")
return popcount(X,ones,count)
GroundOnes=x.count("1")
GroundX=int(x,2)
if GroundOnes>1:
CaseOne= GroundX%(GroundOnes-1)
else:
CaseOne=2
CaseZero= GroundX%(GroundOnes+1)
TwoPowerCaseOne=[]
TwoPowerCaseZero=[]
# if GroundOnes>1:
# for j in range(N):
# TwoPowerCaseOne.append(pow(2,(N-j-1) , (GroundOnes-1)))
# TwoPowerCaseZero.append(pow(2**(N-j-1), (GroundOnes+1)))
# else:
# for j in range(N):
# TwoPowerCaseZero.append(pow(2**(N-j-1), (GroundOnes+1)))
for i in range(N):
#CaseOne
if x[i]=="1":
ones=GroundOnes-1
if ones>0:
X=CaseOne-pow(2,N-i-1,ones)
else:
X=0
#CaseZero
else:
ones=GroundOnes+1
X=CaseZero+pow(2,N-i-1,ones)
# print("for loop",i)
# print("ones",ones)
# print("new2bit",new2bit)
#print(" ------ return --- ",popcount(X,ones,0))
print(popcount(X,ones,0))
| 0 | null | 5,572,696,686,112 | 75 | 107 |
import math
def S(i):
return ((i * (i+1)) // 2)
N = int(input())
ans = 0
sqrt_N = math.floor(math.sqrt(N))
for K in range(1, N+1, 1):
if((N // K) < sqrt_N):
break
# 個別に足す
ans += S(N // K) * K
for NdivK in range(1, sqrt_N, 1):
# [N // K]が等しいKの区間を求める
Kbegin = N // (NdivK + 1)
Kend = N // NdivK
ans += (S(NdivK) * (S(Kend) - S(Kbegin)))
print(ans)
|
N = int(input())
A = [1] * (N+1)
for i in range(2,N+1):
a = i
while a < N+1:
A[a] += 1
a += i
#print(A)
ans = 0
for i in range(N+1):
ans += i * A[i]
print(ans)
| 1 | 10,980,864,314,292 | null | 118 | 118 |
N = int(input())
data = [input() for _ in range(N)]
def f(s):
c = len([x for x in data if x in s])
print(f"{s} x {c}")
f("AC")
f("WA")
f("TLE")
f("RE")
|
a,b,m = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
ans = []
ans.append(min(A)+min(B))
for i in range(m):
M = list(map(int,input().split()))
tmp = A[M[0]-1] + B[M[1]-1] -M[2]
ans.append(tmp)
print(min(ans))
| 0 | null | 31,327,511,296,070 | 109 | 200 |
# E - Active Infants
N = int(input())
A = list(map(int,input().split()))
dp = [[] for _ in range(N+1)]
dp[0].append(0)
for i in range(N):
A[i] = [A[i],i+1]
A.sort(reverse=True)
for M in range(1,N+1):
Ai,i = A[M-1]
# x=0
dp[M].append(dp[M-1][0]+Ai*(N-(M-1)-i))
# 1<=x<=M-1
for x in range(1,M):
dp[M].append(max(dp[M-1][x-1]+Ai*(i-x),dp[M-1][x]+Ai*(N-(M-x-1)-i)))
# x=M
dp[M].append(dp[M-1][M-1]+Ai*(i-M))
print(max(dp[N]))
|
def main():
N = int(input())
A = list(map(int, input().split()))
AA = [(a, i) for i, a in enumerate(A)]
AA.sort(reverse=True)
dp = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(N):
a, t = AA[i]
for x in range(i + 2):
y = i + 1 - x
dp[x][y] = max((dp[x - 1][y] + abs(t - (x - 1)) * a) if x > 0 else 0,
(dp[x][y - 1] + abs(t - (N - y)) * a) if y > 0 else 0)
return max(dp[i][N - i] for i in range(N + 1))
print(main())
| 1 | 33,589,889,403,370 | null | 171 | 171 |
N,M,K = list(map(int, input().split()))
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())
uf = UnionFind(N)
V = [[] for _ in range(N)]
for _ in range(M):
a,b = map(int, input().split())
a,b = a-1, b-1
V[a].append(b)
V[b].append(a)
uf.union(a,b)
for _ in range(K):
a,b = map(int, input().split())
a,b = a-1, b-1
if uf.same(a,b):
V[a].append(b)
V[b].append(a)
ans = [-1] * N
for i in range(N):
ans[i] = uf.size(i) - len(V[i]) - 1
print(" ".join(list(map(str, ans))))
|
n,m,k=map(int,input().split())
par = [-1]*n
num = [0]*n
def find(x):
if par[x]<0:
return x
else:
par[x] = find(par[x])
return par[x]
def union(x, y):
p,q=find(x), find(y)
if p==q:
return
if p>q:
p,q = q,p
par[p] += par[q]
par[q] = p
def size(x):
return -par[find(x)]
def same(x,y):
return find(x)==find(y)
for i in range(m):
a,b=map(int,input().split())
a-=1
b-=1
union(a,b)
num[a]+=1
num[b]+=1
for i in range(k):
c,d=map(int,input().split())
c-=1
d-=1
if same(c,d):
num[c]+=1
num[d]+=1
for i in range(n):
print(size(i)-1-num[i], end=" ")
| 1 | 61,696,976,515,850 | null | 209 | 209 |
S = input()
k = int(input())
from itertools import groupby
x = y = 0
g = [len(list(v)) for k,v in groupby(S)]
for c in g:
x += c//2
#print(len(S),g[0])
if S[-1] == S[0]:
if g[-1]%2 == 0 or g[0]%2 == 0:
pass
elif len(S) == 1:
y = k//2
elif len(S) == g[0]:
y = k//2
#print('?',y)
else:
y = k-1
print(x*k + y)
|
def main():
n=int(input())
u,k,v=0,0,[[] for _ in range(n+1)]
for i in range(n):
l=list(map(int,input().split()))
u=l[0]
for j in l[2:]:
v[u].append(j)
d=[0]*(n+1)
f=[0]*(n+1)
def dfs(s,t):
d[s]=t
for i in v[s]:
if d[i]==0:
t=dfs(i,t+1)
f[s]=t+1
return t+1
s,t=1,1
while 0 in d[1:]:
T=dfs(s,t)
for i in range(1,n+1):
if d[i]==0:
s=i
t=T+1
break
for i in range(1,n+1):
print(i,d[i],f[i])
if __name__ == '__main__':
main()
| 0 | null | 87,950,261,296,032 | 296 | 8 |
import sys
import itertools
# import numpy as np
import time
import math
from heapq import heappop, heappush
from collections import defaultdict
from collections import Counter
from collections import deque
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
N, M, L = map(int, input().split())
dist = [[INF] * N for _ in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
if c > L:
continue
a -= 1
b -= 1
dist[a][b] = c
dist[b][a] = c
Q = int(input())
for k in range(N):
for i in range(N):
for j in range(N):
if dist[i][j] > dist[i][k] + dist[k][j]:
dist[i][j] = dist[i][k] + dist[k][j]
fuel = [[INF] * N for _ in range(N)]
for i in range(N):
for j in range(N):
fuel[i][j] = 1 if dist[i][j] <= L else INF
for k in range(N):
for i in range(N):
for j in range(N):
if fuel[i][j] > fuel[i][k] + fuel[k][j]:
fuel[i][j] = fuel[i][k] + fuel[k][j]
for i in range(Q):
s,t = map(int, input().split())
if fuel[s - 1][t - 1] != INF:
print(fuel[s - 1][t - 1] - 1)
else:
print(-1)
|
H = int(input())
W = int(input())
N = int(input())
cnt, paint = 0, 0
while paint < N:
paint += max(H,W)
cnt += 1
print(cnt)
| 0 | null | 131,039,134,323,330 | 295 | 236 |
from decimal import Decimal
from math import floor
def main():
a, b = map(Decimal,input().split())
print(floor(a*b))
main()
|
A, B = input().split()
B = B.replace('.', '')
A, B = list(map(int, [A, B]))
ans_b = A*B
print(int(ans_b//100))
| 1 | 16,475,149,103,688 | null | 135 | 135 |
import sys
t1, t2 = map(int, input().split())
a1, a2 = map(int, input().split())
b1, b2 = map(int, input().split())
a = a1 * t1 + a2 * t2
b = b1 * t1 + b2 * t2
ha = a1 * t1
hb = b1 * t1
if a == b or ha == hb:
print ("infinity")
sys.exit(0)
if a > b:
a, b = b, a
ha, hb = hb, ha
gap = b - a
hgap = ha - hb
if hgap < 0:
print (0)
sys.exit(0)
ans = 2 * (hgap // gap) + (1 if hgap % gap > 0 else 0)
print (ans)
|
t1,t2 = map(int,input().split())
a1,a2 = map(int,input().split())
b1,b2 = map(int,input().split())
if (a1<b1 and a2<b2) or (a1>b1 and a2>b2):
print(0)
exit()
if a1 > b1:
a1,b1 = b1,a1
a2,b2 = b2,a2
_b1 = b1 - a1
_a2 = a2 - b2
v1 = t1*_b1
v2 = t2*_a2
if v1 == v2:
print('infinity')
exit()
if v1 > v2:
print(0)
exit()
d = v2 - v1
k = v1 // d
ans = k*2 + 1
if v2*k == v1*(k+1):
ans -= 1
print(ans)
| 1 | 131,072,267,813,090 | null | 269 | 269 |
n = int(input())
a = list(map(int, input().split()))
c = 10 ** 9 + 7
ans = 0
s = 0
for i in range(n-1, -1, -1):
ans += s * a[i]
s += a[i]
print(ans % c)
|
def atc_158a(input_value: str) -> str:
if input_value == "AAA" or input_value == "BBB":
return "No"
return "Yes"
input_value = input()
print(atc_158a(input_value))
| 0 | null | 29,293,664,658,540 | 83 | 201 |
n,m,l=map(int,input().split())
e=[list(map(int,input().split()))for _ in[0]*(n+m)]
for c in e[:n]:print(*[sum(s*t for s,t in zip(c,l))for l in zip(*e[n:])])
|
from queue import deque
n, m, k = map(int, input().split())
friends = [[] for _ in range(n)]
for _ in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
friends[a].append(b)
friends[b].append(a)
checked = [False] * n
groups = []
for i in range(n):
if checked[i]:
continue
checked[i] = True
que = deque([i])
group = [i]
while que:
now = que.popleft()
friends_now = friends[now]
for friend in friends_now:
if checked[friend] == False:
checked[friend] = True
group.append(friend)
que.append(friend)
groups.append(group)
# print(groups)
D = dict()
for i in range(len(groups)):
for j in groups[i]:
D[j] = i
# print(D)
block = [0] * n
for _ in range(k):
c, d = map(int, input().split())
c -= 1
d -= 1
if D[c] == D[d]:
block[c] += 1
block[d] += 1
for i in range(n):
group_i = D[i]
print(len(groups[group_i]) - block[i] - len(friends[i]) - 1)
| 0 | null | 31,708,369,214,240 | 60 | 209 |
s = input()
l = len(s)
ans = 'x' * l
print(ans)
|
s=input()
ans="x"*len(s)
print(ans)
| 1 | 72,947,613,230,790 | null | 221 | 221 |
import sys
import numpy as np
from math import ceil as C, floor as F, sqrt
from collections import defaultdict as D, Counter as CNT
from functools import reduce as R
import heapq as HQ
class Heap:
def __init__(self, data, reverse=False):
self.reverse = -1 if reverse else 1
self.data = [self.reverse * d for d in data]
HQ.heapify(self.data)
def push(self, x): return HQ.heappush(self.data, self.reverse * x)
def pop(self): return self.reverse * HQ.heappop(self.data)
ALP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
alp = 'abcdefghijklmnopqrstuvwxyz'
def _X(): return sys.stdin.readline().rstrip().split(' ')
def _S(ss): return tuple(ss) if len(ss) > 1 else ss[0]
def S(): return _S(_X())
def Ss(): return list(S())
def _I(ss): return tuple([int(s) for s in ss]) if isinstance(ss, tuple) else int(ss)
def I(): return _I(S())
def _Is(ss): return list(ss) if isinstance(ss, tuple) else [ss]
def Is(): return _Is(I())
n = I()
xs = Is()
ans = 0
now = xs[0]
for x in xs[1:]:
if x < now:
ans += (now - x)
now = max(x, now)
print(ans)
|
n = input()
list_height = list(map(int, input().split()))
pre = 0
max_chair = 0
list_chair = list()
for i in list_height:
if i < pre:
max_chair = pre - i
pre = i + max_chair
list_chair.append(max_chair)
else:
pre = i
print(sum(list_chair))
| 1 | 4,557,025,245,098 | null | 88 | 88 |
from collections import defaultdict
from sys import stdin
input = stdin.readline
def main():
N, X, Y = list(map(int, input().split()))
dic = defaultdict(int)
for l in range(1, N):
for r in range(l+1, N+1):
spath = r - l
if l <= X and Y <= r:
spath -= (Y-X-1)
elif l <= X and X < r <= Y:
spath = min(spath, X-l+1+Y-r)
elif X <= l < Y and Y <= r:
spath = min(spath, l-X+1+r-Y)
elif X < l < Y and X < r < Y:
spath = min(spath, l-X+1+Y-r)
dic[spath] += 1
for k in range(1, N):
print(dic[k])
if(__name__ == '__main__'):
main()
|
while True:
m, f, r = map(int, raw_input().split(" "))
if m==f==r==-1:
break
if m==-1 or f==-1:
print("F")
elif m+f >= 80:
print("A")
elif 65 <= m+f < 80:
print("B")
elif 50 <= m+f < 65:
print("C")
elif 30 <= m+f < 50:
if r >= 50:
print("C")
else:
print("D")
elif m+f < 30:
print("F")
| 0 | null | 22,811,877,959,070 | 187 | 57 |
dice = list(map(int,input().split()))
kaisuu = int(input())
lastlist = []
frlist = []
for i in range(kaisuu):
up,front = list(map(int,input().split()))
if up == dice[0] :
frlist = [1,2,4,3,1]
if up == dice[1]:
frlist = [0,3,5,2,0]
if up == dice[2]:
frlist = [0,1,5,4,0]
if up == dice[3]:
frlist = [0,4,5,1,0]
if up == dice[4]:
frlist = [0,2,5,3,0]
if up == dice[5] :
frlist = [1,3,4,2,1]
k = dice.index(int(front))
for n in frlist[0:4] :
if n == k :
l = frlist.index(int(n))
m = l + 1
lastlist.append(dice[frlist[m]])
for g in lastlist :
print(g)
|
import random
class Cube:
def __init__(self, u, s, e, w, n, d):
self.u = u
self.s = s
self.e = e
self.w = w
self.n = n
self.d = d
def rotate(self, dic):
if dic == "N":
tmp = self.u
self.u = self.s
self.s = self.d
self.d = self.n
self.n = tmp
elif dic == "E":
tmp = self.u
self.u = self.w
self.w = self.d
self.d = self.e
self.e = tmp
elif dic == "W":
tmp = self.u
self.u = self.e
self.e = self.d
self.d = self.w
self.w = tmp
else:
tmp = self.u
self.u = self.n
self.n = self.d
self.d = self.s
self.s = tmp
def main():
u, s, e, w, n, d = map(int, input().split())
cube = Cube(u, s, e, w, n, d)
q = int(input())
for i in range(q):
upper, front = map(int, input().split())
while True:
cube.rotate(random.choice("NWES"))
if upper == cube.u and front == cube.s:
print(cube.e)
break
if __name__ == '__main__':
main()
| 1 | 264,218,911,748 | null | 34 | 34 |
K=int(input())
S=input()
print(S if len(S)<=K else S[:K]+"...")
|
from scipy.sparse.csgraph import floyd_warshall
N, M, L = map(int, input().split())
edges = [[0] * N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
edges[a - 1][b - 1] = c
edges[b - 1][a - 1] = c
Q = int(input())
st = []
for _ in range(Q):
st.append([int(j) - 1 for j in input().split()])
edges = floyd_warshall(edges)
for i in range(N):
for j in range(N):
if edges[i][j] <= L:
edges[i][j] = 1
else:
edges[i][j] = 0
edges = floyd_warshall(edges)
for i, j in st:
if edges[i][j] == float("inf"):
print(-1)
else:
print(int(edges[i][j]) - 1)
| 0 | null | 96,578,481,021,220 | 143 | 295 |
s = input()
n = list(s)
print(n[0]+n[1]+n[2])
|
# -*- coding: utf-8 -*-
from sys import stdin
input = stdin.readline
s = input()
print(s[0:3])
| 1 | 14,773,113,864,350 | null | 130 | 130 |
from collections import defaultdict
n = int(input())
A = list(map(int, input().split()))
cnt = defaultdict(int)
ans = 0
for i, a in enumerate(A):
ans += cnt[i+1 - a]
cnt[i+1 + a] += 1
print(ans)
|
N = int(input())
*A, = map(int, input().split())
dic = {}
ans = 0
for i in range(N):
if A[i] + i in dic:
dic[A[i] + i] += 1
if A[i] + i not in dic:
dic[A[i] + i] = 1
if i - A[i] in dic:
ans += dic[i - A[i]]
print(ans)
| 1 | 26,058,731,175,044 | null | 157 | 157 |
from decimal import Decimal
A,B,C=map(str,input().split())
if Decimal(A)**Decimal("0.5")+Decimal(B)**Decimal("0.5")<Decimal(C)**Decimal("0.5"):
print("Yes")
else:
print("No")
|
#!/usr/bin/env python3
from itertools import product
def solve(n,a):
testimony = product([0,1],repeat=n)
ans = 0
for l in testimony:
flag = True
for test in a:
if l[test[0]] and l[test[1]] and (test[2] == 0):
flag = False
if l[test[0]] and l[test[1]]==0 and test[2]:
flag = False
if flag:
ans = max(ans,sum(l))
return ans
def main():
N = int(input())
a = []
for i in range(N):
tmp = int(input())
for _ in range(tmp):
x,y = map(int,input().split())
a.append([i,x-1,y])
print(solve(N,a))
return
if __name__ == '__main__':
main()
| 0 | null | 86,564,352,005,154 | 197 | 262 |
N, K = map(int, input().split())
arr = list(map(int, input().split()))
jj = 0
koho=[]
for i in range(K):
jj+=arr[i]
koho.append(jj)
for i in range(N-K):
jj+=arr[i+K]
jj-=arr[i]
koho.append(jj)
a=max(koho)
print(a/2+(K/2))
|
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n, k = map(int, readline().split())
p = list(map(int, readline().split()))
l = [i for i in range(1, 1001)]
av = np.cumsum(l) / l
tmp = [av[i - 1] for i in p]
cs = list(np.cumsum(tmp))
if n == k:
print(cs[-1])
exit()
ans = 0
for i in range(n - k):
ans = max(ans, cs[i + k] - cs[i])
print(ans)
| 1 | 75,136,934,316,552 | null | 223 | 223 |
N, M, K = list(map(int, input().split()))
A = [0] + [int(i) for i in input().split() ]
B = [0] + [int(i) for i in input().split() ]
best = 0
a_time = 0
b_time = sum(B)
b_i = len(B)-1
end_flag = False
for a_i in range(N+1):
a_time += A[a_i]
while a_time + b_time > K:
if b_i == 0:
end_flag = True
break
b_time -= B[b_i]
b_i -= 1
if end_flag == True:
break
if a_i + b_i > best:
best = a_i + b_i
print(best)
|
N=int(input())
DP=[-1]*10000
DP[0]=1
DP[1]=0
DP[2]=0
mod=10**9+7
for i in range(3,N+1):
DP[i]=(DP[i-3]+DP[i-1])%mod
print(DP[N])
| 0 | null | 7,004,734,296,222 | 117 | 79 |
class DoublyLinkedList:
def __init__(self):
self.nil = self.make_node(None)
self.nil['next'] = self.nil
self.nil['prev'] = self.nil
def make_node(self,v):
return {'key':v, 'next':None, 'prev':None}
def dump(self):
n = self.nil['next']
while True:
if n['key'] == None:
break
else:
print str(n['key']),
n = n['next']
print
def insert(self,v):
n = self.make_node(v)
n['next'] = self.nil['next']
self.nil['next']['prev'] = n
n['prev'] = self.nil
self.nil['next'] = n
def delete(self,v):
self.delete_node(self.list_search(v))
def delete_node(self,n):
if n['key'] == None: return
n['next']['prev'] = n['prev']
n['prev']['next'] = n['next']
def list_search(self,v):
cur = self.nil['next']
while (cur['key'] != None) and (cur['key'] != v):
cur = cur['next']
return cur
def deleteFirst(self):
self.delete_node(self.nil['next'])
def deleteLast(self):
self.delete_node(self.nil['prev'])
n = int(raw_input())
commands = []
for i in range(n):
commands.append(raw_input())
l = DoublyLinkedList()
for c in commands:
a = c[6]
if a == "F":
l.deleteFirst()
elif a == "L":
l.deleteLast()
else:
val = int(c[7:])
op = c[0]
if op == "i":
l.insert(val)
else:
l.delete(val)
l.dump()
|
def answer(a: int, b: int) -> str:
return min(str(a) * b, str(b) * a)
def main():
a, b = map(int, input().split())
print(answer(a, b))
if __name__ == '__main__':
main()
| 0 | null | 41,949,932,972,156 | 20 | 232 |
# coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
MOD = 10 ** 9 + 7
N, K = lr()
answer = 0
for i in range(K, N+2):
low = i * (i-1) // 2
high = i * (N+N-i+1) // 2
answer += high - low + 1
answer %= MOD
print(answer%MOD)
|
n,k = map(int,input().split())
a = list(range(n))
ans = 0
for i in range(k,n+2):
min1 = 0.5*i*(i-1)
max1 = 0.5*(n*(n+1)-(n-i)*(n-i+1))
sub1 = max1 - min1+1
ans += sub1
print(int(ans%(10**9+7)))
| 1 | 32,935,093,549,512 | null | 170 | 170 |
N=int(input())
a,b,c,d=0,1e10,-1e10,1e10
for i in range(N):
A,B=input().split()
A=int(A)
B=int(B)
a=max(a,A+B)
b=min(b,A+B)
c=max(c,A-B)
d=min(d,A-B)
print(max(abs(a-b),abs(c-d)))
|
N = int(input())
A = [list(map(int, input().split())) for _ in range(N)]
Z = sorted([x+y for x,y in A])
W = sorted([x-y for x,y in A])
print(max(Z[-1]-Z[0], W[-1]-W[0]))
| 1 | 3,396,302,154,838 | null | 80 | 80 |
n=int(input())
a=input()
s=list(a)
b=list(a)
j=0
for i in range(0,n-1):
if s[i]==s[i+1]:
b.pop(i-j)
j=j+1
else:
pass
print(len(b))
|
#!/usr/bin/env python3
n,s = open(0).read().split()
print(1+sum(s[i-1]!=s[i] for i in range(1,int(n))))
| 1 | 169,898,461,392,140 | null | 293 | 293 |
from bisect import *
N, D, A = map(int, input().split())
data = []
for _ in range(N):
x, h = map(int, input().split())
data.append((x,h))
data.sort()
X = []
H = []
for x, h in data:
X.append(x)
H.append(h)
Imos = [0]*(N+1)
cnt = 0
damage = 0
res = 0
for i in range(N):
damage -= Imos[i]*A
h = H[i] - damage
x = X[i]
if h > 0:
cnt = h//A + (h%A!=0)
p = min(bisect_right(X, x+2*D)-1, N-1)
Imos[p+1] += cnt
damage = damage + cnt * A
res += cnt
print(res)
|
n = int(input())
cards = [[0 for i in range(13)] for j in range(4)]
for i in range(n):
Input = input().split()
if Input[0] == "S":
cards[0][int(Input[1])-1]= 1
if Input[0] == "H":
cards[1][int(Input[1]) - 1] = 1
if Input[0] == "C":
cards[2][int(Input[1]) - 1] = 1
if Input[0] == "D":
cards[3][int(Input[1]) - 1] = 1
for i in range(4):
for j in range(13):
if cards[i][j] == 0:
if i == 0:
print("S",j+1)
if i == 1:
print("H",j+1)
if i == 2:
print("C", j + 1)
if i == 3:
print("D", j + 1)
| 0 | null | 41,601,288,895,392 | 230 | 54 |
print(input().find('0')//2+1)
|
a,b = map(int,input().split(" "))
c = a // b
d = a % b
e = float(a) / float(b)
print(c,d,"{:.5f}".format(e))
| 0 | null | 6,987,376,264,036 | 126 | 45 |
MOD = 1000000007
n, k = map(int, input().split())
rsw = [0]*(n+2)
for i in range(1,n+2):
rsw[i] = (rsw[i-1]+i-1)%MOD
rsw_e = [0]*(n+2)
for i in range(1,n+2):
rsw_e[i] = (rsw_e[i-1]+n-(i-1))%MOD
res = 0
for i in range(k,n+2):
start = rsw[i]
end = rsw_e[i]
res += (end-start+1)%MOD
print(res%MOD)
|
i,j=map(int,input().split())
listA=[]
for n in range(i):
listA.append(list(map(int,input().split())))
listA[n].append(sum(listA[n]))
listA.append([])
for n in range(j+1):
number=0
for m in range(i):
number+=listA[m][n]
listA[i].append(number)
for n in range(i+1):
print(' '.join(map(str,listA[n])))
| 0 | null | 17,169,241,926,592 | 170 | 59 |
from collections import Counter
N = int(input())
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
a = prime_factorize(N)
num = list(Counter(a).values())
ans = 0
for i in num:
j = 1
while i - j >= 0:
ans += 1
i -= j
j += 1
print(ans)
|
def prime_factorization(n):
"""do prime factorization using trial division
Returns:
[[prime1,numbers1],[prime2,numbers2],...]
"""
res = []
for i in range(2,int(n**0.5)+1):
if n%i==0:
cnt=0
while n%i==0:
cnt+=1
n//=i
res.append([i,cnt])
if n!=1:
res.append([n,1])
return res
def main():
import sys
input = sys.stdin.readline
N = int(input())
prime_factors = prime_factorization(N)
ans = 0
for p in prime_factors:
i = 1
while i <= p[1]:
ans += 1
N /= p[0]**i
p[1] -= i
i += 1
print(ans)
if __name__ == '__main__':
main()
| 1 | 16,802,661,281,002 | null | 136 | 136 |
# AC: 753 msec(Python3)
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.size = [1] * (n+1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.find(self.par[x])
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.size[x] < self.size[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
return self.find(x) == self.find(y)
def get_size(self, x):
return self.size[self.find(x)]
def main():
N,M,K,*uv = map(int, read().split())
ab, cd = uv[:2*M], uv[2*M:]
uf = UnionFind(N)
friend = [[] for _ in range(N+1)]
for a, b in zip(*[iter(ab)]*2):
uf.unite(a, b)
friend[a].append(b)
friend[b].append(a)
ans = [uf.get_size(i) - 1 - len(friend[i]) for i in range(N+1)]
for c, d in zip(*[iter(cd)]*2):
if uf.is_same(c, d):
ans[c] -= 1
ans[d] -= 1
print(*ans[1:])
if __name__ == "__main__":
main()
|
N = int(input())
if N == 1 or N == 2:
print(0)
else:
if N % 2 == 0:
print(N//2-1)
else:
print(N//2)
| 0 | null | 107,713,435,068,188 | 209 | 283 |
s=input()
ans=0
a=[0]
for i in s:
if i=='<':
if a[-1]>=0:a[-1]+=1
else:a+=[1]
else:
if a[-1]<0:a[-1]-=1
else:a+=[-1]
n=len(a)
for i in range(n//2):
i*=2
j=i+1
if a[i]<abs(a[j]):
x=abs(a[j])
y=a[i]-1
else:
x=abs(a[j])-1
y=a[i]
ans+=x*(x+1)//2+y*(y+1)//2
ans+=n%2*a[-1]*(a[-1]+1)//2
print(ans)
|
a, b, c = map(int, input().split())
sahen = 4*a*b
uhen = (c-a-b)**2
if c-a-b < 0:
ans = "No"
elif sahen < uhen:
ans = "Yes"
else:
ans = "No"
print(ans)
| 0 | null | 104,391,337,081,372 | 285 | 197 |
n = input()
x =map(int,raw_input().split())
y =map(int,raw_input().split())
sum_1,sum_2,sum_3 = [0,0,0]
sum_end = []
for i in range(n):
if x[i] > y[i]:
sum_1 += x[i]-y[i]
sum_2 += (x[i]-y[i])**2
sum_3 += (x[i]-y[i])**3
sum_end.append(x[i]-y[i])
else :
sum_1 += y[i]-x[i]
sum_2 += (y[i]-x[i])**2
sum_3 += (y[i]-x[i])**3
sum_end.append(y[i]-x[i])
print(sum_1)
print(pow(sum_2,0.5))
print(pow(sum_3,1.0/3.0))
sum_end.sort()
print(sum_end[len(sum_end)-1])
|
n = int(input())
a = [0]+list(map(int,input().split()))
dp = [[0]*2 for _ in range(n+1)]
dp[1][1] = a[1]
dp[2][1] = max(a[1],a[2])
for i in range(3,n+1):
if i % 2 == 1:
dp[i][0] = max(dp[i-1][1],dp[i-2][0]+a[i])
dp[i][1] = dp[i-2][1]+a[i]
else:
dp[i][0] = max(dp[i-1][0],dp[i-2][0]+a[i])
dp[i][1] = max(dp[i-1][1],dp[i-2][1]+a[i])
if n % 2 == 1:
print(dp[-1][0])
else:
print(dp[-1][1])
#print(dp)
| 0 | null | 18,847,185,157,828 | 32 | 177 |
from collections import deque
n=int(input())
alpha=['a','b','c','d','e','f','g','h','i','j','k']
q=deque(['a'])
for i in range(n-1):
qi_ans=[]
while(len(q)>0):
qi=q.popleft()
qiword_maxind=0
for j in range(len(qi)):
qi_ans.append(qi+qi[j])
qij_ind=alpha.index(qi[j])
if(qiword_maxind<qij_ind):
qiword_maxind=qij_ind
else:
qi_ans.append(qi+alpha[qiword_maxind+1])
qi_ans=sorted(list(set(qi_ans)))
# print(qi_ans)
q.extend(qi_ans)
lenq=len(q)
for i in range(lenq):
print(q.popleft())
|
status = ['AC','WA','TLE','RE']
li = []
N = int(input())
for n in range(N):
li.append(input())
for s in status:
print(s,'x',li.count(s))
| 0 | null | 30,507,978,832,760 | 198 | 109 |
#!/usr/bin/env python3
# input
n, k = map(int, input().split())
p = list(map(int, input().split()))
c = list(map(int, input().split()))
for i in range(n):
p[i] -= 1
# calc
ans = -int(1e18)
for si in range(n):
x = si
s = []
opscore = 0
while True:
x = p[x]
opscore += c[x]
s.append(c[x])
if x == si:
break
oplen = len(s)
t = 0
for i in range(oplen):
t += s[i]
if i+1 > k:
break
now = t
if opscore > 0:
e = (k-(i+1))//oplen
now += opscore * e
ans = max(ans, now)
print(ans)
|
import sys
mod=10**9+7 ; inf=float("inf")
from math import sqrt, ceil
from collections import deque, Counter, defaultdict #すべてのkeyが用意されてる defaultdict(int)で初期化
input=lambda: sys.stdin.readline().strip()
sys.setrecursionlimit(11451419)
from decimal import ROUND_HALF_UP,Decimal #変換後の末尾桁を0や0.01で指定
#Decimal((str(0.5)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
from functools import lru_cache
#メモ化再帰defの冒頭に毎回 @lru_cache(maxsize=10**10)
#引数にlistはだめ
#######ここまでテンプレ#######
#ソート、"a"+"b"、再帰ならPython3の方がいい
#######ここから天ぷら########
n,k=map(int,input().split())
P=list(map(int,input().split()))
P=[i-1 for i in P]
C=list(map(int,input().split()))
ans=-inf
for i in range(n):
now=i
total=0
roop= 0
po=deque([0])
for kai in range(1,k+1):
now=P[now]
total += C[now]
roop+=1
po.append(total)
ans=max(ans, total)
if now == i:
la= kai;break
else: continue
if total<0 : continue
po=list(po)
ans=max(ans, total* (k//roop) + max(po[:k%roop+1]), total*(k//roop-1) + max(po))
#print(total, roop,po ,ans)
print(ans)
| 1 | 5,336,030,543,438 | null | 93 | 93 |
while True:
a,op,b = input().split()
a = int(a)
b = int(b)
if op == "?":
break
else:
if op == "+":
ans = a + b
elif op == "-":
ans = a-b
elif op == "*":
ans = a * b
elif op == "/":
rem = a%b
if rem == 0:
ans = int(a/b)
else:
ans = int(a/b)
print(ans)
|
import numpy as np
N = int(input())
X = str(input())
num_one = X.count("1")
dp = [-1] * N
dp[0] = 0
def dfs(n):
if dp[n] == -1:
dp[n] = 1 + dfs(n % bin(n).count('1'))
return dp[n]
num_one = X.count("1")
bool_arr = np.array([True if X[N-i-1] == "1" else False for i in range(N)])
zero_ver = np.array([pow(2, i, num_one + 1) for i in range(N)])
zero_ver_sum = sum(zero_ver[bool_arr])
one_ver = -1
one_ver_sum = 0
flag = False
if num_one != 1:
one_ver = np.array([pow(2, i, num_one - 1) for i in range(N)])
one_ver_sum = sum(one_ver[bool_arr])
else:
flag = True
for i in range(1,N+1):
start = 0
if bool_arr[N-i] == False:
start = (zero_ver_sum + pow(2, N - i, num_one + 1)) % (num_one + 1)
print(dfs(start)+1)
else:
if flag:
print(0)
else:
start = (one_ver_sum - pow(2, N - i, num_one - 1)) % (num_one - 1)
print(dfs(start)+1)
| 0 | null | 4,414,128,888,992 | 47 | 107 |
n=input()
m = 100000
for _ in xrange(n):
m = m + m*0.05
if m % 1000:
m = m + 1000 - m % 1000
print int(m)
|
import math
a=100
for _ in[0]*int(input()):a=math.ceil(a*1.05)
print(a*1000)
| 1 | 1,054,730,660 | null | 6 | 6 |
l=list(input())
if(l[0]==l[1]==l[2]):
print("No")
else:
print("Yes")
|
import sys
k = int(input())
a,b = list(map(int,input().split()))
for i in range(a,b+1):
if i % k == 0:
print("OK")
sys.exit()
print("NG")
| 0 | null | 40,889,162,280,220 | 201 | 158 |
n = int(input())
result = []
for i in range(1,n+1):
si = str(i)
if (not i % 3) or "3" in si:
result.append(si)
print(" " + " ".join(result))
|
import sys
alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
cnt = 26 * [0]
Input = ""
loop = True
#while loop:
# I = input()
# if not I:
# loop = False
# Input += I
for I in sys.stdin:
Input += I
for i1 in range(len(alphabet)):
for i2 in range(len(Input)):
if 'A' <= Input[i2] <= 'Z':
w = Input[i2].lower()
else:
w = Input[i2]
if alphabet[i1] == w:
cnt[i1] += 1
print(alphabet[i1] + " : " + str(cnt[i1]))
| 0 | null | 1,300,114,260,610 | 52 | 63 |
def gen_factorization(N):
tables=[-1]*(N+1)
for i in range(2,N+1):
if tables[i]!=-1:continue
tmp=i
while tmp<=N:
tables[tmp]=i
tmp+=i
def fuctorization(n):
if n==1:return {1:1}
elif n<0:n=abs(n)
if n>N:return "error"
ans={}
while n!=1:
tmp=tables[n]
#debug print
#print(tmp,n)
ans.setdefault(tmp,0)
ans[tmp]+=1
n//=tmp
return ans
return fuctorization
N=int(input())
f=gen_factorization(10**6+10)
A=list(map(int,input().split()))
primes={}
for i in A:
d=f(i)
for j in d:
primes.setdefault(j,0)
primes[j]+=1
primes[1]=1
ansMax=max(primes.values())
if ansMax==1:
print('pairwise coprime')
elif ansMax==N:
print('not coprime')
else:
print('setwise coprime')
|
N = int(input())
A = list(map(int, input().split()))
B = [0 for i in range(max(A)+1)]
for i in range(2, len(B)):
if B[i] != 0:
continue
for j in range(i, len(B), i):
B[j] = i
def func(X):
buf = set()
while X>1:
x = B[X]
buf.add(x)
while X%x==0:
X = X//x
#print(buf)
return buf
set1 = func(A[0])
set2 = func(A[0])
totallen = len(set1)
for a in A[1:]:
set3 = func(a)
totallen += len(set3)
#print(a, set1, set2)
set1 |= set3
set2 &= set3
#print(set1, set2, set3)
#print(totallen, set1, set2)
if len(set2)!=0:
print("not coprime")
elif len(set1)==totallen:
print("pairwise coprime")
else:
print("setwise coprime")
| 1 | 4,127,811,876,192 | null | 85 | 85 |
import sys
#import numpy as np
import math
#from fractions import Fraction
#import itertools
#from collections import deque
#import heapq
#from fractions import gcd
input=sys.stdin.readline
n=int(input())
a=list(map(int,input().split()))
mod=10**9+7
ans=1
d={x:0 for x in range(n)}
for i in range(n):
if a[i]==0:
d[0]+=1
else:
m=a[i]
ans=(ans*(d[m-1]-d[m]))%mod
if ans<=0:
print(0)
exit()
d[m]+=1
if d[a[i]]>3:
print(0)
exit()
if d[0]==1:
print(ans*3%mod)
elif d[0]==2:
print(ans*6%mod)
elif d[0]==3:
print(ans*6%mod)
|
N = int(input())
A = list(map(int,input().split()))
C = [0,0,0]
Ans = 1
MOD = 1000000007
for a in A:
ask = C.count(a)
if ask==0:
Ans=0
break
ind = C.index(a)
C[ind] += 1
Ans = (Ans*ask)%MOD
print(Ans)
| 1 | 130,483,140,136,650 | null | 268 | 268 |
import math
import sys
import collections
import bisect
readline = sys.stdin.readline
def main():
n, m = map(int, readline().rstrip().split())
a = list(map(int, readline().rstrip().split()))
print(n - sum(a) if n - sum(a) >= 0 else -1)
if __name__ == '__main__':
main()
|
N,M = map(int, input().split())
A_list = [int(i) for i in input().split()]
playable_days = N - sum(A_list)
if playable_days >= 0:
print(playable_days)
else:
print("-1")
| 1 | 32,191,182,250,928 | null | 168 | 168 |
#!/usr/bin/env python3
n = list(input())
if '3' == n[-1]:
print('bon')
elif n[-1] in ['0', '1', '6', '8']:
print('pon')
else:
print('hon')
|
n=int(input())
a=n%10
if a==2 or a==4 or a==5 or a==7 or a==9:
print("hon")
elif a==0 or a==1 or a==6 or a==8:
print("pon")
else:
print("bon")
| 1 | 19,169,832,363,968 | null | 142 | 142 |
N,M = map(int,input().split())
ans = []
s = 1
e = M+1
while e>s:
ans.append([s,e])
s += 1
e -= 1
s = M+2
e = 2*M+1
while e>s:
ans.append([s,e])
s += 1
e -= 1
for s,e in ans:
print(s,e)
|
a, b = input().split()
str = ''
if int(a)<=int(b):
for _ in range(int(b)):
str += a
else:
for _ in range(int(a)):
str += b
print(str)
| 0 | null | 56,577,933,707,940 | 162 | 232 |
def rec(num, string, total, xy_list, n):
x, y = xy_list[num]
if string:
pre_one = int(string[-1])
pre_x, pre_y = xy_list[pre_one]
distance = ((x - pre_x)**2 + (y - pre_y)**2)**0.5
total+=distance
string+=str(num)
if len(string)==n:
return total
all_total = 0
ret_list = [i for i in range(n) if str(i) not in string]
for one in ret_list:
all_total+=rec(one, string, total, xy_list, n)
return all_total
def main():
n = int(input())
xy_list = []
k = 1
for i in range(n):
x, y = list(map(int, input().split(" ")))
xy_list.append((x, y))
k*=(i+1)
all_total = 0
for i in range(n):
all_total+=rec(i, "", 0, xy_list, n)
print(all_total/k)
if __name__=="__main__":
main()
|
import math
N = int(input())
x = []
y = []
for i in range(N):
tmp = input().split(" ")
x.append(int(tmp[0]))
y.append(int(tmp[1]))
d = 0
for i in range(N):
for j in range(N):
d += math.sqrt((x[j]-x[i]) ** 2 + (y[j]-y[i]) ** 2)
print(d/N)
| 1 | 148,049,354,867,208 | null | 280 | 280 |
#!/usr/bin/pypy
# coding: utf-8
N,M,L=map(int, raw_input().split())
RG=[[ 0 if i==j else float('inf') for i in range(N)] for j in range(N)]
for i in xrange(M):
f,t,c = map(int, raw_input().split())
if c <= L:
RG[f-1][t-1] = c
RG[t-1][f-1] = c
for k in xrange(N):
for i in xrange(N):
for j in xrange(i, N):
t = RG[i][k] + RG[k][j]
if RG[i][j] > t:
RG[i][j] = t
RG[j][i] = t
FG=[[float('inf') for i in range(N)] for j in range(N)]
for i in xrange(N):
for j in xrange(i, N):
if RG[i][j] <= L:
FG[i][j] = 1
FG[j][i] = 1
for k in xrange(N):
for i in xrange(N):
for j in xrange(i, N):
t = FG[i][k] + FG[k][j]
if FG[i][j] > t:
FG[i][j] = t
FG[j][i] = t
Q=int(raw_input())
for i in xrange(Q):
s, t = map(int, raw_input().split())
v = FG[s-1][t-1]
if v == float('inf'):
print (str(-1))
else:
print (str(int(v-1)))
|
K = int(input())
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
ans = 0
for i in range(1,K+1):
for j in range(1,K+1):
for k in range(1,K+1):
ans += (gcd(i,j,k))
print(ans)
| 0 | null | 104,119,068,083,420 | 295 | 174 |
# 168_b
K = int(input())
S = input()
# str.islower()
# >文字列中の大小文字の区別のある文字全てが小文字で、
# >かつ大小文字の区別のある文字が 1 文字以上あるなら True を、そうでなければ False を返します。
if (1 <= K and K <= 100) and S.islower() and (1 <= len(S) and len(S) <= 100):
if len(S)<=K:
print(S)
elif len(S)>K:
print("{}...".format(S[0:K]))
|
import collections
import sys
sys.setrecursionlimit(10 ** 8)
def Z(): return int(input())
def ZZ(): return [int(_) for _ in input().split()]
class edge:
def __init__(self, to, id): self.to, self.id = to, id
def main():
N = Z()
col = [0] * (N-1)
G = collections.defaultdict(list)
for i in range(N-1):
a, b = ZZ()
G[a].append(edge(b, i))
G[b].append(edge(a, i))
numCol = 0
for i in range(1, N+1): numCol = max(numCol, len(G[i]))
def dfs(v):
colSet = set()
for ed in G[v]:
if col[ed.id] != 0: colSet.add(col[ed.id])
c = 1
for ed in G[v]:
if col[ed.id] != 0: continue
while c in colSet: c += 1
col[ed.id] = c
c += 1
dfs(ed.to)
dfs(1)
print(numCol)
for i in range(N-1): print(col[i])
return
if __name__ == '__main__':
main()
| 0 | null | 77,603,223,696,768 | 143 | 272 |
import sys
from collections import Counter
import numba as nb
import numpy as np
input = sys.stdin.readline
@nb.njit("i8(i8[:],i8[:])", cache=True)
def solve(keys, values):
MAX_A = 10 ** 6
divisible = [False] * (MAX_A + 1)
ans = 0
for k, v in zip(keys, values):
if v == 1 and not divisible[k]:
ans += 1
for i in range(k, MAX_A + 1, k):
divisible[i] = True
return ans
def main():
N = int(input())
A = list(map(int, input().split()))
A.sort()
c = Counter(A)
keys = np.array(tuple(c.keys()), dtype=np.int64)
values = np.array(tuple(c.values()), dtype=np.int64)
ans = solve(keys, values)
print(ans)
if __name__ == "__main__":
main()
|
from numba import njit
@njit(fastmath=True)
def fact(x):
i = 1
while i * i <= x:
if x % i == 0:
yield i
yield x // i
i += 1
def main():
n = int(input())
a = tuple(map(int, input().split()))
c = [0] * (max(a) + 1)
for e in a:
c[e] += 1
ans = n
for e in a:
c[e] -= 1
for fct in fact(e):
if c[fct]:
ans -= 1
break
c[e] += 1
print(ans)
if __name__ == "__main__":
main()
| 1 | 14,522,750,688,520 | null | 129 | 129 |
import sys
x = int(input())
for a in range(-(10 ** 3), 10 ** 3):
for b in range(-(10 ** 3), 10 ** 3):
if a ** 5 - b ** 5 == x:
print(a, b)
sys.exit()
|
pay = int(input())
if pay % 1000 == 0:
print(0)
else:
print(1000 - pay % 1000)
| 0 | null | 17,134,870,116,480 | 156 | 108 |
T = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
da, db = 0, 0
for i in range(2):
da += T[i] * A[i]
db += T[i] * B[i]
if da == db:
print("infinity")
exit()
x = (B[0] - A[0]) * T[0]
y = da - db
print(max(0, x // y * 2 + (0 if x % y == 0 else 1)))
|
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
P = (A1 - B1) * T1
Q = (A2 - B2) * T2
if P > 0:
P *= -1
Q *= -1
if P + Q < 0:
print(0)
elif P + Q == 0:
print("infinity")
else:
S = (-P) // (P + Q)
T = (-P) % (P + Q)
if T != 0:
print(S * 2 + 1)
else:
print(S * 2)
| 1 | 131,697,611,416,950 | null | 269 | 269 |
n = int(input())
q = list(map(int,input().split()))
ans = 0
for i in range(n):
for j in range(n):
if i == j:
continue
ans += q[i] * q[j]
print(ans//2)
|
x,y=map(int,input().split())
while x%y!=0:
tmp=y
y=x%y
x=tmp
print(y)
| 0 | null | 84,499,070,315,492 | 292 | 11 |
if __name__ == "__main__":
n = int(input())
taro, hanako = 0, 0
for _ in range(n):
tw, hw = input().split()
if tw > hw:
taro += 3
elif tw < hw:
hanako += 3
else:
taro += 1
hanako += 1
print(taro, hanako)
|
class SwappingTwoNumbers:
def output(self, n):
n.sort()
print "%d %d" % (n[0], n[1])
if __name__ == "__main__":
stn = SwappingTwoNumbers();
while True:
n = map(int, raw_input().split())
if n[0] == 0 and n[1] == 0:
break
stn.output(n)
| 0 | null | 1,250,384,459,652 | 67 | 43 |
N, K = [int(i) for i in input().split()]
P = [int(i) for i in input().split()]
P2 = [(((P[i]+1)) / 2) for i in range(N)]
# i番目は1~P[i]の値を出す
# P[i]が大きいものからK個選んで期待値を求める
# 幅が最大のところを見つける
s = 0
init = 0
for i in range(K):
s += P2[i]
tmp = s
for i in range(1, N-K+1):
tmp = tmp - P2[i-1] + P2[i+K-1]
if s < tmp:
s = tmp
init = i
print(s)
|
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n, k = map(int, readline().split())
p = list(map(int, readline().split()))
l = [i for i in range(1, 1001)]
av = np.cumsum(l) / l
tmp = [av[i - 1] for i in p]
cs = list(np.cumsum(tmp))
if n == k:
print(cs[-1])
exit()
ans = 0
for i in range(n - k):
ans = max(ans, cs[i + k] - cs[i])
print(ans)
| 1 | 74,878,629,965,324 | null | 223 | 223 |
st = input()
q = int(input())
for x in range(q):
ip = list(input().split())
if ip[0] == "print":
print(st[int(ip[1]):int(ip[2])+1])
elif ip[0] == "replace":
ip[1] = int(ip[1])
ip[2] = int(ip[2])
temp = st[0:ip[1]] + ip[3] + st[ip[2]+1:]
st = temp
elif ip[0] == "reverse":
ip[1] = int(ip[1])
ip[2] = int(ip[2])
temp = st[0:ip[1]] + st[ip[1]:ip[2]+1][::-1] + st[ip[2]+1:]
st = temp
|
import itertools
n = int(input())
p = tuple([int(i) for i in input().split()])
q = tuple([int(i) for i in input().split()])
lst = list(itertools.permutations(list(range(1, n + 1))))
print(abs(lst.index(p) - lst.index(q)))
| 0 | null | 51,242,388,894,112 | 68 | 246 |
def main():
s, t = input().split()
a, b = map(int, input().split())
u = input()
if s == u:
print(a-1, b)
else:
print(a, b-1)
if __name__ == "__main__":
main()
|
def main():
d, t, s = (int(i) for i in input().split())
if t*s >= d:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| 0 | null | 37,789,979,936,100 | 220 | 81 |
def bubble_sort(A):
cnt = 0
for i in range(len(A) - 1):
for j in reversed(range(i+1, len(A))):
if A[j] < A[j - 1]:
cnt += 1
tmp = A[j]
A[j] = A[j - 1]
A[j - 1] = tmp
return cnt
cnt = 0
amount = int(input())
nl = list(map(int, input().split()))
cnt = bubble_sort(nl)
for i in range(amount - 1):
print(nl[i], end=" ")
print(nl[amount - 1])
print(cnt)
|
N=int(input())
X=[0]*N
for i in range(N):
X[i]=[list(map(int,input().split())) for _ in [0]*int(input())]
print(max(['{:b}'.format(i).count('1')for i in range(2**N) if all([all([y[1]==i>>(y[0]-1)&1 for y in X[j]]) for j in range(N) if (i>>j&1)])]))
| 0 | null | 60,442,999,037,820 | 14 | 262 |
n = int(input())
s = input().split(" ")
nums = list(map(int,s))
koukan = 0
for i in range(n):
minj = i
for j in range(i+1,n):
if nums[j] < nums[minj]:
minj = j
w = nums[i]
nums[i] = nums[minj]
nums[minj] = w
if i != minj:
koukan += 1
for i in range(n):
if i == n-1:
print(nums[i])
else:
print(nums[i],end=" ")
print(koukan)
|
K = int(input())
S = input()
if len(S) <= K:
ans = S
else:
ans = S[0:K] + '...'
print(ans)
| 0 | null | 9,885,166,919,160 | 15 | 143 |
def resolve():
import itertools
N = int(input())
A = []
X = []
ans = [0]
for _ in range(N):
a = int(input())
xx = []
for __ in range(a):
x = list(map(int, input().split()))
xx.append(x)
X.append(xx)
A.append(a)
for i in itertools.product([0, 1], repeat=N):
flag = 0
for p in range(N):
for q in range(A[p]):
if i[p] == 1 and X[p][q][1] != i[X[p][q][0]-1]:
flag = 1
if flag == 0:
ans.append(i.count(1))
print(max(ans))
resolve()
|
a, b = map(int, input().split())
def gcd(a, b):
big = max(a, b)
small = min(a, b)
while not big % small == 0:
big, small = small, big%small
return small
print(gcd(a, b))
| 0 | null | 60,549,792,267,240 | 262 | 11 |
cards = {
'S': [0 for _ in range( 13)],
'H': [0 for _ in range( 13)],
'C': [0 for _ in range( 13)],
'D': [0 for _ in range( 13)],
}
n = int( input())
for _ in range( n):
(s, r) = input().split()
r = int(r)
cards[s][r - 1] = r
for s in ( 'S', 'H', 'C', 'D'):
for r in range( 13):
if cards[s][r] == 0:
print( '{0:s} {1:d}'.format( s, r+1))
|
pictures = ['S','H','C','D']
card_li = []
for i in range(4):
for j in range(1,14):
card_li.append(pictures[i] + ' ' + str(j))
n = int(input())
for i in range(n): del card_li[card_li.index(input())]
for i in card_li:
print(i)
| 1 | 1,043,658,157,662 | null | 54 | 54 |
n = int(input())
iteration = n
ex = 0
count = 0
for i in range(1,n):
ex = iteration-i
#print(ex)
if ex <=i:
break
else:
count += 1
print(count)
|
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
N,K = LI()
s = set()
for i in range(K):
_ = I()
s.update(LI())
print(N-len(s))
| 0 | null | 89,038,299,054,112 | 283 | 154 |
n = input()
c = input()
i = 0
while 1:
l = c.find('W')
r = c.rfind('R')
if l == -1 or r == -1 or l >= r:
break
c = c[:l] + 'R' + c[l + 1:r] + 'W' + c[r + 1:]
i += 1
print(i)
|
n=int(input())
s=input()
rcnt=s.count("R")
wcnt=s[:rcnt].count("W")
print(wcnt)
| 1 | 6,247,326,000,992 | null | 98 | 98 |
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
if not V > W:
print("NO")
elif (V-W)*T >= abs(B-A):
print("YES")
else:
print("NO")
|
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
# 相対速度、距離
S = V - W
D = abs(A - B)
if(D > S * T):
print('NO')
exit(0)
else:
print('YES')
| 1 | 15,103,239,405,182 | null | 131 | 131 |
lis = [int(x) for x in input().split()]
if lis[0] < lis[1]and lis[1] < lis[2]:
print("Yes")
else:
print("No")
|
N, K = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(K)]
# dpの高速化 => 累積和によって、O(N)で解く
dp = [0] * N
acc = [0]* (N+1)
dp[0], acc[1] = 1, 1
# acc[0] = 0
# acc[1] = dp[0]
# acc[2] = dp[0] + dp[1]
# acc[n] = dp[0] + dp[1] + dp[n-1]
# dp[0] = acc[1] - acc[0]
# dp[1] = acc[2] - acc[1]
# dp[n-1] = acc[n] - acc[n-1]
mod = 998244353
for i in range(1, N):
# acc[i] = dp[0] + ... + dp[i-1] が既知
# 貰うdp
for j in range(K):
r = i - X[j][0]
l = i - X[j][1]
if r < 0: continue
l = max(l, 0)
dp[i] += acc[r+1] - acc[l] # s = dp[L] + ... + dp[R]
dp[i] %= mod
acc[i+1] = acc[i] + dp[i] # acc[i+1] = dp[0] + ... + dp[i]
print(dp[N-1])
| 0 | null | 1,532,202,793,992 | 39 | 74 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.