Ogni numero intero positivo può essere espresso come la somma di al massimo tre numeri interi positivi palindromici in qualsiasi base b ≥5.   Cilleruelo et al., 2017

Un numero intero positivo è palindromico in una data base se la sua rappresentazione in quella base, senza zeri iniziali, legge lo stesso all'indietro. Di seguito, verrà considerata solo la base b = 10.

La decomposizione come somma di numeri palindromici non è unica . Ad esempio, 5può essere espresso direttamente come 5o come la somma di 2, 3. Allo stesso modo, 132può essere scomposto come 44, 44, 44o come 121, 11.

La sfida

Dato un numero intero positivo, produce la sua scomposizione in tre o meno numeri interi positivi che sono palindromici in base 10.

Regole aggiuntive

• L'algoritmo utilizzato dovrebbe funzionare per input arbitrariamente grandi. Tuttavia, è accettabile se il programma è limitato da limitazioni di memoria, tempo o tipo di dati.

• Input e output possono essere presi con qualsiasi mezzo ragionevole . Il formato di input e output è flessibile come al solito.

• È possibile scegliere di produrre una o più decomposizioni valide per ciascun input, purché il formato di output sia inequivocabile.

• Programmi o funzioni sono consentiti, in qualsiasi linguaggio di programmazione . Sono vietate le scappatoie standard .

• Vince il codice più breve in byte.

Esempi

Poiché un input può avere molte decomposizioni, questi sono esempi piuttosto che casi di test. Ogni decomposizione è mostrata su una linea diversa.

Input  ->  Output

5     ->   5
           2, 3

15    ->   1, 3, 11
           9, 6

21    ->   11, 9, 1
           7, 7, 7

42    ->   22, 11, 9
           2, 7, 33

132   ->   44, 44, 44
           121, 11

345   ->   202, 44, 99
           2, 343

1022  ->   989, 33
           999, 22, 1

9265  ->   9229, 33, 3
           8338, 828, 99

Brachylog , 7 byte

~+ℕᵐ.↔ᵐ

Provalo online!

Sorprendentemente non così lento.

Spiegazione

(?)~+  .          Output is equal to the Input when summed
     ℕᵐ.          Each element of the Output is a positive integer
       .↔ᵐ(.)     When reversing each element of the Output, we get the Output

Python 2 , 82 79 byte

f=lambda n:min([f(n-k)+[k]for k in range(1,n+1)if`k`==`k`[::-1]]or[[]],key=len)

Provalo online!

Gelatina , 12 10 9 8 byte

ŒṗDfU$ṪḌ

Provalo online!

Come funziona

ŒṗDfU$ṪḌ  Main link. Argument: n (integer)

Œṗ        Find all integer partitions of n.
  D       Convert each integer in each partition to base 10.
     $    Combine the two links to the left into a chain.
    U     Upend; reverse all arrays of decimal digits.
   f      Filter the original array by the upended one.
      Ṫ   Take the last element of the filtered array.
          This selects  the lexicographically smallest decomposition of those with
          the minimal amount of palindromes.
       Ḍ  Undecimal; convert all arrays of decimal digits to integers.

Python 2 , 117 byte

def f(n):p=[x for x in range(n+1)if`x`==`x`[::-1]];print[filter(None,[a,b,n-a-b])for a in p for b in p if n-a-b in p]

Provalo online!

Stampa un elenco di elenchi, ognuno dei quali è una soluzione. Rod ha salvato 9 byte.

JavaScript (ES6), 115 ... 84 83 byte

Restituisce sempre un array a tre elementi, in cui le voci non utilizzate sono riempite con zeri.

f=(n,b=a=0)=>(r=[b,a%=n,n-a-b]).some(a=>a-[...a+''].reverse().join``)?f(n,b+!a++):r

Casi test

f=(n,b=a=0)=>(r=[b,a%=n,n-a-b]).some(a=>a-[...a+''].reverse().join``)?f(n,b+!a++):r

