Prima domanda qui, non urlare a me se questa è una sfida duplicata o cattiva.

introduzione

Ho pensato a questa sfida da solo, e sembra essere un buon puzzle di base per i golfisti principianti. Potrebbe anche aiutarmi a decidere quale lingua di golf da imparare.

Sfida

Dato un array di numeri interi che sono minori o uguali a n, emette o restituisce il numero minimo di numeri dall'array che si sommano esattamente n.

Puoi scegliere di scrivere una funzione o un programma completo.

Ingresso

Puoi tranquillamente supporre 0 <= n < 2^31.

Prendi un array o un elenco di qualsiasi tipo ( sono consentiti vectorC ++ o Java LinkedList), insieme a nun parametro facoltativo length, che specifica la lunghezza dell'array.

Puoi anche prendere l'input come una stringa separata da spazio, separata da nuna virgola o da uno spazio:

1 5 7 3 7 3 6 3 2 6 3,10

1 5 7 3 7 3 6 3 2 6 3 10

se è più facile.

Produzione

Output o restituisce il numero minimo di numeri dall'array che si sommano esattamente n. Utilizzando l'esempio sopra:

1 5 7 3 7 3 6 3 2 6 3,10

Il tuo programma dovrebbe stampare:

2

perché il numero minimo di numeri che si sommano a 10è 2( 7e3 ).

Nel caso in cui non vi sia soluzione, stampare o restituire un valore negativo, 0"Nessuna soluzione" (sebbene ciò non sarebbe intelligente), ∞(come suggerito) o qualsiasi altro valore errato, ad eccezione di una stringa vuota.

Esempio di input e output

Ingresso:

1 5 7 3 7 3 6 3 2 6 3,10
143 1623 1646 16336 1624 983 122,18102
5 6 9,12

Produzione:

2
3
-1

punteggio

Questo è code-golf, quindi vince il codice più breve in byte.

La risposta migliore sarà accettata a Natale.

Pyth, 12 11 byte

lhafqsTQyEY

Questo prende ncome prima riga di input e l'elenco sulla seconda riga.

lhafqsTQyEY     (Implicit: Q = 1st line of input; E = 2nd line)
         E      The list
        yE      Powerset (sorted by increasing length; empty set first)
   f            Filter by lambda T:
     sT         sum(T)
    q                  ==
       Q                  Q
   fqSTQyE      Sublists that sum to Q, sorted by increasing length
  a       Y     append an empty array (in case none match)
lh              take the length of the first element (0 for empty array)

Provalo qui .

Japt , 30 21 18 byte

Si scopre che c'era un metodo molto più efficiente. ;)

Uà f_x ¥V} ml n- g

Provalo online! (Nota: n-è stato modificato in n@X-Y}per motivi di compatibilità)

Questo accetta l'input come un array separato da spazio o virgola, seguito da un numero. Uscite undefinedper casi di test senza soluzioni.

Uà f_  x ¥ V} ®   l} n- g
UàfmZ{Zx ==V} mZ{Zl} n- g

            // Implicit: U = input array, V = input integer
Uà fZ{   }  // Generate all possible combinations of U, then filter to only items Z where
Zx ==V      //   the sum of Z is equal to V.
mZ{Zl}      // Map each remaining combination to its length.
n-          // Sort by subtraction; smaller items end up in the front.
g           // Take the first item.
            // Implicit: output last expression

Non riesco a credere di non aver pensato a questa versione quando ho scritto questo ...

Da allora sono state apportate diverse ottimizzazioni che sono utili qui:

• A Uall'inizio del programma di solito può essere lasciato fuori.
• Ãè una scorciatoia per } .
• n ora ordina i numeri correttamente per impostazione predefinita.

Ognuno di questi decolla un byte, per un totale di 15:

à f_x ¥VÃml n g

Provalo online!

Mathematica, 73 65 byte

