Il mio array dovrebbe eguagliare questo, ma non lo fa!

21

Dato un array di numeri interi ache contiene n numeri interi e un singolo numero intero x; rimuovere il minor numero di elementi da aper rendere la somma apari a x. Se nessuna combinazione di apuò formare x, restituisce un valore errato.

Come sottolineato in un commento, questo è il set massimo con una somma di x , scusa il mio cervello matematico minore. Ho dimenticato molti termini dal college.

Esempi (verità):

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] (Invariato)

f([], 0) = [] (Caso invariato di somma zero)

Esempi (Falsy, qualsiasi valore coerente non array):

Caso impossibile da realizzare: f([-2,4,6,-8], 3) = falsy (E.G. -1)

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

  • Nota: qualsiasi valore come [-1]non può essere valido per la falsità, in quanto è un potenziale output di verità.

Regole:

  • L'input può essere preso in forma di matrice o come elenco di argomenti, l'ultimo o il primo essere x.
  • L'output può essere qualsiasi elenco delimitato di numeri interi. EG 1\n2\n3\no [1,2,3].
  • Qualsiasi valore può essere utilizzato come indicatore di falsa, diverso da una matrice di numeri interi.
  • Il codice deve massimizzare la dimensione dell'array finale, l'ordine non ha importanza.
    • EG per f([3,2,3],5)entrambi [2,3]e [3,2]sono ugualmente validi.
    • Ad esempio f([1,1,2],2), puoi tornare solo [1,1]perché [2]è più breve.
  • Sia la somma di ache il valore di xsaranno minori di 2^32-1e maggiori di -2^32-1.
  • Questo è code-golf , vince il conteggio di byte più basso.
  • Se ci sono più sottoschiere della stessa dimensione che sono valide, è non accettabile uscita tutti loro. Devi sceglierne uno singolo e crearne uno.

Fammi sapere se questo è stato pubblicato, non sono riuscito a trovarlo.

Post che ho trovato in questo modo : correlati ma chiusi , ...

code-golf  array-manipulation 
— Urna di polpo magico
fonte
1
Suppongo che "Falsy, qualunque valore coerente non array" includa la generazione di un errore?
— Jonathan Allan,
" Qualsiasi valore può essere utilizzato come indicatore di falsi, diverso da un array di numeri interi. " Include un array vuoto?
— Shaggy
@shaggy [] è indicativo di un potenziale valore di verità, giusto? Consentire questa meta regola è più importante di verità e falsità distinte?
— Magic Octopus Urn
@JohnathanAllan se quell'errore non può essere sollevato in uno scenario di Verità, suppongo. Ma penso che questo stia intenzionalmente cercando di estendere le specifiche. Se cambio la dicitura dall'indicatore per restituire un valore, allora va bene?
— Magic Octopus Urn
Credo che valori di uscita coerenti contino come valore di ritorno se per meta?
— Magic Octopus Urn

Risposte:

7

Brachylog , 8 byte

h⊇.+~t?∧

Provalo online!

Risposta mensile a Brachylog. Restituisce false.se non è possibile.

Spiegazione

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)
— Fatalize
fonte
6

Python 2 , 108 104 byte

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*

Provalo online!

-4 byte, grazie a Jonathan Allan

Python 2 , 108 106 byte

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

Provalo online!

-2 byte, grazie a Janathan Frech

— TFeld
fonte
1
Puoi usare range(-len(a),1)e -lsalvare 2, ma lambda a,n:[x for l in range(len(a)+1)for x in combinations(a,l)if sum(x)==n][-1]salva 4.
— Jonathan Allan,
@JonathanAllan Thanks :)
— TFeld
1
Possibili 106 byte .
— Jonathan Frech,
@JonathanFrech Grazie, devo essere stato stanco ieri;)
— TFeld
4

