Dado un número entero no negativo n >= 0, genera para siempre la secuencia de números enteros x_i >= 3que son palíndromos en nbases exactamente diferentes b, donde puede estar la base 2 <= b <= x_i-2.

Esto es básicamente el inverso de OEIS A126071 , donde se muestran los índices en esa secuencia que tienen el valor n. Es un poco diferente, porque lo cambié para que ignore las bases b = x_i-1, x_i, x_i+1, ya que los resultados para esas bases son siempre los mismos (los valores son siempre palíndromos o siempre no). Además, el desplazamiento es diferente.

x_iestá restringido a números >= 3para que el primer término del resultado para cada uno nsea A037183 .

Tenga en cuenta que el formato de salida es flexible, pero los números deben estar delimitados de una manera agradable.

Ejemplos:

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 ...

Entonces n=0, obtienes la salida de este desafío (comenzando en 3), porque obtienes números que son palíndromos en n=0bases.

Porque n=1, 5es un palíndromo en la base 2, y esa es la única base en la 2 <= b <= (5-2)que es un palíndromo. 7Es un palíndromo en la base 2, y esa es la única base en la 2 <= b <= (7-2)que es un palíndromo. Etc.

Si su idioma no admite salida infinita, puede tomar otro entero zcomo entrada y salida de los primeros zelementos de la secuencia, o todos los elementos menores que z. El que tu prefieras. Indique cuál utilizó en su respuesta si este es el caso.

Relacionado

Jalea , 18 bytes

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

Pruébalo en línea! - el intérprete en línea tendrá un tiempo de espera de 60 segundos y luego vaciará su salida (a menos que tenga una copia en caché), sin conexión imprimirá cada uno por turno.

¿Cómo?

Evalúa los números desde narriba, imprimiéndolos si están en la secuencia. Tenga en cuenta que el primer número en cualquier salida será mayor que ndado que, de lo contrario, el rango de bno es lo suficientemente grande, por lo que no es necesario iniciar el proceso 3. También tenga en cuenta que el número de palíndromos desde la base 2 hasta x _i -2 inclusive es solo dos menos que el número de palíndromos desde la base 1 hasta 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 bytes

¡Gracias a JungHwan Min por guardar 9 bytes!

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

( ∞es el carácter de tres bytes U + 221E.) Función pura que toma un entero no negativo como entrada. i~IntegerReverse~Range[2,i-2]crea una lista de las reversiones del número ien todas las bases desde 2hasta i-2; luego Length[...~Cases~i]cuenta cuántas de estas reversiones son iguales de inuevo. #!=...||Echo@ise detiene en silencio si ese recuento no es igual a la entrada, y hace eco isi es igual a la entrada. Ese procedimiento está incrustado en un bucle infinito directo.

Pyth, 21 19 18 bytes

.V3IqQlf_IjbTr2tbb

Esto debería funcionar en teoría. Funciona correctamente si sustituyo el bucle infinito por uno finito (por ejemplo, JQFbr3 50*`bqJlf_IjbTr2tbde 3 a 50, intente aquí ), pero el intérprete de Pyth no sabe cuándo o cómo imprimir literalmente una salida infinita.

Explicación:

.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 bytes

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

Intentalo

-> \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
}

Utilidades Bash + Unix, 134 132 bytes

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
}

Pruébalo en línea!

La entrada se pasa como argumento. La salida está en stdout.

Si ejecuta esto normalmente, mostrará un número a la vez en la secuencia infinita.

Si intenta esto en TIO, mostrará la mayor cantidad de salida que ha generado cuando se agota el tiempo de espera en 60 segundos.

Python 2, 132 bytes

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

Pruébalo en línea

El programa TIO tiene un pie de página agregado para que no tenga que esperar 1 minuto para que el programa agote el tiempo de espera antes de ver la salida.