Yo ragazzo, deve riassumere


67

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

32
mmm, gioco di
parole

Mi chiedo: esiste un numero intero che deve essere composto in due palindromi? Questo renderebbe un bel caso di prova (in caso contrario, ehi, i golfisti possono usare questo fatto e solo controllare k=1e k=3.)
Lynn,

@Lynn Sembra "improbabile", dato che ci sono alcune scomposizioni per ogni input. Ma come sappiamo, l'intuizione in matematica può essere così fuorviante ...
Luis Mendo,

1
@Lynn Se stai permettendo k=1(come nel numero originale è già un palindromo), significa che stai assumendo che gli altri 2 numeri siano entrambi 0. Quindi se 0 è accettabile come uno dei numeri, qualsiasi numero che deve essere fatto con k=2funzionerebbe anche k=3se uno dei tre numeri fosse 0.
Darrel Hoffman,

Non credo ci siano numeri che possono ESSERE espressi SOLO come somma di 2. Pertanto, puoi semplicemente coprire il caso 3 e 1 e ignorare 2.
Magic Octopus Urn

Risposte:


19

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

2
Cos'è il casuale .nella spiegazione e il (.)? Non conosco davvero Brachylog.
Magic Octopus Urn

3
@MagicOctopusUrn .è la variabile di output. ~+, ℕᵐe ↔ᵐsono predicati con una variabile sinistra e destra. La duplicazione di quelli .indica semplicemente che l'output è direttamente coinvolto in ognuna di quelle 3 chiamate predicate. Il finale (.)è qui per mostrare che la variabile di output è implicitamente l'ultima variabile del programma. Pertanto, l'ultima relazione dichiarata è in realtà il .↔ᵐ.che significa "mappatura inversa sui risultati di output nell'output" .
Fatalizza il

Finalmente molto buono l'input potrebbe essere> 10000
RosLuP il


8

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.

5
Volevo solo inviare una soluzione con ~ 140 byte, quindi vedo 8 byte e sono tipo: "No, non pubblicherò il mio".
NO NO WORK

15
Il confronto dei punteggi tra le lingue è praticamente insignificante. Ho pubblicato una risposta Python da solo, non perché ha la possibilità di battere questa risposta, ma perché è la risposta Python più breve che mi viene in mente.
Dennis,

8

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.


-9 byte passando alla funzione, sostituendo ccon sottrazioni e usandofilter
Rod

1
@Rod Grazie! filter(Nonecolpiscimi anche mentre stavo preparando la cena, ahah. c → n-a-bè bello :)
Lynn,

7

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


6

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.


1
128 byte . +1, tuttavia, un buon uso di Mapper generare palindromi!
Giuseppe,

oops, trovato un 126 byte
Giuseppe,

4

Gelatina , 14 byte

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

Provalo online!

Molto, molto inefficiente.


Sembra troppo lento, anche se l'obiettivo è lunghezza del codice, per me non è solo la lunghezza
RosLuP

@RosLuP Qui non miri a mantenere il codice efficiente, qui miri ad abbreviare il codice il più possibile. Si deve lavorare in teoria , non necessariamente in pratica, dal momento che si tratta di un codice di-golf sfida, non un codice di-golf restricted-complessità o code-golf -tempo limitato sfida.
Erik the Outgolfer,

4

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.


1
C'è un is palindromelol incorporato
HyperNeutrino,

Inoltre, se si utilizza l'intervallo normale (rialzato), è possibile rimuovere gli ultimi 4 byte
HyperNeutrino,


@cairdcoinheringaahing Still non può battere né Dennis né Erik. In ogni caso, decrittograferò un URL con codifica Base64 compresso Deflate troncato ?
user202729

@utente202729 Eh, non è necessario aver copiato correttamente il collegamento. Il codice eraRŒḂÐfṗ3R¤YS⁼¥Ðf
caird coinheringaahing il


4

Mathematica, 49 byte

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

Provalo online!

restituisce tutte le soluzioni

-2 ~ ~ MartinEnder byte


#~IntegerPartitions~3~Select~AllTrue@PalindromeQ&, Penso?
Martin Ender,


3

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.


Questo secondo me è meglio di tutte le altre soluzioni pubblicate fino ad ora
RosLuP,

@RosLuP Perché, se posso chiedere?
Olivier Grégoire,

Perché alla fine dai le risposte per input> 500000 (se ricordo bene)
RosLuP

Suggerisci i++<--jinvece di++i<=--j
ceilingcat

2

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


920 come input non restituisce l'output in 1 minuto in tio ... Non parlo di 364757698688 ma solo 920
RosLuP

1
@RosLuP Non importa. L'efficienza non è una cosa importante nel code-golf. Funzionerà teoricamente per tutte le dimensioni di input, quindi non importa; dato abbastanza tempo, darà l'output corretto per 920.
HyperNeutrino,

2

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.

2

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.


2

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

1

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!



1

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

1

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.

È possibile salvare un byte non invertendo il xx 3.
Jo King,

1

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.


0

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!


0

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,231nn

1,2,...,ngRÞggUN

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

BcB]
Gd‽k
dG‽k€bF

UN[1 2 3 4 ...][[1] [2] [3] [4] ... ]UNk

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.

UN€bF

1,23nln

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.