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
|
|---|---|---|---|---|---|---|
def main():
n = int(input())
A = list(map(int,input().split()))
A.sort()
A_max = A[-1]
g = []
table = [True]*(A_max+1)
for i,a in enumerate(A):
if table[a]:
temp = a
while A_max >= temp:
table[temp] = False
temp+=a
if i==n-1 or a!=A[i+1]:
g.append(a)
print(len(g))
main()
|
from bisect import *
n,m = map(int,input().split())
S = input()
ok = []
for i,s in enumerate(S[::-1]):
if s == '0':
ok.append(i)
now = 0
ans = []
while now != n:
nxt = ok[bisect_right(ok, now + m) - 1]
if nxt == now:
ans = [str(-1)]
break
else:
ans.append(str(nxt - now))
now = nxt
print(' '.join(ans[::-1]))
| 0 | null | 77,104,965,898,312 | 129 | 274 |
num = list(map(int,input().split()))
circle_px = num[2] + num[4]
circle_mx = num[2] - num[4]
circle_py = num[3] + num[4]
circle_my = num[3] - num[4]
if(circle_px <= num[0] and circle_mx >= 0 and circle_py <= num[1] and circle_py >= 0): print("Yes")
else: print("No")
|
h = int(input())
ans = 0
n_enemy = 1
while h > 1:
h //= 2
ans += n_enemy
n_enemy *= 2
if h == 1:
ans += n_enemy
print(ans)
| 0 | null | 40,283,723,559,002 | 41 | 228 |
def resolve():
n=int(input())
print((n-1)//2)
resolve()
|
n=int(input())
if n<3:
print(0)
elif n%2==0:
print(int((n/2)-1))
else:
print(int(n//2))
| 1 | 152,563,345,765,798 | null | 283 | 283 |
n, m = map(int, raw_input().split())
l = map(int, raw_input().split())
INF = 1<<31
dp = [INF]*(n+1)
dp[0] = 0
for c in l:
for i in range(n-c+1):
if dp[i] != INF:
dp[i + c] = min(dp[i] + 1, dp[i + c])
print dp[n]
|
a, b, m = map(int, input().split())
a_list = [int(i) for i in input().split()]
b_list = [int(i) for i in input().split()]
money = []
for _ in range(m):
x, y, c = map(int, input().split())
x -= 1
y -= 1
total = a_list[x] +b_list[y] - c
money.append(total)
money.append(min(a_list) + min(b_list))
print(min(money))
| 0 | null | 26,944,411,052,480 | 28 | 200 |
N = int(input())
A = list(map(int,input().split()))
bunretsu = sum(A) - 1
zanretsu = 1
souwa = 0
for i in range(N+1):
souwa += zanretsu
if A[i] <= zanretsu:
zanretsu -= A[i]
else:
souwa = -1
break
if bunretsu >= 1 and bunretsu <= zanretsu:
zanretsu += bunretsu
bunretsu = 0
elif bunretsu >= 1 and bunretsu > zanretsu:
bunretsu -= zanretsu
zanretsu *= 2
print(souwa)
|
n = int(input())
a = list(map(int, input().split()))
s = sum(a)
k = 1-a[0]
s -= a[0]
ans = 1
for i in range(1,n+1):
if k*2 <= s:
k *= 2
else:
k = s
ans += k
k -= a[i]
s -= a[i]
if k == 0 and s == 0:
print(ans)
else:
print(-1)
| 1 | 18,916,460,206,168 | null | 141 | 141 |
K = int(input())
id = 1
cnt = 7
while cnt < K:
cnt = cnt * 10 + 7
id += 1
visited = [0] * K
while True:
remz = (cnt % K)
if remz == 0:
break
visited[remz] += 1
if visited[remz] > 1:
id = -1
break
cnt = remz * 10 + 7
id += 1
print(id)
|
K=int(input())
A=0
for i in range(K):
A=(A*10+7)%K
if A%K==0:
print(i+1)
break
if i==K-1:print(-1)
| 1 | 6,122,882,927,040 | null | 97 | 97 |
a,b = list(map(int,input().split()))
print("%d %d %f" % ((a//b),(a%b),float((a/b))))
|
"""
dp[i][j][k] => i行目j列到達時点での最大価値。i行目において拾えるアイテムの数はK個。
"""
def main():
import sys
input = sys.stdin.readline
R,C,K = map(int,input().split())
items = [[0]*C for _ in range(R)]
for _ in range(K):
r,c,v = map(int,input().split())
items[r-1][c-1] = v
dp = [[0]*4 for _ in range(C)]
for i in range(R):
for j in range(C):
v = items[i][j]
#上から入るパターン
dp[j][0] = max(dp[j])
if v:
dp[j][1] = dp[j][0]+v
#左から入ってくるパターン
if j > 0:
for k in range(4):
#このマスのアイテムをとらないパターン
dp[j][k] = max(dp[j][k],dp[j-1][k])
if v and k>0:
dp[j][k] = max(dp[j][k],dp[j-1][k-1]+v)
print(max(dp[-1]))
main()
| 0 | null | 3,078,085,418,492 | 45 | 94 |
S = int(input())
h = int(S/3600)
left = S-3600*h
m = int(left/60)
s = left-60*m
print("{}:{}:{}".format(h,m,s))
|
def insertionSort():
N = int(input())
lst = list(map(int, input().split()))
for i in range(1, N):
print(*lst)
v = lst[i]
j = i - 1
while j >= 0 and lst[j] > v:
lst[j+1] = lst[j]
j -= 1
lst[j+1] = v
print(*lst)
insertionSort()
| 0 | null | 162,883,265,860 | 37 | 10 |
inp=input().split()
if inp[0] < inp[1] and inp[1] < inp[2]:
print("Yes")
else:
print("No")
|
for i in range(1,10):
for j in range(1,10):
a=i*j
print(f'{i}x{j}={a}')
| 0 | null | 198,054,228,450 | 39 | 1 |
X=int(input())
sen=X//500
X=X%500
go=X//5
print(1000*sen + 5*go)
|
x = int(input())
b = x
a = 1
while b%360!=0:
a += 1
b += x
print(a)
| 0 | null | 27,824,159,532,638 | 185 | 125 |
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
N, K = LI()
# 逆に考える
"""
X = gcd(A_1, A_2,...A_K)
となるようなXを考えると溶ける
X = 3の時その個数は
[K/3]**N
"""
x_cnt = [0] * (K + 1)
for x in range(K, 0, -1):
# print(x)
tmp = pow(K // x, N, mod)
for j in range(x + x, K+1, x):
tmp -= x_cnt[j]
x_cnt[x] = tmp
ans = 0
for i in range(1,K+1):
ans += i * x_cnt[i]
ans %= mod
print(ans)
|
N,K=map(int,input().split())
MOD=int(1e9)+7
dp=[0]*(K+1)
for i in range(K):
j=K-i
dp[j]+=pow(K//j, N, MOD)
k=2*j
while k<=K:
dp[j]=(dp[j]-dp[k]+MOD) % MOD
k+=j
ans=0
for i in range(1,K+1):
ans+=dp[i]*i
ans%=MOD
print(ans)
| 1 | 36,754,077,858,916 | null | 176 | 176 |
import bisect
import math
N, D, A = map(int, input().split())
cusum = [0] * (N+1)
X = []
XH =[]
for i in range(N):
xi, hi = map(int, input().split())
X += [xi]
XH += [(xi, hi)]
X = sorted(X)
XH = sorted(XH)
cusumD = 0
ans = 0
for i, (xi, hi) in enumerate(XH):
cusumD -= cusum[i]
hi = max(0, hi-cusumD)
r = bisect.bisect_right(X, xi+2*D)
b = int(math.ceil(hi/A))
d = b * A
ans += b
cusumD += d
cusum[r] += d
print(ans)
|
n = int(input())
import collections
d = collections.deque([])
for _ in range(n):
s = input().split()
if s[0] == "deleteFirst":
d.popleft()
elif s[0] == "deleteLast":
d.pop()
elif s[0] == "insert":
d.appendleft(s[1])
else:
try:
d.remove(s[1])
except:
pass
print(" ".join(d))
| 0 | null | 41,254,562,232,862 | 230 | 20 |
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
d = abs(A-B)
if d-(V-W)*T<=0:
print("YES")
else:
print("NO")
|
n=int(input())
s=[]
t=[]
for i in range(n):
st,tt=input().split()
s.append(st)
t.append(int(tt))
x=str(input())
temp=0
ans=sum(t)
for i in range(n):
temp=temp+t[i]
if s[i]==x:
break
print(ans-temp)
| 0 | null | 56,107,488,427,770 | 131 | 243 |
n, k, s = map(int, input().split())
la = list()
if s == 1:
l = [1] * k + [2] * (n-k)
elif s == 10**9:
l = [s] * k + [1] * (n-k)
else:
l = [s] * k + [s+1] * (n-k)
l = [str(i) for i in l]
print(" ".join(l))
|
N,K,S=map(int,input().split())
ans=[S]*K+[[7,S+1][S!=10**9]]*(N-K)
print(*ans)
| 1 | 91,079,346,137,262 | null | 238 | 238 |
import sys
import math
from enum import Enum
while True:
n=int(input())
if n==0:
break
s=list(map(int,input().split()))
sum1=0
for i in range(len(s)):
sum1+=s[i]
a=sum1/len(s)
sum2=0
for i in range(len(s)):
sum2+=s[i]*s[i]
b=sum2/len(s)
print("%.10f"%(math.sqrt(b-a*a)))
|
while True:
num = int(input())
if num == 0:
break
data = list(map(int, input().split()))
datasqr = [i ** 2 for i in data]
print("%lf" % (sum(datasqr) / num - (sum(data) / num) ** 2) ** 0.5)
| 1 | 192,349,182,872 | null | 31 | 31 |
st= input().split()
s=st[0]
t=st[1]
print(t+s)
|
base = input().split()
print(base[1],end="")
print(base[0])
| 1 | 103,020,620,413,260 | null | 248 | 248 |
h,w = list(map(int,input().split()))
h += 2
w += 2
grid = '#'*w
for _ in range(h-2):
grid += '#' + input() + '#'
grid += '#'*w
from collections import deque
ans = 0
for i in range(len(grid)):
INF = 10**9
dist = [INF]*(h*w)
if grid[i]=='#':
continue
dist[i] = 0
q = deque([i])
while q:
v = q.popleft()
dv = dist[v]
for m in (-1,1,w,-w):
move = v + m
if grid[move]=='#':
continue
dmove = dv + 1
if dmove >= dist[move]:
continue
dist[move] = dmove
q.append(move)
# print([dist[i] if dist[i]!=INF else 0 for i in range(len(dist))])
ans = max(ans, max([dist[i] if dist[i]!=INF else 0 for i in range(len(dist))]))
# print(ans)
print(ans)
|
# Aizu Problem 0001: List of Top 3 Hills
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input2.txt", "rt")
for h in sorted([int(input()) for _ in range(10)], reverse=True)[:3]:
print(h)
| 0 | null | 47,002,897,872,868 | 241 | 2 |
import math
import collections
import copy
import sys
n = int(input())
a = list(map(int,input().split()))
limit = 10 ** 6
sCheck = math.gcd(a[0],a[1])
if n == 2:
if sCheck == 1:
print("pairwise coprime")
else:
print("not coprime")
sys.exit()
else:
for i in range(2,n):
sCheck = math.gcd(sCheck,a[i])
beforeQ = collections.deque([int(i) for i in range(3,(limit + 1))])
D = dict()
p = 2
D[2] = 2
D[1] = 1
while p < math.sqrt(limit):
afterQ = collections.deque()
while len(beforeQ) > 0:
k = beforeQ.popleft()
if k % p != 0:
afterQ.append(k)
else:
D[k] = p
beforeQ = copy.copy(afterQ)
p = beforeQ.popleft()
D[p] = p
while len(beforeQ) > 0:
k = beforeQ.popleft()
D[k] = k
ansSet = set()
count = 0
for i in a:
k = i
kSet = set()
while k != 1:
if D[k] in ansSet:
if not(D[k] in kSet):
count = 1
break
else:
ansSet.add(D[k])
kSet.add(D[k])
k = int(k // D[k])
if count == 1:
break
if count == 0:
print("pairwise coprime")
elif sCheck == 1:
print("setwise coprime")
else:
print("not coprime")
|
print(sum([i for i in range(int(input()) + 1) if (i % 3 != 0 and i % 5 != 0)]))
| 0 | null | 19,560,295,027,196 | 85 | 173 |
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)
|
N = int(input())
S = str(input())
print(S.count("ABC"))
| 0 | null | 66,135,186,626,660 | 170 | 245 |
n=int(input())
print(sum(i*(n//i*(n//i+1))//2 for i in range(1,n+1)))
|
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n = int(input())
ans = 0
for i in range(1, n+1):
ans += i*(1 + n//i)*(n//i)//2
print(ans)
if __name__=='__main__':
main()
| 1 | 11,003,299,232,958 | null | 118 | 118 |
# B - Multiple of 9
n = input()
print('Yes' if sum(int(d) for d in n) % 9 == 0 else 'No')
|
def main():
s = str(input())
print(s[:3])
if __name__ == '__main__':
main()
| 0 | null | 9,645,896,521,434 | 87 | 130 |
n = int(input())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
ans = 0
for i in range(n):
ans += abs(x[i] - y[i])
print(ans)
ans = 0
for i in range(n):
ans += (x[i] - y[i])**2
print(ans**(1/2))
ans = 0
for i in range(n):
ans += (abs(x[i] - y[i]))**3
print(ans**(1/3))
ans = 0
for i in range(n):
ans = max(ans, abs(x[i] - y[i]))
print(ans)
|
n,m = map(int, input().split())
a = list(map(int,input().split()))
sum = 0;
for i in a:
sum += i
if(sum > n):
print(-1)
else:
print(n-sum)
#print(a)
| 0 | null | 16,102,656,577,328 | 32 | 168 |
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
if n == 1:
print(0)
exit()
primes = prime_factorize(n)
max_primes = primes[-1]
dic = {}
tmp = 0
for i in primes:
if i not in dic:
dic[i] = 1
tmp = 0
continue
if tmp == 0:
tmp = i
else:
tmp *= i
if tmp not in dic:
dic[tmp] = 1
tmp = 0
print(len(dic))
|
def factorize(n):
b = 2
fct = []
while b * b <= n:
while n % b == 0:
n //= b
fct.append(b)
b = b + 1
if n > 1:
fct.append(n)
return fct
def getpattern(x):
pattern = 0
d = 0
for i in range(1, 1000000):
d += i
if x < d:
break
pattern += 1
return pattern
n = int(input())
f = factorize(n)
fu = set(factorize(n))
r = 0
for fui in fu:
r += getpattern(f.count(fui))
print(r)
| 1 | 16,931,192,576,382 | null | 136 | 136 |
class Dice:
def __init__(self):
self.N = [1, 5, 2, 3, 0, 4]
self.S = [4, 0, 2, 3, 5, 1]
self.E = [3, 1, 0, 5, 4, 2]
self.W = [2, 1, 5, 0, 4, 3]
def roll(self, dice, dice_t, direction):
for d in direction:
if d == "N":
for i in range(6):
dice_t[i] = dice[self.N[i]]
elif d == "S":
for i in range(6):
dice_t[i] = dice[self.S[i]]
elif d == "E":
for i in range(6):
dice_t[i] = dice[self.E[i]]
else:
for i in range(6):
dice_t[i] = dice[self.W[i]]
for i in range(6):
dice[i] = dice_t[i]
d = Dice()
dice = [dice for dice in input().split()]
dice_t = ["" for dice_t in range(6)]
direction = input()
d.roll(dice, dice_t, direction)
print(dice[0])
|
import bisect
import copy
import heapq
import math
import sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
sys.setrecursionlimit(500000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
n=int(input())
a=list(map(int,input().split()))
dic=defaultdict(int)
ans=0
for i in range(n):
ans+=dic[i-a[i]]
dic[a[i]+i]+=1
print(ans)
| 0 | null | 13,112,465,027,192 | 33 | 157 |
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)
|
a,b = map(int,input().split())
ans = 0
if a == 1 or b == 1:
print(1)
elif a*b % 2 == 0:
print(int(a*b/2))
else:
print(int((a*b-1)/2 + 1))
| 1 | 50,687,086,196,084 | null | 196 | 196 |
n,m=list(map(int,input().split()))
s=input()
a=[0]*(n+1)
a[0]=1
for i in range(1,n+1):
if s[i]=='1':
continue
for j in range(max(0,i-m),i):
if s[j]=='1':
continue
if a[j]>0:
break
a[i]=i-j
ans=''
cur=n
while cur>0:
d=a[cur]
cur-=d
if d==0:
print(-1)
exit(0)
ans=str(d)+' '+ans
print(ans[:-1])
|
from collections import Counter
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N = int(input())
edge = [[] for _ in range(N + 1)]
for i in range(N - 1):
x, y = map(int, input().split())
edge[x].append((y, i))
edge[y].append((x, i))
color = [-1] * (N - 1)
def dfs(s, p=-1, pc=-1):
c = 0
for t, x in edge[s]:
if color[x] != -1:
continue
if t == p:
continue
c += 1
if c == pc:
c += 1
color[x] = c
dfs(t, s, c)
dfs(1)
print(len(Counter(color)))
print(*color, sep="\n")
| 0 | null | 137,401,350,048,120 | 274 | 272 |
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
INF = 10**9
def ok(l):
cnt = 0
for L in a:
cnt += L//l
if L%l != 0:
cnt+=1
cnt-=1
return cnt <= k
if __name__ == "__main__":
n,k = map(int,input().split())
a = list(map(int,input().split()))
left = 0
right = max(a)
#最大値の最小値は二分探索
while right - left > 1:
mid = (right+left)//2
if ok(mid):
right = mid
else:
left = mid
print(right)
|
# -*- coding: utf-8 -*-
"""
A - Can't Wait for Holiday
https://atcoder.jp/contests/abc146/tasks/abc146_a
"""
import sys
def solve(S):
return {'SUN': 7, 'MON': 6, 'TUE': 5, 'WED': 4, 'THU': 3, 'FRI': 2, 'SAT': 1}[S]
def main(args):
S = input()
ans = solve(S)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
| 0 | null | 69,522,119,727,446 | 99 | 270 |
L, R = input().split()
print(int(R)*int(L))
|
a,b=input().split()
print((int(a)*int(b))//1)
| 1 | 15,923,361,672,192 | null | 133 | 133 |
def main():
n, k = list(map(int, input().split()))
mod = 1000000007
N = list(range(n + 1))
mn = [0] * (n + 1)
mx = [0] * (n + 1)
mx[0] = n
for i in range(1, n + 1):
mn[i] = mn[i - 1] + N[i]
mx[i] = mx[i - 1] + N[n - i]
ans = 0
for a, b in zip(mn[k - 1:], mx[k - 1:]):
ans += b - a + 1
ans %= mod
print(ans)
if __name__ == '__main__':
main()
|
value = input()
convert_value = []
for x in value:
if x.isupper():
convert_value.append(x.lower())
elif x.islower():
convert_value.append(x.upper())
else:
convert_value.append(x)
print(''.join(x for x in convert_value))
| 0 | null | 17,307,389,210,332 | 170 | 61 |
import sys
from collections import deque, defaultdict, Counter
from itertools import accumulate, product, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush
from math import ceil, floor, sqrt, gcd, inf
from copy import deepcopy
import numpy as np
import scipy as sp
INF = inf
MOD = 1000000007
x = int(input())
tmp = [i ** 5 for i in range(ceil(x ** 0.25) + 1)]
res = 0
for a in range(len(tmp) - 1):
for b in range(a + 1, len(tmp)):
if tmp[a] - tmp[b] == x:
res = f"{a} {b}"
break
elif tmp[a] + tmp[b] == x:
res = f"{a} {-b}"
break
elif -tmp[a] + tmp[b] == x:
res = f"{-a} {-b}"
break
elif -tmp[a] - tmp[b] == x:
res = f"{-a} {b}"
break
print(res)
|
import sys
X = int(input())
#%%
for a in range(1000):
for b in range(-1000, 1000):
if pow(a, 5) - pow(b, 5) == X:
print(a,b)
sys.exit( )
| 1 | 25,635,949,736,910 | null | 156 | 156 |
N = int(input())
n = N % 10
if n == 3:
ans = 'bon'
elif n == 0 or n == 1 or n == 6 or n == 8:
ans = 'pon'
else:
ans = 'hon'
print(ans)
|
N = int(input())
ans = ""
letter = "abcdefghijklmnopqrstuvwxyz"
while N != 0:
N -= 1
ans = letter[N % 26] + ans
N = N // 26
print(ans)
| 0 | null | 15,569,561,001,758 | 142 | 121 |
i = 1
while True:
x, y = map(int, input().split())
if x == 0 and y == 0:
break
else:
print(min(x,y), max(x,y))
|
N,D=map(int, input().split())
A = 0
for i in range(N):
X,Y=map(int, input().split())
if (D*D) >= (X*X)+(Y*Y):
A +=1
print(A)
| 0 | null | 3,241,052,320,240 | 43 | 96 |
from collections import deque
def marge_ponds(lx, area_of_pond):
global ponds
if ponds and ponds[-1][0] > lx:
return marge_ponds(lx, area_of_pond + ponds.pop()[1])
return area_of_pond
terrains = input().strip()
x, last_x, ponds = 0, deque(), deque()
for terrain in terrains:
if terrain == '\\':
last_x.append(x)
elif terrain == '/':
if last_x:
lx = last_x.pop()
ponds.append((lx, marge_ponds(lx, x - lx)))
x += 1
print(sum(pond[1] for pond in ponds))
ponds.appendleft((0, len(ponds)))
print(' '.join(map(str, [pond[1] for pond in ponds])))
|
def main():
N = int(input())
A = input().split()
if len(set(A)) == N:
print("YES")
else:
print("NO")
if __name__ == '__main__':
main()
| 0 | null | 36,764,474,010,080 | 21 | 222 |
def solve():
x = int(input())
for i in range(-150, 151):
for j in range(-150,i):
if i ** 5 - j ** 5 == x:
print(i,j)
return
if __name__ == '__main__':
solve()
|
def main():
A=int(input())
B=int(input())
for i in range(1,4):
if i not in (A,B):
print(i)
return
main()
| 0 | null | 68,477,736,940,028 | 156 | 254 |
import math
N = int(input())
even = False
if N % 2 == 0:
even = True
factor1 = int(math.floor(N ** (1/2)))
# if even: # Nが偶数の時はfactor1を偶数にしておく
# if factor1 % 2 == 1:
# factor1 -= 1
# else:
# if factor1 % 2 == 0:
# factor1 -= 1
while True:
if N % factor1 == 0:
factor2 = int(N / factor1)
break
else:
factor1 -= 1
print(factor1 + factor2 - 2)
|
#!/usr/bin/env python3
import sys
def input():
return sys.stdin.readline()[:-1]
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 main():
N = int(input())
ans = 1e18
for i in range(1, N + 1):
if i * i > N:
break
if N % i != 0:
continue
j = N // i
ans = min(ans, i + j - 2)
print(ans)
if __name__ == '__main__':
main()
| 1 | 162,179,945,306,314 | null | 288 | 288 |
N, K, S = map(int, input().split(" "))
ans = []
for i in range(K):
ans.append(S)
for i in range(N - K):
ans.append(10 ** 9 if S != 10 ** 9 else 1)
print(' '.join([str(a) for a in ans]))
|
D = int(input())
c = [int(i) for i in input().split()]
s = [[int(i) for i in input().split()] for _ in range(D)]
t = [int(input())-1 for _ in range(D)]
ans = 0
llst = [0]*26
for day,i in enumerate(range(D),1):
llst[t[i]] = day
ans += s[i][t[i]]
for j in range(26): ans -= c[j]*(day-llst[j])
print(ans)
| 0 | null | 50,577,767,421,152 | 238 | 114 |
import sys
sys.setrecursionlimit(10 ** 9)
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M, K = map(int, input().split())
uf = UnionFind(N)
FG = [0] * N
BG = [0] * N
for _ in range(M):
a, b = map(int, input().split())
a, b = a-1, b-1
uf.union(a, b)
FG[a] += 1
FG[b] += 1
for _ in range(K):
c, d = map(int, input().split())
c, d = c-1, d-1
if uf.same(c, d):
BG[c] += 1
BG[d] += 1
ans = []
for i in range(N):
ans.append(uf.size(i) - FG[i] - BG[i] - 1)
print(*ans)
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
n,m,k=map(int,input().split())
uf=UnionFind(n)
block={}
for i in range(n):
block[i]=[i]
for i in range(m):
a,b=map(int,input().split())
uf.union(a-1,b-1)
block[a-1].append(b-1)
block[b-1].append(a-1)
for i in range(k):
a,b=map(int,input().split())
block[a-1].append(b-1)
block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
res=uf.size(i)
# print(res)
for value in block[i]:
if uf.same(value,i):
res-=1
ans.append(res)
print(*ans)
if __name__=="__main__":
main()
| 1 | 61,679,567,546,288 | null | 209 | 209 |
li = []
for i in range(2):
a,b = map(int, input().split())
li.append(a)
if li[1] == li[0]+1:
print(1)
else:
print(0)
|
import copy
h, w, k = map(int, input().split())
s = [[0] * w for _ in range(h)]
for i in range(h):
inp = input()
for j in range(w):
s[i][j] = int(inp[j])
# 最終的に出力する操作回数の最小値
ans = h + w - 2
for i in range(2 ** (h-1)):
# bit全探索によるcutの仕方
cutIdx = [0] * (h-1)
for j in range(h-1):
cutIdx[j] = (i >> j) & 1
#print('cI : ', cutIdx)
# cutする場所を示したリスト
div = []
cut_row_begin, cut_row_end = 0, 1
for j in range(h-1):
if cutIdx[j] == 0:
# cutしない
cut_row_end += 1
else:
# cutする
div.append((cut_row_begin, cut_row_end))
cut_row_begin = cut_row_end
cut_row_end += 1
div.append((cut_row_begin, cut_row_end))
#print('div: ', div)
# 既にここまででcutされている回数
cnt = sum(cutIdx)
#print(cnt)
# divごとのホワイトチョコの数をカウント
whiteCnt = [0] * len(div)
# まずは1列目をチェック
for a in range(len(div)):
cal = 0
for b in range(div[a][0], div[a][1]):
cal += s[b][0]
whiteCnt[a] = cal
#print('wC : ', whiteCnt)
# もしこの時点でwhiteCntの要素でkを超えるものがあるとき
# その横の切り方は不可能なのでbreak
if max(whiteCnt) > k:
continue
# Wが1ならそこで終わり
if w == 1:
ans = min(ans, cnt)
# 次行のホワイトチョコ数を保持
search = [0] * len(div)
# 2列目以降を同様にチェックしていく
for a in range(1, w):
# その次行のホワイトチョコの数
for b in range(len(div)):
cal = 0
for c in range(div[b][0], div[b][1]):
cal += s[c][a]
search[b] = cal
# その行単体でmax値とkを比べる
# オーバーしていればcut不可
if max(search) > k:
break
# greedy
for b in range(len(div)):
if whiteCnt[b] + search[b] > k:
# cut対象
cnt += 1
whiteCnt = copy.copy(search)
break
else:
whiteCnt[b] += search[b]
#print('cnt: ', cnt)
ans = min(ans, cnt)
print(ans)
| 0 | null | 86,285,012,016,338 | 264 | 193 |
_ = input()
a = list(input())
cnt = 0
word = 0
for i in a:
if word == 0 and i == 'A':
word = 1
elif word == 1 and i =='B':
word = 2
elif word == 2 and i =='C':
word = 0
cnt += 1
else:
if i == 'A':
word = 1
else:
word = 0
print(cnt)
|
A = int(input())
B = int(input())
if (A==1 and B ==2) or (A==2 and B==1):
print('3')
elif (A==1 and B==3) or (A==3 and B==1):
print('2')
elif (A==2 and B==3) or (A==3 and B==2):
print('1')
| 0 | null | 104,872,850,298,960 | 245 | 254 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
low = 0
top = max(a) + 1
while top - low > 1:
mid = (top + low) // 2
cnt = 0
for i in range(n):
if a[i] % mid == 0:
cnt += (a[i] // mid) - 1
else:
cnt += a[i] // mid
if cnt <= k:
top = mid
else:
low = mid
print(top)
|
def solve():
N, K = map(int,input().split())
A = list(map(int,input().split()))
left = 0
right = 10 ** 9
while right - left > 1:
mid = (right+left) // 2
cnt = 0
for a in A:
cnt += (a-1) // mid
if cnt <= K:
right = mid
else:
left = mid
print(right)
if __name__ == '__main__':
solve()
| 1 | 6,511,364,530,564 | null | 99 | 99 |
n, x, t = map(lambda x: int(x), input().split())
if n % x == 0:
group = n // x
else:
group = n // x + 1
answer = group * t
print(answer)
|
def sheep_and_wolves():
condition = input()
condition_list = condition.split()
S = int(condition_list[0])
W = int(condition_list[1])
if S > W:
print('safe')
return
elif S <= W:
print('unsafe')
return
sheep_and_wolves()
| 0 | null | 16,630,457,396,252 | 86 | 163 |
# -*- coding: utf-8 -*-
import sys
N=input()
bit=[ [ 0 for _ in range(N+1) ] for __ in range(27) ]
def add(i,a,w):
while a<=N:
bit[i][a]+=w
a+=a&-a
def sum(i,a):
ret=0
while 0<a:
ret+=bit[i][a]
a-=a&-a
return ret
S=sys.stdin.readline().strip()
S=[None]+list(S) #1-indexed
for j,x in enumerate(S):
if j==0: continue
i=ord(x)-96
add(i,j,1)
Q=input()
for _ in range(Q):
q1,q2,q3=sys.stdin.readline().split()
if q1=="1":
q1=int(q1)
q2=int(q2)
current_s=q3
former_s=S[q2]
former_s=ord(former_s)-96 #1-indexed
S[q2]=current_s #文字列で更新された1文字を置き換える
current_s=ord(current_s)-96
add(current_s,q2,1)
add(former_s,q2,-1)
if q1=="2":
q2=int(q2)
q3=int(q3)
begin,end=q2,q3
cnt=0
for i in range(1,27):
if 0<sum(i,end)-sum(i,begin-1):
cnt+=1
print cnt
|
import sys
res = dict()
dll = [None] * 2000000
left = 0
right = 0
n = int(input())
for inpt in sys.stdin.read().splitlines():
i = inpt.split()
if i[0] == "insert":
x = int(i[1])
dll[left] = x
if(x in res):
res[x].add(left)
else:
res[x] = set([left])
left += 1
if i[0] == "delete":
x = int(i[1])
if(x in res):
ind = max(res[x])
dll[ind] = None
res[x].remove(ind)
if(len(res[x]) == 0):
del res[x]
if(ind == (left - 1)):
left = ind
if(ind == right):
right += 1
if i[0] == "deleteFirst":
left -= 1
x = dll[left]
res[x].remove(left)
if(len(res[x]) == 0):
del res[x]
dll[left] = None
if i[0] == "deleteLast":
right += 1
# print(dll[right:left])
ret = []
for x in dll[right:left]:
if(x is not None):
ret.append(str(x))
ret.reverse()
print(" ".join(ret))
| 0 | null | 31,321,505,732,108 | 210 | 20 |
A, B, K = map(int, input().split())
if A <= K:
B -= K - A
if B < 0:
B = 0
A = 0
else:
A -= K
print(A, B)
|
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools
import itertools
import math
import sys
INF = float('inf')
def solve(A: int, B: int, K: int):
return f'{max(A-K,0)} {max(B-max(0,K-A),0)}'
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
print(f'{solve(A, B, K)}')
if __name__ == '__main__':
main()
| 1 | 104,442,908,952,448 | null | 249 | 249 |
#!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
from functools import lru_cache
@lru_cache(maxsize=2*10**5)
def f2(x):
if x == 0: return 0
y = bin(x).count("1")
return 1 + f2(x % y)
def resolve():
N = int(input())
W = 16
S = input()
cnt0 = S.count("1")
if cnt0 == 0:
print(*[1]*N, sep="\n")
return
X = int(S, 2)
dc = {}
for k, v in (("0", 1), ("1", -1)):
x = cnt0 + v
y = X % x if x else 0
dc[k] = (x, v, y)
ans = []
for i, si in enumerate(S):
cnt, v, n = dc[si]
if cnt == 0:
ans.append(0)
continue
ni = N - i - 1
n = (n + v * pow(2, ni, cnt)) % cnt
ans.append(1+f2(n))
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
|
import numpy as np
N = int(input())
X = [[] for _ in range(N)]
L = [[] for _ in range(N)]
for i in range(N):
X[i], L[i] = map(int, input().split())
def indexSort(L):
D = dict(zip(range(len(L)), L))
E = sorted(D.items(), key=lambda x: x[1])
F = [e[0] for e in E]
return F
L1 = [x-l for x, l in zip(X, L)]
L2 = [x+l for x, l in zip(X, L)]
Ind = np.argsort(L2)
Remain = [Ind[0]]
i = 0
while i < len(Ind)-1:
now = Remain[-1]
After = Ind[i+1:]
skip = 0
for after in After:
if L2[now] > L1[after]:
# print(L2[now], L1[after])
skip += 1
else:
# print(after)
Remain.append(after)
break
i += 1 + skip
print(len(Remain))
| 0 | null | 49,027,111,915,588 | 107 | 237 |
def main():
N=10
l = list()
for i in range(N):
l.append(int(input()))
l.sort(reverse=True)
for x in l[:3]:
print(x)
if __name__=='__main__':
main()
|
import sys
import re
import math
import collections
import decimal
import bisect
import itertools
import fractions
import functools
import copy
import heapq
import decimal
import statistics
import queue
# import numpy as np
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
n, t = ns()
d = [na() for _ in range(n)]
d.sort()
dp = [-1 for _ in range(t + 3000 + 1)]
dp[0] = 0
for a, b in d:
for i in range(t - 1, -1, -1):
if dp[i] >= 0:
dp[i + a] = max(dp[i + a], dp[i] + b)
print(max(dp))
if __name__ == '__main__':
main()
| 0 | null | 75,445,675,703,552 | 2 | 282 |
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF = float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353
import numpy
N = int(input())
A = list(map(int, input().split()))
a = numpy.argsort(A)
b = []
for i in range(N):
b.append(str(a[i]+1))
print(" ".join(b))
|
while 1:
H, W = map(int ,raw_input().split())
if H == 0 and W == 0:
break
else:
print ('#'*W + '\n')*H
| 0 | null | 90,397,922,721,358 | 299 | 49 |
n,m,l=map(int,input().split())
a=[list(map(int,input().split(" "))) for i in range(n)]
b=[list(map(int,input().split(" "))) for i in range(m)]
c=[[0]*l for i in range(n)]
for i in range(n):
for j in range(l):
for k in range(m):
c[i][j]=c[i][j]+a[i][k]*b[k][j]
for d in range(n):
print(c[d][0],end="")
for e in range(1,l):
print(" %d"%c[d][e],end="")
print()
|
# coding: utf-8
# Here your code !
import sys
def culc_division(x) :
"""
??\???x????´???°?????°??????????????§??????
"""
culc_list = []
for i in range(1,x+1) :
if x % i == 0 :
culc_list.append(i)
return culc_list
in_std = list(map(int, sys.stdin.readline().split(" ")))
a = in_std[0]
b = in_std[1]
c = culc_division(in_std[2])
counter = 0
for idx in range(a, b+1):
if idx in c:
counter += 1
print(counter)
| 0 | null | 992,626,949,860 | 60 | 44 |
# -*- coding: utf-8 -*-
"""
E - Travel by Car
https://atcoder.jp/contests/abc143/tasks/abc143_e
"""
import sys
from scipy.sparse.csgraph import floyd_warshall
def main(args):
N, M, L = map(int, input().split())
g1 = [[float('inf')] * (N+1) for _ in range(N+1)]
for i in range(N+1):
g1[i][i] = 0
for _ in range(M):
A, B, C = map(int, input().split())
g1[A][B] = g1[B][A] = C
d1 = floyd_warshall(g1)
g2 = [[float('inf')] * (N+1) for _ in range(N+1)]
for i in range(N+1):
for j in range(N+1):
if i == j:
g2[i][j] = 0
elif d1[i][j] <= L:
g2[i][j] = g2[j][i] = 1
d2 = floyd_warshall(g2)
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
print(-1 if d2[s][t] == float('inf') else int(d2[s][t]) - 1)
if __name__ == '__main__':
main(sys.argv[1:])
|
import sys
input = sys.stdin.readline
N, m, l = map(int, input().split())
graph = [[] for i in range(N+1)]
INF = 2 ** 31 - 1
d = [[INF for i in range(N+1)] for j in range(N+1)]
for i in range(N+1):
d[i][i] = 0
for i in range(m):
a, b, c = map(int, input().split())
d[a][b] = c
d[b][a] = c
for k in range(N+1):
for i in range(N+1):
for j in range(N+1):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
d2 = [[INF for i in range(N+1)] for j in range(N+1)]
for i in range(N+1):
d[i][i] = 0
for i in range(N+1):
for j in range(N+1):
if d[i][j] <= l:
d2[i][j] = 1
for k in range(N+1):
for i in range(N+1):
for j in range(N+1):
d2[i][j] = min(d2[i][j], d2[i][k] + d2[k][j])
q = int(input())
for i in range(q):
s, t = map(int, input().split())
if d2[s][t] == INF:
print(-1)
else:
print(d2[s][t] - 1)
| 1 | 173,559,173,717,162 | null | 295 | 295 |
from math import ceil
t1,t2 = map(int,input().split())
a1,a2 = map(int,input().split())
b1,b2 = map(int,input().split())
a1 -= b1
a2 -= b2
a1 *= t1
a2 *= t2
if a1 + a2 == 0:
print("infinity")
exit()
if a1*(a1+a2) > 0:
print(0)
exit()
x = -a1/(a1+a2)
n = ceil(x)
if n == x:
print(2*n)
else:
print(2*n-1)
|
import sys,collections
input = sys.stdin.readline
def main():
N,M,K = list(map(int,input().split()))
fr = [[] for i in range(N+1)]
bl = [[] for i in range(N+1)]
for _ in range(M):
a,b = map(int,input().split())
fr[a].append(b)
fr[b].append(a)
for _ in range(K):
c,d = map(int,input().split())
bl[c].append(d)
bl[d].append(c)
fl = [-1 for i in range(N+1)]
fl[0] = 0
fl[1] = 1
nxt = 1
dic = {}
s = set(range(1,N+1))
while nxt != 0:
q = collections.deque([nxt])
fl[nxt]=nxt
cnt = 0
while q:
now = q.popleft()
s.discard(now)
for f in fr[now]:
if fl[f] == -1:
fl[f] = nxt
cnt +=1
q.append(f)
dic[nxt] = cnt
#try:
#nxt = fl.index(-1)
#except:
#nxt = 0
if len(s) == 0:
nxt = 0
else:
nxt = s.pop()
mbf = collections.deque()
for i in range(1,N+1):
ff = 0
for j in bl[i]:
if fl[j] == fl[i]:
ff -= 1
ff += dic[fl[i]]-len(fr[i])
mbf.append(ff)
print(*mbf)
if __name__ == '__main__':
main()
| 0 | null | 96,411,254,810,950 | 269 | 209 |
n,k = map(int,input().split())
r,s,p = map(int,input().split())
t = input()
ans = 0
memo = [0]*(n+1)
for i in range(n):
if t[i] == "r":
if i-k >= 0 and memo[i-k] == 1:
pass
else:
ans += p
memo[i] = 1
elif t[i] == "s":
if i-k >= 0 and memo[i-k] == 2:
pass
else:
ans += r
memo[i] = 2
else:
if i-k >= 0 and memo[i-k] == 3:
pass
else:
ans += s
memo[i] = 3
print(ans)
|
a,b=map(int, input().split())
if max(a,b)>9:
print("-1")
else:
print( a*b )
| 0 | null | 132,691,549,652,612 | 251 | 286 |
n,k = map(int,input().split())
li = list(map(int,input().split()))
licsum = [0]
for i in range(n):
licsum.append(licsum[i] + li[i])
lia = []
for i in range(n-k+1):
a = licsum[k+i] - licsum[i] + k
lia.append(float(a)/2)
print(max(lia))
|
n=int(input())
s=input()
res=s[0]
ans=1
for i in range(1,n):
if s[i]==res:
continue
else:
res=s[i]
ans+=1
print(ans)
| 0 | null | 122,658,042,602,020 | 223 | 293 |
a,b=map(int,input().split())
if a<0 or a>9:
print(-1)
elif b<0 or b>9:
print(-1)
else:
print(a*b)
|
a, b = map(int, input().split())
if a > 0 and a < 10:
if b > 0 and b < 10:
print(a * b)
else:
print(-1)
else:
print(-1)
| 1 | 158,709,264,922,310 | null | 286 | 286 |
N=input()
N=float(N)
import math
X=math.ceil(N/1.08)
if int(X*1.08)==N:
print(X)
else:
print(':(')
|
N=int(input())
import math
X=math.ceil(N/1.08)
if int(X*1.08)==N:
print(X)
else:
print(':(')
| 1 | 126,137,130,595,090 | null | 265 | 265 |
n = int(input())
l = [0 for _ in range(10**4)]
def fib(n):
if n==0:
l[0]=1
return 1
if n==1:
l[1]=1
return 1
if l[n]!=0:
return l[n]
else:
l[n]=fib(n-1)+fib(n-2)
return fib(n-1)+fib(n-2)
print(fib(n))
|
a, b = 1, 1
for i in range(int(input())):
a, b = b, a + b
print(a)
| 1 | 1,844,646,048 | null | 7 | 7 |
# coding: utf-8
def toAdd(a, b):
return int(a) + int(b)
def toSubtract(a, b):
return int(a) - int(b)
def toMultiply(a, b):
return int(a) * int(b)
def toDivide(a, b):
return int(int(a) / int(b))
operations = {
"+": toAdd,
"-": toSubtract,
"*": toMultiply,
"/": toDivide
}
while True:
valueA, operation, valueB = input().split(" ")
if operation == "?":
break
function = operations[operation]
print("{0}".format(int(function(valueA, valueB))))
|
while True:
t = input()
if t.find("?") > 0:
break
print(int(eval(t)))
| 1 | 688,455,660,288 | null | 47 | 47 |
l =int(input())
s =input()
r = s.count("R")
g = s.count("G")
b = s.count("B")
A = r * g * b
B = 0
gapmax = (l - 3) // 2
for _ in range(gapmax+1):
for i in range(l-2-2*_):
c1, c2, c3 = s[i], s[i+1+_],s[i+2+2*_]
if not (c1 == c2) and not (c1 == c3) and not (c2 ==c3):
B += 1
print(A-B)
|
from collections import defaultdict
n,k = map(int,input().split())
a = list(map(int,input().split()))
for i in range(n):
a[i] -= 1
a[i] %= k
S = [0]
for i in range(n):
S.append((S[-1]+a[i])%k)
ans = 0
dic = defaultdict(int)
dic[0] = 1
for i in range(1,n+1):
if i >= k:
dic[S[i-k]] -= 1
ans += max(0,dic[S[i]])
dic[(S[i])] += 1
print(ans)
| 0 | null | 86,778,012,678,230 | 175 | 273 |
N = int(input())
A = list(map(int, input().split()))
M = 0
S = 0
for a in A:
if M < a:
M = a
if a < M:
S += M - a
print(S)
|
n = int(input())
graph = {}
for _ in range(n):
i = list(map(int,input().split()))
graph[i[0]] = i[2:]
first = {i:0 for i in range(1,n+1)}
last = {i:0 for i in range(1,n+1)}
seen = set()
time = 1
def dfs(v):
global time
seen.add(v)
first[v] = time
time += 1
for nxt in graph[v]:
if nxt in seen:
continue
dfs(nxt)
last[v] = time
time += 1
for i in range(1,n+1):
if i not in seen:
dfs(i)
for i in range(1,n+1):
print(i, first[i], last[i])
| 0 | null | 2,317,845,111,552 | 88 | 8 |
ab = [int(x) for x in input().split()]
a, b = ab[0], ab[1]
print(a // b)
print(a % b)
print("{0:f}".format(a / b))
|
S = input()
a = ['x']*len(S)
print(''.join(a))
| 0 | null | 36,787,878,747,928 | 45 | 221 |
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()
|
import sys
input = sys.stdin.readline
def main():
K = int(input())
t = 7
t %= K
for i in range(K+1):
if t == 0:
print(i+1)
break
t = (t * 10 + 7) % K
else:
print(-1)
main()
| 0 | null | 11,462,514,097,958 | 136 | 97 |
import sys
n=int(input())
data=list(map(int,input().split()))
for i in data:
if i%2==1:
continue
if i%3!=0 and i%5!=0:
print("DENIED")
sys.exit()
print("APPROVED")
|
N = input()
A = list(map(int, input().split()))
print('APPROVED' if all(a & 1 or a % 3 == 0 or a % 5 == 0 for a in A) else 'DENIED')
| 1 | 68,900,623,213,490 | null | 217 | 217 |
import bisect
N = int(input())
L = sorted(map(int, input().split(' ')))
ans = 0
for i in range(len(L)):
for j in range(i + 1, len(L)):
a = L[i]
b = L[j]
ans += max(0, bisect.bisect_right(L, a + b - 1) - (j + 1))
print(ans)
|
n = int(input())
L = list(map(int, input().split()))
L.sort()
#print(L)
import bisect
ans = 0
for i in range(n-2):
for j in range(i+1, n-1):
k = bisect.bisect_left(L, L[i]+L[j])
#print(i, j, k)
ans += max(0, k-j-1)
print(ans)
| 1 | 172,110,814,530,678 | null | 294 | 294 |
a,b,c=map(int,input().split())
k=int(input())
for i in range(1,k+1):
if a>=b>=c or a>=c>=b:
c=c*2
elif b>=a>=c or b>=c>=a:
c=c*2
elif c>=b>a:
c=c*2
elif c>b==a:
b=b*2
elif c>a>=b:
b=b*2
if c>b>a:
print('Yes')
else:
print('No')
|
a,b,c=map(int,input().split())
k=int(input())
while a>=b:
k-=1
b*=2
if k>=0:
print('Yes' if c*(2**k)>b else 'No')
else:
print('No')
| 1 | 6,870,882,074,780 | null | 101 | 101 |
n = int(input())
tenant = [
[ [0]*10, [0]*10, [0]*10, ],
[ [0]*10, [0]*10, [0]*10, ],
[ [0]*10, [0]*10, [0]*10, ],
[ [0]*10, [0]*10, [0]*10, ]
]
for i in range(n):
b,f,r,nu = map(int, input().split())
tenant[b-1][f-1][r-1] += nu
for b in range(4):
for f in range(3):
print(' ', end='')
print(' '.join(map(str,tenant[b][f])))
if b < 3:
print('#'*20)
|
# ??¬????????±
room = [[[0 for a in range(10)] for b in range(3)] for c in range(4)]
n = int(input())
for cnt0 in range(n):
# ?????°??????????????????
a,b,c,d = map(int,input().split())
room[a-1][b-1][c-1]+=d
# ???????????±??????
for cnt1 in range(4):
for cnt2 in range(3):
for cnt3 in range(10):
# OutputPrit
print(" "+str(room[cnt1][cnt2][cnt3]),end="")
# ??????
print ()
if cnt1<3:
# ????£???????####################(20??????#)?????????
print("#"*20)
| 1 | 1,084,338,244,980 | null | 55 | 55 |
a,b,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
ans=10**6
for i in range(m):
x,y,c=map(int,input().split())
ans=min(ans,a[x-1]+b[y-1]-c)
print(min(ans,min(a)+min(b)))
|
N,M=map(int, input().split())
A=[list(map(int, input().split())) for _ in range(M)]
A = sorted(A, reverse=False, key=lambda x: x[0])
if M==0:
if N==3:
print(100)
exit(0)
elif N==2:
print(10)
exit(0)
elif N==1:
print(0)
exit(0)
if N!=1 and A[0][0]==1 and A[0][1]==0:
print(-1)
exit(0)
i=1
j=len(A)
while i<j:
if A[i][0]==A[i-1][0] and A[i][1]==A[i-1][1]:
A.pop(i)
j-=1
continue
elif A[i][0]==A[i-1][0] and A[i][1]!=A[i-1][1]:
print(-1)
exit(0)
i+=1
ans=[None]*N
for i,j in A:
ans[i-1]=j
for i in range(len(ans)):
if ans[i]==None:
if i==0:
ans[i]=1
else:
ans[i]=0
print(''.join(map(str,ans)))
| 0 | null | 57,288,221,232,176 | 200 | 208 |
k = int(input())
s = input()
if len(s)>k:
print('{}...'.format(s[:k]))
else:
print(s)
|
n,m = map(int,input().split())
ans_list = [False for _ in range(n+1)]
pe_list = [0 for _ in range(n+1)]
ac=0
pe=0
for _ in range(m):
p,s = input().split()
if not ans_list[int(p)]:
if s == 'AC':
ac+=1
pe+=pe_list[int(p)]
ans_list[int(p)]=True
else:
pe_list[int(p)]+=1
print(ac,pe)
| 0 | null | 56,560,872,429,780 | 143 | 240 |
n = int(input())
s = input()
q = int(input())
class SegmentTree:
def __init__(self, a, func=max, one=-10 ** 18):
self.logn = (len(a) - 1).bit_length()
self.n = 1 << self.logn
self.func = func
self.one = one
self.b = [self.one] * (2 * self.n - 1)
for i, j in enumerate(a):
self.b[i + self.n - 1] = j
for i in reversed(range(self.n - 1)):
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
self.ll = []
self.rr = []
i = self.n
for _ in range(self.logn+1):
for j in range(0, self.n, i):
self.ll.append(j)
self.rr.append(j + i)
i //= 2
def get_item(self, i):
return self.b[i + self.n - 1]
def update(self, index, x):
i = index + self.n - 1
self.b[i] = x
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def update_func(self, index, x):
i = index + self.n - 1
self.b[i] = self.func(self.b[i], x)
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def get_segment(self, l, r, i=0):
ll = self.ll[i]
rr = self.rr[i]
if l <= ll and rr <= r:
return self.b[i]
elif rr <= l or r <= ll:
return self.one
else:
return self.func(self.get_segment(l, r, i * 2 + 1),
self.get_segment(l, r, i * 2 + 2))
def get_int(s):
abc = "abcdefghijklmnopqrstuvwxyz"
return 1 << abc.index(s)
seg = SegmentTree([get_int(i) for i in s], int.__or__, 0)
for _ in range(q):
q, i, j = input().split()
if q == "1":
seg.update(int(i) - 1, get_int(j))
else:
aa = seg.get_segment(int(i) - 1, int(j))
ans = 0
for i in range(26):
if (aa >> i) & 1 == 1:
ans += 1
print(ans)
|
from bisect import bisect_left,bisect_right
TO_ACII = 97
N = int(input())
S = ["0"] + list(input())
Q = int(input())
ABC = [[]for i in range(0,26,1)]#該当文字a:0 b:1 ...z:26 が何文字目に出てきたかを保持する配列
for i in range(1,N+1,1):
ABC[ord(S[i])-TO_ACII].append(i)
ans = []
for i in range(0,Q,1):
q = list(input().split())
if q[0]=="1":#文字変更
changed = S[int(q[1])]
ABC[ord(changed)-TO_ACII].pop(bisect_left(ABC[ord(changed)-TO_ACII],int(q[1])))
ABC[ord(q[2])-TO_ACII].insert(bisect_left(ABC[ord(q[2])-TO_ACII],int(q[1])),int(q[1]))
S[int(q[1])]=q[2]
else:
tmpans = 0
for i in range(0,26,1):
if bisect_right(ABC[i],int(q[1])-1)<len(ABC[i]) and int(q[2]) >= ABC[i][bisect_right(ABC[i],int(q[1])-1)]:
tmpans+=1
ans.append(tmpans)
for i in range(0,len(ans),1):
print(ans[i])
| 1 | 62,342,428,232,526 | null | 210 | 210 |
#ALDS1_3-A Elementary data structures - Stack
A=input().split()
while(len(A)>1):
for i in range(len(A)):
if(A[i]=="+"):
A[i]=int(A[i-2])+int(A[i-1])
A=A[:i-2]+A[i:]
break
elif(A[i]=="-"):
A[i]=int(A[i-2])-int(A[i-1])
A=A[:i-2]+A[i:]
break
elif(A[i]=="*"):
A[i]=int(A[i-2])*int(A[i-1])
A=A[:i-2]+A[i:]
break
print(A[0])
|
N = int(input())
cnt = 0
for _ in range(N):
d1, d2 = map(int, input().split())
if d1 == d2:
cnt += 1
else:
cnt = 0
if cnt == 3:
print("Yes")
break
else:
print("No")
| 0 | null | 1,265,551,038,880 | 18 | 72 |
import sys
#import time
#from collections import deque, Counter, defaultdict
#from fractions import gcd
import bisect
#import heapq
#import math
import itertools
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**18
MOD = 1000000007
ri = lambda : int(input())
rs = lambda : input().strip()
rl = lambda : list(map(int, input().split()))
n = ri()
ans=0
for i in range(1,n+1):
ans+=(n//i)*(n//i+1)*i//2
print(ans)
|
n = int(input())
ans = 0
for i in range(1, n + 1):
for j in range(1, n//i + 1):
if i * j <= n:
ans += i * j
else:
break
print(ans)
| 1 | 11,066,054,150,588 | null | 118 | 118 |
[H, N] = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
a = sum(A)
if H > a:
print('No')
else:
print('Yes')
|
n,u,v = map(int,input().split())
lis = [list(map(int,input().split())) for i in range(n-1)]
graph = [[] for _ in range(n+1)]
for a,b in lis:
graph[a].append(b)
graph[b].append(a)
def dfs(v):
dist = [-1] * (n+1)
stack = [v]
dist[v] = 0
while stack:
v = stack.pop()
dw = dist[v] + 1
for w in graph[v]:
if dist[w] >= 0:
continue
dist[w] = dw
stack.append(w)
return dist
takahashi = dfs(u)
aoki = dfs(v)
ans = 0
for i in range(1,n+1):
if takahashi[i] < aoki[i]:
ans = max(ans,aoki[i]-1)
print(ans)
| 0 | null | 98,167,398,457,560 | 226 | 259 |
X = int(input())
i = 1
while i <= 360:
if i * X % 360 == 0:
print(i)
break
else:
i += 1
|
import numpy;x=int(input());print(numpy.lcm(360,x)//x)
| 1 | 13,202,587,389,030 | null | 125 | 125 |
def call(n):
s = ""
for x in range(1, n + 1):
y = x
if y % 3 == 0:
s = s + " " + str(x)
else:
while y != 0:
if y % 10 == 3:
s = s + " " + str(x)
break
y = int(y / 10)
return s
n = int(input())
print(call(n))
|
while True:
h,w = map(int, input().split())
if h == 0 and w == 0:
break
else:
for i in range(h):
l = "#"*w
print(l)
print()
| 0 | null | 866,023,937,152 | 52 | 49 |
N = int(input())
L = sorted([int(i) for i in input().split()])
count = 0
from bisect import bisect_left as bi
for j in range(N):
for k in range(j + 1,N - 1):
right = L[j] + L[k]
ite_right = bi(L,right)
count = count + (ite_right - k - 1)
print(count)
|
#それゆけにぶたんまん
#python3.8.2のTLEの壁に阻まれました
n = int(input())
l = sorted(list(map(int,input().split())))
ans = 0
for i in range(n):
for j in range(i+1,n):
#jより大きい整数kでl[k]<l[i]+l[j]を満たす最大のk
le = j
ri = n
while ri-le>1:
m = (ri+le)//2
if l[m]<l[i]+l[j]:
le = m
else:
ri = m
ans += le-j
print(ans)
| 1 | 172,379,707,171,220 | null | 294 | 294 |
while True:
inputs = input().split(' ')
a = int(inputs[0])
op = inputs[1]
b = int(inputs[2])
if op == "?":
break
elif op == "+": # (和)
print(a + b)
elif op == "-": # (差)
print(a - b)
elif op == "*": #(積)
print(a * b)
else: # "/"(商)
print(a // b)
|
while 1 :
a,op,b=raw_input().split()
ai=int(a)
bi=int(b)
if op=='?':break
elif op=='+':print ai+bi
elif op=='-':print ai-bi
elif op=='*':print ai*bi
elif op=='/':print ai/bi
| 1 | 674,456,190,272 | null | 47 | 47 |
a, b, c = map(int, input().split())
x = c - b - a
if x > 0 and a * b * 4 < x * x:
print("Yes")
else:
print("No")
|
from decimal import Decimal
a,b,c = input().split()
if Decimal(a).sqrt()+Decimal(b).sqrt()<Decimal(c).sqrt():
print('Yes')
else:
print('No')
| 1 | 51,719,283,936,362 | null | 197 | 197 |
x1,x2,x3,x4,x5,x6 = map(int,(input().split()))
n = int(input())
T=[]
for k in range(n):
i,j = map(int, (input().split()))
T.append([i,j])
L=[x1,x2,x3,x4,x5,x6]
for k in T:
while L[0] != k[0]:
L = [L[4], L[0], L[2], L[3], L[5], L[1]]
if L[0] == k[0]:
pass
else:
L = [L[3], L[1], L[0], L[5], L[4], L[2]]
while L[1] != k[1]:
L = [L[0], L[3], L[1], L[4], L[2], L[5]]
if L[1] == k[1]:
pass
else:
L = [L[0], L[3], L[1], L[4], L[2], L[5]]
print(L[2])
|
a, b = list(map(int, input().split(' ')))
print(a * b if a < 10 and b < 10 else -1)
| 0 | null | 79,174,144,427,800 | 34 | 286 |
print(list(map(int,input().split())).index(0) + 1)
|
def main():
a = list(map(int,input().split()))
ans = 0
for i in range(5):
ans += a[i]
print(15 - ans)
main()
| 1 | 13,453,319,331,748 | null | 126 | 126 |
import sys
input = lambda: sys.stdin.readline().rstrip()
def main():
D = int(input())
c = [0] + list(map(int, input().split()))
s = [[0]*27]
t = [0]
satisfy = 0
last = [0] * 27
for _ in range(D):
s.append([0] + list(map(int, input().split())))
for _ in range(D):
t += [int(input())]
for i in range(1, D+1):
decrease = 0
last[t[i]] = i
for j in range(1, 27):
decrease += (c[j] * (i - last[j]))
satisfy += (s[i][t[i]] - decrease)
print(satisfy)
if __name__ == '__main__':
main()
|
data = input().split()
print(int(data[0])*int(data[1]))
| 0 | null | 12,773,634,369,720 | 114 | 133 |
N = int(input())
ans = 0
wnasi = []
for i in range(1, int(pow(N - 1, 0.5)) + 1):
if (N - 1) % i == 0:
wnasi.append(i)
if i != (N - 1) // i:
wnasi.append((N - 1) // i)
ans += len(wnasi) - 1
wari = []
for i in range(2, int(pow(N, 0.5)) + 1):
if N % i == 0:
wari.append(i)
if i != N // i:
wari.append(N // i)
for i in wari:
if i == 1:
continue
tmpN = N
while True:
if tmpN % i == 0:
tmpN //= i
else:
if tmpN % i == 1:
ans += 1
break
print(ans + 1)
|
#!/usr/bin/env python3
x = int(input())
print(10 - (x // 200))
| 0 | null | 23,874,881,033,600 | 183 | 100 |
n,m,k = map(int,input().split())
a_list = list(map(int,input().split()))
b_list = list(map(int,input().split()))
a_sum = [0]
b_sum = [0]
for i in range(n):
a_sum.append(a_sum[i] + a_list[i])
for i in range(m):
b_sum.append(b_sum[i] + b_list[i])
ans = 0
for i in range(n+1):
if a_sum[i] > k:
break
rem = k - a_sum[i]
while b_sum[m] > rem:
m -= 1
if ans < i + m:
ans = i + m
print(ans)
|
K, X = map(int, input().split())
print('Yes') if 500 * K >= X else print('No')
| 0 | null | 54,711,997,812,670 | 117 | 244 |
N,M=map(int,input().split())
par=[i for i in range(N+1)]
size=[1 for i in range(N+1)]
def find(x):
if x!=par[x]:
par[x]=find(par[x])
return par[x]
def union(x,y):
if find(x)!=find(y):
x, y = par[x], par[y]
par[y] = par[x]
size[x] += size[y]
res=N
for i in range(M):
s,e=map(int,input().split())
union(s,e)
print(max(size))
|
n,k = map(int,input().split())
h = [int(s) for s in input().split()]
h.sort(key=int)
for _ in range(min(k,len(h))):del h[-1]
print(sum(h))
| 0 | null | 41,442,522,374,700 | 84 | 227 |
n = int(input())
i = 1
ret = ""
while True:
x = i
if x % 3 == 0:
ret += " " + str(i)
elif x % 10 == 3:
ret += " " + str(i)
else:
x //= 10
while x != 0:
if x % 10 == 3:
ret += " " + str(i)
break
x //= 10
i+=1
if i > n:
break
print(ret)
|
L = int(input())
a = float(L/3)
b = float(L/3)
c = float(L / 3)
print(a * b * c)
| 0 | null | 23,803,917,790,168 | 52 | 191 |
n, m = input().split()
a = list(map(int, input().split()))
s = 0
for i in a:
s += int(i)
if int(s) <= int(n):
print(int(n) - int(s))
else:
print("-1")
|
# 回答を読んで作成
# 全体の半分に到達可能、ただし１行もしくは１列の時は動けない
h,w = map(int, input().split())
if h==1 or w==1:
ans = 1
else:
ch = (h*w)/2
ans = (ch//1)+((h*w)%2)
print(int(ans))
| 0 | null | 41,365,710,022,598 | 168 | 196 |
def main():
S = input()
L = len(S)
print('x' * L)
if __name__ == '__main__':
main()
|
s=input()
ans="x"*len(s)
print(ans)
| 1 | 72,819,112,965,312 | null | 221 | 221 |
s=input()
l1=[]
l2=[]
num1=0 #0は反転なし 1はあり
def ap1(str1):
l1.append(str1)
def ap2(str2):
l2.append(str2)
nq=int(input())
for i in range(nq):
q=list(input().split())
if q[0]=="1":
num1=(num1+1)%2
else:
f=int(q[1])
if (num1+f)%2==1: #1で先頭 2で末尾
ap1(q[2])
else:
ap2(q[2])
if num1==0:
ans=""
for i in range(len(l1)):
ans+=l1[-1-i]
ans+=s
for i in range(len(l2)):
ans+=l2[i]
else:
ans=""
for i in range(len(l2)):
ans+=l2[-1-i]
for i in range(len(s)):
ans+=s[-1-i]
for i in range(len(l1)):
ans+=l1[i]
print(ans)
|
import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right #func(リスト,値)
from heapq import heapify, heappop, heappush
from itertools import combinations, permutations, product
from math import *
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x):
self.setdefault(x,0)
self[x] += 1
S = input()
L = deque()
for i in range(len(S)):
L.append(S[i])
Q = int(input())
rev = False
for _ in range(Q):
q = input()
if q[0]=='1':
rev = not rev
else:
_,f,c = q.split()
if rev==(f=='1'):
L.append(c)
else:
L.appendleft(c)
L = list(L)
if rev:
L = L[::-1]
print(''.join(L))
| 1 | 57,159,389,643,340 | null | 204 | 204 |
n, m, k = [int(i) for i in input().split()]
subsets = []
splits = [i for i in range(1, n)]
n -= 1
for i in range(2**n):
x = []
for j in range(n):
if i&(1<<j):
x.append(j)
subsets.append(x)
n+=1
A = []
for i in range(n):
A.append([int(j) for j in input()])
ans = n*m
for subset in subsets:
cur_ans = len(subset)
tmp = []
col = 0
subset.append(100000)
running_sum = [0 for i in range(len(subset))]
while col<m:
row_ptr = 0
for row in range(n):
if row > subset[row_ptr]:
row_ptr += 1
running_sum[row_ptr] += A[row][col]
if running_sum[row_ptr] > k:
col -= 1
running_sum = [0 for i in range(len(subset))]
cur_ans += 1
break
col += 1
if cur_ans >= ans:
break
ans = min(ans, cur_ans)
print(ans)
|
import itertools
H,W,K = map(int,input().split())
S = []
for i in range(H):
s= map(int,input())
S.append(list(s))
l = list(itertools.product([0,1], repeat=H-1))
l = [list(li) for li in l]
for i in range(len(l)):
l[i] = [j+1 for j in range(len(l[i])) if l[i][j] > 0]
S_t = [list(x) for x in zip(*S)]
for i in range(W):
for j in range(1,H):
S_t[i][j] += S_t[i][j-1]
flag = False
min_cnt = H*W
for i in range(len(l)):
cnt = 0
bh = [0]+[li for li in l[i] if li > 0]+[H]
white = [0]*(len(bh)-2+1)
j = 0
while j < W:
if flag == True:
white = [0]*(len(bh)-2+1)
cnt += 1
flag = False
for k in range(len(bh)-1):
if bh[k] == 0:
su = S_t[j][bh[k+1]-1]
else:
su = S_t[j][bh[k+1]-1]-S_t[j][max(0,bh[k]-1)]
if white[k] + su > K:
if su > K:
j = W
cnt = H*W+1
flag = False
else:
flag = True
break
white[k] += su
if flag == False:
j += 1
min_cnt = min(cnt+len(bh)-2,min_cnt)
print(min_cnt)
| 1 | 48,470,925,096,772 | null | 193 | 193 |
# -*- coding: utf-8 -*-
import sys
import os
lst = input().split()
stack = []
for c in lst:
if c == '+':
a = stack.pop()
b = stack.pop()
stack.append(b + a)
elif c == '-':
a = stack.pop()
b = stack.pop()
stack.append(b - a)
elif c == '*':
a = stack.pop()
b = stack.pop()
stack.append(b * a)
else:
stack.append(int(c))
print(stack[0])
|
import operator
func = {'+':operator.add, '-':operator.sub, '*':operator.mul}
stack = []
for symbol in input().split():
if symbol.isdigit():
stack.append(int(symbol))
else:
a = stack.pop()
b = stack.pop()
stack.append(func[symbol](b, a))
print(stack[0])
| 1 | 37,940,171,262 | null | 18 | 18 |
n = int( raw_input( ) )
t = [ int( val ) for val in raw_input( ).rstrip( ).split( " " ) ]
q = int( raw_input( ) )
s = [ int( val ) for val in raw_input( ).split( " " ) ]
cnt = 0
for si in s:
for ti in t:
if si == ti:
cnt += 1
break
print( cnt )
|
def linearSearch(A, key):
i = 0
A.append(key)
while A[i] != key:
i += 1
if i == len(A)-1:
A.pop()
return 'Not_found'
A.pop()
return i
if __name__ == '__main__':
c = 0
n = int(input())
hoge1 = [int(x) for x in input().split()]
q = int(input())
for key in (int(x) for x in input().split()):
if linearSearch(hoge1, key) == 'Not_found':
continue
else:
c += 1
print (c)
| 1 | 68,784,962,260 | null | 22 | 22 |
x, y = map(int, input().split())
ans = 'No'
for i in range(x + 1):
j = x - i
if i * 2 + j * 4 == y:
ans = 'Yes'
break
print(ans)
|
X, Y = [int(arg) for arg in input().split()]
def f(X, Y):
for i in range(X + 1):
for j in range(X + 1):
kame = i
tsuru = j
if kame + tsuru == X and kame * 4 + tsuru * 2 == Y:
return 'Yes'
return 'No'
print(f(X, Y))
| 1 | 13,745,150,604,900 | null | 127 | 127 |
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
a,b = nm()
if a<10 and b<10:
print(a*b)
exit()
print(-1)
|
import os, sys, re, math
N = int(input())
D = [int(n) for n in input().split()]
value = 0
for i in range(len(D) - 1):
for j in range(i + 1, len(D)):
value += D[i] * D[j]
print(value)
| 0 | null | 163,143,726,844,640 | 286 | 292 |
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)
|
def e_bomber():
import sys
input = sys.stdin.readline
H, W, M = [int(i) for i in input().split()]
bomb_row = [0] * H
bomb_col = [0] * W
bomb_pos = set()
for _ in range(M):
r, c = [int(i) - 1 for i in input().split()]
bomb_row[r] += 1
bomb_col[c] += 1
bomb_pos.add((r, c))
bomb_row_max = max(bomb_row)
bomb_col_max = max(bomb_col)
row_index_list = [r for r, v in enumerate(bomb_row) if v == bomb_row_max]
col_index_list = [c for c, v in enumerate(bomb_col) if v == bomb_col_max]
# 破壊できる数が最大になるような行と列の組を全探索する。
# (行, 列) が破壊対象の上になってしまわないような組があれば、そこに置けばいい。
# そのような組がまったくなければ、破壊対象の上に置かざるを得ない (-1 される)。
for row in row_index_list:
for col in col_index_list:
if (row, col) not in bomb_pos:
return bomb_row_max + bomb_col_max
return bomb_row_max + bomb_col_max - 1
print(e_bomber())
| 0 | null | 3,526,734,450,322 | 70 | 89 |
N = int(input())
sum = 0
for i in range(1,N+1):
if i % 3 == 0 and i % 5 == 0:
i = ["FizzBuzz"]
elif i % 3 == 0:
i = ["Fizz"]
elif i % 5 == 0:
i = ["Buzz"]
# if i % 3 == 0 and i % 5 == 0:
else:
sum += i
print(sum)
|
n = int(input())
ans = 0
for i in range(1,n+1):
if i % 3 == 0 and i % 5 == 0:
ans += 0
elif i % 3 == 0 or i % 5 == 0:
ans += 0
else:
ans += i
print(ans)
| 1 | 34,778,371,838,440 | null | 173 | 173 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools, bisect
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def S(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007
def main():
N = I()
A = LI()
def lcm(a, b): return a * b // math.gcd(a, b)
l = reduce(lcm, A, 1) % MOD
ans = 0
for ai in A:
ans = (ans + l * pow(ai, MOD - 2, MOD)) % MOD
print(ans)
if __name__ == '__main__':
main()
|
"""
最小公倍数LCMを求めて、LCMを各Aで除した商を合計すればよい
"""
from math import gcd
def lcm(a,b):
return a*b//gcd(a,b)
def main():
mod = 10**9 +7
N = int(input())
A = list(map(int,input().split()))
l = A[0]
for i in range(1,N):
l = lcm(l,A[i])
ans = 0
for a in A:
ans += l//a
print(ans%mod)
main()
| 1 | 87,940,524,061,118 | null | 235 | 235 |
mod=10**9+7
N=int(input())
A=list(map(int,input().split()))
B=[0]
for x in A:
B.append(B[-1]+x)
ans=0
for i in range(N):
s=(B[N]-B[i+1])%mod
ans+=A[i]*s
ans%=mod
print(ans)
|
N = int(input())
As = list(map(int, input().split()))
sum = 0
for i in range(N):
sum += As[i]
sum %= 10**9+7
ans = 0
for i in range(N):
sum -= As[i]
ans += As[i]*sum
ans %= 10**9+7
print(ans)
| 1 | 3,797,757,179,132 | null | 83 | 83 |
x = input()
for i in range(int(input())):
o = input().split()
a,b = map(int,o[1:3])
b+=1
t = o[0][2]
if t == 'i':
print(x[a:b])
elif t =='p':
x = x[:a] + o[3] + x[b:]
else:
x = x[:a] + x[a:b][::-1] + x[b:]
|
s = list(input())
n = int(input())
for i in range(n):
d = input().split(" ")
if d[0] == "replace":
a = int(d[1])
b = int(d[2])
c = list(d[3])
k = 0
for j in range(a, b+1):
s[j] = c[k]
k += 1
elif d[0] == "reverse":
a = int(d[1])
b = int(d[2])
c = list(s)
k = b
for j in range(a, b+1):
s[j] = c[k]
k -= 1
else:
a = int(d[1])
b = int(d[2])
for j in range(a, b+1):
print(s[j],end="")
print("")
| 1 | 2,089,911,680,010 | null | 68 | 68 |
def main():
a, b, c = map(int, input().split())
if (a + b + c) >= 22:
print("bust")
else:
print("win")
main()
|
#!/usr/bin/env pypy3
import collections
import itertools as it
import math
#import numpy as np
# = input()
# = int(input())
a1, a2, a3 = map(int, input().split())
# = list(map(int, input().split()))
# = [int(input()) for i in range(N)]
#
# c = collections.Counter()
print('bust' if a1 + a2 + a3 >= 22 else 'win')
| 1 | 118,738,422,821,060 | null | 260 | 260 |
N,K = map(int,input().split())
A = list(map(int,input().split()))
A.insert(0,0)
for i in range(K+1,N+1):
if A[i]>A[i-K]:
print("Yes")
else:
print("No")
|
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10 ** 9)
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
INF=float('inf')
N,M=MAP()
C=LIST()
dp=[INF]*(N+1)
dp[0]=0
for i in range(N):
for j in range(M):
if i+C[j]<=N:
dp[i+C[j]]=min(dp[i+C[j]], dp[i]+1)
print(dp[N])
| 0 | null | 3,611,466,479,890 | 102 | 28 |
H, N = map(int,input().split())
X = [list(map(int, input().split())) for i in range(N)]
X = sorted(X, key = lambda x:x[0])
DP = [float("inf")]*(H+X[-1][0]+X[-1][0])
DP[X[-1][0]-1] = 0
for i in range(X[-1][0], H+2*X[-1][0]):
min = float("inf")
for j in range(N):
if min > DP[i-X[j][0]]+X[j][1]:
min = DP[i-X[j][0]]+X[j][1]
DP[i] = min
kouho = DP[H+X[-1][0]-1]
for i in range(X[-1][0]):
if kouho > DP[H+X[-1][0]+i]:
kouho = DP[H+X[-1][0]+i]
print(kouho)
|
# -*- coding: utf-8 -*-
from collections import deque
if __name__ == '__main__':
n = int(input())
L = deque()
for _ in range(n):
command = input().split(" ")
if command[0] == "insert":
L.appendleft(command[1])
elif command[0] == "delete":
try:
L.remove(command[1])
except:
pass
elif command[0] == "deleteFirst":
L.popleft()
elif command[0] == "deleteLast":
L.pop()
print(" ".join(L))
| 0 | null | 40,437,302,392,512 | 229 | 20 |
k = int(input())
value = 7
for i in range(1, 10 ** 6):
if value % k == 0:
print(i)
exit()
value = (value * 10 + 7) % k
print(-1)
|
k=int(input())
k *= 9
amari = 63
for i in range(1, 10 ** 6 + 1):
amari %= k
if amari == 0:
print(i)
break
else:
amari = amari * 10 + 63
else:
print(-1)
| 1 | 6,046,313,321,422 | null | 97 | 97 |
N = int(input())
N1 = N % 10
if N1 == 3:
print("bon")
elif (N1 == 0) or (N1 == 1) or (N1 == 6) or (N1 == 8):
print("pon")
else:
print("hon")
|
import random
name = input()
name_lenght = len(name)
start = random.randint(0, name_lenght - 3)
end = start + 3
print(name[start:end])
| 0 | null | 17,069,619,387,324 | 142 | 130 |
tmp = input()
tmp = tmp.split(" ")
tmp = list(map(int,tmp))
if tmp[0] < tmp[1] and tmp[1] < tmp[2]:
print("Yes")
else :
print("No")
|
x, y, z = map(int,raw_input().split())
if(x<y and y<z):
print "Yes"
else:
print "No"
| 1 | 391,357,834,802 | null | 39 | 39 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.