Tôi là một phù thủy trẻ, và tôi rất cố gắng để không lãng phí mana trong các cuộc gặp gỡ ma thuật của mình.
Tôi có các phép thuật X có sẵn tại bất kỳ thời điểm nào và mỗi một trong số chúng có giá trị mana riêng Y.
X, Y là số nguyên dương thấp hơn 11.
Khi mới bắt đầu, lượng mana của tôi dao động rất nhiều (luôn thấp hơn 11) và tôi cần trợ giúp để sử dụng một vài phép thuật như những vật sở hữu (cuộn rất đắt, bạn biết đấy) trong khi làm trống hồ mana của tôi. Nếu bạn không thể tìm thấy bất kỳ kết hợp chính tả nào phù hợp với kích thước chính xác của hồ mana của tôi, thì bạn sẽ cung cấp cho tôi một tổ hợp gần nhất (và rẻ hơn).

Tôi đến với bạn và trí tuệ vô hạn của bạn để giúp tôi trở thành phù thủy bóng tối vĩ đại nhất. Tôi sẽ không thất vọng.

Kiểu INPUT (vì kiểu là tất cả):
Y; abcdef
Y là kích thước của hồ mana. (a, b, c, d, e, f) là các phép thuật. Có 6 phép thuật, một phép đầu tiên có giá 'a' mana, phép thuật thứ hai có giá 'b' mana, v.v.

INPUT: 4; 1 2 3 3 7 6
Tôi có sẵn 4 manas và 6 phép thuật có sẵn. Hai phép thuật tốn 1 mana, 1 phép thuật tốn 2 mana, hai phép thuật tốn 3 mana, v.v.

ĐẦU RA: (3,1)

VÀO: 3; 1 3 5 2 10
ĐẦU RA: (3)

VÀO: 8; 4 1 9
ĐẦU RA: (4,1)

INPUT: 4; 1 2 2 3
OUTPUT: (2,2), (1,3)
Bạn sẽ xuất ra mọi tổ hợp phép thuật, nhưng không cần phải phân biệt các phép thuật có cùng chi phí.

Câu thần chú ngắn nhất cho bất kỳ cỗ máy nào bạn mong muốn sẽ được cấp một lời cảm ơn và một đòn roi định mệnh.

GolfScript, 55 ký tự

[[]]\{{+}+1$%|}/.@{1$0+{+}*.@>!*100*\,-~}+:s%$0={\s=}+,

Hãy thử trực tuyến .

> 4 [1 1 2 3 3 7 6]
[[1 3]]

> 3 [1 3 5 2 10]
[[3]]

> 8 [4 1 9]
[[4 1]]

> 4 [1 2 2 3]
[[2 2] [1 3]]

APL (87)

↑∪m/⍨t=⌊/t←⊃∘⍴¨m←m/⍨t=⌈/t←+/¨m←{a/⍨⊃i≥+/a←k[⍵]}¨⊃,/g,{z/⍨∧/¨2>/¨z←,⍳⍵/⍴k}¨1↓g←⍳⍴k←1↓i←⎕

Định dạng đầu vào là một danh sách APL, trong đó phần tử đầu tiên là nhóm mana và phần còn lại của các phần tử là các phép thuật. Đầu ra có mỗi sự kết hợp có thể của các phép thuật trên một dòng riêng biệt.

⎕:    4, 1 2 3 3 7 6
3 1
⎕:    3, 1 3 5 2 10
3
⎕:    8, 4 1 9
1 4
⎕:    4, 1 2 2 3
2 2
3 1

Giải trình:

• k←1↓i←⎕: đọc danh sách từ đầu vào và lưu nó vào i. Thả phần tử đầu tiên (mana) và lưu phần còn lại vào k.
• 1↓g←⍳⍴k: tạo một danh sách từ 1đến chiều dài kvà lưu trữ nó vào g. Thả yếu tố đầu tiên, cho [2..len k].
• {... }¨: Đối với mỗi trong số này, hãy lấy các chỉ số của từng kết hợp duy nhất theo kđộ dài ⍵:
  • z←,⍳⍵/⍴k: lấy một ⍵ma trận hai chiều gồm các chỉ số độ dài k, làm phẳng nó và lưu trữ nó trong z.
  • ∧/¨2>/¨: cho mỗi tọa độ trong mỗi chỉ mục, hãy xem liệu tất cả các tọa độ cho Nthứ nguyên có cao hơn các tọa độ cho N-1thứ nguyên không.
  • z/⍨: chọn từ zcác yếu tố mà những điều trên đúng
