Soy un joven mago, y trato mucho de no desperdiciar maná durante mis encuentros mágicos.
Tengo X hechizos disponibles en cualquier momento y cada uno de ellos tiene su propio coste de maná.
Y, X, Y son enteros positivos estrictamente inferiores a 11.
Como principiante, mi reserva de maná fluctúa mucho (siempre es inferior a 11). , y necesito ayuda para lanzar la menor cantidad de hechizos posibles (los pergaminos son caros, ya sabes) mientras vacío mi reserva de maná. Si no puedes encontrar ninguna combinación de hechizos que coincida exactamente con el tamaño de mi reserva de maná, entonces me ofrecerás la más cercana (y más barata).

Vine a ti y a tu infinita sabiduría para ayudarme a convertirme en el mejor mago oscuro. No me decepcionaré.

Estilo INPUT (porque el estilo lo es todo):
Y; abcdef
Y es el tamaño del grupo de maná. (a, b, c, d, e, f) son los hechizos. Hay 6 hechizos, el primero cuesta 'a' maná, el segundo hechizo cuesta 'b' maná, etc.

ENTRADA: 4; 1 2 3 3 7 6
Tengo 4 manas disponibles y 6 hechizos disponibles. Dos hechizos cuestan 1 maná, 1 hechizo cuesta 2 maná, dos hechizos cuestan 3 maná, etc.

SALIDA: (3,1)

ENTRADA: 3; 1 3 5 2 10
SALIDA: (3)

ENTRADA: 8; 4 1 9
SALIDA: (4,1)

ENTRADA: 4; 1 2 2 3
SALIDA: (2,2), (1,3)
Debes sacar todas las combinaciones de hechizos, pero no hay necesidad de hechizos distintos que tengan el mismo costo.

El conjuro más corto para cualquier máquina que desee recibirá una profusión de agradecimientos y un látigo de destino.

GolfScript, 55 caracteres

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

Pruébalo en línea .

> 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←⎕

El formato de entrada es una lista APL, donde el primer elemento es el grupo de maná y el resto de los elementos son los hechizos. La salida tiene cada combinación posible de hechizos en una línea separada.

⎕:    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

Explicación:

• k←1↓i←⎕: lee una lista de la entrada y la almacena i. Suelta el primer elemento (maná) y almacena el resto k.
• 1↓g←⍳⍴k: genera una lista de 1hasta la longitud ky la almacena en g. Suelta el primer elemento, dando [2..len k].
• {... }¨: Para cada uno de estos, obtenga los índices de cada combinación única en klongitud ⍵:
  • z←,⍳⍵/⍴k: obtener una ⍵matriz dimensional de índices de longitud k, aplanarla y almacenarla z.
  • ∧/¨2>/¨: para cada coordenada en cada índice, vea si todas las coordenadas para la Ndimensión th son más altas que las de la N-1dimensión th.
  • z/⍨: seleccione de zaquellos elementos para los cuales lo anterior es verdadero
• ⊃,/g,: como lo anterior no funciona para vectores unidimensionales, agregue gal frente. Ahora tenemos una lista de listas de listas (debido al foreach) de todos los índices únicos en k. Concatenar las listas juntas y cerrarlas (de modo que terminamos con una lista de listas).
• {... }¨: para cada posible lista de coordenadas, busque la combinación correspondiente de valores ky filtre los que son demasiado caros:
  • a←k[⍵]: busque la combinación actual ky guárdela a.
  • a/⍨⊃i≥+/a: seleccione asolo si el primer elemento en i(el grupo de maná) es igual o mayor que la suma de los elementos de a.
• m←: almacena todas las combinaciones de hechizos que no excedan el límite de maná en m.
• m←m/⍨t=⌈/t←+/¨m: seleccione msolo aquellas combinaciones cuya suma sea igual a la suma de la combinación más cara y almacénela mnuevamente.
• m/⍨t=⌊/t←⊃∘⍴¨m: seleccione msolo aquellas combinaciones cuya longitud sea igual a la longitud de la combinación más corta.
• ↑∪: elimine cualquier duplicado y conviértalo en una matriz (para mostrar cada combinación en una línea separada).

Rubí, 114 113 caracteres

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]}}

Entrada: una matriz de dos elementos del asistente de maná y la lista de hechizos, formateado un JSON de una línea.

Salida: una matriz 2D de las listas de hechizos, formateada como un JSON de una línea, o nilsi el asistente no puede lanzar hechizos.

En especial me encanta x,y = eval gets. Tan peligroso y malvado, pero tan poderoso y simple. Perfecto para jugar al golf.

Ambos sorty uniqson necesarios. De lo contrario, esto producirá duplicados para entradas como [4, [1, 3, 1]]. No estoy contento con esto.

findEs un método útil para controlar el flujo. Sin embargo, su valor de retorno no es tan útil aquí. En cuanto a la longitud, está a la par any?, cuyo valor de retorno es aún menos útil.

Ejemplos:

> [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 caracteres

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

Desobuscado:

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)

• Formato de entrada: lista entre corchetes con cabeza como maná disponible, cola como hechizos disponibles (por ejemplo [4,1,2,3,3,7,6]).
• Formato de salida: lista de listas entre corchetes, cada sublista representa un posible conjunto de hechizos.

Solución directa: tome el conjunto de potencia de la entrada, luego reduzca eso filtrando las combinaciones para las que tenemos suficiente maná, etc.

Mathematica 131

Debe haber formas más cortas, pero esto es lo que pude encontrar.

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}}