Ogni palindromo con un numero pari di cifre è divisibile per 11, quindi 11 è l'unico [primo palindromico] con un numero pari di cifre. - David Wasserman, OEIS

L'ho imparato oggi in modo manuale, prima di fare le mie ricerche, quando il mio programma ha saltato i numeri con un numero pari di cifre (tranne 11) durante il calcolo dei primi palindromici. Il tuo compito: crea un programma o una funzione che, quando viene immesso un input intero N, genera l'ennesimo termine in Stephen's Palindromic Sequence ™.

Stephen's Palindromic Sequence ™

Stephen's Palindromic Sequence ™ inizia con 11 e continua con semiprime palindromici divisibili per 11. In sostanza, tutti i semiprimi che sarebbero primi se 11 non "contasse". Il lato positivo è che questo elenco contiene numeri con un numero pari di cifre! Sìì. E molti numeri con un numero dispari di cifre vengono saltati, poiché erano già primi.

L'inizio della sequenza:

1   : 11
2   : 22
3   : 33
4   : 55
5   : 77
6   : 121
7   : 737
8   : 979
9   : 1111
10  : 1441
11  : 1661
12  : 1991
13  : 3113
14  : 3223
15  : 3443
16  : 3883
17  : 7117
18  : 7447
19  : 7997
20  : 9119
21  : 9229
22  : 9449
23  : 10901

_{^{* Sebbene 1331 (11 ^ 3) e simili si adattino allo spirito di questa sequenza, non si adattano alle regole.}}

Casi di prova più lunghi:

26  : 91619
31  : 103301
41  : 139931
51  : 173371
61  : 305503
71  : 355553
81  : 395593
91  : 725527
101 : 772277
127 : 997799
128 : 1099901
141 : 3190913
151 : 3739373
161 : 7589857
171 : 9460649
200 : 11744711
528 : 39988993

Ingresso

Numero intero N,> = 1. È possibile utilizzare un N indicizzato 0 (assicurarsi di regolare i casi di test) se lo si specifica nella risposta. Trailing newline ammessi.

Produzione

L'ennesimo termine in Stephen's Palindromic Sequence ™. Trailing newline ammessi.

Regole

• L'unico input che il tuo programma / funzione può accettare è N. Il tuo programma non può, ad esempio, recuperare una sequenza da OEIS (ovvero le scappatoie standard si applicano ).
• Devi essere in grado di stampare un output fino a sei cifre (N = 127). Il tempo non è un fattore: tuttavia, se il programma / funzione diventa molto lungo molto velocemente, è necessario dimostrare che l'algoritmo funziona. Se la tua lingua consente naturalmente output più lunghi, puoi lasciarlo espandere naturalmente fino al limite o limitarlo a dieci cifre, a seconda delle tue preferenze. L'output / terminazione oltre il limite non ha importanza, purché non sembri un output valido.
• La funzione programma / funzione su input non validi è irrilevante.

Gelatina , 18 13 byte

ṬÆẸש11ŒḂµ#ṛ®

Per qualche ragione, questo è molto più lento della mia revisione iniziale, nonostante faccia esattamente lo stesso.

Provalo online!

N = 127

dennis-home:~$ time jelly eun 'ṬÆẸש11ŒḂµ#ṛ®' <<< 127
997799

real    1m43.745s
user    1m43.676s
sys     0m0.113s

Come funziona

ṬÆẸש11ŒḂµ#ṛ®  Main link. No arguments.

         µ     Combine all links to the left into a chain.
          #    Read an integer n from STDIN and call the chain monadically, with
               argument k = 0, 1, 2, ... until n values of k result in a truthy
               output. Return the array of all matching values of k.
Ṭ                Untruth; yield [0, 0, 0, ..., 1] (k-1 zeroes followed by a 1) or
                 [] if k = 0.
 ÆẸ              Unexponents; consider the resulting array as exponents of the
                 sequence of primes and yield the corresponding integer. For k = 0,
                 this yields 1. For k > 0, it yields the k-th prime.
   ש11          Multiply the result by 11 and copy the product to the register.
       ŒḂ        Test if the product is a palindrome.
           ṛ®  Replace the resulting array with the integer in the register.

Python 2 , 76 73 72 70 69 68 byte

n=input();c=k=m=11
while n:m*=k/c;k+=c;n-=`k`==`k`[::~m%k-c]
print k

Grazie a @WheatWizard per giocare a golf da 3 byte!

Grazie a @ ØrjanJohansen per il golf off 1 byte!

Grazie a @xnor e @ ØrjanJohansen per aver spianato la strada a 68 byte!

L'input è indicizzato 0. Provalo online! oppure verifica i primi 31 casi di test .

sfondo

Ricordiamo che il teorema di Wilson afferma che per tutti gli interi p> 1 ,

nel senso che (p - 1)! + 1 è uniformemente divisibile per p se e solo se p è primo.

