Alcuni numeri, come , sono palindromi nella base 10: se si scrivono le cifre in ordine inverso, si ottiene lo stesso numero.$14241$

Alcuni numeri sono la somma di 2 palindromi; ad esempio, o .$110=88+22$$2380=939+1441$

Per altri numeri, 2 palindromi non sono sufficienti; ad esempio, 21 non può essere scritto come la somma di 2 palindromi e il meglio che puoi fare è 3: .$21=11+9+1$

Scrivi una funzione o un programma che accetta l'input intero ne genera il nnumero th che non può essere scomposto come la somma di 2 palindromi. Ciò corrisponde a OEIS A035137 .

Le cifre singole (incluso 0) sono palindromi.

Si applicano le regole standard per le sequenze:

• input / output è flessibile
• è possibile utilizzare l'indicizzazione 0 o 1-
• puoi emettere il ntermine o i primi ntermini o una sequenza infinita

(Come un sidenote: tutti i numeri interi possono essere scomposti come la somma di al massimo 3 palindromi.)

Casi di test (1 indicizzato):

1 -> 21
2 -> 32
10 -> 1031
16 -> 1061
40 -> 1103

Questo è code-golf, quindi vince la risposta più breve.

JavaScript (ES6),  93 83 80  79 byte

Salvato 1 byte grazie a @tsh

Restituisce il $n$ ^° periodo, 1-indicizzati.

i=>eval("for(n=k=1;k=(a=[...k+[n-k]+k])+''!=a.reverse()?k-1||--i&&++n:++n;);n")

Provalo online!

Come?

Dato $n$ , testiamo se esiste $1\le k\le n$ tale che sia $k$ che $n-k$ sono palindromi. Se troviamo tale $k$ , allora $n$ è la somma di due palindromi.

Il trucco qui è elaborare $k$ e $n-k$ allo stesso tempo testando una singola stringa fatta della concatenazione di $k$ , $n-k$ e $k$ .

Esempio:

Per $n=2380$ :

• alla fine raggiungiamo $k=1441$ e $n-k=939$
• testiamo la stringa " $1441\color{red}{939}1441$ " e scopriamo che è un palindromo

Commentate

NB: questa è una versione senza eval()leggibilità.

i => {                       // i = index of requested term (1-based)
  for(                       // for loop:
    n = k = 1;               //   start with n = k = 1
    k =                      //   update k:
      ( a =                  //     split and save in a[] ...
        [...k + [n - k] + k] //     ... the concatenation of k, n-k and k
      ) + ''                 //     coerce it back to a string
      != a.reverse() ?       //     if it's different from a[] reversed:
        k - 1                //       decrement k; if the result is zero:
          || --i             //         decrement i; if the result is not zero:
            && ++n           //           increment n (and update k to n)
                             //         (otherwise, exit the for loop)
      :                      //     else:
        ++n;                 //       increment n (and update k to n)
  );                         // end of for
  return n                   // n is the requested term; return it
}                            //

Gelatina ,  16 10  9 byte

-1 byte grazie a Erik the Outgolfer . Emette i primi $n$ termini.

2_ŒḂƇ⁺ṆƲ#

Provalo online!

Ho provato a trovare un'idea diversa rispetto al mio approccio originale. Rivediamo il processo di pensiero:

• Inizialmente, il test ha funzionato come segue: ha generato le partizioni intere di quel numero, quindi ha filtrato quelle che contenevano anche non-palindromi, quindi ha contato quante liste ammissibili lunghezza 2 c'erano. Questo ovviamente non era troppo efficiente in termini di lunghezza del codice.

• La generazione delle partizioni intere di $N$ e quindi il filtraggio presentavano 2 principali svantaggi: lunghezza e efficienza temporale. Per risolvere questo problema, ho pensato che avrei prima escogitato un metodo per generare solo le coppie di numeri interi $(x, y)$ che si sommano a $N$ (non tutti gli elenchi di lunghezza arbitraria) a condizione che entrambi i numeri debbano essere palindromi.

