Wandle eine Zahl in eine Summe von Ziffern um

Keine Summe: Wir brauchen die kürzeste Summe.
Keine Ziffern: Sie können nur Ziffern der Zahl verwenden

Beispiel
Als Eingabe erhalten Sie eine ganze Zahln>0

Sagen wir mal n=27. Sie müssen zum Ausdruck bringen 27als Summe , indem nur die Ziffern [2,7] , in dem kürzesten Weg möglich. Sie müssen nicht alle Ziffern der angegebenen Nummer verwenden!

Also 27=2+2+2+7+7+7. Wir haben dann nehmen diese Ziffern und zählen sie : [2,2,2,7,7,7].
Endgültige Antwort für n=27ist6

Ein weiteres Beispiel n=195, um die kürzeste Summe zu erhalten, müssen wir die folgenden Ziffern verwenden:
[5,5,5,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]und die Antwort lautet23

Die Herausforderung

Geben Sie bei einer Ganzzahl n>0die Mindestanzahl von Ziffern (in der Zahl enthalten) aus, die sich zu dieser Zahl summieren

Testfälle

Input->Output

1->1  
2->1  
10->10  
58->8  
874->110  
1259->142  
12347->1765  
123456->20576  
3456789->384088  

Dies ist Code-Golf. Die kürzeste Antwort in Bytes gewinnt!

Schale , 12 Bytes

Lḟo=⁰ΣṁΠḣ∞d⁰

Verarbeitet zweistellige Zahlen ziemlich schnell. Probieren Sie es online!

Erläuterung

