Dada una matriz de enteros aque contiene n enteros y un solo entero x; eliminar la menor cantidad de elementos apara hacer la suma de aigual a x. Si no se apueden formar combinaciones de xlatas, devuelve un valor falso.

Como se señaló en un comentario, este es el conjunto máximo con una suma de x , disculpe mi cerebro matemático menor. Olvidé muchos términos desde la universidad.

Ejemplos (Verdad):

f([1,2,3,4,5,6,7,8,9,10], 10) = [1,2,3,4]

f([2,2,2,2,2,2,2,2,2], 10) = [2,2,2,2,2]

f([2,2,2,2,-2,-2,-2,-4,-2], -8) = [2,2,-2,-2,-2,-4,-2]

f([-2,-4,-2], -6) = [-4,-2] OR [-2,-4]

f([2,2,2,4,2,-2,-2,-2,-4,-2], 0) = [2,2,2,4,2,-2,-2,-2,-4,-2] (Sin alterar)

f([], 0) = [] (Caso de suma cero sin cambios)

Ejemplos (Falsy, cualquier valor consistente que no sea de matriz):

Imposible hacer caso: f([-2,4,6,-8], 3) = falsy (E.G. -1)

Caso de suma cero: f([], non-zero number) = falsy (E.G. -1)

• Nota: cualquier valor como [-1]no puede ser válido para falsedad, ya que es una salida de verdad potencial.

Reglas:

• La entrada puede tomarse en forma de matriz, o como una lista de argumentos, siendo el último o el primero x.
• La salida puede ser cualquier lista delimitada de enteros. EG 1\n2\n3\no [1,2,3].
• Cualquier valor puede usarse como un indicador falso, que no sea una matriz de enteros.
• Su código debe maximizar el tamaño de la matriz final, el orden no importa.
  • EG Para f([3,2,3],5)ambos [2,3]y [3,2]son igualmente válidos.
  • Por ejemplo f([1,1,2],2), solo puede regresar [1,1]cuando [2]sea ​​más corto.
• Tanto la suma de acomo el valor de xserán menores 2^32-1y mayores que -2^32-1.
• Este es el código de golf , el menor recuento de bytes gana.
• Si hay varios subconjuntos del mismo tamaño que sean válidos, es no aceptable para la producción de todos ellos. Debe elegir uno único y generarlo.

Avíseme si esto se ha publicado, no pude encontrarlo.

Publicaciones que encontré así : relacionadas pero cerradas , ...

Brachylog , 8 bytes

h⊇.+~t?∧

Pruébalo en línea!

Respuesta mensual de Brachylog. Devuelve false.si no es posible.

Explicación

h⊇.           The output is a subset of the head of the input
  .+~t?       The sum of the elements of the output must equal the tail of the input
       ∧      (Avoid implicit unification between the output and the input)

Python 2 , 108104 bytes

lambda a,n:[x for l in range(len(a)+1)for x in combinations(a,l)if sum(x)==n][-1]
from itertools import*

Pruébalo en línea!

_{-4 bytes, gracias a Jonathan Allan}

Python 2 , 108 106 bytes

def f(a,n):
 q=[a]
 while q:
  x=q.pop(0);q+=[x[:i]+x[i+1:]for i in range(len(x))]
  if sum(x)==n:return x

Pruébalo en línea!

_{-2 bytes, gracias a Janathan Frech}

05AB1E , 9 bytes

æʒOQ}0ªéθ

Pruébalo en línea!

Japt -h , 11 bytes

à f_x ¥VÃñl

Pruébalo en línea!

Pyth , 8 bytes