Se p> 1 non è primo, è composito; lascia che q sia il più piccolo divisore primo di p . Chiaramente, q ≤ p / q . Esistono due casi:

• Se q = p / q , abbiamo che p = q² .

  Se q = 2 , (p - 1)! = 3! = 6 , quindi (p - 1)! è congruente con 2 modulo p .

  Se p / q = q> 2 , quindi 2q <p . In questo modo, q e 2q sono entrambi tra 1, ..., p - 1 , il cui prodotto è il fattoriale di p - 1 , quindi 2p = 2q² = q · 2q divide (p - 1)! in modo uniforme.

• Se q <p / q , q e p / q sono entrambi tra 1, ..., p - 1 , quindi p = q · p / q divide (p - 1)! in modo uniforme.

Riassumendo,

per tutti i numeri interi p> 1 .

Ora, per tutte le congruenze di numeri interi e tutti i numeri interi a , b e c , vale quanto segue.

Quando a = -1 , b = 11 e c = -1 , lo seguiamo

e poiché 21 e -23 sono congruenti modulo 44 e -1 e 11p-1 sono congruenti modulo 11p , arriviamo alla seguente conclusione.

Per tutti i possibili valori di p , il risultato ( 11 , 21 o 11p - 1 ) rientrerà nell'intervallo 0, ..., 11p - 1 , quindi questi valori corrispondono a quelli che verranno restituiti da Python% .

Come funziona

Inizializziamo c , k e m su 11 dopo il salvataggio dell'ingresso in n . c sarà costante per il resto del programma. Poiché sulla riga seguente sono presenti tre occorrenze di c e l'assegnazione di c costa solo due byte, questo salva un byte. k può essere considerato 11p usando il significato di p del paragrafo precedente; inizialmente, k = 11 = 11 · 1! . m prende il posto di 11 · (p - 1)! ; inizialmente, m = 11 = 11 · 0! . k e msoddisferà la relazione m = 11 · (k / 11)! sempre.

n rappresenta il numero di "palindromi di Stephen" che dobbiamo trovare. Poiché inizialmente k = 11 , possiamo produrre k testualmente senza ulteriore calcolo. Tuttavia, quando n è positivo, entriamo nel ciclo while. Il ciclo inizia moltiplicando m per k / c = p , quindi aggiungendo 11 a k , aumentando così p . Se k è un membro della sequenza, sottraggiamo 1 da n e ricominciamo. Quando n raggiunge 0 , abbiamo trovato il membro della sequenza nell'indice desiderato e siamo usciti dal ciclo, quindi stampiamo l'ultimo valore di k.

L'espressione

`k`==`k`[::~m%k-c]

esegue il test effettivo e il suo risultato ( True / 1 per i membri della sequenza, 0 / False altrimenti) viene sottratto da n . Come visto in precedenza, ~ m% k = (-m - 1)% k = (-11 · (p - 1)! - 1)% 11p è uguale a 10 se p è primo, 21 se p = 4 e 11p - 1 > 43 se p> 4 è composito. Quindi, dopo aver sottratto c = 11 , rimaniamo con -1 per il primo p e un numero intero positivo maggiore di 9 altrimenti.

Per p principale , ​`k`[::-1]ci fornisce la rappresentazione in forma di stringa di k con ordine di cifra invertito, quindi confrontandola per ​`k`​verificare se k è un palindromo. In tal caso, tutte le condizioni sono soddisfatte e k è un membro della sequenza. Tuttavia, se p non è un numero primo, il passo a grande intervallo e il fatto che k avrà sempre più di una cifra significa che ​`k`[::-1]non può avere lo stesso numero di cifre ​`k`​, figuriamoci essere uguale a esso.

Brachylog , 17 byte

:I{11|ṗ×₁₁≜.↔}ᶠ⁽t

Provalo online!

Questo è 1-indicizzato.

Spiegazione

:I{          }ᶠ⁽t    Find the Input'th result of the following:
   11                  Output = 11
     |                 Or
          ≜.           Output is an integer…
      ṗ×₁₁             …which is the result of multiplying a prime by 11…
           .↔          …and Output reversed is still the Output

Due realizzazioni con questa risposta:

• Ho bisogno di correggere il fatto che l'apice del passaggio ai metapredicati (con ⁽) non funziona se non ci sono input da passare (motivo per cui devo aggiungere :I).
• Ho bisogno di aggiungere un metapredicato per ottenere il Nrisultato di un predicato (che eviterebbe di usare ᶠ⁽te invece ad es ⁿ⁽.).

L'implementazione di entrambe le modifiche renderebbe tale risposta 14 byte.

Mathematica, 65 60 byte

