Ein Array von ganzen Zahlen gegeben, adas n ganze Zahlen und eine einzelne ganze Zahl enthält x; Entfernen Sie die geringste Anzahl von Elementen aus a, um die Summe von agleich zu machen x. Wenn sich keine Kombinationen von abilden können x, wird ein falscher Wert zurückgegeben.

Wie in einem Kommentar erwähnt, ist dies die maximale Menge mit einer Summe von x , entschuldigen Sie mein geringeres mathematisches Gehirn. Ich habe seit dem College viele Begriffe vergessen.

Beispiele (Wahrheit):

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] (Unverändert)

f([], 0) = [] (Unveränderter Nullsummenfall)

Beispiele (Falsy, jeder konsistente Nicht-Array-Wert):

Es ist unmöglich, einen Fall zu machen: f([-2,4,6,-8], 3) = falsy (E.G. -1)

Nullsummenfall: f([], non-zero number) = falsy (E.G. -1)

• Hinweis: Jeder Wert wie [-1]kann nicht für falsch gelten, da es sich um eine potenzielle wahrheitsgemäße Ausgabe handelt.

Regeln:

• Die Eingabe kann in Array-Form oder als Liste von Argumenten erfolgen, wobei das letzte oder erste Argument vorliegt x.
• Die Ausgabe kann eine durch Trennzeichen getrennte Liste von ganzen Zahlen sein. EG 1\n2\n3\noder [1,2,3].
• Jeder Wert kann als falscher Indikator verwendet werden, außer als Array von Ganzzahlen.
• Ihr Code muss die Größe des Endarrays maximieren, die Reihenfolge spielt keine Rolle.
  • EG Für f([3,2,3],5)beide [2,3]und [3,2]gelten gleichermaßen.
  • EG Denn f([1,1,2],2)Sie können nur so zurückkehren, [1,1]wie [2]es kürzer ist.
• Sowohl die Summe aals auch der Wert von xwerden kleiner als 2^32-1und größer als sein -2^32-1.
• Dies ist Code-Golf , die niedrigste Anzahl an Bytes gewinnt.
• Wenn mehrere Subarrays derselben Größe gültig sind, ist es nicht akzeptabel, alle auszugeben. Sie müssen eine einzelne auswählen und diese ausgeben.

Lassen Sie mich wissen, wenn dies gepostet wurde, ich konnte es nicht finden.

Beiträge fand ich wie folgt : Verwandte aber geschlossen , ...

Brachylog , 8 Bytes

h⊇.+~t?∧

Probieren Sie es online!

Monatliche Brachylog-Antwort. Gibt zurück, false.wenn es nicht möglich ist.

Erläuterung

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 , 108 104 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*

Probieren Sie es online!

_{-4 Bytes, danke an 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

Probieren Sie es online!

_{-2 Bytes, danke an Janathan Frech}

05AB1E , 9 Bytes

æʒOQ}0ªéθ

Probieren Sie es online!

Japt -h , 11 Bytes

à f_x ¥VÃñl

Probieren Sie es online!

Pyth , 8 Bytes

• 8-Byte ( Try it! ) - Gibt nur eine mögliche Lösung aus. Bei unlösbaren Eingaben wird nichts an STDOUT ausgegeben, was eine leere Zeichenfolge ist, was in Pyth technisch gesehen falsch ist, sondern an STDERR. Vielen Dank an FryAmTheEggman , der dies vorgeschlagen hat (STDERR ignoriert und sich nur auf die STDOUT-Ausgabe konzentriert) und somit 1 Byte gespart hat.

  efqz`sTy    
  

• 9-Byte ( Try it! ) - Gibt nur eine mögliche Lösung aus, die standardmäßig in eine Singleton-Liste eingeschlossen ist (z ([1...10], 10) -> [[1,2,3,4]]; ([], 0) -> [[]]. B. ). Bei unlösbaren Eingaben wird zurückgegeben [], was in Pyth falsch ist.

  >1fqz`sTy
  