• 8 bytes (¡ Pruébelo! ): Genera solo una solución posible. Para entradas insolubles, no imprime nada en STDOUT, que es una cadena vacía, que técnicamente habla falsey en Pyth, pero escribe en STDERR. Gracias a FryAmTheEggman por sugerir esto (ignorando STDERR y centrándose solo en la salida STDOUT), ahorrando así 1 byte.

  efqz`sTy    
  

• 9 bytes (¡ Pruébelo! ): Genera solo una solución posible, envuelta en una lista de un solo tono según lo permitido por defecto (por ejemplo ([1...10], 10) -> [[1,2,3,4]]; ([], 0) -> [[]]). Para entradas insolubles, regresa [], lo cual es falsey en Pyth.

  >1fqz`sTy
  

• 10 bytes (¡ Pruébelo! ): Para obtener una salida más clara, sin usar la regla de lista única y usar en 0lugar de []un valor falso.

  e+0fqz`sTy
  

Explicación

Primero, el código calcula el conjunto de potencia de la lista de entrada (todas las posibles subcolecciones ordenadas de la misma). Luego, solo mantiene aquellas colecciones cuya suma es igual al número de entrada. Cabe señalar que las colecciones se generan de la más corta a la más larga, por lo que nos centramos en la última. Para obtenerlo:

• El 8-byter simplemente usa el final incorporado, que arroja un error, pero STDERR puede ignorarse según las reglas de nuestro sitio, siendo la salida a STDOUT una cadena vacía, lo cual es falso.
• El 9-byter toma el último elemento, pero usa el código Python equivalente lst[-1:]en lugar de lst[-1]evitar que se generen errores para entradas insolubles.
• El byte 10 antepone un 0 a la lista de sub-colecciones filtradas, luego toma el final de esa colección (último elemento). Si las entradas no tienen solución, entonces se usa 0 en su lugar.

Jalea , 7 bytes

ŒPS⁼¥ƇṪ

Pruébalo en línea!

Salida aclarada sobre TIO.

Perl 6 , 38 37 bytes

{*.combinations.grep(*.sum==$_).tail}

Pruébalo en línea!

Función curry

Brachylog , 4 bytes

⟨⊇+⟩

Pruébalo en línea!

Casi equivalente a Fatalize h⊇.+~t?∧, excepto que es mucho más corto, gracias a la función de composición de predicados que, según el historial de edición de la referencia, era un trabajo en progreso hasta el 8 de enero, posponiendo la respuesta por más de dos meses. ⟨⊇+⟩es un sándwich que se expande hacia {[I,J]∧I⊇.+J∧}donde los frenos son irrelevantes en este caso, ya que el sándwich está en su propia línea de todos modos.

                The input
[I,J]           is a list of two elements I and J.
        .       The output,
         +J     which sums to J
           ∧    (which we don't unify with the output),
      I⊇        is a sublist of I
     ∧          (which we don't unify with [I,J]).

Una transformación mucho menos dramática de la respuesta de Fatalize, que usa los mismos predicados con las mismas variables pero sale un byte más corto de ser organizado de manera diferente:

Brachylog , 7 bytes

h⊇.&t~+

Pruébalo en línea!

           The input
h          's first element
 ⊇         is a superlist of
  .        the output,
   &       and the input
    t      's last item
     ~+    is the sum of the elements of
           the output.

(Además, si alguien quiere ver algo extraño, cambie cualquiera de los guiones bajos en los casos de prueba a guiones).

Pyth , 14 bytes

A.Q|>1fqsTHyG0

Pruébalo en línea!

Limpiar , 89 bytes

import StdEnv,Data.List,Data.Func
$n=find((==)n o sum)o sortBy(on(>)length)o subsequences

Pruébalo en línea!

Define la función de $ :: Int -> [Int] -> (Maybe [Int])retorno Nothingsi no hay una combinación adecuada de elementos, y de lo (Just [elements...])contrario.

JavaScript (ES6), 108 bytes

Toma entrada como (array)(n). Devuelve una matriz o false.

a=>n=>a.reduce((a,x)=>[...a,...a.map(y=>1/r[(y=[...y]).push(x)]||eval(y.join`+`)-n?y:r=y)],[[]],r=!n&&[])&&r

Pruébalo en línea!

Esto comenzó genial y pequeño, pero los casos extremos me atraparon. Pase lo que pase, estoy orgulloso del trabajo que puse en esto.

Python 3 , 169161154 bytes

from itertools import*
def f(a,x):
	if sum(a)==x:return a
	try:return[c for i in range(len(a))for c in combinations(a,i)if sum(c)==x][-1]
	except:return 0

Pruébalo en línea!

R , 100 80 bytes

function(a,x){i[sum(a|1):0,j[combn(a,i,,F),if(sum(j)==x)return(j)]]
F}
`[`=`for`

Pruébalo en línea!

20 bytes guardados gracias a digEmAll

Devoluciones FALSEpor criterios imposibles.

Adjunto , 28 bytes

${(y&`=@Sum\Radiations@x)@0}

