code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
178,025B
⌀ | question_pair_id
float64 27.1M
177,113B
⌀ | code1_group
int64 1
297
| code2_group
int64 1
297
|
|---|---|---|---|---|---|---|
import math
N = int(input())
ans = -1
for i in range(N+1):
if math.floor(i*1.08) == N:
ans = i
if ans == -1:
print(':(')
else:
print(ans)
|
import math
N = int(input())
A = list(map(int, input().split()))
inf = int(1e6+5)
C = [0]*inf
for a in A:
C[a] += 1
pa = True
se = True
for i in range(2, inf):
cnt = 0
cnt += sum(C[i::i])
if cnt > 1:
pa = False
if cnt == N:
se = False
if pa:
print("pairwise coprime")
elif se:
print("setwise coprime")
else:
print("not coprime")
| 0 | null | 64,705,629,790,490 | 265 | 85 |
print("A" if input().isupper() else "a")
|
a,b,c,d,e=map(int,input().split())
x=a*60+b
y=c*60+d
print(y-x-e)
| 0 | null | 14,708,349,539,534 | 119 | 139 |
from collections import deque
n=int(input())
edge=[[] for _ in range(n+1)]
for i in range(n):
v,k,*u=map(int,input().split())
edge[v]=u
p=[-1]*(n+1)
p[1]=0
q=deque([])
q.append(1)
v=[1]*(n+1)
v[1]=0
while q:
now=q.popleft()
for i in edge[now]:
if v[i]:
q.append(i)
p[i]=p[now]+1
v[i]=0
for i in range(1,n+1):
print(i,p[i])
|
S = input()
T = input()
S_chars = list(S)
T_chars = list(T)
i = 0
count = 0
for roop in S_chars:
if not S_chars[i] == T_chars[i]:
count += 1
i += 1
print(count)
| 0 | null | 5,190,899,655,198 | 9 | 116 |
N,M=input().split()
N=int(N)
M=int(M)
if N==M:
print("Yes")
else:
print("No")
|
a, b = map(int, input().split())
print(a == b and "Yes" or "No")
| 1 | 83,159,949,544,800 | null | 231 | 231 |
import sys
n = input()
for i in range(1,n+1):
x = i
if x%3==0:
sys.stdout.write(' %d' % i)
continue
while x<=n:
if x%10==3:
sys.stdout.write(' %d' % i)
break
else:
x /= 10
if x==0:
break
sys.stdout.write('\n')
|
n = int(raw_input())
output = ""
for i in range(1, n + 1):
x = i
if x % 3 == 0:
output += " "
output += str(i)
continue
while True:
if x % 10 == 3:
output += " "
output += str(i)
break
else:
x /= 10
if x == 0:
break
print output
| 1 | 943,648,093,980 | null | 52 | 52 |
ini = lambda : int(input())
inm = lambda : map(int,input().split())
inl = lambda : list(map(int,input().split()))
gcd = lambda x,y : gcd(y,x%y) if x%y else y
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
#maincode-------------------------------------------------
n = ini()
s = input()
r = s.count('R')
g = s.count('G')
b = s.count('B')
ans = r*g*b
for j in range(n):
for i in range(j):
k = 2*j-i
if k < n:
if (s[i] == s[j]):
continue
if (s[i] == s[k]):
continue
if (s[j] == s[k]):
continue
ans -= 1
print(ans)
|
def main():
import bisect
n = int(input())
s = input()
r,g,b = 0,0,0
for i in range(n):
if s[i]=='R':
r+=1
elif s[i]=='G':
g+=1
else:
b+=1
ans = r*g*b
for i in range(n-1):
for j in range(i+1,n):
k = 2*(j+1)-(i+1)-1
if k>n-1:
continue
if s[i]!=s[j] and s[i] != s[k] and s[j]!=s[k]:
ans -= 1
print(ans)
if __name__ == "__main__":
main()
| 1 | 35,878,941,041,088 | null | 175 | 175 |
N = int(input())
MOD = 10**9 + 7
val1 = pow(9,N,MOD)
val2 = pow(8,N,MOD)
ans = pow(10,N,MOD) - 2*val1 + val2
print(ans%MOD)
|
import sys
input = sys.stdin.readline
import math
MOD = 10**9+7
N = int(input())
F = []
zero_v = 0
inf = 0
zero = 0
for _ in range(N):
x,y = map(int,input().split())
if x==0 and y==0:
zero_v += 1
elif x==0:
inf += 1
elif y==0:
zero += 1
else:
G = math.gcd(abs(x),abs(y))
F.append((x//G,y//G))
all_keys = set()
for x,y in F:
if x*y >0:
if x>0:
all_keys.add((x,y))
else:
all_keys.add((-x,-y))
x,y = -y,x
if x*y >0:
if x>0:
all_keys.add((x,y))
else:
all_keys.add((-x,-y))
all_dic = {k:[0,0] for k in all_keys}
for x,y in F:
if x*y > 0:
if x>0:
all_dic[(x,y)][0] += 1
else:
all_dic[(-x,-y)][0] += 1
else:
if x>0:
all_dic[(-y,x)][1] += 1
else:
all_dic[(y,-x)][1] += 1
ans = (pow(2,inf,MOD)) + (pow(2,zero,MOD))-1
ans %= MOD
for k in all_keys:
P,N = all_dic[k]
ans *= (pow(2,P,MOD)) + (pow(2,N,MOD))-1
ans %= MOD
ans += zero_v-1
print(ans%MOD)
| 0 | null | 12,126,298,684,312 | 78 | 146 |
import math
def solve(depth, p1, p2):
if depth == 0:
return
else:
px = (p2[0] - p1[0]) / 3
py = (p2[1] - p1[1]) / 3
s = [p1[0] + px, p1[1] + py]
t = [p1[0] + 2 * px, p1[1] + 2 * py]
u = [(t[0] - s[0]) * math.cos(math.pi/3) -
(t[1] - s[1]) * math.sin(math.pi/3) + s[0],
(t[0] - s[0]) * math.sin(math.pi/3) +
(t[1] - s[1]) * math.cos(math.pi/3) + s[1]]
solve(depth-1, p1, s)
print(*s)
solve(depth-1, s, u)
print(*u)
solve(depth-1, u, t)
print(*t)
solve(depth-1, t, p2)
def main():
n = int(input())
print("%f %f" % (0, 0))
solve(n, [0, 0], [100, 0])
print("%f %f" % (100, 0))
if __name__ == '__main__':
main()
|
n = input()
print "%d:%d:%d" % (n/3600,(n/60)%60,n%60)
| 0 | null | 229,728,962,498 | 27 | 37 |
ii = lambda:int(input())
mi = lambda:list(map(int,input().split()))
ix = lambda x:list(input() for _ in range(x))
mix = lambda x:list(mi() for _ in range(x))
iix = lambda x:list(int(input()) for _ in range(x))
##########
def resolve():
h1,m1,h2,m2,k = mi()
res = convert(h2,m2) - convert(h1,m1) - k
print(res)
def convert(h,m):
return h*60 + m
if __name__ == "__main__":
resolve()
|
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
a,b,c,d,e = map(int, input().split())
if d >= b:
res = (c-a)*60 + d-b
print(res-e)
else:
res = (c-a-1)*60 + d-b+60
print(res-e)
if __name__ == '__main__':
main()
| 1 | 18,019,978,884,008 | null | 139 | 139 |
N=int(input())
k=N%1000
if k==0:
t=0
else:
t=1000-k
print(t)
|
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 7 01:24:25 2020
@author: saito
"""
# %% import phase
# %% define phase
# %% input phase
N = int(input())
# %% process phase
answer = 1000-((N-1)%1000+1)
# %%output phase
print(answer)
| 1 | 8,391,871,280,740 | null | 108 | 108 |
from string import ascii_lowercase, ascii_uppercase
s = open(0).read()
ans = [0]*26
for c in s:
i = ascii_lowercase.find(c)
if i > -1:
ans[i] += 1
i = ascii_uppercase.find(c)
if i > -1:
ans[i] += 1
for c, t in zip(ascii_lowercase, ans):
print("%s : %d" % (c, t))
|
K = int(input())
A, B = map(int, input().split())
ans = 'OK' if B//K-(A-1)//K > 0 else 'NG'
print(ans)
| 0 | null | 14,059,639,664,060 | 63 | 158 |
N,M = (int(x) for x in input().split())
A = [int(x) for x in input().split()]
A = sorted(A,reverse=True)
if A[M-1] * 4 * M >= sum(A):
print("Yes")
else:
print("No")
|
n,m = map(int, input().split())
A = list(map(int,input().split()))
min_limit = sum(A)*(1 / (4*m))
select_ok = 0
for i in A:
if i >= min_limit:
select_ok += 1
if select_ok >= m:
print("Yes")
else:
print("No")
| 1 | 38,664,405,367,328 | null | 179 | 179 |
import sys
def lcm(a, b):
a, b = max(a, b), min(a, b)
c = a * b
while a % b > 0:
a, b = b, a % b
return c // b
def solve():
input = sys.stdin.readline
X = int(input())
L = lcm(360, X)
print(L // X)
return 0
if __name__ == "__main__":
solve()
|
import numpy as np
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
N, K = map(int, input().split())
A = np.array(list(map(int, input().split())), dtype = np.int64)
F = np.array(list(map(int, input().split())), dtype = np.int64)
A.sort()
F.sort()
F = F[::-1]
l = 0
r = 10**12 + 100
def solve(num):
B = num // F
tmp = np.sum(np.maximum(0, A - B))
if tmp <= K:
return 1
else:
return 0
while r - l > 1:
mid = (l + r) // 2
if solve(mid):
r = mid
else:
l = mid
if solve(l):
print(l)
else:
print(r)
| 0 | null | 88,587,816,829,750 | 125 | 290 |
n,m = input().split()
print(((int(n) * (int(n) - 1)) + (int(m) * (int(m) - 1))) // 2)
|
def main():
n,a,b = list(map(int,input().split()))
ans=0
count=int(n/(a+b))
ans+=count*a
amari=n-count*(a+b)
if amari <= a:
ans+=amari
else:
ans+=a
print(ans)
main()
| 0 | null | 50,588,585,766,544 | 189 | 202 |
a=input()
b=int(input())
while b>0:
tmp=input().split(" ")
if tmp[0]=="replace":
a=a[:int(tmp[1])]+tmp[3]+a[int(tmp[2])+1:]
if tmp[0]=="reverse":
tmp2="".join(list(a)[int(tmp[1]):int(tmp[2])+1])[::-1]
a=a[:int(tmp[1])]+tmp2+a[int(tmp[2])+1:]
if tmp[0]=="print":
print(a[int(tmp[1]):int(tmp[2])+1])
b-=1
|
#
# 9d
#
def main():
s = input()
q = int(input())
for i in range(q):
l = list(input().split())
a = int(l[1])
b = int(l[2])
if l[0] == "print":
print(s[a:b+1])
elif l[0] == "reverse":
s = s[0:a] + s[a:b+1:][::-1] + s[b+1:]
elif l[0] == "replace":
s = s[0:a] + l[3] + s[b+1:]
else:
pass
if __name__ == '__main__':
main()
| 1 | 2,094,442,433,638 | null | 68 | 68 |
H, W, K = map(int, input().split())
c = []
b_h = [0] * H
b_w = [0] * W
b = 0
for h in range(H):
c.append(input().rstrip())
for w in range(W):
if c[h][w] == "#":
b_h[h] += 1
b_w[w] += 1
b += 1
ans = 0
for hi in range(2 ** H):
for wi in range(2 ** W):
bsum = b
for h in range(H):
if hi & (2 ** h) != 0:
bsum -= b_h[h]
for w in range(W):
if wi & 2 ** w != 0:
if c[h][w] == '#':
bsum += 1
for w in range(W):
if wi & (2 ** w) != 0:
bsum -= b_w[w]
if bsum == K:
ans += 1
print(ans)
|
from decimal import *
import math
getcontext().prec = 50
a, b, c = map(int, input().split())
a = Decimal(a)
b = Decimal(b)
c = Decimal(c)
a = Decimal.sqrt(a)
b = Decimal.sqrt(b)
c = Decimal.sqrt(c)
if a + b < c:
print("Yes")
else:
print("No")
| 0 | null | 30,133,952,616,790 | 110 | 197 |
nn = int(input())
aa = list(map(int,input().split()))
joushi = [0]*nn
for i in range(len(aa)):
joushi[aa[i]-1] += 1
for j in range(len(joushi)):
print(joushi[j])
|
modulo = 10**9+7
def modpow(base, n):
ans = 1
while n:
if n&1:
ans = (ans*base)%modulo
base = (base*base)%modulo
n >>= 1
return ans
factorials = [1]
N = 10**5
for i in range(1, N+1):
factorials.append((factorials[-1]*i)%modulo)
inv = [0]
for i in range(1, N+1):
inv.append(modpow(factorials[i], modulo-2))
def nCr(n, r):
if r == 0 or r == n:
return 1
return (factorials[n]*inv[n-r]*inv[r])%modulo
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
N, K = read_ints()
A = read_ints()
A.sort()
max_sum = 0
for i in range(K-1, N):
max_sum = (max_sum+A[i]*nCr(i, K-1))%modulo
min_sum = 0
for i in range(N-K+1):
min_sum = (min_sum+A[i]*nCr(N-i-1, K-1))%modulo
return (max_sum-min_sum)%modulo
if __name__ == '__main__':
print(solve())
| 0 | null | 64,001,650,752,868 | 169 | 242 |
#Digit Number
while True:
try:
i, n = input(). split()
m = str(int(i) + int(n))
print(len(m))
except:
break
|
while 1:
try:
a,b=map(int,input().split())
print(len(str(a+b)))
except:
break
| 1 | 70,145,260 | null | 3 | 3 |
N = int(input())
a_array = []
b_array = []
for i in range(N):
a, b = map(int, input().split())
a_array.append(a)
b_array.append(b)
a_array.sort()
b_array.sort()
if N % 2 != 0:
mid_min = a_array[(N - 1) // 2]
mid_max = b_array[(N - 1) // 2]
print(mid_max - mid_min + 1)
else:
mid_min = (a_array[N // 2 - 1] + a_array[N // 2]) / 2
mid_max = (b_array[N // 2 - 1] + b_array[N // 2]) / 2
print(int((mid_max - mid_min) * 2) + 1)
|
from itertools import combinations
h,w,k = map(int,input().split())
mat = [input() for i in range(h)]
r = [0 for i in range(h)]
c = [0 for i in range(w)]
black = 0
for i in range(h):
for j in range(w):
if mat[i][j]=="#":
r[i] += 1
c[j] += 1
black += 1
ans = 0
for i in range(h):
for combr in combinations(range(h),i):
for j in range(w):
for combc in combinations(range(w),j):
temp = 0
for x in combr:
temp += r[x]
for y in combc:
temp += c[y]
overlap = 0
for x in combr:
for y in combc:
if mat[x][y]=="#":
overlap += 1
if black+overlap-temp==k:
ans += 1
print(ans)
| 0 | null | 13,101,518,784,868 | 137 | 110 |
num = input()
lst = []
for x in num:
lst.append(int(x))
total = sum(lst)
if total % 9 == 0:
print('Yes')
else:
print('No')
|
# -*- coding: utf-8 -*-
import math
def main():
N = int(input())
if N % 1.08 == 0:
print(N/1.08)
else:
x = math.ceil(N/1.08)
if x < (N+1)/1.08:
print(x)
else:
print(':(')
return
if __name__ == '__main__':
main()
| 0 | null | 64,805,219,704,808 | 87 | 265 |
import sys
dict = {}
n = int(input())
l = []
line = map(lambda x:x.split(), sys.stdin.readlines())
s = ""
for (c,arg) in line:
if c == "insert":
dict[arg] = 0
elif c == "find":
if arg in dict:
s += "yes\n"
else:
s += "no\n"
print(s,end="")
|
from collections import Counter
MOD = 2019
S = input()
S = tuple(map(int, reversed(S)))
counter = Counter([0])
digit = 1
cumsum = 0
for i in range(len(S)):
cumsum += S[i] * digit % MOD
cumsum %= MOD
counter[cumsum] += 1
digit = digit * 10 % MOD
print(sum([v * (v - 1) // 2 for v in counter.values()]))
| 0 | null | 15,401,244,154,908 | 23 | 166 |
S,W = list(map(int,input().split()))
if W >= S:print('unsafe')
else: print('safe')
|
n, t = map(int, input().split())
a, b, ab = [], [], []
for _ in range(n):
ab.append(tuple(map(int, input().split())))
ab.sort(key=lambda x:x[0])
for i in ab:
a.append(i[0])
b.append(i[1])
# dp[i][j] = 0~i番目の料理でj分以内に完食できる美味しさの合計の最大値
# 0 <= i < n-1, 0 <= j <= t-1
dp = [[0 for _ in range(min([t, a[0]]))] + [b[0] for _ in range(t-a[0])]]
for i in range(1, n-1):
dp.append([])
for j in range(min([t, a[i]])):
dp[i].append(dp[i-1][j])
for j in range(a[i], t):
dp[i].append(max([dp[i-1][j], dp[i-1][j-a[i]]+b[i]]))
ans = []
for i in range(1, n):
ans.append(dp[i-1][t-1] + b[i])
print(max(ans))
| 0 | null | 90,760,533,402,612 | 163 | 282 |
a = input ()
numbers = map(int,raw_input().split())
numbers.reverse()
print ' '.join(map(str,numbers))
|
S = input()
print(S[0:3:1])
| 0 | null | 7,790,863,818,140 | 53 | 130 |
a,b,k = map(int,input().split())
t1 = min(a,k)
k -= t1
a -= t1
t2 = min(b,k)
k -= t2
b -= t2
print(a,b)
|
a,b,k = map(int,input().split())
a -= k
if a <= -1:
p = abs(a)
a = 0
b -= p
if b <= -1:
b = 0
print(str(a) + ' ' + str(b))
| 1 | 103,773,557,616,608 | null | 249 | 249 |
def main():
mod=1000000007
s=int(input())
m=s*2
inv=lambda x: pow(x,mod-2,mod)
Fact=[1] #階乗
for i in range(1,m+1):
Fact.append(Fact[i-1]*i%mod)
Finv=[0]*(m+1) #階乗の逆元
Finv[-1]=inv(Fact[-1])
for i in range(m-1,-1,-1):
Finv[i]=Finv[i+1]*(i+1)%mod
def comb(n,r):
if n<r:
return 0
return Fact[n]*Finv[r]*Finv[n-r]%mod
ans=0
num=s//3
for i in range(1,num+1):
n=s-i*3
ans+=comb(n+i-1,n)
ans%=mod
print(ans)
if __name__=='__main__':
main()
|
import math
mod = 10**9+7
N = int(input())
M = math.ceil(N/3)+1
x = [[0]*(N+1) for _ in range(M)]
for i in range(3,N+1):
x[1][i] = 1
for i in range(2,M):
for j in range(i*3,N+1):
x[i][j] = (x[i][j-1] + x[i-1][j-3]) % mod
ans = 0
for i in range(1,M):
ans = (ans + x[i][N]) % mod
print(ans)
| 1 | 3,283,235,146,130 | null | 79 | 79 |
# coding: utf-8
# ?????????????????¨????????????
class Dice(object):
def __init__(self):
# ????????¶???
self.dice = (2, 5), (3, 4), (1, 6) # x, y, z
self.ax = [[0, False], [1, False], [2, False]]
self.axmap = [0, 1, 2]
self.mm = {"N": (0, 2), "S": (2, 0), "E": (1, 2), "W": (2, 1), "R": (0, 1), "L": (1, 0)}
def rotate(self, dir):
def rot(k, r):
t = self.axmap[r]
self.axmap[k], self.axmap[r] = t, self.axmap[k]
self.ax[t][1] = not self.ax[t][1]
rot(*self.mm[dir])
def front(self): return self.value(0, True)
def rear(self): return self.value(0, False)
def right(self): return self.value(1, True)
def left(self): return self.value(1, False)
def top(self): return self.value(2, True)
def bottom(self): return self.value(2, False)
def value(self, ax, d):
a = self.ax[self.axmap[ax]]
return self.dice[a[0]][a[1] if d else not a[1]]
if __name__=="__main__":
dice = Dice()
labels = input().split()
q = int(input())
def tf(p, f, d):
for _ in range(4):
if p==f(): break
dice.rotate(d)
for _ in range(q):
a, b = input().split()
p = labels.index(a) + 1
f = dice.top
tf(p, f, "N")
tf(p, f, "E")
p = labels.index(b) + 1
f = dice.front
tf(p, f, "R")
print(labels[dice.right()-1])
|
N=int(input())
A=["a"]
if N==1:
print("a")
exit()
else:
S="abcdefghijklmn"
slist=list(S)
for i in range(2,N+1):
temp=[[] for _ in range(N)]
for j in range(i-1):
for w in A[j]:
for u in slist[:j+1]:
temp[j].append(w+u)
temp[j+1].append(w+slist[j+1])
A=temp
B=[]
for j in range(N):
for t in A[j]:
B.append(t)
B.sort()
for i in range(len(B)):
print(B[i])
| 0 | null | 26,374,140,235,120 | 34 | 198 |
def main():
for i in range(1, 10):
for j in range(1, 10):
ans = i * j
s = str(i) + 'x' + str(j) + '=' + str(ans)
print(s)
main()
|
import sys
def input():
return sys.stdin.readline().strip()
sys.setrecursionlimit(20000000)
MOD = 10 ** 9 + 7
INF = float("inf")
def main():
H1, M1, H2, M2, K = map(int, input().split())
if M2 >= M1:
time = (H2 - H1) * 60 + M2 - M1
else:
time = (H2 - H1 - 1) * 60 + M2 + 60 - M1
answer = max(time - K, 0)
print(answer)
if __name__ == "__main__":
main()
| 0 | null | 9,026,195,871,872 | 1 | 139 |
# coding: utf-8
N = int(input())
_A = sorted(enumerate(map(int, input().split()), 1), key=lambda x:x[1], reverse=True)
dp = [[0] * (N+1) for i in range(N+1)]
for i in range(1,N+1):
k, Ak = _A[i-1]
if (N-i-k) < 0:break
dp[0][i] = dp[0][i-1] + (N-i+1-k) * Ak
for i in range(1,N+1):
k, Ak = _A[i-1]
if (k-i) < 0:break
dp[i][0] = dp[i-1][0] + (k-i) * Ak
for x in range(1, N+1):
for y in range(1, N-x+1):
k, val = _A[x+y-1]
dp[x][y]= max(dp[x-1][y] + abs(k-x)*val,
dp[x][y-1] + abs(N-y-k+1) * val)
print(int(max(dp[i][N-i] for i in range(N+1))))
|
# -*- coding: utf-8 -*-
"""
A - 9x9
https://atcoder.jp/contests/abc144/tasks/abc144_a
"""
import sys
def solve(A, B):
if 1 <= A <= 9 and 1 <= B <= 9:
return A * B
return -1
def main(args):
A, B = map(int, input().split())
ans = solve(A, B)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
| 0 | null | 95,525,901,186,700 | 171 | 286 |
from math import gcd
from itertools import product
N = int(input())
print(sum(gcd(gcd(a,b),c) for a, b, c in product(range(1,N+1), repeat=3)))
|
import math
from functools import reduce
def gcd(*numbers):
return reduce(math.gcd, numbers)
k = int(input())
ans = 0
for a in range(1, k+1):
for b in range(a, k+1):
for c in range(b, k+1):
t = len({a,b,c})
if t == 3:
ans += gcd(a,b,c) * 6
elif t == 2:
ans += gcd(a,b,c) * 3
else:
ans += gcd(a,b,c)
print(ans)
| 1 | 35,657,527,717,560 | null | 174 | 174 |
import sys
class UnionFind():
def __init__(self, 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
N, M = map(int, input().split())
uf = UnionFind(N)
for _ in range(M):
a, b = map(lambda x: int(x) - 1, sys.stdin.readline().split())
uf.union(a, b)
print(sum(p < 0 for p in uf.parents) - 1)
|
import math
n, M= map(int,input().split())
#AB=[]
#N = int(input())
#C = input()
parents = [-1] * n
def find( x):
if parents[x] < 0:
return x
else:
parents[x] = find(parents[x])
return parents[x]
def union(x, y):
x = find(x)
y = find(y)
if x == y:
return
if parents[x] > parents[y]:
x, y = y, x
parents[x] += parents[y]
parents[y] = x
def size( x):
return -parents[find(x)]
def same( x, y):
return find(x) == find(y)
def members( x):
root = find(x)
return [i for i in range(n) if find(i) == root]
def roots():
return [i for i, x in enumerate(parents) if x < 0]
def group_count():
return len(roots())
def all_group_members():
return {r: members(r) for r in roots()}
def __str__():
return '\n'.join('{}: {}'.format(r, members(r)) for r in roots())
C = []
for i in range(M):
A, B = map(int,input().split())
union(A-1,B-1)
'''
c = 0
for p in C:
if A in p:
c = 1
p.add(B)
elif B in p:
c = 1
p.add(A)
if c != 1:
C.append(set([A,B]))
'''
print(group_count()-1)
| 1 | 2,297,512,385,130 | null | 70 | 70 |
A, B, K = [int(s) for s in input().split(' ')]
print(max(0, A - K), max(0, (B - max(0, K - A))))
|
def Distance(X,Y,p):
s=0
for x,y in zip(X,Y):
s+=abs(x-y)**p
print(s**(1/p))
n=int(input())
X=list(map(int,input().split()))
Y=list(map(int,input().split()))
for p in range(1,4):
Distance(X,Y,p)
print(max(abs(x-y) for x,y in zip(X,Y)))
| 0 | null | 52,373,876,837,260 | 249 | 32 |
import fileinput
dict = {}
for i in range(ord("a"), ord("z") + 1):
dict[chr(i)] = 0
for line in fileinput.input():
for char in list(line):
c = char.lower()
if c in dict:
dict[c] += 1
# ?????????????????¨?????????.
for i in range(ord("a"), ord("z") + 1):
print(chr(i), ":", dict[chr(i)])
|
#coding:utf-8
#1_8_C 2015.4.8
sentence = ''
while True:
try:
sentence += input().lower()
except:
break
for i in range(ord('a') , ord('z') + 1):
print('{} : {}'.format(chr(i),sentence.count(chr(i))))
| 1 | 1,652,184,255,590 | null | 63 | 63 |
def dfs(s):
global ans
if len(s) == n:
cnt = 0
for i in range(q):
if s[abcd[i][1]-1]-s[abcd[i][0]-1] == abcd[i][2]:
cnt += abcd[i][3]
ans = max(ans, cnt)
return
last = 1
if len(s) > 0:
last = s[-1]
for i in range(last, m+1):
dfs(s+[i])
return
n, m, q = map(int, input().split())
abcd = [list(map(int, input().split())) for i in range(q)]
ans = 0
dfs([])
print(ans)
|
# https://atcoder.jp/contests/abc165/tasks/abc165_c
from itertools import combinations_with_replacement
N, M, Q = map(int, input().split())
data = []
for _ in range(Q):
data.append(list(map(int, input().split())))
res = []
for A in combinations_with_replacement(range(1,M+1), N):
score = 0
for i in range(Q):
a,b,c,d = data[i]
if A[b-1] - A[a-1] == c:
score += d
res.append(score)
print(max(res))
| 1 | 27,617,149,683,750 | null | 160 | 160 |
a, b = input().split()
a, b = int(a), int(b)
print('%d %d' % (a * b, 2 * (a + b)))
|
a,b = map (int,input().split())
print(a*b,a+a+b+b)
| 1 | 303,697,361,110 | null | 36 | 36 |
seen = [0,0,0,0,0,0,0,0,0]
seen[0],seen[1],seen[2] = (map(int,input().split()))
seen[3],seen[4],seen[5] = (map(int,input().split()))
seen[6],seen[7],seen[8] = (map(int,input().split()))
over = "No"
N = int(input())
for x in range(N):
num = int(input())
if num in seen:
seen[seen.index(num)] = "O"
if seen[0] == "O":
if seen[1] == "O" and seen[2] == "O":
over = "Yes"
if seen[3] == "O" and seen[6] == "O":
over = "Yes"
if seen[4] == "O" and seen[8] == "O":
over = "Yes"
if seen[8] == "O":
if seen[6] == "O" and seen[7] == "O":
over = "Yes"
if seen[2] == "O" and seen[5] == "O":
over = "Yes"
if seen[4] == "O":
if seen[6] == "O" and seen[2] == "O":
over = "Yes"
if seen[1] == "O" and seen[7] == "O":
over = "Yes"
if seen[3] == "O" and seen[5] == "O":
over = "Yes"
print(over)
|
board = [list(map(int,input().split())) for i in range(3)]
num = int(input())
for n in range(num):
bi = int(input())
for i in range(3):
for j in range(3):
if board[i][j] == bi:
board[i][j] = 0
#横
for i in range(3):
if board[i][0] == board[i][1] == board[i][2] == 0:
print("Yes")
exit()
#縦
for i in range(3):
if board[0][i] == board[1][i] == board[2][i] == 0:
print("Yes")
exit()
if board[0][0] == board[1][1] == board[2][2] == 0:
print("Yes")
exit()
if board[0][2] == board[1][1] == board[2][0] == 0:
print("Yes")
exit()
print("No")
| 1 | 59,836,180,743,456 | null | 207 | 207 |
# -*- coding: utf-8 -*-
import math
a, b, C = map(float, input().split())
c = math.sqrt((a * a) + (b * b) - 2 * a * b * math.cos(math.radians(C)))
s = (a * b * math.sin(math.radians(C))) / 2
l = a + b + c
h = (2 * s) / a
print(s)
print(l)
print(h)
|
from bisect import bisect
N, M, K = map(int, input().split())
A = map(int, input().split())
B = map(int, input().split())
a_cum = [0]
cum = 0
for x in A:
cum += x
a_cum.append(cum)
b_cum = []
cum = 0
for x in B:
cum += x
b_cum.append(cum)
answer = 0
for i, a in enumerate(a_cum):
remain = K - a
if remain < 0:
break
t = bisect(b_cum, remain)
# print('remain', remain, 't', t)
answer = max(answer, i + t)
print(answer)
| 0 | null | 5,523,911,945,230 | 30 | 117 |
n = int(input())
a,b = divmod(n,2)
if b == 0:
a -= 1
print(a)
|
#!/usr/bin/env python
# coding: utf-8
# In[5]:
H,N = map(int, input().split())
A = []; B = []
for _ in range(N):
a,b = map(int, input().split())
A.append(a)
B.append(b)
# In[12]:
a_max = max(A)
dp = [0]*(H+a_max)
for i in range(H+a_max):
dp[i] = min(dp[i-a] + b for a,b in zip(A,B))
print(min(dp[H-1:]))
# In[ ]:
| 0 | null | 117,243,880,527,732 | 283 | 229 |
N = int(input())
L = []
for i in range(N):
s, t = input().split()
L.append((s, int(t)))
X = input()
ans = 0
f = False
for s, t in L:
if f:
ans += t
if s == X:
f = True
print(ans)
|
N = int(input())
music_list = [input().split(' ') for i in range(N)]
X = input()
sleep_switch = False
total_time = 0
for music in music_list:
if not sleep_switch:
if music[0] == X:
sleep_switch = True
else:
total_time += int(music[1])
print(total_time)
| 1 | 96,683,845,969,174 | null | 243 | 243 |
n = int(input())
a = list(map(int, input().split()))
dict_diffs1 = dict()
dict_diffs2 = dict()
for i in range(1, n+1):
dict_diffs1[i+a[i-1]] = dict_diffs1.get(i+a[i-1], 0) + 1
dict_diffs2[i-a[i-1]] = dict_diffs2.get(i-a[i-1], 0) + 1
total = 0
for j in range(1, n+1):
total += dict_diffs1.get(j-a[j-1], 0)
total += dict_diffs2.get(j+a[j-1], 0)
total = total//2
print(total)
|
from sys import stdin
a, b = [int(x) for x in stdin.readline().rstrip().split()]
print(a*b, 2*(a+b))
| 0 | null | 13,240,272,840,132 | 157 | 36 |
import math
x = int(input())
ans = x
flag = True
while True:
flag = True
for i in range(2, math.floor(math.sqrt(ans))):
if ans % i ==0:
ans += 1
flag = False
break
if flag:
print(ans)
break
|
x=int(input())
while 1:
for i in range(2,x):
if x%i==0:
x+=1
break
else:
break
print(x)
| 1 | 105,701,012,824,070 | null | 250 | 250 |
h, w, k = map(int, input().split())
mat = [input() for i in range(h)]
num = 0
ans = [[0]*w for _ in range(h)]
heights = [0]*h
for i in range(h):
for j in range(w):
if mat[i][j] == "#":
heights[i] += 1
hs = []
for v in range(h):
if heights[v] >= 1:
hs.append(v)
for i in range(len(hs)):
h1 = 0
h2 = h-1
if i >= 1:
h1 = hs[i-1] + 1
if i < len(hs)-1:
h2 = hs[i]
ws = []
for j in range(h1, h2+1):
for k in range(w):
if mat[j][k] == "#":
ws.append(k)
ws.sort()
for j in range(len(ws)):
w1 = 0
w2 = w-1
if j >= 1:
w1 = ws[j-1]+1
if j < len(ws)-1:
w2 = ws[j]
num += 1
for k in range(h1, h2+1):
for l in range(w1, w2+1):
ans[k][l] = num
for i in range(h):
print(*ans[i])
|
def colorchange(i,l,r,col):
k=i-1
while(k>=0):
if not '#' in G[k]:
for j in range(l+1,r+1):
A[k][j]=col
else:
break
k-=1
k=i+1
while(k<H):
if not '#' in G[k]:
for j in range(l+1,r+1):
A[k][j]=col
else:
break
k+=1
H,W,K=map(int,input().split())
G=[list(input()) for i in range(H)]
s=set()
A=[[-1]*W for i in range(H)]
now=1
for i in range(H):
if not '#' in G[i]:
continue
last=-1
first=True
for j in range(W):
if G[i][j]=='#' and j==0:
first=False
A[i][j]=now
if j==W-1:
colorchange(i,last,j,now)
now+=1
elif G[i][j+1]=='#':
if first:
first=False
else:
colorchange(i,last,j,now)
last=j
now+=1
for i in range(H):
print(*A[i])
| 1 | 143,728,912,384,470 | null | 277 | 277 |
x,y = map(int,input().split())
if(x+y==2):
print(1000000)
else:
answer = 0
if(x==2):
answer+=200000
elif(x==3):
answer+=100000
elif(x==1):
answer+=300000
if(y==2):
answer+=200000
elif(y==3):
answer+=100000
elif(y==1):
answer+=300000
print(answer)
|
codePlace, implePlace = map(int, input().split(" "))
priceDict = {
1:300000,
2:200000,
3:100000
}
totalPrice = priceDict[codePlace] if codePlace in priceDict.keys() else 0
totalPrice += priceDict[implePlace] if implePlace in priceDict.keys() else 0
totalPrice += 400000 if codePlace == 1 and implePlace == 1 else 0
print(totalPrice)
| 1 | 140,777,671,484,316 | null | 275 | 275 |
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
def isok(bs, RT):
return True if bs <= RT else False
def search(B, RT):
left = -1
right = M+1
while right-left>1:
mid = left+(right-left)//2
if isok(B[mid], RT):
left = mid
else:
right = mid
return left
def solve():
asum = [0]*(N+1)
bsum = [0]*(M+1)
for i in range(N):
asum[i+1]=asum[i]+A[i]
for i in range(M):
bsum[i+1]=bsum[i]+B[i]
ans = 0
for i in range(N+1):
RT = K-asum[i]
if RT < 0:
break
ans = max(ans, i+search(bsum, RT))
print(ans)
if __name__ == '__main__':
solve()
|
import sys
input = lambda: sys.stdin.readline().rstrip()
def main():
print(10 - int(input()) // 200)
if __name__ == '__main__':
main()
| 0 | null | 8,710,258,685,608 | 117 | 100 |
input();a=1
for i in input().split():a*=int(i);a=[-1,a][0<=a<=10**18]
print(a)
|
N = int(input())
line = list(map(int, input().split()))
cnt = 0
for i in range(N):
minj = i
for j in range(i+1, N):
if line[j] < line[minj]:
minj = j
if minj != i:
tmp = line[i]
line[i] = line[minj]
line[minj] = tmp
cnt += 1
print(' '.join(list(map(str, line))))
print(cnt)
| 0 | null | 8,190,353,752,470 | 134 | 15 |
L = int(input())
a = L / 3
print(a*a*a)
|
N=int(input())
A=N/3
print(A*A*A)
| 1 | 46,937,245,390,050 | null | 191 | 191 |
k, n = map(int, input().split())
a_list = list(map(int, input().split()))
longest = 0
for i in range(n-1):
distance = a_list[i+1] - a_list[i]
longest = max(longest, distance)
print(k-max(longest, k-a_list[n-1]+a_list[0]))
|
K,N = map(int,input().split())
A = list(map(int,input().split()))
max_range = 0
for i in range(N):
if i == N-1:
if max_range < K-A[i]+A[0]:
max_range = K-A[i]+A[0]
else:
if max_range < A[i+1]-A[i]:
max_range = A[i+1]-A[i]
ans = K - max_range
print(ans)
| 1 | 43,295,375,228,160 | null | 186 | 186 |
INF = int(1e9)
def main():
n, m = map(int, input().split())
a = [int(i) for i in input().split()]
a.sort()
s = [0]
for i in range(n):
s.append(s[i]+a[i])
#Xより大きい要素の数を数える
def counter(x):
count = 0
for i in range(n):
l = -1
r = n
while r-l>1:
mid = (l+r)//2
if a[i] + a[mid] > x:
r = mid
else:
l = mid
count += n-r
return count
#Xより大きい要素数がm個未満であるXのうち最大のものを探す
l = 0
r = INF
while r-l>1:
mid = (l+r)//2
if counter(mid) < m:
r = mid
else:
l = mid
#lより大きい要素の総和を求める
def sigma(x):
cnt = 0
sgm = 0
for i in range(n):
l = -1
r = n
while r-l >1:
mid = (l+r)//2
if a[i]+a[mid]>x:
r = mid
else:
l = mid
cnt += n-r
sgm += a[i] * (n-r) + (s[n]-s[r])
return (sgm, cnt)
sgm, cnt = sigma(l)
ans = sgm+(m-cnt)*r
print(ans)
main()
|
N = int(input())
A = [int(a) for a in input().split()]
print((" ").join((str(a) for a in A)))
for i in range(1, N):
v = A[i]
j = i - 1
while(j >=0 and A[j] > v):
A[j+1] = A[j]
j -= 1
A[j+1] = v
print((" ").join((str(a) for a in A)))
| 0 | null | 53,815,710,822,468 | 252 | 10 |
n = int(input())
A = list(map(int,input().split()))
ans = 0
for i,a in enumerate(A):
if (i+1)%2 != 0 and a%2 != 0:
ans +=1
print(ans)
|
top = 0
def push(x):
global top
L.append(x)
top += 1
def pop():
global top
x = L.pop(top)
top -= 1
return x
L = [0]
S = input().split()
for i in S:
if i == "+":
a = pop()
b = pop()
push(a + b)
elif i == "-":
a = pop()
b = pop()
push(b - a)
elif i == "*":
a = pop()
b = pop()
push(a * b)
else:
push(int(i))
print(str(pop()))
| 0 | null | 3,904,542,347,600 | 105 | 18 |
a = int(input())
print(a**3)
|
A=int(input())
print A**3
| 1 | 278,242,185,540 | null | 35 | 35 |
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
H, W = map(int, readline().split())
import math
if H == 1 or W == 1:
print(1)
exit()
total = H * W
ans = (total + 2 - 1) // 2
print(ans)
|
H,W = map(int,input().split())
if(H == 1 or W == 1):
print("1")
elif((H*W)%2 == 0):
print(str((H*W)//2))
else:
print(str((H*W)//2+1))
| 1 | 50,897,504,622,272 | null | 196 | 196 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint,time,random
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()))
def cal(T):
res = 0
last = [0] * 26
for day in range(D):
t = T[day]; t -= 1
last[t] = 0
res += s[day][t]
for i in range(26):
if i == t: continue
last[i] += 1
res -= c[i] * last[i]
return res
start_time = time.time()
n = 26
D = inp()
c = inpl()
s = [inpl() for _ in range(D)]
last = [0] * n
res = [-1] * D
for d in range(D):
ans = -1
mx = -INF
for i in range(n):
now = s[d][i]
for j in range(n):
if i == j: continue
now -= s[d][j] * (last[j]+1)
if now > mx:
mx = now
ans = i
res[d] = ans+1
for j in range(n):
last[j] += 1
if j == ans: last[j] = 0
score = cal(res)
# print(now_score)
while time.time() - start_time < 1.83:
td,tq = random.randrange(0,D), random.randrange(1,n+1)
old_q = res[td]
res[td] = tq
now = cal(res)
if now > score:
score = now
else:
res[td] = old_q
for x in res:
print(x)
|
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
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())
S = input()
K = int(input())
import functools
@functools.lru_cache(None)
def rec(i, k, is_same):
if k == 0:
return 1
if i == 0:
if k >= 2:
return 0
if is_same == 1:
return int(S[len(S) - i - 1])
else:
return 9
res = 0
a = int(S[len(S) - i - 1])
if is_same == 1:
for x in range(a + 1):
if x == a and x == 0:
res += rec(i - 1, k, 1)
elif x == 0:
res += rec(i - 1, k, 0)
elif x == a:
res += rec(i - 1, k - 1, 1)
else:
res += rec(i - 1, k - 1, 0)
else:
for x in range(10):
if x == 0:
res += rec(i - 1, k, 0)
else:
res += rec(i - 1, k - 1, 0)
return res
n = len(S)
res = rec(n - 1, K, 1)
print(res)
| 0 | null | 42,775,626,165,742 | 113 | 224 |
while True:
H,W = map(int,input().split())
if H == W == 0:
break
for i in range(H):
print(('#.'*W)[i%2:][:W])
print()
|
nums = []
while True:
in_line = raw_input().split()
h = int(in_line[0])
w = int(in_line[1])
if h == 0 and w == 0:
break
else:
nums.append([h,w])
for num in nums:
for i in range(0,num[0]):
if i%2 == 0:
if num[1]%2 == 1:
print "#."*(num[1]/2) + "#"
else:
print "#."*(num[1]/2)
else:
if num[1]%2 == 1:
print ".#"*(num[1]/2) + "."
else:
print ".#"*(num[1]/2)
print ""
| 1 | 879,569,960,218 | null | 51 | 51 |
import numpy as np
N,K=map(int, input().split())
A=np.array(list(map(int, input().split())))
for i in range(K,N):
if A[i]/A[i-K]>1:
print('Yes')
else:
print('No')
|
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
# N, K = LI()
# A = LI()
# for i in range(N - K):
# if A[i] < A[i + K]:
# ans = "Yes"
# else:
# ans = "No"
# print(ans)
N, K = LI()
A = LI()
for i in range(N - K):
if A[i] < A[i + K]:
ans = "Yes"
else:
ans = "No"
print(ans)
| 1 | 7,078,643,511,820 | null | 102 | 102 |
from sys import stdin
def main():
#入力
readline=stdin.readline
n,m=map(int,readline().split())
s=readline().strip()
ans=[]
flag=False
i=n
while True:
max_i=i
for sa in range(1,m+1):
if i-sa==0:
ans.append(sa)
flag=True
break
else:
if s[i-sa]=="0":
max_i=i-sa
if flag: break
else:
if max_i!=i:
ans.append(i-max_i)
i=max_i
else:
break
if flag:
ans.reverse()
print(*ans)
else:
print(-1)
if __name__=="__main__":
main()
|
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
class SWAG(object):
def __init__(self,dot):
self.__front=[]; self.__back=[]; self.__dot=dot
def __bool__(self):
return bool(self.__front or self.__back)
def __len__(self):
return len(self.__front)+len(self.__back)
def append(self,x):
back=self.__back
if(not back): back.append((x,x))
else: back.append((x,self.__dot(back[-1][1],x)))
def popleft(self):
assert(self)
front=self.__front; back=self.__back
if(not front):
front.append((back[-1][0],back[-1][0]))
back.pop()
while(back):
front.append((back[-1][0],self.__dot(back[-1][0],front[-1][1])))
back.pop()
return front.pop()[0]
def sum(self):
assert(self)
front=self.__front; back=self.__back
if(not front): return back[-1][1]
elif(not back): return front[-1][1]
else: return self.__dot(front[-1][1],back[-1][1])
def resolve():
n,m=map(int,input().split())
S=list(map(int,input()))
dp=[INF]*(n+1) # dp[i] : i から何手でゴールできるか
dp[-1]=0
swag=SWAG(min)
for i in range(n-1,-1,-1):
swag.append(dp[i+1])
if(len(swag)>m): swag.popleft()
if(S[i]==1): continue
dp[i]=swag.sum()+1
if(dp[0]==INF):
print(-1)
return
ans=[]
now=0
turn=dp[0]
for i in range(1,n+1):
if(dp[i]==INF): continue
if(turn>dp[i]):
ans.append(i-now)
now=i
turn=dp[i]
print(*ans)
resolve()
| 1 | 138,884,216,101,110 | null | 274 | 274 |
x = int(input())
def judge_prime_number(x):
for i in range(2, int(x ** (1/2)) + 1):
if x % i == 0:
return False
else:
return True
while True:
if not judge_prime_number(x):
x += 1
continue
else:
print(x)
break
|
S = input()
if S == 'ABC':
print('ARC')
else:print('ABC')
| 0 | null | 64,719,566,211,300 | 250 | 153 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n, s, *a = map(int, read().split())
dp = [0] * (s + 1)
dp[0] = 1
mod = 998244353
for aa in a:
for j in range(s, -1, -1):
ss = j + aa
if ss <= s:
dp[ss] += dp[j]
dp[ss] %= mod
dp[j] *= 2
dp[j] %= mod
print(dp[-1])
|
import sys
MOD = 998244353
def main():
input = sys.stdin.buffer.readline
n, s = map(int, input().split())
a = list(map(int, input().split()))
dp = [[None] * (s + 1) for _ in range(n + 1)]
# dp[i][j]:=集合{1..i}の空でない部分集合T全てについて,和がjとなる部分集合の個数の和
for i in range(n + 1):
for j in range(s + 1):
if i == 0 or j == 0:
dp[i][j] = 0
continue
if j > a[i - 1]:
dp[i][j] = dp[i - 1][j] * 2 + dp[i - 1][j - a[i - 1]]
elif j == a[i - 1]:
dp[i][j] = dp[i - 1][j] * 2 + pow(2, i - 1, MOD)
else:
dp[i][j] = dp[i - 1][j] * 2
dp[i][j] %= MOD
print(dp[n][s])
if __name__ == '__main__':
main()
| 1 | 17,525,677,618,640 | null | 138 | 138 |
n = int(input())
an = [int(num) for num in input().split()]
sum = 0
for i in range(len(an)-1):
if an[i] > an[i+1]:
sum += an[i] - an[i+1]
an[i+1] += an[i] - an[i+1]
print(sum)
|
n,k = map(int,input().split())
h = list(map(int,input().split()))
h.sort(reverse = True)
m = 0
for i in range(k,n):
m += h[i]
print(m)
| 0 | null | 42,046,837,072,900 | 88 | 227 |
# C - Sum of product of pairs
import numpy as np
N = int(input())
A = list(int(a) for a in input().split())
MOD = 10**9 + 7
A = np.array(A)
csA = np.zeros((N+1), np.int64)
for i in range(N):
csA[i+1] = (csA[i] + A[i]) % MOD
ans = 0
for i in range(N-1):
ans += (A[i] * (csA[N] - csA[i+1])) % MOD
print(ans%MOD)
|
from bisect import *
N = int(input())
L = sorted(map(int,input().split()))
a = 0
for i in range(N):
for j in range(i+1,N):
a+=bisect_left(L,L[i]+L[j])-(j+1)
print(a)
| 0 | null | 87,847,839,999,136 | 83 | 294 |
d=int(input())
*c,=map(int, input().split())
s=[]
for _ in range(d):
*si,=map(int, input().split())
s.append(si)
t=[int(input())-1 for _ in range(d)]
last=[-1]*26
smx=0
ss=0
for i in range(d):
ss+=s[i][t[i]]
last[t[i]]=i
for j in range(26):
ss-= c[j]*(i-last[j])
print(ss)
|
def down(d, last, c):
result = 0
for i in range(26):
result += c[i] * (d - last[i])
return result
def main():
D = int(input())
C = [int(c) for c in input().split()]
S = [0] * D
for d in range(D):
S[d] = [int(s) for s in input().split()]
last = [0] * 26
score = 0
scores = [0] * D
for d in range(D):
t = int(input()) - 1
score += S[d][t]
last[t] = d + 1
score -= down(d + 1, last, C)
scores[d] = score
for score in scores:
print(score)
if __name__ == "__main__":
main()
| 1 | 9,933,171,245,246 | null | 114 | 114 |
def main2():
K = int(input())
rem = set()
n = ans = 0
while True:
n = n * 10 + 7
ans += 1
if n % K == 0:
print(ans)
break
else:
n = n % K
if n in rem:
print(-1)
break
else:
rem.add(n)
if __name__ == "__main__":
main2()
|
N = int(input())
A = list(map(int,input().split()))
M = max(A)
X = [1]*(M+1)
for a in A:
X[a]-=1
for i in range(a*2,M+1,a):
X[i]=-2
ans = 0
for a in A:
if X[a]>=0:
ans+=1
print(ans)
| 0 | null | 10,237,458,556,480 | 97 | 129 |
k = int(input())
from collections import deque
q = deque() # FIFOキューの作成
for i in range(1,10):
q.append(str(i))
for i in range(k-1):
a = q.popleft()
last = int(a[-1:])
if last == 0:
q.append(a+"0")
q.append(a + "1")
elif last ==9:
q.append(a+"8")
q.append(a + "9")
else:
q.append(a + str(last - 1))
q.append(a + str(last ))
q.append(a + str(last + 1))
print(q.popleft())
|
from collections import deque
k = int(input())
cnt = 9
q = deque([])
for i in range(1,10):
q.append(i)
ans = 0
if k < 10:
print(k)
else:
while cnt != k:
n = q.popleft()
if n%10 == 0:
tmp = n*10
q.append(n*10)
cnt += 1
if cnt == k:
print(tmp)
break
q.append(1+tmp)
cnt += 1
if cnt == k:
print(tmp+1)
break
elif n%10 == 9:
tmp = n*10
q.append(tmp+8)
cnt+=1
if cnt == k:
print(tmp+8)
break
q.append(tmp+9)
cnt += 1
if cnt == k:
print(tmp+9)
break
else:
tmp = n%10
q.append(tmp-1+(n*10))
cnt += 1
if cnt ==k:
print(tmp-1+(n*10))
break
q.append(tmp+(n*10))
cnt +=1
if cnt == k:
print(tmp+(n*10))
break
q.append(tmp+1+(n*10))
cnt += 1
if cnt == k:
print(tmp+1+(n*10))
break
| 1 | 40,050,465,034,018 | null | 181 | 181 |
r,c = list(map(int,input().split()))
sum_li = [0]*(c+1)
for i in range(r):
line = list(map(int, input().split()))
line += [sum(line)]
print(' '.join(list(map(str,line))))
sum_li = [x+y for (x,y) in zip(sum_li,line)]
print(' '.join(list(map(str,sum_li))))
|
s=input()
p=input()
result="No"
for i in range(len(s)):
r=s[i:]+s[:i]
if r[0:len(p)]==p:
result="Yes"
break
print(result)
| 0 | null | 1,532,325,492,142 | 59 | 64 |
A, B, K = map(int, input().split())
if K <= A:
print("{} {}".format(A - K, B))
else:
K -= A
print("{} {}".format(0, max(B - K, 0)))
|
H, N = list(map(int,input().split()))
A = []
B = []
for i in range(N):
in1, in2 = list(map(int,input().split()))
A.append(in1)
B.append(in2)
# dp[i]: モンスターの体力がiのときの最適値
INF = 10 ** 9 + 7
dp = [INF for _ in range(H + 1)]
dp[0] = 0
for i in range(1, H + 1):
for j in range(N):
dp[i] = min(dp[i], dp[max(0, i - A[j])] + B[j])
print(dp[H])
| 0 | null | 92,609,190,102,082 | 249 | 229 |
N = int(input())
mod = 10**9+7
ans = pow(10, N, mod) - ((pow(9, N, mod) * 2) - pow(8, N, mod))
ans %= mod
print(ans)
|
N, K = map(int, input().split())
cad = N // K
n = N - K * cad
m = K * (cad + 1) - N
print(min(n, m))
| 0 | null | 21,262,794,719,458 | 78 | 180 |
import math
def main():
a, b, ang_ab = [float(x) for x in input().split()]
rad_ab = (ang_ab/180)*math.pi
c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(rad_ab))
h = b*math.sin(rad_ab)
s = (a*h)/2
l = a+b+c
print("{:f} {:f} {:f}".format(s, l, h))
if __name__ == '__main__':
main()
|
from math import gcd
from itertools import combinations_with_replacement
k = int(input())
lst = [i for i in range(1,k+1)]
itr = combinations_with_replacement(lst, 3)
ans = 0
for i in itr:
st = set(i)
num = len(st)
if num == 1:
ans += i[0]
elif num == 2:
a,b = st
ans += gcd(a,b) * 3
else:
ans += gcd(gcd(i[0],i[1]), i[2]) * 6
print(ans)
| 0 | null | 17,791,411,993,418 | 30 | 174 |
from collections import Counter
import sys
n, m, k = map(int, input().split())
F = [[] for _ in range(n)]
B = [[0] for _ in range(n)]
sys.setrecursionlimit(10**9)
for _ in range(m):
a, b = map(int, input().split())
F[a-1].append(b)
F[b-1].append(a)
rks = [0]*(n)
def dfs(s,r):
if rks[s] == 0:
rks[s] = r
for i in F[s]:
if rks[i-1] != 0:
continue
dfs(i-1,r)
r = 0
for i in range(n):
if rks[i] == 0:
r += 1
dfs(i,r)
for _ in range(k):
c, d = map(int, input().split())
if rks[c-1] == rks[d-1]:
B[c-1][0] += 1
B[d-1][0] += 1
counter = Counter(rks)
for i in range(n):
print(counter[rks[i]] - len(F[i]) - (B[i][0]) - 1)
|
n,m,k=map(int,input().split())
edge=[[] for _ in range(n)]
for _ in range(m):
a,b=map(int,input().split())
a,b=a-1,b-1
edge[a].append(b)
edge[b].append(a)
from collections import deque
label=[-1]*n
i=0
for start in range(n):
if label[start]!=-1:
continue
else:
i+=1
label[start]=i
f=deque([start])
while f:
v=f.popleft()
for e in edge[v]:
if label[e]==-1:
label[e]=i
f.append(e)
Renketsu=[0]*(n+1)
for i in label:
Renketsu[i]+=1
Block=[0]*n
for _ in range(k):
c,d=map(int,input().split())
c,d=c-1,d-1
if label[c]==label[d]:
Block[c]+=1
Block[d]+=1
ans=[]
for k in range(n):
ans.append(Renketsu[label[k]]-1 - len(edge[k]) - Block[k])
print(*ans)
| 1 | 61,732,339,719,920 | null | 209 | 209 |
a=""
for i in range(int(input())):
a+="ACL"
print(a)
|
x = int(input())
if(x < 1 or x > 5):
print("")
else:
for i in range(x):
print("ACL",end='')
| 1 | 2,220,032,554,036 | null | 69 | 69 |
A,B = map(int,input().split())
for n in range(10000):
if int(0.08*n)==A and int(0.10*n)==B:
print(n)
exit()
print(-1)
|
a, b = map(int, input().split())
tmp_a = int((a / 0.08) // 1)
tmp_b = int((b / 0.10) // 1)
check = True
# print(tmp_a, tmp_b)
for i in range(min(tmp_a,tmp_b), max(tmp_a + 1, tmp_b + 1) + 1):
if int((i * 0.08)//1) == a and int((i * 0.10)//1) == b:
print(i)
check = False
break
if check:
print(-1)
| 1 | 56,639,443,363,690 | null | 203 | 203 |
a,b,c=map(int,input().split())
if a==b==c or (a!=b!=c and a!=c!=b):
print("No")
else:
print("Yes")
|
#!python3
from time import perf_counter
limit = 1.92
tick = perf_counter()
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
from random import randrange
from bisect import bisect
def resolve():
G = 26
it = map(int, sys.stdin.read().split())
D = next(it)
C = [next(it) for i in range(G)]
S = [[next(it) for i in range(G)] for i in range(D)]
L = [[-1] for i in range(G)]
T = [0] * D
def update(di, qi):
score = 0
t0 = T[di]
score += S[di][qi]-S[di][t0]
a1 = li = L[t0][:]
ii = li.index(di)
la = D if len(li)-1 == ii else li[ii+1]
score -= C[t0] * (di-li[ii-1])*(la-di)
li.pop(ii)
a2 = li = L[qi][:]
ii = bisect(li, di)
li.insert(ii, di)
la = D if len(li)-1 == ii else li[ii+1]
score += C[qi] * (di-li[ii-1])*(la-di)
return score, (a1, a2)
U = 7
def calc(i, j):
score = S[i][j]
for k in range(G):
u = k - L[k][-1]
score -= C[k] * (u + u + U) * U // 2
score += C[k] * U * (i-L[j][-1])
return score
def dswap(di, dj):
qi, qj = T[di], T[dj]
swap0 = (L[qi], L[qj])
score, swap1 = update(di, qj)
T[di] = qj
L[qi], L[qj] = swap1
diff, swap2 = update(dj, qi)
score += diff
if score > 0:
T[dj] = qi
L[qj], L[qi] = swap2
else:
score = 0
T[di], T[dj] = qi, qj
L[qi], L[qj] = swap0
return score
def fullscore():
score = 0
last = [-1] * 26
for i, ti in enumerate(T):
score += S[i][ti]
last[ti] = i
for ci, la in zip(C, last):
score -= ci * (i-la)
return score
for di in range(D):
i, score = 0, calc(di, 0)
for qi in range(1, G):
x = calc(di, qi)
if x > score:
i, score = qi, x
T[di] = i
L[i].append(di)
print(*(i+1 for i in T), sep="\n")
if __name__ == "__main__":
resolve()
| 0 | null | 39,046,026,953,810 | 216 | 113 |
from collections import deque
rand = False
verbose = False
if rand:
import random
N, K = 200000, 10000
A = random.choices(range(-10**9, 10**9), k=N)
else:
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10**9 + 7
def mul(A):
ret = 1
for i in range(len(A)):
ret = (ret * A[i]) % MOD
# print (ret)
return ret
if K==N:
print(mul(A))
exit()
POS, NEG = list(), list()
for i in range(len(A)):
if A[i] < 0:
NEG.append(A[i])
else:
POS.append(A[i])
POS.sort(reverse=True)
NEG.sort()
if len(POS)==0 and K%2==1: # must go negative
print(mul(NEG[-K:]))
exit()
POS = deque(POS)
NEG = deque(NEG)
ans = list()
while len(ans)<K:
if len(NEG) <= 1:
if verbose: print('no more neg numbers')
ans.append(POS.popleft()) # no negative numbers to add
elif len(POS) <= 1:
if verbose: print('no more pos numbers')
if K-len(ans)>=2:
ans.append(NEG.popleft())
ans.append(NEG.popleft())
else:
ans.append(POS.popleft())
elif POS[0]*POS[1] > NEG[0]*NEG[1] or K-len(ans)==1:
if verbose: print('pos bigger')
ans.append(POS.popleft())
else:
if verbose: print('neg biger')
ans.append(NEG.popleft())
ans.append(NEG.popleft())
print(mul(ans))
|
N,K = map(int,input().split())
A = list(map(int,input().split()))
MOD = 10**9+7
if all(a>=0 for a in A):
A.sort()
ans = 1
for _ in range(K):
ans *= A.pop()
ans %= MOD
print(ans)
exit()
if all(a<0 for a in A):
A.sort(reverse=K%2==0)
ans = 1
for _ in range(K):
ans *= A.pop()
ans %= MOD
print(ans)
exit()
if N==K:
ans = 1
for a in A:
ans *= a
ans %= MOD
print(ans)
exit()
arr = []
for a in A:
if a < 0:
arr.append((-a,1))
else:
arr.append((a,0))
arr.sort()
pz = []
ng = []
ans = 1
for _ in range(K):
v,s = arr.pop()
if s:
ng.append(v)
else:
pz.append(v)
for v in ng:
ans *= v
ans %= MOD
for v in pz:
ans *= v
ans %= MOD
if len(ng)%2 == 0:
print(ans)
exit()
b = pz[-1] if pz else None
c = ng[-1] if ng else None
a = d = None
while arr and (a is None or d is None):
v,s = arr.pop()
if s:
if a is None:
a = v
else:
if d is None:
d = v
if (a is None or b is None) and (c is None or d is None):
assert False
if a is None or b is None:
ans *= d * pow(c,-1,MOD)
elif c is None or d is None:
ans *= a * pow(b,-1,MOD)
else:
if a*c > b*d:
ans *= a * pow(b,-1,MOD)
else:
ans *= d * pow(c,-1,MOD)
ans %= MOD
print(ans)
| 1 | 9,535,009,016,648 | null | 112 | 112 |
n = input().strip()
h = list(map(int, input().strip().split()))
m = 0
for i in range(len(h)):
d = h[i - 1] - h[i]
if i > 0 and d >= 0:
m += d
h[i] += d
print(m)
|
X = int(input())
for a in range(-119, 120):
for b in range(-119, 120):
if X == a**5 - b**5:
la = a
lb = b
print(la, lb)
| 0 | null | 15,078,973,701,240 | 88 | 156 |
isExist = [0]*2001
n = int( input() )
A = [ int( val ) for val in input().rstrip().split( ' ' ) ]
for i in A:
for j in range( 2000-i, 0, -1 ):
if 1 == isExist[j]:
isExist[ i+j ] = 1
isExist[i] = 1
q = int( input() )
M = [ int( val ) for val in input().rstrip().split( ' ' ) ]
for i in range( 0, q ):
if 1 == isExist[ M[i] ]:
print( "yes" )
else:
print( "no" )
|
import sys, os, math \
# , bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque
# import copy
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
A = il()
Q = ii()
M = il()
num_set = set()
for i in range(1 << N):
num = 0
for n in range(N):
if i >> n & 1:
num += A[n]
num_set.add(num)
for m in M:
if m in num_set:
print('yes')
else:
print('no')
if __name__ == '__main__':
main()
| 1 | 99,288,930,300 | null | 25 | 25 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
N, R = map(int, readline().split())
ans = R
if (N<10):
ans += 100*(10-N)
print(ans)
|
N = int(input())
digits = list(map(int,str(N)))
if sum(digits) % 9 == 0:
print('Yes')
else:
print('No')
| 0 | null | 33,795,865,595,520 | 211 | 87 |
s=input()
for c in s:
if 'A' <= c and c <= 'Z':
print(c.lower(), end='')
elif 'a' <= c and c <= 'z':
print(c.upper(), end='')
else:
print(c,end='')
print()
|
c=str(input())
cl=list(c)
for i in range(len(cl)):
if cl[i].islower():
cl[i]=cl[i].upper()
print(cl[i],end='')
elif cl[i].isupper():
cl[i] =cl[i].lower()
print(cl[i], end='')
elif not cl[i].isalpha():
print(cl[i], end='')
print('')
| 1 | 1,530,639,460,302 | null | 61 | 61 |
import sys
sys.setrecursionlimit(10**9)
INF = 110110110
H, W, K = list(map(int, input().split()))
S = [''] * H
for i in range(H):
S[i] = input()
ans = H * W
for bit in range(2**(H-1)):
cnt = bin(bit).count('1')
id = [0] * H
for i in range(H-1):
if bit>>i & 1:
id[i+1] = id[i] + 1
else:
id[i+1] = id[i]
num = [[0] * W for i in range(id[H-1]+1)]
for i in range(H):
for j in range(W):
if S[i][j] == '1':
num[id[i]][j] += 1
for i in range(id[H-1]+1):
for j in range(W):
if num[i][j] > K:
cnt = INF
sum = [0] * (id[H-1]+1)
for j in range(W):
need = False
for i in range(id[H-1]+1):
if sum[i] + num[i][j] > K:
need = True
if need:
cnt += 1
for i in range(id[H-1]+1):
sum[i] = num[i][j]
else:
for i in range(id[H-1]+1):
sum[i] += num[i][j]
ans = min(ans, cnt)
print(ans)
|
#E
H,W,K = map(int,input().split())
S = [list(str(input())) for _ in range(H)]
inf = float("inf")
ans = inf
T = 2**(H-1)
for i in range(T):
b = bin(i)
b = b.lstrip("0b")
blist = list(b)
lb = len(b)
clist = blist[::-1]
while lb < H-1:
clist.append("0")
lb+=1
r = clist.count("1")
count = r
nw = [0]*(r+1)
for w in range(W):
nind = 0
for h in range(H):
if h > 0:
if clist[h-1] == "1":
nind+=1
if S[h][w] == "1":
nw[nind]+=1
if w == 0:
pass
else:
for k in nw:
if k > K:
count+=1
nw = [0]*(r+1)
nind = 0
for h in range(H):
if h > 0:
if clist[h-1] == "1":
nind+=1
if S[h][w] == "1":
nw[nind]+=1
if max(nw) > K:
count = inf
break
ans = min(ans,count)
print(ans)
| 1 | 48,498,726,898,700 | null | 193 | 193 |
N = int(input())
A = input()
if len(A) <= N:
print(A)
else:
print(A[:N] + '...')
|
# local search is all you need
# 「日付 d とコンテストタイプ q をランダムに選び、d 日目に開催するコンテストをタイプ q に変更する」を実装する
from time import time
t0 = time()
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def a_int(): return int(read())
def ints(): return list(map(int, read().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, zip(*ret)))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
from random import randint
def score(D, C, S, T):
last = [-1] * 26
# scores = [0]
score = 0
for d in range(D):
# scores.append(scores[-1] + S[d][T[d]])
score += S[d][T[d]]
last[T[d]] = d
for i in range(26):
# scores[-1] -= C[i] * (d - last[i])
score -= C[i] * (d - last[i]) # この場で一番罰則が大きいやつを使うとか？
return score
D = a_int()
C = ints()
S = read_tuple(D)
def maximizer(newT, bestT, bestscore):
tmpscore = score(D, C, S, newT)
if tmpscore > bestscore:
return newT, tmpscore
else:
return bestT, bestscore
def ret_init_T():
'''greedyで作ったTを初期値とする。
return
----------
T, score ... 初期のTとそのTで得られるscore
'''
def _make_T(n_days):
# editorialよりd日目の改善は、改善せずにd+n_days経過したときの関数にしたほうが
# 最終的なスコアと相関があるんじゃない？
T = []
last = [-1] * 26
for d in range(D):
ma = -INF
for i in range(26):
tmp = S[d][i]
for j in range(n_days):
tmp += C[i] * (d + j - last[i])
if tmp > ma:
t = i
ma = tmp
last[t] = d # Tを選んだあとで決める
T.append(t)
return T
T = _make_T(0)
sco = score(D, C, S, T)
for i in range(1, 20):
T, sco = maximizer(_make_T(i), T, sco)
return T, sco
bestT, bestscore = ret_init_T()
def add_noise(T):
'''日付dとコンテストqをランダムに選びd日目に開催するコンテストのタイプをqに変更する'''
ret = T.copy()
d = randint(0, D - 1)
q = randint(0, 25)
ret[d] = q
return ret
t1 = time()
bestT, bestscore = maximizer(add_noise(bestT), bestT, bestscore)
dt = time() - t1
times = (1.95 - (time() - t0)) // dt
for _ in range(int(times)):
bestT, bestscore = maximizer(add_noise(bestT), bestT, bestscore)
# while time() - t0 < 1.92:
# # while time() - t0 < 5:
# bestT, bestscore = maximizer(add_noise(bestT), bestT, bestscore)
# print(bestscore)
# print(bestscore)
# print(t0, t1, dt, times, time() - t0)
# print(score(D, C, S, T))
print(*mina(*bestT, sub=-1), sep='\n')
| 0 | null | 14,618,749,093,440 | 143 | 113 |
x,k,d = map(int,input().split())
if x < 0:
x *= -1
m = x // d
if k <= m:
print(x - k*d)
else:
x %= d
y = abs(x-d)
print([x,y][(k-m)%2])
|
tmp = raw_input().split()
a = int(tmp[0])
b = int(tmp[1])
s = a * b
l = 2 * (a+b)
print "%d %d" % (s, l)
| 0 | null | 2,805,320,682,880 | 92 | 36 |
def main():
s=set('123')
a=int(input())
b=int(input())
s.remove(str(a))
s.remove(str(b))
print(s.pop())
main()
|
from collections import deque
N, X, Y = [int(x) for x in input().split()]
X -= 1
Y -= 1
result = {x: 0 for x in range(N)}
def push(v, d, queue, dist):
if v in dist:
return
dist[v] = d
queue.appendleft(v)
def check(i):
queue = deque()
dist = {}
push(i, 0, queue, dist)
while queue:
pos = queue.pop()
d = dist[pos]
if pos - 1 >= 0:
push(pos - 1, d + 1, queue, dist)
if pos + 1 < N:
push(pos + 1, d + 1, queue, dist)
if pos == X:
push(Y, d + 1, queue, dist)
if pos == Y:
push(X, d + 1, queue, dist)
for i in range(N):
result[dist[i]] += 1
for i in range(N):
check(i)
for i in range(1, N):
print(result[i] // 2)
| 0 | null | 77,682,015,308,380 | 254 | 187 |
S = input()
out = 'ABC' if S == 'ARC' else 'ARC'
print(out)
|
#import numpy as np
#import math
#from decimal import *
#from numba import njit
#@njit
def main():
S = input()
if S == 'ABC':
print('ARC')
else:
print('ABC')
main()
| 1 | 24,089,026,208,380 | null | 153 | 153 |
l = int(raw_input())
print "",
for i in range(l+1):
if i//3 != 0:
if i%3 ==0:
print i,
elif "3" in str(i):
print i,
|
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
N, M = map(int, input().split())
ans = N * (N - 1) // 2 + M * (M - 1) // 2
print(ans)
if __name__ == '__main__':
solve()
| 0 | null | 23,390,250,948,090 | 52 | 189 |
a=int(input())
b=a//200
print(str(10-b))
|
def resolve():
rate = int(input())
if rate < 600:
print('8')
elif rate < 800:
print('7')
elif rate < 1000:
print('6')
elif rate < 1200:
print('5')
elif rate < 1400:
print('4')
elif rate < 1600:
print('3')
elif rate < 1800:
print('2')
else:
print('1')
if __name__ == "__main__":
resolve()
| 1 | 6,658,685,801,128 | null | 100 | 100 |
n = int(input())
print(int(n**2))
|
n = int(input())
low = [0]*n
high = [0]*n
for i in range(n):
a, b = [int(x) for x in input().split(" ")]
low[i] = a
high[i] = b
low.sort()
high.sort()
if n%2 == 1:
print(high[n//2]-low[n//2]+1)
else:
x = (low[(n-1)//2] + low[n//2])/2
y = (high[(n-1)//2] + high[n//2])/2
print(int(2*y - 2*x + 1))
| 0 | null | 81,539,269,076,540 | 278 | 137 |
def main():
n,*d=map(int,open(0).read().split())
e=[0]*n
for i in d:e[i]+=1
a=1if d[0]<1else 0
for i in d[1:]:a=a*e[i-1]%998244353
print(a)
main()
|
s, t = input().split()
a, b = list(map(int, input().split()))
u = input()
if s == u:
print('{} {}'.format(a - 1, b))
else:
print('{} {}'.format(a, b - 1))
| 0 | null | 113,592,618,741,664 | 284 | 220 |
def main():
N, K = map(int, input().split())
A = list(map(int, input().split()))
for k in range(K):
A_temp=[0]*(N+1)
for i in range(N):
A_temp[max(0,i-A[i])]+=1
if i+A[i]+1<=N-1:
A_temp[i+A[i]+1]-=1
A[0]=A_temp[0]
for j in range(1,N):
A_temp[j]+=A_temp[j-1]
A[j]=A_temp[j]
for ai in A:
if ai != N:
break
else:
break
print(' '.join([str(a) for a in A]))
if __name__ == "__main__":
main()
|
n=int(input())
x=100000
for i in range(n):
x=x+x*0.05
x=((x-1)//1000+1)*1000
print(int(x))
| 0 | null | 7,738,179,786,338 | 132 | 6 |
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))
h,a = map(int, input().split())
ans = h // a
if (h % a != 0):
ans += 1
print(ans)
|
H, A = map(int, input().split())
count = 0
while True:
H -= A
count += 1
if H <= 0:
print(count)
exit()
| 1 | 77,153,830,306,980 | null | 225 | 225 |
from collections import defaultdict
import math
import sys
input = sys.stdin.readline
def select_num(a, b, mod=1000000007):
sum = pow(2, a, mod) + pow(2, b, mod) - 1
return sum % mod
def dict_count(d, a, b):
this = a / b
pair = b / a
if not d.get(this, False):
d[this] = {"num": 0, "pair": pair}
d[this]["num"] += 1
def main():
MOD = 1000000007
n = int(input())
d = defaultdict(lambda: [0] * 2)
zero = 0
for i in range(n):
a, b = map(int, input().split())
if a == 0 or b == 0:
if a == b == 0:
n -= 1
zero += 1
elif a == 0:
d[0][True] += 1
elif b == 0:
d[0][False] += 1
else:
gcd = math.gcd(a, b)
a //= gcd
b //= gcd
if b < 0:
a, b = -a, -b
rot = False
if a < 0:
b, a = -a, b
rot = True
d[(a, b)][rot] += 1
ans = 1
for k, v in d.items():
ans *= select_num(v[0], v[1], MOD)
ans %= MOD
ans += zero - 1
ans %= MOD
print(ans)
if __name__ == '__main__':
main()
|
N=int(input())
AB=[list(map(int,input().split())) for i in range(N)]
from collections import defaultdict
d=defaultdict(int)
d2=defaultdict(int)
a0=0
b0=0
c0=0
from math import gcd
for a,b in AB:
if a==b==0:
c0+=1
elif a==0:
a0+=1
elif b==0:
b0+=1
else:
if a<0:
a,b=-a,-b
g=gcd(a,b)
a,b=a//g,b//g
if b>0:
d[(a,b)]+=1
else:
d2[(-b,a)]+=1
m=10**9+7
a=1
for k,v in d.items():
if k in d2:
a=a*(pow(2,v,m)+pow(2,d2[k],m)-1)%m
else:
a=a*pow(2,v,m)%m
for k,v in d2.items():
if k not in d:
a=a*pow(2,v,m)%m
print((a*(pow(2,a0,m)+pow(2,b0,m)-1)-1+c0)%m)
| 1 | 20,985,733,141,380 | null | 146 | 146 |
#155_A
a, b, c = map(int, input().split())
if a==b and a!=c and b!=c:
print('Yes')
elif a==c and a!=b and c!=b:
print('Yes')
elif b==c and b!=a and c!=a:
print('Yes')
else:
print('No')
|
l = input().split(' ')
print('Yes' if len(set(l)) == 2 else 'No')
| 1 | 68,150,983,340,840 | null | 216 | 216 |
class SegmentTree(object):
"""
セグメントツリー (0-indexed)
1. 値の更新 O(logN)
2. 区間クエリ O(logN)
"""
def __BinOp(self, x, y):
""" セグ木で使用する二項演算 """
return x | y
def __init__(self, init_ele, N:int):
"""
セグ木を構築する
init_ele: 単位元
N: 要素数
"""
self.__init_ele = init_ele
self.__n = 1
while self.__n < N:
self.__n <<= 1
self.__dat = [init_ele] * (2 * self.__n)
def update(self, k:int, x):
""" k番目の値をxに変更する """
k += self.__n - 1
self.__dat[k] = x
while k:
k = (k - 1) // 2
self.__dat[k] = self.__BinOp(
self.__dat[k * 2 + 1], self.__dat[k * 2 + 2]
)
def query(self, p:int, q:int):
""" 区間クエリ [p,q) """
if q <= p: return self.__init_ele
p += self.__n - 1
q += self.__n - 2
res = self.__init_ele
while q - p > 1:
if not (p & 1):
res = self.__BinOp(res, self.__dat[p])
if q & 1:
res = self.__BinOp(res, self.__dat[q])
q -= 1
p = p // 2
q = (q - 1) // 2
res = self.__BinOp(res, self.__dat[p])
if p != q: res = self.__BinOp(res, self.__dat[q])
return res
def get_num(self, k:int):
""" k番目の値を取得する """
k += self.__n - 1
return self.__dat[k]
############################################################
N = int(input())
ST = SegmentTree(0, N)
for i, s in enumerate(list(input())):
ST.update(i, 1 << (ord(s) - ord('a')))
Q = int(input())
for _ in range(Q):
x,y,z = map(str,input().split())
x = int(x); y = int(y)
if x == 1:
ST.update(y - 1, 1 << (ord(z) - ord('a')))
else:
z = int(z)
print(bin(ST.query(y - 1, z)).count("1"))
|
# https://atcoder.jp/contests/abc157/tasks/abc157_e
from string import ascii_lowercase
from bisect import bisect_left, insort
from collections import defaultdict
N = int(input())
S = list(input())
Q = int(input())
locs = {c: [] for c in ascii_lowercase}
for i in range(N):
locs[S[i]].append(i + 1)
for _ in range(Q):
qt, l, r = input().split()
l = int(l)
if int(qt) == 1:
if S[l - 1] != r:
locs[S[l - 1]].remove(l)
S[l - 1] = r
insort(locs[r], l)
else:
count = 0
r = int(r)
for ch in ascii_lowercase:
if len(locs[ch]) > 0:
left = bisect_left(locs[ch], l)
if left != len(locs[ch]):
if locs[ch][left] <= r:
count += 1
print(count)
| 1 | 62,244,324,943,830 | null | 210 | 210 |
def main():
s, t = input().split(' ')
print(t, end='')
print(s)
if __name__ == '__main__':
main()
|
N = int(input())
for i in range(1, N + 1):
if i + (i * 8) // 100 == N:
print(i)
break
else:
print(":(")
| 0 | null | 114,765,409,762,468 | 248 | 265 |
import math
m,n = map(int,input().split())
print(m*n//(math.gcd(m, n)))
|
a,b = map(int, input().split())
def gcd(x, y):
if y < x:
x,y = y,x
while x%y != 0:
x,y = y,x%y
return y
def lcm(x, y):
return (x*y)//gcd(x,y)
print(lcm(a,b))
| 1 | 113,171,031,894,200 | null | 256 | 256 |
d = int(input())
cs = list(map(int, input().split()))
sm = [list(map(int, input().split())) for _ in range(d)]
import random
for i in range(d):
mx = max(sm[i])
t = sm[i].index(mx) + 1
print(t)
|
import numpy as np
import sys
read = sys.stdin.read
D = int(input())
CS = np.array(read().split(), np.int32)
C = CS[:26]
S = CS[26:].reshape((-1, 26))
del CS
last = np.zeros((26, ))
ans = []
def getContestType_at_d(d):
s = -10000000
for i in range(26):
mask = np.ones((26, ))
mask[i] = 0
tmp = S[d][i] - np.sum(C * (d + 1 - last) * mask)
if s < tmp:
s = tmp
t = i
last[t] = d + 1
return t + 1, s
for d in range(D):
s = -10000000
for i in range(26):
mask = np.ones((26, ))
mask[i] = 1
score = S[d][i] - np.sum(C * (d + 1 - last) * mask)
if s < score:
s = score
t = i
last[t] = d + 1
ans.append(t + 1)
print('\n'.join(map(str, ans)))
| 1 | 9,646,856,254,464 | null | 113 | 113 |
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
n = I()
suuretu = LI()
q = I()
dic = collections.Counter(suuretu)
nowsum = sum(suuretu)
for _ in range(q):
b,c = LI()
cnt = dic[b]
nowsum += (c-b)*cnt
print(nowsum)
dic[b] = 0
dic[c] += cnt
main()
|
x,k,d=map(int,input().split());xx=abs(x)
tmp=xx;tmp=(xx//d);cc=min(tmp,k)
xx-=d*cc;k-=cc;k&=1;xx-=d*k
print(abs(xx))
| 0 | null | 8,689,917,769,912 | 122 | 92 |
n, k = map(int, input().split())
r, s, p = map(int, input().split())
t = input()
dict = {'s': r, 'p': s, 'r': p}
cnt, ans = set(), 0
for i, ti in enumerate(t):
if (i - k in cnt) and ti == t[i - k]:
continue
ans += dict[ti]
cnt.add(i)
print(ans)
|
mod = 998244353
n, k = map(int, input().split())
s = []
for _ in range(k):
l, r = map(int, input().split())
s.append((l, r))
dp = [0] * (n + 1)
dp[1] = 1
for i in range(2, n+1):
for l, r in s:
jl = max(i - l, 0)
jr = max(i - r - 1, 0)
dp[i] = (dp[i] + dp[jl] - dp[jr]) % mod
dp[i] += dp[i-1]
print((dp[n] - dp[n-1]) % mod)
| 0 | null | 54,976,792,707,612 | 251 | 74 |
def puts(x, y):
print '{0}x{1}={2}'.format(x, y, x*y)
[puts(i ,j)
for i in range(1, 10)
for j in range(1, 10)]
|
N = int(input())
s = input()
res = 0
search = [("00"+str(s))[-3:] for s in range(0,1000)]
for v in search:
tmp = s
if v[0] in tmp:
tmp = tmp[tmp.index(v[0])+1:]
else:
continue
if v[1] in tmp:
tmp = tmp[tmp.index(v[1])+1:]
else:
continue
if v[2] in tmp:
res += 1
print(res)
| 0 | null | 64,655,022,906,270 | 1 | 267 |
S = list(map(str, input()))
N = len(S)+1
List = [0]*N
rightcount = 0
leftcount = 0
if S[0] == "<":
leftcount+=1
else:
rightcount+=1
for i in range(1, N-1):
if S[i] == "<":
leftcount+=1
if S[i-1] == "<":
List[i] = List[i-1]+1
elif S[i-1] == ">":
for j in range(rightcount):
List[i-j] = j
if List[i-rightcount]<=List[i-rightcount+1]:
List[i-rightcount] = List[i-rightcount+1] + 1
rightcount = 0
if S[i] == ">":
rightcount+=1
if S[i-1] =="<":
for j in range(leftcount+1):
List[i-j] = leftcount - j
leftcount = 0
if S[N-2] == "<":
List[N-1] = List[N-2] + 1
else:
for j in range(rightcount):
List[N-1-j] = j
if List[N-1-rightcount]<=List[N-1-rightcount+1]:
List[N-1-rightcount] = List[N-1-rightcount+1] + 1
print(sum(List))
|
a=list(input())
count=1
ans = 0
temp = 0
for i in range(len(a)-1):
if a[i] ==a[i+1]:
count+=1
else:
if a[i]=='<':
ans += count*(count+1)//2
temp = count
#print('<', count, ans)
count = 1
else:
ans += count*(count+1)//2
ans -= min(count, temp)
#print('>', count, ans)
count =1
else:
if a[-1]=='<':
ans += count*(count+1)//2
else:
ans += count*(count+1)//2
ans -= min(count, temp)
print(ans)
| 1 | 156,493,202,521,400 | null | 285 | 285 |
import heapq
def main():
_ = int(input())
A = sorted(list(map(int, input().split())), reverse=True)
q = []
heapq.heapify(q)
ans = A[0]
tmp_score = min(A[0], A[1])
heapq.heappush(q, (-tmp_score, A[0], A[1]))
heapq.heappush(q, (-tmp_score, A[1], A[0]))
for a in A[2:]:
g = heapq.heappop(q)
ans += -g[0]
tmp_score1 = min(a, g[1])
tmp_push1 = (-tmp_score1, a, g[1])
tmp_score2 = min(a, g[2])
tmp_push2 = (-tmp_score2, a, g[2])
heapq.heappush(q, tmp_push1)
heapq.heappush(q, tmp_push2)
print(ans)
if __name__ == '__main__':
main()
|
import sys
input_num = int(sys.stdin.readline())
ans = ''
for i in range(3, input_num + 1):
if i % 3 == 0 or '3' in str(i):
ans += ' ' + str(i)
print ans
| 0 | null | 5,057,271,095,152 | 111 | 52 |
import collections
def resolve():
n = int(input())
a = tuple(map(int,input().split()))
A = collections.Counter(a)
cnt_0 = 0
for i in A.values():
cnt_0 += int(i*(i-1)/2)
for i in a:
cnt_1 = A[i]-1
print(cnt_0-cnt_1)
resolve()
|
def resolve():
N = int(input())
A = list(map(int, input().split()))
import collections
counter = collections.Counter(A)
total = 0
for k, v in counter.items():
total += v*(v-1)//2
for a in A:
cnt = counter[a]
cntm1 = cnt - 1
print(total - cnt*(cnt-1)//2 + cntm1*(cntm1-1)//2)
if '__main__' == __name__:
resolve()
| 1 | 47,746,016,382,912 | null | 192 | 192 |
n, k = list(map(int, input().split()))
h = list(map(int, input().split()))
h.sort()
if k > 0:
h = h[:-k]
print(sum(h))
|
import sys
sys.setrecursionlimit(10 ** 9)
# 昔同じ問題を atcoder で見た？
n = int(input())
edges = []
paths = {}
for i in range(n-1):
a, b = list(map(int, input().split(' ')))
edges.append((a, b))
paths[a] = paths.get(a, []) + [b]
paths[b] = paths.get(b, []) + [a]
# print(edges)
# print(paths)
colors = {} # (a->b) 1 とか
current = 1
biggest = 1
def f(current, prev, prev_color):
global biggest
color = 0
for vertex in paths[current]:
if vertex == prev:
continue
color += 1
if color == prev_color:
color += 1
biggest = max(biggest, color)
colors[(current, vertex)] = color
f(vertex, current, color)
f(1, None, None)
print(biggest)
for a, b in edges:
print(colors[(a, b)])
# pypy3
| 0 | null | 107,466,366,019,050 | 227 | 272 |
import copy
def BubbleSort(C, n):
flag = 1
while flag:
flag = 0
for i in range(n-1, 0, -1):
if int(C[i][1]) < int(C[i - 1][1]):
C[i], C[i-1] = C[i-1], C[i]
flag = 1
return C
def SelectionSort(C, n):
for i in range(n-1):
minj = i
for j in range(i, n):
if int(C[j][1]) < int(C[minj][1]):
minj = j
if minj != i:
C[i], C[minj] = C[minj], C[i]
return C
n = int(input())
C = list(input().split())
C2 = C.copy()
print(*BubbleSort(C, n), sep=' ')
print("Stable")
print(*SelectionSort(C2, n), sep=' ')
if C ==C2:
print("Stable")
else:
print("Not stable")
|
class Card:
def __init__(self, inf):
self.num = int(inf[1])
self.inf = inf
n, card = int(input()), [Card(i) for i in input().split()]
card1 = card[:]
for i in range(n-1):
for j in range(n-1, i, -1):
if card[j].num < card[j-1].num:
card[j], card[j-1] = card[j-1], card[j]
print(" ".join([i.inf for i in card]))
print("Stable")
for i in range(n-1):
for j in range(i+1, n):
if j == i+1:
idx = j
elif card1[idx].num > card1[j].num:
idx = j
if card1[i].num > card1[idx].num:
card1[i], card1[idx] = card1[idx], card1[i]
print(" ".join([i.inf for i in card1]))
if card == card1:
print("Stable")
else:
print("Not stable")
| 1 | 25,179,550,108 | null | 16 | 16 |
a = int(input())
b_list = list(map(int, input().split()))
count = 0
mini=a
for i in range(len(b_list)):
if b_list[i] <= mini:
count += 1
mini = b_list[i]
print(count)
|
N = int(input())
Pli = list(map(int,input().split()))
a = Pli[0]
res = 1
for i in range(1,N):
if Pli[i] <= a:
a = Pli[i]
res += 1
print(res)
| 1 | 85,592,074,693,500 | null | 233 | 233 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.