Min[Length/@Select[IntegerPartitions[#2,#2,#],Sort@#==Union@#&]]&

Funzione pura, ritorna ∞se non c'è soluzione.

Python 3, 128 byte

Non è così divertente come vorrei che fosse, ma ci lavorerò più tardi.

from itertools import*
def s(a,n):
 for i in range(len(a)):
  for j in permutations(a,i+1):
   if sum(j)==n:return i+1
 return 0

Mathematica, 45 byte

Min@Cases[Subsets@#,i_/;Tr@i==12:>Length@#2]&

CJam, 34 byte

0q~_,2,m*\f.*{:+1$=},\;0f-{,}$0=,+

Provalo online . Il formato di input è la somma seguita dall'elenco dei valori, ad esempio:

18102 [143 1623 1646 16336 1624 983 122]

Si noti che ciò genererà un'eccezione se non viene trovata alcuna soluzione. L'eccezione va a stderr quando CJam viene eseguito dalla riga di comando e il risultato corretto ( 0) viene comunque stampato su stdout. Quindi questo incontra il consenso stabilito a Dovrebbe essere consentito agli invii di uscire con un errore?

Il codice potrebbe apparire più lungo di quanto ti aspetti. Il motivo principale è che CJam non ha un built-in per la generazione di combinazioni. O almeno questa è la mia scusa, e mi sto attenendo ad essa.

Spiegazione:

0       Push 0 result for exception case.
q~      Get and interpret input.
_,      Copy and get length of input value list.
2,      Push [0 1].
m*      Cartesian power. This generates all possible lists of 0/1 values with the
        same length as the input value list.
\       Swap input value list to top.
f.*     Apply element-wise product of input value list with all 0/1 lists.
        We now have all combinations of values, with 0 in place of unused values.
{       Start filter block.
  :+      Sum values.
  1$      Copy target sum to top.
  =       Compare.
},      Filter.
\;      Swap target sum to top and discard.
0f-     Remove 0 values. We now have all solution lists.
{,}$    Sort by length.
0=      Get first solution, which after sorting is the shortest.
        This will raise an exception if the list of solutions is empty, bailing
        out with the initial 0 on the stack.
,       Get length of solution.
+       Add the 0 we initially pushed for the exception case.

JavaScript (ES6), 84 byte

f=(a,n,m=1e999,x)=>n&&a.map((v,i)=>(x=[...a],x.splice(i,1),x=f(x,n-v)+1)<m?m=x:0)&&m

Spiegazione

Prende una Arraydi Numbers ed una Numbercome argomenti. Restituisce un numero di Infinityse nessun risultato. È una funzione ricorsiva che sottrae ne rimuove ogni elemento dall'array uno a uno fino a n == 0.

f=(a,n,m=1e999,x)=> // m and x are not passed, they are here to declare them in the local
                    //     scope instead of globally, initialise m to Infinity
  n&&               // if n == 0, return 0
  a.map((v,i)=>     // iterate over each number in a
    (x=[...a],      // x = copy of a
    x.splice(i,1),  // remove the added number from the array
    x=f(x,n-v)+1)   // x = result for the numbers in this array
      <m?m=x:0      // set m to minimum result
  )
  &&m               // return m

Test

Questo test viene impostato min un Infinitysecondo momento anziché come argomento predefinito per farlo funzionare in Chrome (anziché solo Firefox).

var solution = f=(a,n,m,x)=>n&&a.map((v,i)=>(x=[...a],x.splice(i,1),x=f(x,n-v)+1)<m?m=x:0,m=1e999)&&m

Array (space-delimited) = <input type="text" id="array" value="143 1623 1646 16336 1624 983 122" /><br />
n = <input type="number" id="N" value="18102" /><br />
<button onclick="result.textContent=solution(array.value.split` `,N.value)">Go</button>
<pre id="result"></pre>

Haskell, 72 byte

import Data.List
n#l=head$sort[length x|x<-subsequences l,sum x==n]++[0]

Restituisce 0se non c'è soluzione.

Esempio di utilizzo: 10 # [1,5,7,3,7,3,6,3,2,6,3]-> 2.

Trova tutti gli elenchi secondari dell'elenco di input lche hanno una somma di n. Prendi la lunghezza di ciascuno di questi sotto-elenchi e ordina. Aggiungi a 0e prendi il primo elemento.

Se un elenco Singleton è consentita per l'uscita, ad esempio [2], siamo in grado di salvare i 7 byte: n#l=minimum[length x|x<-subsequences l,sum x==n]. In caso di mancata soluzione, []viene restituito l'elenco vuoto .