• 10-byter ( Try it! ) - Für eine klarere Ausgabe, ohne die Singleton-Listenregel zu verwenden und 0stattdessen []einen falschen Wert zu verwenden.

  e+0fqz`sTy
  

Erläuterung

Zunächst berechnet der Code den Powerset der Eingabeliste (alle möglichen geordneten Untersammlungen davon). Dann werden nur die Sammlungen gespeichert, deren Summe der eingegebenen Nummer entspricht. Es ist zu beachten, dass die Sammlungen von der kürzesten bis zur längsten erstellt werden, sodass wir uns auf die letzte konzentrieren. So erhalten Sie es:

• Das 8-Byte-Format verwendet einfach die integrierte Funktion end , die einen Fehler auslöst. STDERR kann jedoch gemäß unseren Site-Regeln ignoriert werden. Die Ausgabe an STDOUT ist eine leere Zeichenfolge, die falsch ist.
• Der 9-byter nimmt das letzte Element, jedoch unter Verwendung des äquivalenten Python Code lst[-1:]anstelle von lst[-1]Fehlern zu vermeiden aus für unlösbare Eingänge geworfen.
• Das 10-Byte-Element stellt der Liste der gefilterten Untersammlungen eine 0 voran und übernimmt dann das Ende dieser Sammlung (letztes Element). Wenn die Eingaben nicht lösbar sind, wird natürlich stattdessen 0 verwendet.

Gelee , 7 Bytes

ŒPS⁼¥ƇṪ

Probieren Sie es online!

Ausgabe über TIO geklärt.

Perl 6 , 38 37 Bytes

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

Probieren Sie es online!

Curry-Funktion.

Brachylog , 4 Bytes

⟨⊇+⟩

Probieren Sie es online!

Fast gleichbedeutend mit Fatalizes h⊇.+~t?∧, nur viel kürzer, dank der Kompositionsfunktion für Prädikate, die laut dem Bearbeitungsverlauf der Referenz bis zum 8. Januar noch in Bearbeitung war und die Antwort um mehr als zwei Monate verzögerte. ⟨⊇+⟩ist ein Sandwich , das erweitert wird {[I,J]∧I⊇.+J∧}, wobei die Klammern in diesem Fall irrelevant sind, da sich das Sandwich sowieso in einer eigenen Zeile befindet.

                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]).

Eine weitaus weniger dramatische Transformation der Antwort von Fatalize, die dieselben Prädikate mit denselben Variablen verwendet, jedoch ein Byte kürzer aus der unterschiedlichen Organisation hervorgeht:

Brachylog , 7 Bytes

h⊇.&t~+

Probieren Sie es online!

           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.

(Wenn jemand etwas Seltsames sehen möchte, setzen Sie einen der Unterstriche in den Testfällen in Bindestriche.)

Pyth , 14 Bytes

A.Q|>1fqsTHyG0

Probieren Sie es online!

Sauber , 89 Bytes

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

Probieren Sie es online!

Definiert die Funktion, die $ :: Int -> [Int] -> (Maybe [Int])zurückgibt, Nothingwenn keine geeignete Kombination von Elementen vorhanden ist (Just [elements...]).

JavaScript (ES6), 108 Byte

Übernimmt die Eingabe als (array)(n). Gibt entweder ein Array oder zurück 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

Probieren Sie es online!

Das fing cool und klein an, aber Randfälle haben mich erwischt. Was auch immer passiert, ich bin stolz auf die Arbeit, die ich in diese Sache gesteckt habe.

Python 3 , 169 161 154 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

Probieren Sie es online!

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`

Probieren Sie es online!

20 Bytes gespart dank digEmAll

Gibt FALSEfür unmögliche Kriterien zurück.

Attache , 28 Bytes

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

Probieren Sie es online!

Alternativen

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}

Erläuterung

${(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 Zeichen, 130 Byte

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

↓ wird verwendet, weil das erste Element der Menge von Mengen eine leere Menge wäre (hier ⍬ Zilde), die man eliminieren möchte, weil es so scheint, als ob + / ⍬ Null ist ...

Für nicht gefunden oder Fehler würde es ⍬ oder im Drucktext zurückgeben:

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

Prüfung:

  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
~