Pyth , 8 byte

  • 8-byte ( Provalo! ) - Emette solo una possibile soluzione. Per input irrisolvibili, non stampa nulla su STDOUT, che è una stringa vuota, che è tecnicamente falso in Pyth, ma scrive su STDERR. Grazie a FryAmTheEggman per averlo suggerito (ignorando STDERR e concentrandosi solo sull'uscita STDOUT), risparmiando così 1 byte.

    efqz`sTy

  • 9-byte ( Provalo! ) - Emette solo una possibile soluzione, racchiusa in un elenco singleton come consentito di default (ad es ([1...10], 10) -> [[1,2,3,4]]; ([], 0) -> [[]].). Per input irrisolvibili, ritorna [], il che è falso in Pyth .

    >1fqz`sTy

  • 10-byter ( provalo! ) - Per un output più chiaro, senza usare la regola singleton-list e usando 0piuttosto che []come valore errato.

    e+0fqz`sTy

Spiegazione

Innanzitutto, il codice calcola il powerset dell'elenco di input (tutte le possibili sotto-raccolte ordinate). Quindi, mantiene solo quelle raccolte la cui somma è uguale al numero di input. Va notato che le raccolte sono generate dal più corto al più lungo, quindi ci concentriamo sull'ultimo. Per ottenerlo:

  • L' 8-byte utilizza semplicemente la fine built-in, che genera un errore, ma STDERR può essere ignorato secondo le regole del nostro sito, l'output su STDOUT è una stringa vuota, che è falsa.
  • Il 9-byte prende l'ultimo elemento, ma usa l'equivalente codice Python lst[-1:]al posto di lst[-1]per evitare che vengano generati errori per input irrisolvibili.
  • Il 10-byte antepone uno 0 all'elenco delle sotto-raccolte filtrate, quindi prende la fine di quella raccolta (ultimo elemento). Se gli input non sono risolvibili, al suo posto viene utilizzato naturalmente 0 .
— Mr. Xcoder
fonte
[]è falsa? Neat. Perché Pyth lo fa []?
— Magic Octopus Urn,
@MagicOctopusUrn Pyth eredita questo da Python in realtà: provalo online .
— Mr. Xcoder,
@FryAmTheEggman non sarebbe un elenco vuoto un output veritiero nel caso di test f([], 0) = []?
— Dal
@FryAmTheEggman Grazie per il tuo suggerimento! Ho apportato le modifiche necessarie :)
— Mr. Xcoder
3

Perl 6 , 38 37 byte

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

Provalo online!

Funzione al curry.

— nwellnhof
fonte
Aspetta, è ;addirittura necessario?
— Jo King,
@JoKing In una precedente iterazione era necessario evitare un errore di "doppia chiusura non valida". Ma per qualche motivo adesso può essere omesso. (Penso che dopo aver sostituito $^xcon $_.)
— Nwellnhof
3

Brachylog , 4 byte

⟨⊇+⟩

Provalo online!

Quasi equivalente a quello di Fatalize h⊇.+~t?∧, tranne molto più breve, grazie alla funzione di composizione predicata che, secondo la cronologia delle modifiche del riferimento, era un lavoro in corso fino all'8 gennaio, postdatando la risposta di oltre due mesi. ⟨⊇+⟩è un sandwich , che si sta espandendo {[I,J]∧I⊇.+J∧}, in cui le parentesi graffe sono in questo caso irrilevanti in quanto il sandwich è comunque sulla propria linea.

                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 trasformazione molto meno drammatica della risposta di Fatalize, che utilizza gli stessi predicati con le stesse variabili ma esce un byte più corto dall'essere organizzato in modo diverso:

Brachylog , 7 byte

h⊇.&t~+

Provalo 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.

(Inoltre, se qualcuno vuole vedere qualcosa di strano, cambia uno dei trattini bassi nei casi di prova in trattini.)

— Stringa non correlata
fonte
1
I sandwich sono stati implementati da @ais523 a novembre 2018 ma sono stati estratti solo a Brachylog all'inizio di gennaio 2019.
— Fatalizza il
1
Ovviamente, nessuna di queste ricerche sulla storia è importante, poiché le lingue che postdatano la sfida sono state autorizzate per anni.
— pppery
2

Pulito , 89 byte

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

Provalo online!

Definisce la funzione $ :: Int -> [Int] -> (Maybe [Int])restituita Nothingse non esiste una combinazione appropriata di elementi e in caso (Just [elements...])contrario.

— Οurous
fonte
2

JavaScript (ES6), 108 byte

Accetta input come (array)(n). Restituisce un array 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

Provalo online!

— Arnauld
fonte
2

Questo è iniziato fresco e piccolo, ma i casi limite mi hanno preso. Qualunque cosa accada, sono orgoglioso del lavoro svolto.

Python 3 , 169 161 154 byte

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

Provalo online!

— gigaflop
fonte
Ricorda che questo è [code-golf], quindi dovresti provare a ridurre il numero di byte il più piccolo possibile! Hai una newline leader e alcuni altri banali campi da golf di spazi bianchi , e scommetto che qualcun altro che conosce Python può golf ulteriormente.
— Giuseppe,
@Giuseppe Grazie per avermi ricordato lo spazio bianco principale. Ho trascorso un po 'di tempo cercando di consolidare alcune parti di questo, ma nel frattempo ho deciso di pubblicarlo nel caso in cui altri possano suggerire modifiche.
— Gigaflop,
Non è un problema! Sono passati 5 anni da quando ho fatto Python, ma non range(x)genera (0...x-1)? Quindi il tuo range(len(a))non ti dà la possibilità di lasciare invariato l'array?
— Giuseppe,
@Giuseppe Eureka, che l'ha fatto. Potrei essermi concentrato troppo sul nuovo materiale con cui stavo lavorando.
— Gigaflop,
Invece di if a==[] and x==0usare if sum(a)==x. Quindi puoi anche rimuovere +1da range.
— Vedant Kandoi,
1

Attache , 28 byte

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

Provalo online!

alternative

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

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

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

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

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

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

Spiegazione

${(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)
— Conor O'Brien
fonte
0

APL (NARS), 65 caratteri, 130 byte

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

↓ viene utilizzato perché il primo elemento dell'insieme di insiemi sarebbe un insieme vuoto (qui ⍬ Zilde), che si desidera eliminare perché sembra + / ⍬ è zero ...

Per non trovare, o errore restituirebbe ⍬ o nel testo di stampa:

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

test:

  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
~
— RosLuP
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.