n=NextPrime;11Nest[n@#//.x_/;!PalindromeQ[11x]:>n@x&,1,#-1]&

Scorre direttamente i numeri primi usando NextPrimee controlla se 11 volte il primo è un palindromo. Funziona fino a N = 528 . I risultati 528 e 529 sono distanti più di 2 ¹⁶ numeri primi, a quel punto //.non si tenterà un numero sufficiente di sostituzioni.

Python 2 , 111 107 103 102 101 101 100 91 90 89 byte

Dennis mi ha battuto qui , quindi vai a vedere la sua risposta.

Questa risposta è indicizzata zero

n=input()
r=1
while n:r+=1;c=`r*11`;n-=all(r%x for x in range(2,r))*c==c[::-1]
print r*11

Provalo online!

Un byte salvato grazie al drogato di matematica

Spiegazione

Innanzitutto prendiamo l'input e lo impostiamo su per ncreare anche una nuova variabile r=1. Conteremo alla rricerca di palindromi che sono il prodotto di un numero primo e 11. Ogni volta che ne troviamo uno diminuiremo nfino a raggiungere 0.

Quindi iniziamo un ciclo:

while n:

La prima cosa che facciamo è l'incremento r

r+=1

Abbiamo anche predefinito una variabile ccome rappresentazione di stringa dir*11

c=`r*11`

Ora vogliamo diminuire nse abbiamo trovato un numero simile. Sottrarremo semplicemente un booleano che rappresenta se si r*11adatta allo schema r. In questo caso Falsesottrarremo zero e in caso contrario Truesottrarremo 1.

Per calcolare il valore booleano facciamo:

all(r%x for x in range(2,r))*c==c[::-1]

La prima parte alldeterminerà se rè primo. Moltiplichiamo il risultato cse rè primo questo sarà, cma se rsarà composto sarà ""la stringa vuota. Confrontiamo quindi questo con il c[::-1]quale è il contrario di c. Se rè primo ed cè un palindromo lo sarà True, se uno dei due fallisce, l'intera cosa verrà valutata come falsa.

Quando nè zero, semplicemente print c.

83 byte

Ecco una soluzione ricorsiva che è più breve ma purtroppo non soddisfa le specifiche perché colpisce il tappo di ricorsione di Python troppo velocemente.

f=lambda n,r=1:n and f(n-all(r%x*(`r*11`==`r*11`[::-1])for x in range(2,r)),r+1)+11

Provalo online!

05AB1E , 15 byte

0-indicizzati.

11Iµ11N*DÂQNp*½

Provalo online!

Spiegazione

11               # initialize stack with 11
  Iµ             # loop over N in [1 ... inf] until counter equals input
    11N*         # multiply N by 11
        D        # duplicate
         ÂQ      # check if the copy equals its reverse
           Np    # check if N is prime
             *   # multiply the results of the checks together
              ½  # if 1, increase counter

Haskell , 94 90 byte

h#n|n<2=0|mod n h<1=1+h#div n h|j<-h+1=j#n
([n|n<-[0,11..],(==)=<<reverse$show n,3>2#n]!!)

Provalo online! Esempio di utilizzo: ([n|n<-[0,11..],(==)=<<reverse$show n,3>2#n]!!) 127.

[0,11..]costruisce l'elenco infinito [0,11,22,33, ...](lo zero è necessario per rendere la sequenza 1 indicizzata). Per ognuno nin questo elenco controlliamon==(read.reverse.show)n , cioè se nè un palindromo. 3>2#ncontrolla se nha al massimo due divisori primi. Poiché nè sempre divisibile per 11, non otteniamo numeri primi reali ma solo semiprimi.

Modifica: grazie a Ørjan Johansen per giocare a golf a 4 byte!

PHP, 82 byte

for(;$d<$argn;$i>1||($p=11*$n)!=strrev($p)?:$d++)for($i=++$n;--$i&&$n%$i;);echo$p;

Provalo online!

Assioma, 105 byte

g(n)==(i:=c:=1;repeat(c=n=>break;i:=i+1;if(prime? i)then(x:=(11*i)::String;x=reverse(x)=>(c:=c+1)));i*11)

ungolf, codice test e risultati

f(n)==
   i:=c:=1
   repeat
      c=n=>break
      i:=i+1
      if(prime? i)then(x:=(11*i)::String;x=reverse(x)=>(c:=c+1))
   i*11


(5) -> [[i,g(i)]  for i in 1..23]
   (5)
   [[1,11], [2,22], [3,33], [4,55], [5,77], [6,121], [7,737], [8,979],
    [9,1111], [10,1441], [11,1661], [12,1991], [13,3113], [14,3223], [15,3443],
    [16,3883], [17,7117], [18,7447], [19,7997], [20,9119], [21,9229],
    [22,9449], [23,10901]]
                                          Type: List List PositiveInteger
(6) -> [[i,g(i)]  for i in [26,31,41,101,151,200]]
   (6)
   [[26,91619], [31,103301], [41,139931], [101,772277], [151,3739373],
    [200,11744711]]

Qui g (700) = 92511529 quindi il limite sarebbe> 700; ww (1000) = 703999307 ma utilizzando nextPrime ()