Lḟo=⁰ΣṁΠḣ∞d⁰  Input is n, say n = 13.
          d⁰  Digits of n: [1,3]
         ∞    Repeat infinitely: [[1,3],[1,3],[1,3],[1,3]...
        ḣ     Prefixes: [[],[[1,3]],[[1,3],[1,3]],[[1,3],[1,3],[1,3]],...
      ṁ       Map and concatenate
       Π      Cartesian product: [[],[1],[3],[1,1],[3,1],[1,3],[3,3],[1,1,1],[3,1,1],...
 ḟo           Find the first element
     Σ        whose sum
   =⁰         equals n: [3,3,3,3,1]
L             Return its length: 5

Pyth , 12 Bytes

lef!-TsM`Q./

Probieren Sie es online!

Leider ist es Speicherfehler bei Eingaben so groß wie 58.

Erläuterung

lef!-TsM`Q./
          ./    All lists of integers that sum to [the input]
  f             Filter for:
    -TsM`Q           Remove all occurrences of the digits in the input
   !                 Check if falsey (i.e. an empty list)
le              Length of the last occurrence, which is the shortest because all the
                filtered partitions share the same digit pool

Mathematica, 78 Bytes

(t=1;While[(s=IntegerPartitions[x=#,t,IntegerDigits@x])=={},t++];Tr[1^#&@@s])&  

findet letzten Testfall in 5 sek

R , 78 Bytes

function(n){while(all(F-n)){F=outer(F,n%/%10^(0:nchar(n))%%10,"+")
T=T+1}
T-1}

Probieren Sie es online! (Golfversion)

Ein reiner Brute-Force-Algorithmus, der nicht alle Testfälle löst. Ich denke, er hat versucht, 40.000 GB für den letzten Testfall zuzuweisen ...

Tin R ist der Standardwert 1so , dass wir einen Fehler "off by one" erhalten, den wir im Rückgabeschritt korrigieren, aber wir erhalten auch, Fwelcher Standardwert sich für 0wen auszahlt.

ungolfed Erklärung:

function(n){
 d <- n%/%10^(0:nchar(n))%%10   # digit list with a 0 appended at end
 d <- unique(d[d>0])            # filter zeros (not technically necessary)
                                # and get unique digits
 x <- 0                         # storage for sums
 i <- 0                         # counter for number of sums done
 while(!any(x==n)){             # until we find a combination
  x <- outer(x,d,"+")           # take all sums of x and d, store as x
  i <- i + 1}                   # increment counter
i}                              # return counter

Probieren Sie es online! (weniger Golfversion)

Python 2, 168 155 144 Bytes

Es ist nicht die kürzeste, die es sein könnte, aber es ist die beste und nicht wirklich schlechte, was die Laufzeit angeht.

n=input()
g=sorted(set(n)-{0})[::-1]
def h(k):
 if k<0:return
 if`k`in g:return 1
 for d in g:
  f=h(k-int(d))
  if f:return 1+f
print h(int(n)) 

Das filter(None...ist, 0 als Ziffer zu entfernen, was ich gelernt habe, als ich das gemacht habe.

Das größte Problem sind Python-Stack-Frames, die es mir realistisch gesehen nicht erlauben, diese auf den größten Eingaben auszuführen. Es ist also keine gültige Lösung. Ich habe versucht, das Rekursionslimit zu erhöhen, was zu Seg-Fehlern führte. Dies muss entweder mit einer Schleife und einem Stapel oder mit viel mehr Cleverness geschehen, um in Python zu arbeiten.

edit: Danke an Caird und Chas Brown für 13 Bytes!

Schale , 13 Bytes

Ziemlich ineffizient

VVo=⁰ΣMṖNṘ⁰d⁰

Probieren Sie es online!

JavaScript (ES6), 82 Byte

f=(n,l=0,a=n,[c,...b]=a)=>n?1/c?Math.min(!+c|+c>n?1/0:f(n-c,l+1,a),f(n,l,b)):1/0:l

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

Nimmt die Eingabe als String.

Ruby , 70 Bytes

->n{w,s=n.digits,0;s+=1while !w.product(*[w]*s).find{|x|x.sum==n};s+1}

Probieren Sie sehr langsam alle möglichen Kombinationen aus, um die Größe zu erhöhen, bis wir zu einer Lösung kommen.

Danke Dennis für Ruby 2.4 auf TIO.

Probieren Sie es online!

Jelly , 23 Bytes

D;0ṗµḟ€0
ÇS€=µT
Çị1ĿL€Ṃ

Probieren Sie es online!

Dies ist so ineffizient, dass es für die Testfälle nach dem dritten auf TIO aufgrund eines Zeitlimits> _ <nicht ausgeführt wird

Alle Golftipps sind willkommen!

Python 2 , 183 176 172 166 161 Bytes

def f(n,D=0,p=0,b=0):
	D=D or set(map(int,`n`))-{0}
	d=min(D);c=0;D=D-{d}
	q=[p+n/d,b][n%d>0]
	while c<min(D or{0}):q=b=f(n-c*d,D,p+c,b);c+=1
	return[q,b][q>b>0]

Probieren Sie es online!

Länger als die andere Python-Antwort, führt jedoch alle Testfälle zusammen und 987654321in weniger als einer Sekunde auf TIO aus.

Nutzt die Tatsache aus, dass, wenn d1<d2es sich um Ziffern handelt, höchstens Ziffern d2-1 d1in der Summe vorhanden sein müssen (da d2Instanzen von d1durch d1Instanzen von d2für eine kürzere Summe ersetzt werden können). Wenn Sie also die Ziffern in aufsteigender Reihenfolge sortieren, gibt es "nur" die 9! = 362880höchstmöglichen Beträge, die berücksichtigt werden müssen. und eine maximale Rekursionstiefe von 9(unabhängig vom Wert von n).

Haskell , 91 Bytes

f n=[read[c]|c<-show n,c>'0']#n!!0
s#n|n>0,x:m<-(s#).(n-)=<<s=[1+minimum(x:m)]|1<3=[0|n==0]

Probieren Sie es online! Anwendungsbeispiel: f 58Erträge 8. Schnell für zweistellige Zahlen, horrend langsam für größere Eingaben.

Die Funktion fwandelt die eingegebene Nummer nin eine Liste von Ziffern um, während Nullen herausgefiltert werden. Dann werden diese Liste und sich nselbst an die (#)Funktion übergeben, die eine Singleton-Liste zurückgibt. !!0Gibt das Element dieser Singleton-Liste zurück.

(#)Verwendet Singleton- und leere Listen als Optionstyp. Bei einer Eingabe von n=58und s=[5,8]sollen alle Ziffern svon subtrahiert n, dann rekursiv (#)angewendet und geprüft werden, welche Ziffer zur Mindestanzahl von Schritten geführt hat, und als Ergebnis eins plus dieses Minimum zurückgegeben werden. Der erste Teil wird mit berechnet. Dies (s#).(n-)=<<sist das Gleiche wie concat(map(s#)(map(n-)s)). In unserem Beispiel wird also zuerst [58-5,58-8]berechnet, gefolgt von dem, [[5,8]#53,[5,8]#50]was in [[7],[7]]oder [7,7]nachher resultiert concat. Das Ergebnis wird mit dem Muster abgeglichen x:m, um sicherzustellen, dass die Liste mindestens ein Element enthält ( minimumandernfalls schlägt dies fehl). Anschließend wird die Singleton-Liste von 1 plus dem Minimum des Ergebnisses erneut abgestimmt. WennnWar die Null kleiner oder gab der rekursive Aufruf eine leere Liste zurück, befinden wir uns in einem fehlerhaften Zweig der Suche und es wird eine leere Liste zurückgegeben. Wenn n==0die Verzweigung erfolgreich war und [0]zurückgegeben wird.

Haskell , 101 Bytes

f n=[d|d<-[9,8..1],show d!!0`elem`show n]#n!!0
s@(d:r)#n|n>=d,[x]<-s#(n-d)=[x+1]|1<3=r#n
s#n=[0|n==0]

Probieren Sie es online! Bei einem effizienteren Ansatz werden alle Testfälle in weniger als einer Sekunde überprüft.

Dieses Mal wird die Liste der Ziffern der Eingabe in absteigender Reihenfolge berechnet (#), sodass versucht werden kann, so oft wie möglich die größte und dann die zweitgrößte Ziffer zu verwenden, bis eine Lösung gefunden wird. Die erste auf diese Weise gefundene Lösung ist garantiert auch die kleinste.