Pruébalo en línea!

Alternativas

34 bytes :f[x,y]:=({y=Sum@_}\Radiations@x)@0

30 bytes :First@${y&`=@Sum\Radiations@x}

29 bytes :{(_&`=@Sum\_2)@0}#/Radiations

29 bytes :${({y=Sum@_}\Radiations@x)@0}

29 bytes :`@&0@${y&`=@Sum\Radiations@x}

29 bytes :{_}@@${y&`=@Sum\Radiations@x}

Explicación

${(y&`=@Sum\Radiations@x)@0}
${                         }    function receiving two arguments, x and y
            Radiations@x        calculate the radiations of x
                                (simulates removing all possible subslices of x)
           \                    keep those radiations
        Sum                     ...whose sum...
     `=@                        ...equals...
   y&                           ...y
  (                     )@0     select the first one (always the longest)

APL (NARS), 65 caracteres, 130 bytes

{m←⍺=+/¨v←1↓{0=⍴⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵}⍵⋄0=↑⍴b←m/v:⍬⋄b⊃⍨n⍳⌈/n←⍴¨b}

↓ se usa porque el primer elemento del conjunto de conjuntos sería un conjunto vacío (aquí ⍬ Zilde), que uno quiere eliminar porque parece que + / ⍬ es cero ...

Para no encontrar, o error, devolvería ⍬ o en el texto impreso:

  o←⎕fmt
  o ⍬
┌0─┐
│ 0│
└~─┘

prueba:

  z←{m←⍺=+/¨v←1↓{0=⍴⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵}⍵⋄0=↑⍴b←m/v:⍬⋄b⊃⍨n⍳⌈/n←⍴¨b}

  o 1 z ,1
┌1─┐
│ 1│
└~─┘
  o 2 z ,1
┌0─┐
│ 0│
└~─┘
  o 10 z 1 2 3 4 5 6 7 8 9 10
┌4───────┐
│ 1 2 3 4│
└~───────┘
  o 10 z 2,2,2,2,2,2,2,2,2
┌5─────────┐
│ 2 2 2 2 2│
└~─────────┘
  o ¯8 z 2,2,2,2,¯2,¯2,¯2,¯4,¯2
┌7──────────────────┐
│ 2 2 ¯2 ¯2 ¯2 ¯4 ¯2│
└~──────────────────┘
  o ¯6 z ¯2,¯4,¯2
┌2─────┐
│ ¯4 ¯2│
└~─────┘
  o 0 z 2,2,2,4,2,¯2,¯2,¯2,¯4,¯2
┌10───────────────────────┐
│ 2 2 2 4 2 ¯2 ¯2 ¯2 ¯4 ¯2│
└~────────────────────────┘
  o 10 z 1 2 3 4
┌4───────┐
│ 1 2 3 4│
└~───────┘
  o 10 z 1 2 3
┌0─┐
│ 0│
└~─┘
  o 0 z ⍬
┌0─┐
│ 0│
└~─┘
  o +/⍬  
0
~