Converti un numero in una somma di cifre

Nessuna somma: abbiamo bisogno della somma più breve
Nessuna cifra: puoi usare solo cifre del numero

Esempio
Verrà fornito come input un numero interon>0

Diciamo di Let n=27. Devi esprimere 27come somma , usando solo le cifre [2,7] , nel modo più breve possibile. Non devi usare tutte le cifre del numero dato!

Così 27=2+2+2+7+7+7. Abbiamo poi prendiamo queste cifre e contarli : [2,2,2,7,7,7].
La risposta finale n=27è6

Un altro esempio per n=195per ottenere la somma più breve dobbiamo usare le seguenti cifre:
[5,5,5,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]e la risposta è23

La sfida

Dato un numero intero n>0, genera il numero minimo di cifre (contenuto nel numero) che si sommano a questo numero

Casi test

Input->Output

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

Questo è code-golf. Vince la risposta più breve in byte!

Buccia , 12 byte

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

Gestisce i numeri a due cifre abbastanza velocemente. Provalo online!

Spiegazione

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 byte

lef!-TsM`Q./

Provalo online!

Sfortunatamente memoria errori su input grandi quanto 58.

Spiegazione

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 byte

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

trova l'ultimo caso di test in 5 sec

R , 78 byte

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

Provalo online! (versione golfizzata)

Algoritmo di pura forza bruta, quindi in realtà non risolve tutti i casi di test e penso che abbia tentato di allocare 40.000 GB per l'ultimo caso di test ...

Tin R per impostazione predefinita 1abbiamo quindi un errore off-by-one che correggiamo al passaggio di ritorno, ma otteniamo anche Fquali impostazioni predefinite a 0cui ripaga.

spiegazione non golfata:

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

Provalo online! (versione meno golfy)

Python 2, 168 155 144 byte

Non è il più breve che potrebbe essere, ma è meglio prima e non vero male, runtime saggio.

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

Il filter(None...è quello di rimuovere 0 da una cifra, che ho imparato che potevo fare rendendo questo.

Il problema più grande sono i frame stack di Python, che realisticamente non mi permettono di eseguirlo sugli input più grandi. Quindi, non è una soluzione valida, davvero, ho giocato con l'aumento del limite di ricorsione che ha appena portato a errori di seg. Questo deve essere fatto con un ciclo e uno stack o con molta più intelligenza per lavorare in Python.

modifica: Grazie a caird e Chas Brown per 13 byte!

Buccia , 13 byte

Abbastanza inefficiente

VVo=⁰ΣMṖNṘ⁰d⁰

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

Accetta l'input come stringa.

Rubino , 70 byte

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

Molto lento, prova tutte le possibili combinazioni aumentando le dimensioni fino a raggiungere una soluzione.

Grazie Dennis per Ruby 2.4 su TIO.

Provalo online!

Gelatina , 23 byte

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

Provalo online!

Questo è così inefficiente, che non viene eseguito per i casi di test dopo il terzo su TIO a causa di un limite di tempo> _ <

Tutti i consigli sul golf sono i benvenuti!

Python 2 , 183 176 172 166 161 byte

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]

Provalo online!

Più lungo dell'altra risposta di Python, ma esegue tutti i casi di test combinati più 987654321in meno di un secondo su TIO.

Sfrutta il fatto che se d1<d2sono cifre, allora ci deve essere al massimo d2-1 d1nella somma (poiché le d2istanze di d1possono essere sostituite con d1istanze di d2per una somma più breve). Quindi, ordinando le cifre in ordine crescente, ci sono "solo" al massimo 9! = 362880possibili somme da considerare; e una profondità massima di ricorsione di 9(indipendentemente dal valore di n).

Haskell , 91 byte

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]

Provalo online! Esempio di utilizzo: f 58rese 8. Rapido per numeri a due cifre, tremendamente lento per input più grandi.

La funzione fconverte il numero di input nin un elenco di cifre mentre filtra gli zeri. Quindi questo elenco e nse stesso vengono passati alla (#)funzione, che restituisce un elenco singleton. !!0restituisce l'elemento di questo elenco singleton.

(#)utilizza singleton e liste vuote come tipo di opzione. Dato un input di n=58e s=[5,8], l'idea è di sottrarre tutte le cifre sda n, quindi applicare ricorsivamente (#)e controllare quale cifra ha comportato il numero minimo di passaggi e restituire uno più questo minimo come risultato. La prima parte è calcolata da (s#).(n-)=<<s, che è la stessa di concat(map(s#)(map(n-)s)). Quindi, nel nostro esempio, [58-5,58-8]viene prima calcolata, seguita da [[5,8]#53,[5,8]#50]quali risultati in [[7],[7]]o [7,7]dopo concat. Il risultato viene abbinato sul modello x:mper assicurarsi che l'elenco abbia almeno un elemento ( minimumaltrimenti fallisce), quindi la lista singleton di 1 più il minimo del risultato viene risintonizzata. Senera zero inferiore o la chiamata ricorsiva ha restituito un elenco vuoto, ci troviamo in un ramo non riuscito della ricerca e viene restituito un elenco vuoto. Se n==0il ramo ha avuto successo e [0]viene restituito.

Haskell , 101 byte

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]

Provalo online! Un approccio molto più efficiente, controlla tutti i casi di test in meno di un secondo.

Questa volta, l'elenco delle cifre dell'input viene calcolato in ordine decrescente, il che consente (#)di provare a utilizzare la cifra più grande il più spesso possibile, quindi la seconda più grande e così fino a quando non viene trovata una soluzione. Anche la prima soluzione trovata in questo modo è la più piccola.