Première question ici, ne me criez pas dessus s'il s'agit d'un doublon ou d'un mauvais défi.

introduction

J'ai moi-même pensé à ce défi, et il semble être un bon casse-tête de base pour les golfeurs débutants. Cela pourrait également m'aider à décider quelle langue de golf de code apprendre.

Défi

Étant donné un tableau d'entiers inférieurs ou égaux à n, affichez ou renvoyez le nombre minimum de nombres du tableau qui résument exactement n.

Vous pouvez choisir d'écrire une fonction ou un programme complet.

Contribution

Vous pouvez assumer en toute sécurité 0 <= n < 2^31.

Prenez un tableau ou une liste de tout type ( vectorcar C ++ ou Java LinkedListsont autorisés), avec net un paramètre facultatif length, qui spécifie la longueur du tableau.

Vous pouvez également prendre l'entrée comme une chaîne séparée npar des espaces, séparée par une virgule ou un espace:

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

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

si c'est plus facile.

Production

Générez une sortie ou renvoyez le nombre minimal de nombres du tableau qui résument exactement n. En utilisant l'exemple ci-dessus:

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

Votre programme devrait imprimer:

2

parce que le nombre minimum de nombres qui se résume à 10est 2(7 et 3).

Dans le cas où il n'y a pas de solution, imprimez ou retournez soit un négatif 0, "Pas de solution" (bien que ce ne serait pas intelligent),∞ (comme suggéré), ou toute autre valeur falsifiée, à l'exception d'une chaîne vide.

Exemple d'entrée et de sortie

Contribution:

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

Production:

2
3
-1

Notation

C'est le code-golf, donc le code le plus court en octets gagne.

La meilleure réponse sera acceptée à Noël.

Pyth, 12 11 octets

lhafqsTQyEY

Cela prend ncomme première ligne d'entrée et la liste sur la deuxième ligne.

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)

Essayez-le ici .

Japt , 30 21 18 octets

Il s'avère qu'il y avait une méthode beaucoup plus efficace. ;)

Uà f_x ¥V} ml n- g

Testez-le en ligne! (Remarque: n-a été remplacé parn@X-Y} pour des raisons de compatibilité)

Cela prend l'entrée comme un tableau séparé par des espaces ou des virgules, suivi d'un nombre. Sorties undefinedpour cas de test sans solutions.

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

Je ne peux pas croire que je n'ai pas pensé à cette version quand j'ai écrit cela à l'origine ...

Depuis, plusieurs optimisations ont été apportées qui sont utiles ici:

• A Uau début du programme peut généralement être omis.
• Ãest un raccourci pour } .
• n trie désormais correctement les nombres par défaut.

Chacun d'eux décolle un octet, pour un total de 15:

à f_x ¥VÃml n g

Testez-le en ligne!

Mathematica, 73 65 octets

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

Fonction pure, retourne ∞s'il n'y a pas de solution.

Python 3, 128 octets

Ce n'est pas aussi golfé que je le souhaiterais, mais j'y travaillerai plus tard.

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 octets

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

CJam, 34 octets

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

Essayez-le en ligne . Le format d'entrée est la somme suivie de la liste des valeurs, par exemple:

18102 [143 1623 1646 16336 1624 983 122]

Notez que cela déclenchera une exception si aucune solution n'est trouvée. L'exception va à stderr lorsque CJam est exécuté à partir de la ligne de commande et le résultat correct ( 0) est toujours imprimé sur stdout. Donc, cela répond au consensus établi à Faut-il laisser les soumissions se terminer avec une erreur?

Le code peut sembler plus long que prévu. La raison principale est que CJam n'a pas de fonction intégrée pour générer des combinaisons. Ou du moins, c'est mon excuse, et je m'y tiens.

Explication:

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 octets

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

Explication

Prend un Arrayde Numbers et un Numbercomme arguments. Renvoie un nombre de Infinitysi aucun résultat. Il s'agit d'une fonction récursive qui soustrait net supprime chaque élément du tableau un par un jusqu'à 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

Tester

Ce test est défini msur Infinityplus tard au lieu de comme argument par défaut pour le faire fonctionner dans Chrome (au lieu de simplement 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 octets

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

Retour 0 s'il n'y a pas de solution.

Exemple d'utilisation: 10 # [1,5,7,3,7,3,6,3,2,6,3]->2 .

Trouvez toutes les sous-listes de la liste d'entrée lqui ont une somme de n. Prenez la longueur de chacune de ces sous-listes et triez. Ajoutez un 0et prenez le premier élément.

Si une liste singleton est autorisée pour la production, par exemple [2], nous pouvons sauver 7 octets: n#l=minimum[length x|x<-subsequences l,sum x==n]. En cas d'absence de solution, la liste vide []est retournée.