console.log(JSON.stringify(f(5)))
console.log(JSON.stringify(f(15)))
console.log(JSON.stringify(f(21)))
console.log(JSON.stringify(f(42)))
console.log(JSON.stringify(f(132)))
console.log(JSON.stringify(f(345)))
console.log(JSON.stringify(f(1022)))
console.log(JSON.stringify(f(9265)))

R, 126 byte 145 byte

Grazie a Giuseppe per il golf di 19 byte

function(n){a=paste(y<-0:n)
x=combn(c(0,y[a==Map(paste,Map(rev,strsplit(a,"")),collapse="")]),3)
unique(x[,colSums(x)==n],,2)}

Provalo online!

Spiegazione

R non ha un modo nativo per invertire le stringhe e molte operazioni sulle stringhe predefinite non funzionano sui numeri. Quindi prima convertiamo la serie di numeri interi positivi (più 0) in caratteri.

Successivamente produciamo un vettore di 0 e tutti i palindromi. L'inversione della stringa richiede la suddivisione di ciascun numero per carattere, invertendo l'ordine del vettore e incollandoli di nuovo insieme senza spazi vuoti.

Quindi voglio controllare tutti i gruppi di tre (qui dove gli 0 sono importanti), per fortuna R ha una funzione di combinazione integrata che restituisce una matrice, ogni colonna in una combinazione.

Applico la colSumsfunzione alla matrice e mantengo solo gli elementi che eguagliano l'obiettivo fornito.

Infine, poiché ci sono due 0, qualsiasi serie di due numeri interi positivi verrà duplicata, quindi utilizzo una funzione unica sulle colonne.

L'output è una matrice in cui ogni colonna è un insieme di numeri interi pallindromici positivi che si sommano al valore target. È pigro e restituisce 0 quando vengono utilizzati meno di 3 elementi.

Gelatina , 14 byte

L<4aŒḂ€Ạ
ŒṗÇÐf

Provalo online!

Molto, molto inefficiente.

Gelatina , 17 byte

RŒḂÐfṗ3R¤YS⁼³$$Ðf

Provalo online!

-6 byte grazie a HyperNeutrino.

Emette tutti i modi. Tuttavia l'output è costituito da alcuni duplicati.

Ohm v2 , 13 12 10 byte

#Dð*3ç⁇Σ³E

Provalo online!

Mathematica, 49 byte

#~IntegerPartitions~3~Select~AllTrue@PalindromeQ&

Provalo online!

restituisce tutte le soluzioni

-2 ~ ~ MartinEnder byte

Haskell , 90 86 79 byte

-7 byte grazie a Laikoni!

f=filter
h n=[f(>0)t|t<-mapM(\_->f(((==)<*>reverse).show)[0..n])"123",sum t==n]

Provalo online!

Restituisce un elenco di tutte le soluzioni con alcuni duplicati.

Java (OpenJDK 8) , 185 byte

n->{for(int i=0,j=n,k;++i<=--j;)if(p(i))for(k=0;k<=j-k;k++)if(p(k)&p(j-k))return new int[]{j-k,k,i};return n;}
boolean p(int n){return(""+n).equals(""+new StringBuffer(""+n).reverse());}

Provalo online!

Rimuovere 1 byte da TIO per ottenere l'importo corretto perché l'invio non contiene il ;dopo lambda.

Proton , 117 byte

a=>filter(l=>all(p==p[by-1]for p:map(str,l)),(k=[[i,a-i]for i:1..a-1])+sum([[[i,q,j-q]for q:1..j-1]for i,j:k],[]))[0]

Provalo online!

Emette una soluzione

Pyth ,  16 12  10 byte

ef_I#`MT./

Provalo qui!

Come funziona