• ⊃,/g,: bởi vì ở trên không hoạt động cho các vectơ một chiều, hãy thêm gvào phía trước. Bây giờ chúng tôi có một danh sách các danh sách các danh sách (vì các hướng dẫn) của tất cả các chỉ số duy nhất vào k. Ghép các danh sách lại với nhau và hủy kèm theo (vì vậy chúng tôi kết thúc với một danh sách các danh sách).
• {... }¨: Đối với mỗi danh sách tọa độ có thể, hãy tìm kiếm sự kết hợp các giá trị tương ứng kvà lọc ra những giá trị quá đắt:
  • a←k[⍵]: tra cứu sự kết hợp hiện tại kvà lưu trữ nó trong a.
  • a/⍨⊃i≥+/a: achỉ chọn nếu mục đầu tiên trong i(nhóm mana) bằng hoặc lớn hơn tổng các phần tử của a.
• m←: lưu trữ tất cả các kết hợp phép thuật không vượt quá giới hạn mana trong m.
• m←m/⍨t=⌈/t←+/¨m: chỉ chọn từ mnhững kết hợp có tổng bằng tổng của kết hợp đắt nhất và lưu mlại.
• m/⍨t=⌊/t←⊃∘⍴¨m: chỉ chọn từ mnhững kết hợp có độ dài bằng với độ dài của kết hợp ngắn nhất.
• ↑∪: xóa mọi bản sao và chuyển đổi thành ma trận (để hiển thị mỗi kết hợp trên một dòng riêng biệt).

Hồng ngọc 114 113 ký tự

x,y=eval gets
(d=0..10).find{|r|d.find{|c|s=y.sort.combination(c).select{|s|s.reduce(:+)==x-r}.uniq
p s if s[0]}}

Dữ liệu vào: một mảng hai phần tử của mana wizard và danh sách chính tả, được định dạng JSON một dòng.

Đầu ra: một mảng 2D của danh sách chính tả, được định dạng dưới dạng JSON một dòng hoặc nilnếu trình hướng dẫn có thể không sử dụng chính tả.

Tôi đặc biệt yêu thích x,y = eval gets. Vì vậy, nguy hiểm và xấu xa, nhưng rất mạnh mẽ và đơn giản. Hoàn hảo cho chơi golf.

Cả hai sortvà uniqđều cần thiết. Nếu không, điều này sẽ tạo ra các bản sao cho đầu vào như thế nào [4, [1, 3, 1]]. Tôi không hài lòng về điều này.

findlà một phương pháp hữu ích cho dòng điều khiển. Giá trị trả về của nó không hữu ích ở đây. Theo chiều dài, nó đi ngang với any?, giá trị trả về thậm chí còn ít hữu ích hơn.

Ví dụ:

> [4, [1, 2, 3, 3, 7, 6]]
# [[1, 3]]
> [3, [1, 3, 5, 2, 10]]
# [[3]]
> [8, [4, 1, 9]]
# [[1, 4]]
> [4, [1, 2, 2, 3]]
# [[1, 3], [2, 2]]
> [4, [5, 6, 7]]
# nil

Haskell (GHC), 172 167 143 ký tự

import Data.List
import GHC.Exts
f(x:y)=head.groupWith length.last.groupWith sum.filter((<=x).sum).nub$subsequences y
main=interact$show.f.read

Khử nhiễu:

import Data.List
import GHC.Exts

f (x:xs) = head
         . groupWith length
         . last
         . groupWith sum
         . filter ((<= x) . sum)
         . nub
         $ subsequences xs

main = interact (show . f . read)

• Định dạng đầu vào: danh sách được đặt trong ngoặc có đầu là mana có sẵn, đuôi là các phép thuật có sẵn (ví dụ [4,1,2,3,3,7,6]).
• Định dạng đầu ra: danh sách được liệt kê trong danh sách, mỗi danh sách con đại diện cho một bộ phép thuật có thể.

Giải pháp đơn giản: lấy quyền hạn của đầu vào, sau đó giảm xuống bằng cách lọc các kết hợp chúng tôi có đủ mana cho, v.v.

Toán học 131

Phải có những cách ngắn hơn, nhưng đây là những gì tôi có thể nghĩ ra.

l=Length;
f[{a_,b_}]:=Select[t=Cases[s=SortBy[Union@Cases[Subsets[b],x_/;0<Tr@x<a+1:>{x,Tr@x}],Last],
{x_,s[[-1,2]]}:> x],l@#==l@t[[1]]&]

f[{4, {1, 2, 3, 7, 6}}]

{{1, 3}}

f[{3, {1, 3, 5, 2, 10}}]

{{3}}

f[{8, {4, 1, 9}}]

{{4, 1}}

f[{4, {1, 2, 2, 3}}]

{{1, 3}, {2, 2}}