• Tuttavia, non ero soddisfatto del "modo classico" di procedere. Ho cambiato approccio: invece di generare coppie , concentriamo il programma su palindromi specifici . In questo modo, si può semplicemente calcolare tutti i palindromi $x$ sotto $N$ , e se $N-x$ è anche palindromo, allora abbiamo finito.

Spiegazione del codice

2_ŒḂƇ⁺ṆƲ #: collegamento monadico o programma completo. Argomento: n.
2 # - A partire da 2 * , trova i primi n numeri interi che soddisfano ...
 _ŒḂƇ⁺ṆƲ - ... il collegamento di aiuto. Ripartizione (chiamare l'attuale numero intero N):
    Ƈ - Filtro. Crea l'intervallo [1 ... N] e mantiene solo quelli che ...
  ŒḂ - ... sono palindromi. Esempio: 21 -> [1,2,3,4,5,6,7,8,9,11]
 _ - Sottrarre ciascuno di quei palindromi da N. Esempio: 21 -> [20,19, ..., 12,10]
     ⁺ - Duplica il link precedente (pensalo come se ci fosse un ulteriore ŒḂƇ
            invece di ⁺). Ciò mantiene solo i palindromi in questo elenco.
            Se l'elenco non è vuoto, significa che abbiamo trovato una coppia (x, Nx)
            contiene due palindromi (e ovviamente x + Nx = N, quindi si sommano a N).
      Ṇ - NOT logico (stiamo cercando gli interi per i quali questo elenco è vuoto).
       Ʋ - Raggruppa gli ultimi 4 collegamenti (fondamentalmente fai in modo che _ŒḂƇ⁺Ṇ agisca come una singola monade).

^{* Qualsiasi altra cifra diversa da zero funziona, del resto.}

Gelatina , 11 byte

⁵ŻŒḂ€aṚ$EƲ#

Provalo online!

Il programma completo funziona più o meno in questo modo:

1. Impostare z sull'input.
2. Impostare x su 10 .
3. Impostare R su [] .
4. Per ogni intero k da 0 fino al x , verificare se sia k e x - k sono palindromo.
5. Se tutti gli elementi di L sono uguali (vale a dire, se entrambe le coppie possibili che sommano a x hanno entrambi i loro elementi palindromici, o tutte tali coppie hanno al massimo uno dei loro elementi essere palindromici), imposta z su z - 1 e aggiungi x a R .
6. Se z = 0 , restituisce R e fine.
7. Impostare x su x + 1 .
8. Vai al passaggio 4.

Potresti sospettare che il passaggio 5 in realtà non faccia il lavoro che dovrebbe. Non dovremmo davvero diminuire z se tutte le coppie che sommano x sono palindromiche. Tuttavia, possiamo dimostrare che ciò non accadrà mai:

Scegliamo prima un numero intero $k$ modo che $10\le k\le x$ . Possiamo sempre farlo, perché, al passaggio 2, inizializziamo x su 10 .

Se $k$ non è un palindromo, allora abbiamo la coppia $(k,x-k)$ , dove $k+(x-k)=x$ , quindi non tutte le coppie hanno due palindromi.

Se, d'altra parte, $k$ è un palindromo, allora possiamo dimostrare che $k-1$ non è un palindromo. Lasciare che le prime e ultime cifre $k$ siano $D_F$ e $D_L$ rispettivamente. Poiché $k$ è un palindromo, $D_F=D_L>0$ . Lasciare che le prime e ultime cifre del $k-1$ BE $D'_F$ e $D'_L$ rispettivamente. Poiché $D_L>0$ , $D'_L=D'_F-1\ne D'_F$ . Pertanto,$k-1$ non è un palindromo e abbiamo la coppia$(k-1,x-(k-1))$ , dove$(k-1)+(x-(k-1))=k-1+x-k+1=x$ .

Concludiamo che, se iniziamo con l'impostazione di x su un valore maggiore o uguale a 10 , non possiamo mai avere tutte le coppie di numeri interi non negativi che sommano a x essere coppie di palindromi.

Retina , 135 102 byte

K`0
"$+"{0L$`\d+
*__
L$`
<$.'>$.`>
/<((.)*.?(?<-2>\2)*(?(2)$)>){2}/{0L$`\d+
*__
))L$`
<$.'>$.`>
0L`\d+

Provalo online! Troppo lento per n10 o più. Spiegazione:

K`0

Inizia provando 0.

"$+"{

Ripeti i ntempi.

0L$`\d+
*__

Converti il ​​valore di prova corrente in unario e incrementalo.

L$`
<$.'>$.`>

Crea tutte le coppie di numeri interi non negativi che si sommano al nuovo valore di prova.

/<((.)*.?(?<-2>\2)*(?(2)$)>){2}/{

Ripeti finché esiste almeno una coppia contenente due numeri interi palindromici.

0L$`\d+
*__
))L$`
<$.'>$.`>

Incrementa ed espandi nuovamente il valore di prova.

0L`\d+

Estrarre il valore finale.

Haskell, 68 67 63 byte

[n|n<-[1..],and[p a||p(n-a)|a<-[0..n]]]
p=((/=)=<<reverse).show

Restituisce una sequenza infinita.

Raccogli tutto ndove uno ao n-anon è un palindromo per tutti a <- [0..n].

Provalo online!

Perl 5 -MList::Util=any -p , 59 55 byte

-3 byte grazie a @NahuelFouilleul

++$\while(any{$\-reverse($\-$_)==reverse}0..$\)||--$_}{

Provalo online!

Nota: anypotrebbe essere sostituito da greped evitare l' -Mopzione della riga di comando, ma in base alle regole di calcolo del punteggio correnti, costerebbe un ulteriore byte.

R , 115 111 byte

-4 grazie a Giuseppe

function(n,r=0:(n*1e3))r[!r%in%outer(p<-r[Map(Reduce,c(x<-paste0),Map(rev,strsplit(a<-x(r),"")))==a],p,'+')][n]

Provalo online!

Gran parte del lavoro è impacchettato negli argomenti della funzione per rimuovere la {}chiamata di una funzione multiistruzione e per ridurre le parentesi necessarie nella definizione dell'oggettor

La strategia di base è trovare tutti i palindromi fino a un determinato limite (incluso 0), trovare tutte le somme a coppie e quindi prendere l'n-esimo numero non in quell'output.

Il limite è n*1000stato scelto esclusivamente da un'ipotesi istruita, quindi incoraggio chiunque a dimostrarlo / smentirlo come una scelta valida.

r=0:(n*1e3)può probabilmente essere migliorato con un limite più efficiente.

Map(paste,Map(rev,strsplit(a,"")),collapse="")viene strappato dalla risposta di Mark qui ed è incredibilmente intelligente per me.

r[!r%in%outer(p,p,'+')][n]mi sembra un po 'inefficiente.

C # (compilatore interattivo Visual C #) , 124 byte

n=>{int a=0;for(string m;n>0;)if(Enumerable.Range(0,++a).All(x=>!(m=x+""+(a-x)+x).Reverse().SequenceEqual(m)))n--;return a;}

Provalo online!

J , 57/60 byte

0(](>:^:(1&e.p e.]-p=:(#~(-:|.)&":&>)&i.&>:)^:_)&>:)^:[~]

Provalo online!

La versione collegata aggiunge 3 byte per un totale di 60 al fine di salvare come una funzione che il piè di pagina può chiamare.

Nel REPL, questo viene evitato chiamando direttamente:

   0(](>:^:(1 e.q e.]-q=:(#~(-:|.)&":&>)&i.&>:)^:_)&>:)^:[~] 1 2 10 16 40
21 32 1031 1061 1103

Spiegazione

La struttura generale è quella di questa tecnica da una risposta di Miles :

(s(]f)^:[~]) n
          ]  Gets n
 s           The first value in the sequence
         ~   Commute the argument order, n is LHS and s is RHS
        [    Gets n
      ^:     Nest n times with an initial argument s
  (]f)         Compute f s
         Returns (f^n) s

Ciò ha consentito di risparmiare alcuni byte rispetto alla mia tecnica di looping originale, ma poiché la funzione principale è il mio primo tentativo di scrivere J, probabilmente c'è ancora molto che può essere migliorato.

0(](>:^:(1&e.p e.]-p=:(#~(-:|.)&":&>)&i.&>:)^:_)&>:)^:[~]
0(]                                                 ^:[~] NB. Zero as the first term switches to one-indexing and saves a byte.
   (>:^:(1&e.p e.]-p=:(#~(-:|.)&":&>)&i.&>:)^:_)&>:)      NB. Monolithic step function.
                                                 >:       NB. Increment to skip current value.
   (>:^: <predicate>                        ^:_)          NB. Increment current value as long as predicate holds.
                   p=:(#~(-:|.)&":&>)&i.&>:               NB. Reused: get palindromes in range [0,current value].
                       #~(-:|.)&":&>                      NB. Coerce to strings keeping those that match their reverse.
                 ]-p                                      NB. Subtract all palindromes in range [0,current value] from current value.
    >:^:(1&e.p e.]-p                                      NB. Increment if at least one of these differences is itself a palindrome.

05AB1E , 15 12 byte

°ÝDʒÂQ}ãOKIè

-3 byte grazie a @Grimy .

0-indicizzati.
Molto lento, quindi timeout per la maggior parte dei casi di test.

Provalo online o verifica i primi casi rimuovendo il fileIè .

Versione 15 byte precedente molto più veloce:

µNÐLʒÂQ}-ʒÂQ}g_

1-indicizzati.

Provalo online o invia il primo$n$valori .

Spiegazione:

°Ý              # Create a list in the range [0, 10**input]
  D             # Duplicate this list
   ʒÂQ}         # Filter it to only keep palindromes
       ã        # Take the cartesian product with itself to create all possible pairs
        O       # Sum each pair
         K      # Remove all of these sums from the list we duplicated
          Iè    # Index the input-integer into it
                # (after which the result is output implicitly)

µ               # Loop until the counter variable is equal to the (implicit) input-integer
 NÐ             #  Push the loop-index three times
   L            #  Create a list in the range [1, N] with the last copy
    ʒÂQ}        #  Filter it to only keep palindromes
        -       #  Subtract each from N
         ʒÂQ}   #  Filter it again by palindromes
             g_ #  Check if the list is empty
                #   (and if it's truthy: increase the counter variable by 1 implicitly)
                # (after the loop: output the loop-index we triplicated implicitly as result)

Rosso , 142 byte

func[n][i: 1 until[i: i + 1 r: on repeat k i[if all[(to""k)= reverse
to""k(s: to""i - k)= reverse copy s][r: off break]]if r[n: n - 1]n < 1]i]

Provalo online!

Restituisce n-esimo termine, 1 indicizzato

Python 3 , 107 byte

p=lambda n:str(n)!=str(n)[::-1]
def f(n):
 m=1
 while n:m+=1;n-=all(p(k)+p(m-k)for k in range(m))
 return m

Provalo online!

Inversione del controllo del palindromo salvato 2 byte :)

Per riferimento il controllo positivo diretto (109 byte):

p=lambda n:str(n)==str(n)[::-1]
def f(n):
 m=1
 while n:m+=1;n-=1-any(p(k)*p(m-k)for k in range(m))
 return m

APL (NARS), 486 byte

r←f w;p;i;c;P;m;j
p←{k≡⌽k←⍕⍵}⋄i←c←0⋄P←r←⍬
:while c<w
    i+←1
    :if   p i⋄P←P,i⋄:continue⋄:endif
    m←≢P⋄j←1
    :while j≤m
         :if 1=p i-j⊃P⋄:leave⋄:endif
         j+←1
    :endwhile
    :if j=m+1⋄c+←1⋄r←i⋄:endif
:endwhile

Qual è la parola per interrompere il ciclo? Sembra che sia ": partire", giusto? {k≡⌽k←⍕⍵}in p è il test per palindromo. Questa funzione di cui sopra nel loop memorizza tutto il palindromo trovato nell'insieme P, se per qualche elemento w di P è tale che anche iw è in P ciò significa che l'i non è giusto e abbiamo un incremento i. risultati:

  f 1
21
  f 2
32
  f 10
1031
  f 16
1061
  f 40
1103
  f 1000
4966
  f 1500
7536