ef_I # `MT. / ~ Programma completo.

        ./ ~ Partizioni intere.
 f ~ Filtro con una variabile T.
     `MT ~ Mappa ogni elemento di T su una rappresentazione di stringa.
    # ~ Filtro.
  _I ~ Palindrome è? (cioè invariante sul retro?)
e ~ Ottieni l'ultimo elemento.

05AB1E , 17 byte

LʒÂQ}U4GXNãDO¹QÏ=

Provalo online!

Emette il risultato in tre elenchi come segue:

• Elenchi palindromici di lunghezza 1 (il numero originale IFF è palindromico).

• Elenchi palindromici di lunghezza 2.

• Elenchi palindromici di lunghezza 3.

Assioma, 900 byte

R(x)==>return x;p(r,a)==(n:=#(a::String);if r<0 then(a=0=>R a;n=1 or a=10^(n-1)=>R(a-1);a=10^(n-1)+1=>R(a-2));if r>0 then(n=1 and a<9=>R(a+1);a=10^n-1=>R(a+2));r=0 and n=1=>1;v:=a quo 10^(n quo 2);repeat(c:=v;w:=(n rem 2>0=>v quo 10;v);repeat(c:=10*c+w rem 10;w:=w quo 10;w=0=>break);r<0=>(c<a=>R c;v:=v-1);r>0=>(c>a=>R c;v:=v+1);R(c=a=>1;0));c)
b:List INT:=[];o:INT:=0
f(a:NNI):List INT==(free b,o;o:=p(-1,o);w:=0;c:=#b;if c>0 then w:=b.1;e:=a-o;e>10000000=>R[];if w<e then repeat(w:=p(1,w);w>e=>break;b:=cons(w,b));g:List INT:=[];for i in #b..1 by-1 repeat(b.i>e=>break;g:=cons(b.i,g));if o>e then g:=cons(o,g);n:=#g;for i in 1..n repeat(x:=g.i;x=a=>R[x];3*x<a=>break;for j in i..n repeat(y:=g.j;t:=x+y;t>a=>iterate;t=a=>R[x,y];t+y<a=>break;for k in j..n repeat(z:=t+g.k;z=a=>R[x,y,g.k];z<a=>break)));[])
D(a:NNI):List INT==(free o;p(0,a)=1=>[a];o:=a;for j in 1..10 repeat(t:=f(a);#t>0=>R t);[])

codice di prova

--Lista random di n elmenti, casuali compresi tra "a" e "b"
randList(n:PI,a:INT,b:INT):List INT==
    r:List INT:=[]
    a>b =>r
    d:=1+b-a
    for i in 1..n repeat
          r:=concat(r,a+random(d)$INT)
    r

test()==
   a:=randList(20,1,12345678901234)
   [[i,D(i)] for i in a]

Se questo codice deve scomporre il numero X in 1,2,3 palindromi, cosa fa questo codice, si prova vicino a palindromo N <X e decompone XN in 2 palindromi; se questa decomposizione di XN ha esito positivo, vengono restituiti 3 palindromi; se fallisce, prova il precedente palindromo G <N <X e prova a decomporre XG in 2 palindromi ecc. Codice Ungolf (ma è possibile qualche errore)

 R(x)==>return x

-- se 'r'=0 ritorna 1 se 'a' e' palindrome altrimenti ritorna 0
-- se 'r'>0 ritorna la prossima palindrome >'a'
-- se 'r'<0 ritorna la prossima palindrome <'a'
p(r,a)==(n:=#(a::String);if r<0 then(a=0=>R a;n=1 or a=10^(n-1)=>R(a-1);a=10^(n-1)+1=>R(a-2));if r>0 then(n=1 and a<9=>R(a+1);a=10^n-1=>R(a+2));r=0 and n=1=>1;v:=a quo 10^(n quo 2);repeat(c:=v;w:=(n rem 2>0=>v quo 10;v);repeat(c:=10*c+w rem 10;w:=w quo 10;w=0=>break);r<0=>(c<a=>R c;v:=v-1);r>0=>(c>a=>R c;v:=v+1);R(c=a=>1;0));c)

b:List INT:=[]   -- the list of palindrome
o:INT:=0         -- the start value for search the first is a

--Decompose 'a' in 1 or 2 or 3 palindrome beginning with prev palindrome of o
--if error or fail return []
f(a:NNI):List INT==
    free b,o
    -- aggiustamento di o, come palindrome piu' piccola di o
    o:=p(-1,o)
    -- aggiustamento di b come l'insieme delle palindromi tra 1..a-o compresa
    w:=0;c:=#b
    if c>0 then w:=b.1 --in w la massima palindrome presente in b
    e:=a-o
    output["e=",e,"w=",w,"o=",o,"#b=",#b]
    e>10000000=>R[]   --impongo che la palindrome massima e' 10000000-1
    if w<e then       --se w<a-o aggiungere a b tutte le palindromi tra w+1..a-o
          repeat(w:=p(1,w);w>e=>break;b:=cons(w,b))
                      -- g e' l'insieme dei b palindromi tra 1..a-o,o
    g:List INT:=[];for i in #b..1 by-1 repeat(b.i>e=>break;g:=cons(b.i,g))
    if o>e then g:=cons(o,g)
    --output["g=",g,b]
    n:=#g
    for i in 1..n repeat
        x:=g.i
        x=a  =>R[x]
        3*x<a=>break
        for j in i..n repeat
           y:=g.j;t:=x+y
           t>a   =>iterate
           t=a   =>R[x,y]
           t+y<a =>break
           for k in j..n repeat
                z:=t+g.k
                z=a =>R[x,y,g.k]
                z<a =>break
    []

--Decompose 'a' in 1 or 2 or 3 palindrome
--if error or fail return []
dPal(a:NNI):List INT==
   free o
   p(0,a)=1=>[a]
   o:=a                  -- at start it is o=a
   for j in 1..10 repeat -- try 10 start values only
        t:=f(a)
        #t>0=>R t
   []

i risultati:

(7) -> [[i,D(i)] for i in [5,15,21,42,132,345,1022,9265] ]
   (7)
   [[5,[5]], [15,[11,4]], [21,[11,9,1]], [42,[33,9]], [132,[131,1]],
    [345,[343,2]], [1022,[999,22,1]], [9265,[9229,33,3]]]
                                                      Type: List List Any
                                   Time: 0.02 (IN) + 0.02 (OT) = 0.03 sec
(8) -> test()
   (8)
   [[7497277417019,[7497276727947,624426,64646]],
    [11535896626131,[11535888853511,7738377,34243]],
    [2001104243257,[2001104011002,184481,47774]],
    [3218562606454,[3218561658123,927729,20602]],
    [6849377785598,[6849377739486,45254,858]],
    [375391595873,[375391193573,324423,77877]],
    [5358975936064,[5358975798535,136631,898]],
    [7167932760123,[7167932397617,324423,38083]],
    [11779002607051,[11779000097711,2420242,89098]],
    [320101573620,[320101101023,472274,323]],
    [5022244189542,[5022242422205,1766671,666]],
    [5182865851215,[5182864682815,1158511,9889]],
    [346627181013,[346626626643,485584,68786]],
    [9697093443342,[9697092907969,443344,92029]],
    [1885502599457,[1885502055881,542245,1331]], [10995589034484,[]],
    [1089930852241,[1089930399801,375573,76867]],
    [7614518487477,[7614518154167,246642,86668]],
    [11859876865045,[11859866895811,9968699,535]],
    [2309879870924,[2309879789032,81418,474]]]
                                                      Type: List List Any
      Time: 0.25 (IN) + 115.17 (EV) + 0.13 (OT) + 28.83 (GC) = 144.38 sec

Java (OpenJDK 8) , 605 byte

Stampa i duplicati ma non sono vietati

a->{int i=0,j,k,r[]=new int[a-1];for(;i<a-1;r[i]=++i);for(i=0;i<a-1;i++){if(r[i]==a&(""+r[i]).equals(""+new StringBuffer(""+r[i]).reverse()))System.out.println(r[i]);for(j=0;j<a-1;j++){if(r[i]+r[j]==a&(""+r[i]).equals(""+new StringBuffer(""+r[i]).reverse())&(""+r[j]).equals(""+new StringBuffer(""+r[j]).reverse()))System.out.println(r[i]+" "+r[j]);for(k=0;k<a-1;k++)if(r[i]+r[j]+r[k]==a&(""+r[i]).equals(""+new StringBuffer(""+r[i]).reverse())&(""+r[j]).equals(""+new StringBuffer(""+r[j]).reverse())&(""+r[k]).equals(""+new StringBuffer(""+r[k]).reverse()))System.out.println(r[i]+" "+r[j]+" "+r[k]);}}}

Provalo online!

APL (Dyalog) , 51 byte

{w/⍨⍵=+/¨w←(,y∘.,z),,(z←,∘.,⍨y),y←,x/⍨(⌽≡⊢)¨⍕¨x←⍳⍵}

Provalo online!

05AB1E , 8 byte

ÅœR.ΔDíQ

Provalo online!

Spiegazione:

Ŝ          # integer partitions of the input
  R         # reversed (puts the shortest ones first)
   .Δ       # find the first one that...
     D Q    # is equal to...
      í     # itself with each element reversed

Perl 6 , 51 byte

{first *.sum==$_,[X] 3 Rxx grep {$_ eq.flip},1..$_}

Provalo online!

• grep { $_ eq .flip }, 1 .. $_ produce un elenco di tutti i numeri palindromici da 1 al numero di input.
• 3 Rxx replica quell'elenco tre volte.
• [X]riduce tale elenco di elenchi con l'operatore cross-product X, risultando in un elenco di tutte le 3 tuple di numeri di palindrominc da 1 al numero di input.
• first *.sum == $_ trova la prima di queste 3 tuple che si somma al numero di input.

Python 3 , 106 byte

lambda n:[(a,b,n-a-b)for a in range(n)for b in range(n)if all(f'{x}'==f'{x}'[::-1]for x in(a,b,n-a-b))][0]

Provalo online!

Nel collegamento TIO ho usato una versione più veloce (ma 1 byte più lunga) che prende il primo risultato valido come generatore, piuttosto che costruire l'intero elenco di possibili combinazioni e prendere il primo.

Rubino , 84 byte

Crea un elenco di tutte le possibili combinazioni di 3 palindromi da 0 a n, trova il primo la cui somma corrisponde, quindi elimina gli zero.

->n{a=(0..n).select{|x|x.to_s==x.to_s.reverse};a.product(a,a).find{|x|x.sum==n}-[0]}

Provalo online!

Aggiungi ++ , 62 byte

D,g,@,BDdbR=
D,l,@@,$b+=
D,k,@@*,
L,RÞgdVBcB]Gd‽kdG‽k€bF++A$Þl

Provalo online!

~ 50 byte giocavano a golf mentre scrivevo una spiegazione. Definisce una funzione lambda che restituisce un elenco di elenchi contenenti le soluzioni.

Come funziona

$1, 2$$3$$1$$n$$n$

$1, 2, ..., n$gRÞgg$A$

La sezione successiva può essere suddivisa in tre ulteriori parti:

BcB]
Gd‽k
dG‽k€bF

$A$[1 2 3 4 ...][[1] [2] [3] [4] ... ]$A$k

D,k,@@*,

Questa funzione praticamente non fa nulla. Riceve due argomenti e li avvolge in un array. Tuttavia, il tavolo veloce, ‽è il trucco magico qui. Prende due elenchi e genera ogni coppia di elementi tra questi due elenchi. Così [1 2 3]e [4 5 6]genera [[1 4] [1 5] [1 6] [2 4] [2 5] [2 6] [3 4] [3 5] [3 6]]. Prende quindi il suo argomento funzionale (in questo caso k) ed esegue quella funzione su ciascuna coppia, che, in questo caso, restituisce semplicemente le coppie così come sono.

$A$€bF

$1, 2$$3$$n$l$n$