Dato un numero intero non negativo n >= 0, genera per sempre la sequenza di numeri interi x_i >= 3che sono palindromi in nbasi esattamente diverse b, dove può essere la base 2 <= b <= x_i-2.

Questo è fondamentalmente l'inverso di OEIS A126071 , dove vengono emessi gli indici in quella sequenza che hanno il valore n. È un po 'diverso, perché l'ho modificato in modo da ignorare le basi b = x_i-1, x_i, x_i+1, poiché i risultati per quelle basi sono sempre gli stessi (i valori sono sempre palindromi o sempre no). Inoltre, l'offset è diverso.

x_iè limitato ai numeri in >= 3modo che il primo termine del risultato per ciascuno nsia A037183 .

Si noti che il formato di output è flessibile, ma i numeri dovrebbero essere delimitati in modo piacevole.

Esempi:

n   seq
0   3 4 6 11 19 47 53 79 103 137 139 149 163 167 ...
1   5 7 8 9 12 13 14 22 23 25 29 35 37 39 41 43 49 ...
2   10 15 16 17 18 20 27 30 31 32 33 34 38 44 ...
3   21 24 26 28 42 45 46 50 51 54 55 56 57 64 66 68 70 ...
4   36 40 48 52 63 65 85 88 90 92 98 121 128 132 136 138 ...
5   60 72 78 84 96 104 105 108 112 114 135 140 156 162 164 ...
10  252 400 420 432 510 546 600 648 784 800 810 816 819 828 858 882 910 912 1040 1056 ...

Quindi n=0, ottieni l'output di questa sfida (a partire da 3), perché ottieni numeri che sono palindromi in n=0basi.

Perché n=1, 5è un palindromo in base 2, e questa è l'unica base in 2 <= b <= (5-2)cui è un palindromo. 7È un palindromo in base 2, e questa è l'unica base in 2 <= b <= (7-2)cui è un palindromo. Ecc.

Se la tua lingua non supporta un output infinito, puoi prendere un altro numero intero zcome input e generare i primi zelementi della sequenza o tutti gli elementi in meno z. Qualunque cosa tu preferisca. Si prega di indicare quale è stato utilizzato nella risposta in questo caso.

Relazionato

Gelatina , 18 byte

Ṅ‘µ‘µbRŒḂ€S_2⁼³µ?ß

Provalo online! - l'interprete online scadrà a 60 secondi, quindi scaricherà l'output (a meno che non abbia una copia cache), offline verrà stampato a turno.

Come?

Valuta i numeri dall'alto n, stampandoli se sono nella sequenza. Si noti che il primo numero in qualsiasi output sarà maggiore di npoiché altrimenti l'intervallo di bnon è abbastanza grande, quindi non è necessario eseguire il seeding del processo 3. Si noti inoltre che il numero di palindromi dalla base 2 a x _i -2 compreso è solo due inferiore al numero di palindromi dalla base 1 a x .

Ṅ‘µ‘µbRŒḂ€S_2⁼³µ?ß - Main link: n
 AµBµC         µ?  - ternary if: if C then A else B
      R            - range: [1,2,3...,n]
     b             - n converted to those bases
       ŒḂ€         - is palindromic? for €ach
          S        - sum: counts the 1s
           _2      - subtract 2: throw away the truthy unary and base n-1 effect
             ⁼³    - equals input: Does this equal the ORIGINAL n?
Ṅ                  - if so: print n
 ‘                 -        increment n
   ‘               - else: just increment n
                 ß - calls this link as a monad, with the incremented n.

Mathematica, 80 71 byte

Grazie a JungHwan Min per aver salvato 9 byte!

Do[#!=Length[i~IntegerReverse~Range[2,i-2]~Cases~i]||Echo@i,{i,3,∞}]&

( ∞è il carattere a tre byte U + 221E.) Funzione pura che accetta un intero non negativo come input. i~IntegerReverse~Range[2,i-2]crea un elenco delle inversioni del numero iin tutte le basi da 2a i-2; quindi Length[...~Cases~i]conta quante di queste inversioni sono di inuovo uguali . #!=...||Echo@isi interrompe silenziosamente se quel conteggio non è uguale all'input e fa eco ise è uguale all'input. Tale procedura è integrata in un semplice ciclo infinito.

Pyth, 21 19 18 byte

.V3IqQlf_IjbTr2tbb

Questo dovrebbe funzionare in teoria. Funziona correttamente se sostituisco il ciclo infinito con uno finito (ad esempio JQFbr3 50*`bqJlf_IjbTr2tbper 3 fino a 50, prova qui ), ma l'interprete Pyth non sa quando o come stampare un output letteralmente infinito.

Spiegazione:

.V3IqQlf_IjbTr2tbb
.V3                     increase b infinitely, starting from 3
             r2Tb       range of integers including 2 to b - 2
      lf                length of elements retained if:
          jbT             b in that base
        _I                is invariant under reversal
    qQ                  check if the length is equivalent to the input
   I             b      output b if so

Perl 6 , 90 byte

->\n{->{$_=++($ //=2);$_ if n==grep {($/=[.polymod($^b xx*)])eq[$/.reverse]},2..$_-2}...*}

Provalo

-> \n {

  # sequence generator
  ->{         # using a code block with no parameter

    $_ =      # set the default scalar to the value being tested
      ++(     # preincrement
        $     # anonymous state variable
        //= 2 # initialized to 2 
      );

    # the anonymous state var maintains its state
    # only for this current sequence
    # every time the outer block gets called it is created anew

    $_    # return the current value
      if  # if the following is true

        n == grep # find all that match the following code

          {
            # convert the current value to the base being tested
            # store as an Array in $/
            ($/ = [ .polymod($^b xx*) ] )

            eq    # is string equal to: (shorter than eqv)

            [ $/.reverse ]
          },

          2 .. $_ - 2 # from the list of bases to test
  }

  ...  # keep using that code block to produce values

  *    # indefinitely
}

Utilità Bash + Unix, 134 132 byte

for((x=3;;x++)){
c=$1
for((b=x-1;--b>1;)){
s=`bc<<<"for(y=$x;y;y/=$b)y%$b"`
t=`tac<<<"$s"`
[ "${s#$t}" ]||((c--))
}
((c))||echo $x
}

Provalo online!

L'input viene passato come argomento. L'output è su stdout.

Se lo esegui normalmente, verrà visualizzato un numero alla volta nella sequenza infinita.

Se lo provi in ​​TIO, visualizzerà tutta l'output che ha generato quando scade a 60 secondi.

Python 2, 132 byte

B=lambda n,b:[]if(n<1)else B(n/b,b)+[n%b]
n=input()
x=3
while 1:
    if sum(B(x,b)==B(x,b)[::-1]for b in range(2,x-1))==n:print x
    x+=1

Provalo online

Il programma TIO ha un piè di pagina aggiunto, quindi non è necessario attendere 1 minuto per il timeout del programma prima di vedere l'output.