Dado um número inteiro não negativo n >= 0, imprima para sempre a sequência de números inteiros x_i >= 3que são palíndromos em nbases exatamente diferentes b, onde a base pode estar 2 <= b <= x_i-2.

Isso é basicamente o inverso do OEIS A126071 , no qual você gera quais índices nessa sequência têm o valor n. É um pouco diferente, porque mudei para que você ignore as bases b = x_i-1, x_i, x_i+1, pois os resultados dessas bases são sempre os mesmos (os valores são sempre palíndromos ou sempre não são). Além disso, o deslocamento é diferente.

x_ié restrito a números >= 3para que o primeiro termo do resultado para cada um nseja A037183 .

Observe que o formato de saída é flexível, mas os números devem ser delimitados de uma maneira agradável.

Exemplos:

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

Portanto n=0, você obtém o resultado desse desafio (começando em 3), porque obtém números que são palíndromos em n=0bases.

Pois n=1, 5é um palíndromo na base 2, e essa é a única base em 2 <= b <= (5-2)que é um palíndromo. 7É um palíndromo na base 2, e essa é a única base em 2 <= b <= (7-2)que é um palíndromo. Etc.

Se seu idioma não suporta saída infinita, você pode usar outro número inteiro zcomo entrada e gerar os primeiros zelementos da sequência ou todos os elementos menores que z. O que você preferir. Por favor, indique o que você usou em sua resposta, se for esse o caso.

Relacionado

Geléia , 18 bytes

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

Experimente online! - o intérprete on-line atingirá o tempo limite em 60 segundos e liberará sua saída (a menos que tenha uma cópia em cache); off-line imprimirá cada um por vez.

Como?

Avalia os números de ncima para cima, imprimindo-os se estiverem na sequência. Observe que o primeiro número em qualquer saída será maior do que, npois, caso contrário, o intervalo de bnão é grande o suficiente, portanto, não há necessidade de semear o processo 3. Observe também que o número de palíndromos da base 2 até x _i -2 inclusive é apenas dois a menos que o número de palíndromos da base 1 até 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

Obrigado a JungHwan Min por salvar 9 bytes!

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

( ∞é o caractere de três bytes U + 221E.) Função pura, recebendo um número inteiro não negativo como entrada. i~IntegerReverse~Range[2,i-2]cria uma lista das reversões do número iem todas as bases de 2para i-2; então Length[...~Cases~i]conta quantas dessas reversões são iguais inovamente. #!=...||Echo@ipára silenciosamente se essa contagem não for igual à entrada e ecoará ise for igual à entrada. Esse procedimento é incorporado em um loop infinito direto.

Pitão, 21 19 18 bytes

.V3IqQlf_IjbTr2tbb

Isso deve funcionar em teoria. Funciona corretamente se eu substituir o loop infinito por um finito (por exemplo, JQFbr3 50*`bqJlf_IjbTr2tbde 3 a 50, tente aqui ), mas o interpretador Pyth não sabe quando ou como imprimir uma saída literalmente infinita.

Explicação:

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

Tente

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

Experimente online!

A entrada é passada como argumento. A saída está em stdout.

Se você executar isso normalmente, ele exibirá um número de cada vez na sequência infinita.

Se você tentar isso no TIO, ele exibirá o máximo de saída que gerou quando atingir o tempo limite em 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

Experimente online

O programa TIO possui um rodapé adicionado para que você não precise esperar 1 minuto para o tempo limite do programa expirar antes de ver a saída.