input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
A, B, C, D, E, F = list(map(int, input().split()))
ans = [100 * A, 0]
c = 0
for i in range(1, F // (100 * A) + 1):
for j in range((F - 100 * A * i) // (100 * B) + 1):
a = 100 * A * i + 100 * B * j
for k in range((F - a) // C + 1):
for l in range((F - a - C * k) // D + 1):
... | A, B, C, D, E, F = list(map(int, input().split()))
water = set([])
for i in range(1, F // (100 * A) + 1):
water1 = i * 100 * A
for j in range((F - water1) // (100 * B) + 1):
water2 = j * 100 * B
water.add(water1 + water2)
ans = [100 * A, 0]
c = 0
for i in water:
max_sugar = m... | p03599 |
A, B, C, D, E, F = list(map(int, input().split()))
water = set([])
for i in range(1, F // (100 * A) + 1):
water1 = i * 100 * A
for j in range((F - water1) // (100 * B) + 1):
water2 = j * 100 * B
water.add(water1 + water2)
ans = [100 * A, 0]
c = 0
for i in water:
max_sugar = m... | A, B, C, D, E, F = list(map(int, input().split()))
water = set([])
for i in range(1, F // (100 * A) + 1):
water1 = i * 100 * A
for j in range((F - water1) // (100 * B) + 1):
water2 = j * 100 * B
water.add(water1 + water2)
ans = [100 * A, 0]
c = 0
for i in water:
max_sugar = m... | p03599 |
import sys
import math
cadena = list()
sub = list()
sub2 =list()
s =""" Since <fontstyle="vertical−align:inherit;"><fontstyle="vertical−align:inherit;">1+2=3<⁄font><⁄font>, the output should be <fontstyle="vertical−align:inherit;"><fontstyle="vertical−align:inherit;">3<⁄font><⁄font>."""
salida = """<fontstyle="v... | s = input().split()
if s[1] == "-":
print((int(s[0])-int(s[2])))
if s[1] == "+":
print((int(s[0])+int(s[2]))) | p03844 |
a, op, b = input().split()
a, b = int(a), int(b)
if op == '+':
print((a + b))
else:
print((a - b))
| print((eval(input()))) | p03844 |
l = input().split()
print((int(l[0]) + int(l[2]) if l[1] == '+' else int(l[0]) - int(l[2])))
| print((eval(input()))) | p03844 |
print((eval(input()))) | a,b,c=input().split()
if b=="-":
print((int(a)-int(c)))
else:
print((int(a)+int(c)))
| p03844 |
val = input().split()
if val[1] == "+":
print((int(val[0])+int(val[2])))
else:
print((int(val[0]) - int(val[2])))
| print((eval(input()))) | p03844 |
def main():
A, op, B = input().split()
A = int(A)
B = int(B)
if op == "+":
print((A + B))
else:
print((A - B))
if __name__ == "__main__":
main() | print((eval(input()))) | p03844 |
print((eval(''.join(input().split())))) | print((eval(input()))) | p03844 |
S = input().split()
a, b = int(S[0]), int(S[2])
if S[1] == '+':
print((a + b))
else:
print((a - b))
| print((eval(input()))) | p03844 |
print((eval(input().replace(' ','')))) | print((eval(input()))) | p03844 |
a = input().split()
if a[1] == '+':
ans = int(a[0]) + int(a[2])
else:
ans = int(a[0]) - int(a[2])
print(ans)
| print((eval(input()))) | p03844 |
'''
ABC050 A - Addition and Subtraction Easy
https://atcoder.jp/contests/abc050/tasks/abc050_a
'''
a, op, b = input().split()
a, b = int(a), int(b)
if op == '+':
ans = a+b
elif op == '-':
ans = a-b
print(ans)
| '''
ABC050 A - Addition and Subtraction Easy
https://atcoder.jp/contests/abc050/tasks/abc050_a
'''
def main():
a, op, b = input().split()
a, b = int(a), int(b)
if op == '+':
ans = a+b
elif op == '-':
ans = a-b
print(ans)
if __name__ == '__main__':
main()
| p03844 |
A, op, B = input().split()
print((int(A) + int(B) if op == '+' else int(A) - int(B))) | A, op, B = input().split()
A = int(A); B = int(B)
print((A + B if op == '+' else A - B)) | p03844 |
import functools
import os
import sys
sys.setrecursionlimit(10000)
INF = float('inf')
def inp():
return int(eval(input()))
def inpf():
return float(eval(input()))
def inps():
return eval(input())
def inl():
return list(map(int, input().split()))
def inlf():
retu... | import functools
import os
import sys
sys.setrecursionlimit(10000)
INF = float('inf')
def inp():
return int(eval(input()))
def inpf():
return float(eval(input()))
def inps():
return eval(input())
def inl():
return list(map(int, input().split()))
def inlf():
retu... | p03844 |
s = list((input().split()))
if s[1] =='+':
ans = int(s[0]) + int(s[2])
elif s[1] =='-':
ans = int(s[0]) - int(s[2])
print(ans) | s = input().split()
if s[1] =='+':
print((int(s[0])+ int(s[2])))
else:
print((int(s[0])- int(s[2]))) | p03844 |
a,o,b=input().split()
a=int(a)
b=int(b)
print(([a+b,a-b][o=="-"])) | print((eval(input()))) | p03844 |
A,op,B=input().split()
if op=="+":
print((int(A)+int(B)))
else:
print((int(A)-int(B))) | A,op,B=input().split()
print((int(A)+int(B)if op=="+" else int(A)-int(B)))
| p03844 |
A,op,B=input().split()
A,B=list(map(int,[A,B]))
print((A+B if op=="+" else A-B)) | print((eval(input()))) | p03844 |
print((eval(input()))) | print(eval(input())) | p03844 |
print(eval(input())) | print((eval(input()))) | p03844 |
a,op,b=[i for i in input().split()]
print((int(a)+int(b) if op=='+' else int(a)-int(b))) | print((eval(input()))) | p03844 |
a, op, b = input().split()
print((eval(a+op+b))) | A, op, B = input().split()
print((int(A) + int(B) if op == '+' else int(A) - int(B))) | p03844 |
class Tree():
def __init__(self, n, edge):
self.n = n
self.tree = [[] for _ in range(n)]
for e in edge:
self.tree[e[0] - 1].append(e[1] - 1)
self.tree[e[1] - 1].append(e[0] - 1)
def setroot(self, root):
self.root = root
self.parent = [No... | class Tree():
def __init__(self, n, edge):
self.n = n
self.tree = [[] for _ in range(n)]
for e in edge:
self.tree[e[0] - 1].append(e[1] - 1)
self.tree[e[1] - 1].append(e[0] - 1)
def setroot(self, root):
self.root = root
self.parent = [No... | p03754 |
import sys
input = sys.stdin.readline
from collections import deque, Counter
N = int(input())
X = [[] for i in range(N)]
L = [0]*N
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
L[x-1] += 1
L[y-1] += 1
P = [-1] * N
Q = deque([0])
R = []
... | import sys
input = sys.stdin.readline
from collections import deque, Counter
N = int(input())
X = [[] for i in range(N)]
L = [0]*N
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
L[x-1] += 1
L[y-1] += 1
P = [-1] * N
Q = deque([0])
R = []
... | p03754 |
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [lis... | #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [lis... | p03754 |
import sys,os,io
input = sys.stdin.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
N = int(input())
edge = [[] for _ in range(N)]
for i in range(N-1):
a,b = map(int, input().split())
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def dfs(start):
stack = [start]
parent = [N]*N
... | import sys,os,io
# input = sys.stdin.readline
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
N = int(input())
edge = [[] for _ in range(N)]
for i in range(N-1):
a,b = map(int, input().split())
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def dfs(start):
stack = [start]
parent = [N]*N
... | p03754 |
import itertools
[n,k] = [int(x) for x in input().split()]
data = [int(x) for x in input().split()]
kumi = list(itertools.combinations(list(range(n)), k))
answer = sum(data)
for comb in kumi:
total = 0
for x in comb:
total += data[x]
if total < answer:
answer = total
pri... | [n,k] = [int(x) for x in input().split()]
data = [int(x) for x in input().split()]
data.sort()
print((sum(data[:k]))) | p02628 |
def main():
N , K = list(map(int, input().split()))
A_list = [A for A in input().split()]
A_list = list(map(int, A_list))
import itertools
p = itertools.permutations(A_list, K)
ans = 100000000000
for val in p :
ans_new = sum(val)
if ans_new < ans :
a... | def main():
N , K = list(map(int, input().split()))
A_list = [A for A in input().split()]
A_list = list(map(int, A_list))
A_list.sort()
#print(A_list)
ans = 0
for i in range(0,K) :
ans = ans + A_list[i]
print(ans)
if __name__ == '__main__':
main() | p02628 |
import sys
N, K = list(map(int, sys.stdin.readline().strip().split()))
P = list(map(int, sys.stdin.readline().strip().split()))
ans = 0
for i, p in enumerate(sorted(P)):
if i == K:
break
ans += p
print(ans) | import sys
N, K = list(map(int, sys.stdin.readline().split()))
P = list(map(int, sys.stdin.readline().split()))
P.sort()
print((sum(P[0:K]))) | p02628 |
l=list(map(int,open(0).read().split()));print((sum(sorted(l[2:])[:l[1]]))) | a,b,*l=list(map(int,open(0).read().split()));print((sum(sorted(l)[:b]))) | p02628 |
import itertools
n,k = list(map(int,input().split()))
p = [int(i) for i in input().split()]
ans = []
combi = list(itertools.combinations(p,k))
for i in range(len(combi)) :
ans.append(sum(combi[i]))
print((min(ans))) | n,k = list(map(int,input().split()))
p = [int(i) for i in input().split()]
p.sort()
s = 0
for i in range(k) :
s += p[i]
print(s) | p02628 |
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
ans=0
for i in range(k):
ans+=a[i]
print(ans) | n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
p.sort()
ans=0
for i in range(k):
ans+=p[i]
print(ans) | p02628 |
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
def bubblesort(l):
for index in range(len(l)-1, 0, -1):
for low in range(index):
if l[low] > l[low+1]:
tmp = l[low+1]
l[low+1] = l[low]
l[low] = tmp
return l
... | N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
#print(p)
sum = 0
for i in range(K):
sum = sum + p[i]
print(sum) | p02628 |
import itertools
n,k=list(map(int,input().split()))
price=list(map(int,input().split()))
n_list=[]
for com in itertools.combinations(price,k):
s=sum(com)
n_list.append(s)
print((min(n_list)))
| N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
print((sum(sorted(p)[:K]))) | p02628 |
import itertools
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
l = [sum(i) for i in itertools.combinations(p, K)]
print((min(l))) | N, K = list(map(int, input().split()))
p = sorted(list(map(int, input().split())))
print((sum(p[:K]))) | p02628 |
N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
ans = 0
for i in range(K):
ans += p[i]
print(ans)
| N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
print((sum(p[: K]))) | p02628 |
# import sys
# input = sys.stdin.readline
# import re
import itertools
def main():
n, k = input_list()
p = input_list()
pp = []
for v in itertools.combinations(p, k):
pp.append(sum(v))
print((min(pp)))
def count_tento(l, cur):
count = 0
for v in l:
if v > ... | # import sys
# input = sys.stdin.readline
# import re
import itertools
def main():
n, k = input_list()
p = input_list()
p.sort()
print((sum(p[:k])))
def count_tento(l, cur):
count = 0
for v in l:
if v > cur:
count += 1
return count
def input_list():... | p02628 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.st... | import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def S(): return sys.stdin.readline().rstrip()
N,K = list(map(int,S().split()))
p = LI()
p = sorted(p)
print((sum(p[i] for i in range(K)))) | p02628 |
#!/usr/bin/env python3
import sys
from itertools import chain
from itertools import combinations as comb
# form bisect import bisect_left, bisect_right, insort_left, insort_right
# from collections import Counter
# import numpy as np
def solve(N: int, K: int, p: "List[int]"):
answer = min(list(map(sum, ... | #!/usr/bin/env python3
import sys
from itertools import chain
# form bisect import bisect_left, bisect_right, insort_left, insort_right
# from collections import Counter
# import numpy as np
def solve(N: int, K: int, p: "List[int]"):
p = sorted(p)
return sum(p[:K])
def main():
tokens = c... | p02628 |
import itertools
total =[]
N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
for i in itertools.combinations(p, K):
total.append(sum(i))
print((min(total)))
| N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
m = []
for i in range(K):
a = min(p)
m.append(a)
p.remove(a)
print((sum(m))) | p02628 |
import itertools
N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = 1000000
for v in itertools.combinations(p, K):
tmp = sum(v)
if ans > tmp:
ans = tmp
print(ans) | N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
ans=0
p.sort()
for i in range(K):
ans += p[i]
print(ans) | p02628 |
import itertools
N, K= list(map(int,input().split()))
p = list(map(int, input().split()))
ans = 1000000
for i in itertools.combinations(p, K):
s = sum(i)
ans = min(ans, s)
print(ans)
| import itertools
N, K= list(map(int,input().split()))
p = list(map(int, input().split()))
p.sort()
ans = sum(p[:K])
print(ans)
| p02628 |
import itertools
n, k = list(map(int, input().split()))
prices = list(map(int, input().split()))
ans = 1000000
for i in itertools.permutations(prices, k):
ans = min(ans, sum(i))
print(ans) | import itertools
n, k = list(map(int, input().split()))
prices = list(map(int, input().split()))
prices = sorted(prices)
print((sum(prices[:k]))) | p02628 |
n,k=list(map(int,input().split()))
t=list(map(int,input().split()))
t.sort()
ans=0
for i in range(k):
ans+=t[i]
print(ans)
| n,k=list(map(int,input().split()))
t=[int(i) for i in input().split()]
t.sort()
print((sum(t[:k]))) | p02628 |
N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
import itertools
c = itertools.combinations(p, K)
L = [sum(item) for item in c]
print((min(L))) | N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
print((sum(p[:K]))) | p02628 |
a = list(map(int, input().split()))
b = list(map(int, input().split()))
count = 0
result = []
while count < a[1]:
result.append(min(b))
b.remove(min(b))
count += 1
print((sum(result))) | n, k = list(map(int,input().split()))
p = list(map(int, input().split()))
ans = 0
for _ in range(k):
m = min(p)
ans += m
p.remove(m)
print(ans) | p02628 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, k = list(map(int, readline().split()))
a = list(map(int, readline().split()))
a.sort()
print((sum(a[:k])))
if __name__ == '__main__':
main()
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ans = sum(a[:k])
print(ans) | p02628 |
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P.sort()
ans = 0
for p in P[:K]:
ans += p
print(ans)
| N, K = list(map(int, input().split()))
P = sorted(list(map(int, input().split())))
print((sum(P[:K]))) | p02628 |
from itertools import product, permutations, combinations
import math
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
ans = math.inf
for pt in combinations(P, K):
ans = min(ans, sum(pt))
print(ans)
exit()
| from itertools import product, permutations, combinations
import math
N, K = list(map(int, input().split()))
P = list(sorted((list(map(int, input().split())))))
print((sum([P[i] for i in range(K)])))
exit()
| p02628 |
import itertools
S = list(map(int, input().strip().split()))
N = S[0]
K = S[1]
p = list(map(int, input().strip().split()))
lists = [1000000000000]
for l in list(itertools.combinations(p, K)):
sums = sum(list(l))
if sums <= min(lists):
lists.append(sums)
print((min(lists)))
| S = list(map(int, input().strip().split()))
N = S[0]
K = S[1]
p = list(map(int, input().strip().split()))
lists = []
for l in range(K):
lists.append(min(p))
p.remove(min(p))
print((sum(lists)))
| p02628 |
import itertools
N,K = list(map(int,input().split()))
plist = list(map(int,input().split()))
minprice = sum(plist)
sumlist =[]
for v in itertools.permutations(plist, K):
sumlist.append(sum(v))
print((min(sumlist))) | N,K = list(map(int,input().split()))
plist = list(map(int,input().split()))
plist.sort()
sum = 0
for i in range(K):
sum+=plist[i]
print (sum) | p02628 |
import itertools
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
Sigmas = []
for M in itertools.combinations(P,K):
Sigma = sum(list(M))
Sigmas.append(Sigma)
print((min(Sigmas)))
| import itertools
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
Sigma = sorted(P,reverse = False)
print((sum(Sigma[:K])))
| p02628 |
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
cheap = []
for m in range(k):
for i in range(len(l)):
flag = False
for j in range(len(l)):
if l[i] > l[j]:
flag = True
break
if flag == False:
cheap.... | n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
l.sort()
cheap = l[:k]
print((sum(cheap))) | p02628 |
n, k = list(map(int, input().split()))
p = sorted(list(map(int, input().split())))
print((sum(p[:k]))) | import sys
input = lambda: sys.stdin.readline().rstrip()
def main():
n, k = list(map(int, input().split()))
p = sorted(list(map(int, input().split())))
print((sum(p[:k])))
if __name__ == '__main__':
main() | p02628 |
N,K=list(map(int,input().split()))
p=sorted(list(map(int,input().split())))
print((sum(p[:K])))
| n,k=list(map(int,input().split()))
p=sorted(list(map(int,input().split())))
print((sum(p[:k])))
| p02628 |
NK = input().split()
n = int(NK[0])
k = int(NK[1])
arr = list(map(int, input().split()))
arr.sort()
print((sum(arr[0:k])))
| n, k = input().split()
p = list(map(int, input().split()))
p = sorted(p)
ans = 0
for i in range(int(k)):
ans += p[i]
print(ans)
| p02628 |
import itertools
n, k = list(map(int, input().split()))
p_list = list(map(int, input().split()))
ans = 1000*1000
for i in itertools.permutations(p_list,k):
ans = min(ans, sum(i))
print(ans) | n, k = list(map(int, input().split()))
p_list = list(map(int, input().split()))
p_list_min = sorted(p_list)
ans = sum(p_list_min[0:k])
print(ans) | p02628 |
n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
i=0
while True:
if len(p)==1:
break
if p[i]<=p[i+1]:
i+=1
else:
a=p[i]
p[i]=p[i+1]
p[i+1]=a
i=0
if i==len(p)-1:
break
ans=0
for i in range(k):
ans+=p[i]
p... | n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
ans=0
if n!=1:
for i in range(k):
min=p[i]
for j in range(i+1,n):
if min>p[j]:
min=p[j]
p[j]=p[i]
p[i]=min
ans+=min
else:
ans=p[0]
print(ans)
| p02628 |
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
if __name__ == "__main__":
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
ans = 0
for i in... | import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
def main():
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
ans = 0
for i in range(k):
... | p02628 |
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
result = 0
for i in range(k):
result += p[i]
print(result)
|
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
print((sum(p[:k])))
| p02628 |
import itertools
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = 10**19
for i in itertools.permutations(p,k):
s = sum(i)
if s < ans:
ans = s
print(ans) | n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
q = sorted(p)
print((sum(q[:k]))) | p02628 |
from itertools import combinations
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
buy = list(combinations(P, K))
sum_money = [sum(b) for b in buy]
print((min(sum_money))) | N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P.sort()
print((sum(P[:K]))) | p02628 |
n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
count=0
p.sort()
for i in range(k):
count+=p[i]
print(count) | n,k=list(map(int,input().split()))
p=sorted(list(map(int,input().split())))
print((sum(p[:k]))) | p02628 |
from itertools import combinations as comb
n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
min=None
for x in comb(list(range(n)),k):
sm=0
for i in range(len(x)):
sm+=p[x[i]]
if not min : min=sm
if sm<min : min=sm
print(min) | n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
p.sort()
sm=sum(p[:k])
print(sm) | p02628 |
from itertools import combinations
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
com = list(combinations(p,k))
ans = list(map(sum,com))
print((min(ans))) | n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
ans = 0
for i in range(k):
ans += p[i]
i += 1
print(ans) | p02628 |
import itertools
def main():
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
min_ = float('inf')
all_ = list(range(N))
for items in itertools.combinations(all_, K):
sum_ = sum([P[i] for i in items])
min_ = min(min_, sum_)
print(min_)
if(__name__ == ... | def main():
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P.sort()
print((sum(P[:K])))
if(__name__ == '__main__'):
main() | p02628 |
import itertools
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
t = list(list(itertools.combinations(A,K)))
ans = sum(t[0])
for i in t:
ans = min(ans,sum(i))
print(ans)
| N,K = list(map(int,input().split()))
A = sorted(map(int,input().split()))
print((sum(A[:K])))
| p02628 |
N,K=list(map(int,input().split()))
P=sorted(map(int,input().split()))
r=0
for i in range(K):
r+=P[i]
print(r) | N,K=list(map(int,input().split()))
P=sorted(map(int,input().split()))
print((sum(P[:K]))) | p02628 |
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
ans = float("inf")
for i in range(1 << len(P)):
sum = 0
cnt = 0
for j in range(len(P)):
if (i >> j) & 1 == 1:
sum += P[j]
cnt += 1
if cnt == K:
ans = min(ans, s... | N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
P = sorted(P)
print((sum(P[:K])))
| p02628 |
x,y = list(map(int,input().split()))
n = sorted(list(map(int,input().split())))
print((sum(n[:y]))) | n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
print((sum(a[:k]))) | p02628 |
N,K=list(map(int,input().split()))
p=sorted(map(int,input().split()))
print((sum(p[:K]))) | N, K = list(map(int, input().split()))
p = sorted(map(int, input().split()))
print((sum(p[0:K]))) | p02628 |
N, K = list(map(int, input().split()))
p = sorted(map(int, input().split()))
print((sum(p[:K]))) | N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
print((sum(sorted(p)[0:K]))) | p02628 |
A = list(map(int, input().split()))
B = list(map(int, input().split()))
import itertools
l=[]
for v in itertools.combinations(B, A[1]):
l.append(sum(v))
print((min(l))) | A = list(map(int, input().split()))
B = list(map(int, input().split()))
B.sort()
print((sum(B[:A[1]])))
| p02628 |
import math
import sys
import itertools
from math import gcd
from math import sqrt
from sys import stdin
def input() : return stdin.readline().rstrip()
def mips():
return list(map(int,input().split()))
def ii():
return int(eval(input()))
sys.setrecursionlimit(10**9)
N,K = mips()
ans = 10**9
P = ... | import math
import sys
import itertools
from math import gcd
from math import sqrt
from sys import stdin
def input() : return stdin.readline().rstrip()
def mips():
return list(map(int,input().split()))
def ii():
return int(eval(input()))
sys.setrecursionlimit(10**9)
N,K = mips()
ans = 0
P = [p f... | p02628 |
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
s = 0
for i in range(k):
s += a[i]
print(s) | n,k = list(map(int,input().split()))
p = [int(x) for x in input().split()]
p.sort()
s = 0
for i in range(k):
s+=p[i]
print(s)
| p02628 |
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
ans = 0
for i in range(k):
ans += p[i]
print(ans)
| n, k = list(map(int, input().split()))
ps = list(map(int, input().split()))
ps.sort()
ans = sum(ps[:k])
print(ans)
| p02628 |
from sys import stdin
from collections import defaultdict as dd
from collections import deque as dq
import itertools as it
from math import sqrt, log, log2
from fractions import Fraction
n, k = list(map(int, input().split()))
nums = list(map(int, stdin.readline().split()))
nums.sort()
print((sum(nums[:k])))
| n, k = list(map(int, input().split()))
nums = list(map(int, input().split()))
print((sum(sorted(nums)[:k]))) | p02628 |
from itertools import combinations
n,k = list(map(int,input().split()))
list1 = list(map(int,input().split()))
list2 = []
for i in combinations(list1,k) :
list2.append(sum(i))
print((min(list2))) | from itertools import combinations
n,k = list(map(int,input().split()))
list1 = list(map(int,input().split()))
print((sum(sorted(list1)[:k]))) | p02628 |
import itertools
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
# tmp = itertools.combinations_with_replacement(P, K)
tmp = itertools.combinations(P, K)
hoge = []
for i in tmp:
hoge.append(sum(i))
print((min(hoge)))
| # import itertools
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
# tmp = itertools.combinations_with_replacement(P, K)
# tmp = itertools.combinations(P, K)
P.sort()
print((sum(P[0:K])))
# hoge = []
# for i in tmp:
# hoge.append(sum(i))
# print(min(hoge))
| p02628 |
n, k = list(map(int, input().split()))
price_list = list(map(int, input().split()))
sum = 0
min_index = 0
for i in range(k):
min_index = price_list.index(min(price_list))
sum += price_list.pop(min_index)
print(sum) | n, k = list(map(int, input().split()))
price_list = list(map(int, input().split()))
price_list.sort()
sum = 0
for i in range(k):
sum += price_list[i]
print(sum) | p02628 |
import itertools
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
min_ = float('inf')
combi = itertools.combinations(p, k)
for c in combi:
min_ = min(min_, sum(c))
print(min_) | n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
p = sorted(p)
ans = sum(p[:k])
print(ans) | p02628 |
from itertools import combinations
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
res = 10**16
for t in combinations(list(range(N)), K):
res = min(res, sum([P[i] for i in t]))
print(res)
| N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
P.sort()
print((sum(P[:K]))) | p02628 |
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
print((sum(a[:k]))) | import sys
def Ii():return int(sys.stdin.readline())
def Mi():return list(map(int,sys.stdin.buffer.readline().split()))
def Li():return list(map(int,sys.stdin.buffer.readline().split()))
n,k = Mi();
p = Li();
p.sort();
print((sum(p[:k])))
| p02628 |
from itertools import combinations
N,K=list(map(int, input().split()))
P=list(map(int, input().split()))
ans=float('INF')
L=list(combinations(list(range(N)),K))
for a in L:
sums=0
for i in range(K):
sums+=P[a[i]]
# print(sums)
ans=min(ans,sums)
print(ans) | N,K=list(map(int, input().split()))
P=list(map(int, input().split()))
P.sort()
L=P[:K]
print((sum(L))) | p02628 |
import itertools
N,K,*p = list(map(int,open(0).read().split()))
print((min([sum(x) for x in itertools.combinations(p,K)]))) | N,K,*p = list(map(int,open(0).read().split()))
p.sort()
print((sum(p[:K]))) | p02628 |
N,K = list(map(int,input().split()))
P = sorted(list(map(int,input().split())))
print((sum(P[:K]))) | N,K = list(map(int,input().split()))
print((sum(sorted(list(map(int,input().split())))[:K]))) | p02628 |
def resolve():
import itertools
N, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
minA = 10**9
for a in itertools.combinations(A, K):
minA = min(minA, sum(a))
print(minA)
resolve()
| def resolve():
N, K = [int(i) for i in input().split()]
A = sorted([int(i) for i in input().split()])
sumA = 0
for a in A[:K]:
sumA += a
print(sumA)
resolve()
| p02628 |
# -*- coding: utf-8 -*-
import io
import sys
import math
def solve(n,k,p_lst):
pp_lst = sorted(p_lst)
return sum(pp_lst[0:k])
def main():
n,k = list(map(int, input().split()))
p_lst = list(map(int, input().split()))
ans = str(solve(n,k,p_lst))
print(ans)
return ans
... | n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
print((sum(a[:k]))) | p02628 |
n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p = sorted(p)
ans = 0
for i in range(k):
ans += p[i]
print(ans) | n,k = list(map(int,input().split()))
A = list(map(int,input().split()))
A = sorted(A)
ans = 0
for i in range(k):
ans += A[i]
print(ans) | p02628 |
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
li = []
for i in range(n):
li.append(p[i-1])
li_int = sorted([int(n) for n in li])
li_ans = li_int[:k]
print((sum(li_ans))) | n, k = list(map(int, input().split()))
p = list(map(int,input().split()))
p.sort()
list = []
for i in range(k):
list.append(p[i])
print((sum(list))) | p02628 |
# import sys
# import math #sqrt,gcd,pi
# import decimal
# import queue # queue
# import bisect
# import heapq # priolity-queue
# import time
# from itertools import product,permutations,\
# combinations,combinations_with_replacement
# 重複あり順列、順列、組み合わせ、重複あり組み合わせ
# import collections # deque
# from operato... | n,k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
ans = 0
for i in range(k):
ans += p[i]
print(ans) | p02628 |
N, K, *p = list(map(int, open(0).read().split()))
import itertools
lis = list(itertools.combinations(list(range(N)), K))
mi = 0
for x in lis:
cur = 0
for pos in x:
cur += p[pos]
if mi == 0:
mi = cur
else:
mi = min(mi, cur)
print(mi) | N, K, *p = list(map(int, open(0).read().split()))
sortp = sorted(p)
ans = 0
for x in range(K):
ans += sortp[x]
print(ans)
| p02628 |
import itertools
N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = []
for v in itertools.combinations(p,K):
ans.append(sum(v))
print((min(ans))) | N,K = list(map(int,input().split()))
p = list(map(int,input().split()))
s = sorted(p)
ans = 0
for i in range(N):
ans += s[i]
if i == K-1:
break
print(ans) | p02628 |
n, k = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
print((sum(p[0:k])))
| n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
total = 0
for i in range(k):
total += p[i]
print(total) | p02628 |
import itertools
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
sum0 = 100100100
for i in itertools.combinations(p, k):
sum1 = sum(i)
if sum0 > sum1:
sum0 = sum1
print(sum0)
| import itertools
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
sum = p[0]
for i in range(1,k):
sum += p[i]
print(sum) | p02628 |
N,K=list(map(int,input().split()))
p=list(map(int,input().split()))
import itertools
l=list(itertools.combinations(p,K))
M=999999999999999999
for i in l:
M=min(M,sum(i))
print(M)
... | N,K=list(map(int,input().split()))
p=list(map(int,input().split()))
p.sort()
ans=0
for i in range(K):
ans+=p[i]
print(ans)
... | p02628 |
from itertools import combinations
N, K = list(map(int,input().split()))
lists = combinations(list(range(N)),K)
s = list(map(int,input().split()))
min_result = 1000000000000
for li in lists:
total = 0
for l in li:
total += s[l]
min_result = min(min_result,total)
print(min_result) | N, K = list(map(int,input().split()))
s = list(map(int,input().split()))
s.sort()
print((sum(s[:K]))) | p02628 |
from itertools import combinations
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
ans = float('inf')
for buy_list in list(combinations(P, K)):
ans_ = 0
for buy in buy_list:
ans_ += buy
ans = min(ans, ans_)
print(ans) | N, K = list(map(int, input().split()))
p_list = list(map(int, input().split()))
p_list = sorted(p_list)
print((sum(p_list[:K]))) | p02628 |
import itertools
N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
c = itertools.combinations(p, K)
ans = 10**10
for i in c:
ans = min(ans, sum(i))
print(ans) | N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
print((sum(p[:K]))) | p02628 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.