Números de Confidente

Let xSer um número inteiro de uma base arbitrária, tal que Dé uma matriz de seus dígitos. xé um número confidencial se, para todos os nintervalos 1e o comprimento de D:

D[n+1] = D[n] + D[n-1] + ... + D[1] + n

Pegue, por exemplo, o número 349na base 10. Se rotularmos os índices desse número, temos o seguinte.

Index    Digit
-----    -----
1        3
2        4
3        9

A partir do primeiro dígito, temos 1 + 3 = 4, que produz o próximo dígito. Então, com o segundo dígito, temos o 3 + 4 + 2 = 9que, novamente, gera o próximo dígito. Portanto, esse número é um número confidencial.

Dado um número inteiro com uma base entre 1 e 62, calcule todos os números de confidencial para essa base e produza uma lista deles, separados por novas linhas. Você pode assumir que há uma quantidade finita de números confidenciais para uma determinada base.

Para dígitos maiores que 9, use os caracteres alfa A-Ze para dígitos maiores que Zos caracteres alfa a-z. Você não precisará se preocupar com dígitos além z.

Eles não precisam ser impressos em nenhuma ordem específica.

Entrada de amostra:

16

Saída de amostra:

0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
12
23
34
45
56
67
78
89
9A
AB
BC
CD
DE
EF
125
237
349
45B
56D
67F
125B
237F

Isso é código de golfe, então o código mais curto vence. Boa sorte!

(Obrigado a Zach por ajudar na formatação e apontar alguns problemas.)

Pitão, 38 bytes

0jms@L+s`MT+rG1Gdf<eTQsm.u+N+lNsNQ]dSQ

Experimente online: Demonstração

Explicação:

0jms@L+s`MT+rG1Gdf<eTQsm.u+N+lNsNQ]dSQ  implicit: Q = input base
0                                       print 0
                       m            SQ  map each d of [1, 2, ..., Q] to:
                        .u       Q]d      start with N=[d], apply v Q times
                          +N+lNsN           add (len(N) + sum(N)) to N
                                          gives all intermediate results
                      s                 join to one list of candidates
                 f<eTQ                  filter those, where every digit < Q
  ms@L+s`MT+rG1Gd                       convert numbers to letters 0-9A-Za-z
 j                                      print each on separate line

Python 2, 104 bytes

n=input()
for i in range(n):
 s=''
 while i<n:s+=chr(48+i+(i>9)*7+i/36*6);print s;i+=n**0**i+i*(s>s[:1])

Isso usa a seguinte observação: em um número de confidente, o dígito ié seguido por 2*i+1, exceto i+1pelo segundo dígito. Tentando todos os primeiros dígitos possíveis e adicionando mais dígitos até que fiquem grandes demais, podemos gerar todos os números de confidente.

Calculamos o caractere correspondente ao número icomo chr(48+i+(i>9)*7+i/36*6), que o altera para o número, letra maiúscula ou intervalo de letras maiúsculas para os intervalos 0-9, 10-35, 36-61.

Então, aumentamos ivia i+=i+1com dois ajustes. Para fazer isso i+=1depois do primeiro dígito, adicionamos a icondição de ster mais do que 1caracteres. Além disso, precisamos evitar que os números que começam com 0 sejam impressos e, ao mesmo tempo, permitam 0. Para fazer isso, fazemos um hack que causa i=0falha na condição i<nno próximo loop, adicionando na ele. Isso é feito substituindo 1por n**0**i, que associa à direita n**(0**i), que é igual a n**(i==0)ou n if i==0 else 1.

Python 3, 201 200 bytes

n=int(input())
X=[[i]for i in range(1,n)]
for x in X:
 y=sum(x)+len(x)
 if y<n:X.append(x+[y])
X=[[0]]+X
print('\n'.join(''.join(map(lambda x:[str(x),chr(x+55),chr(x+61)][(x>9)+(x>35)],x))for x in X))

Explicação

O principal insight aqui é que, dada uma sequência x(como, digamos [1,2,5]), você pode obter o próximo termo na sequência com sum(x)+len(x), o que fornece 11neste caso ( B). Verifique se é menor ne, se for, adicione a sequência estendida à lista de todas essas sequências (propagadas por todos os dígitos únicos).

[str(x),chr(x+55),chr(x+61)][(x>9)+(x>35)]

É assim que mapeio itens de sequência para caracteres. Eles são ''.joineditados juntos e impressos, separados por novas linhas.

GS2, 44 bytes

26 c8 2f 08 4d 08 40 64 45 2e 30 42 67 40 24 d0
75 d3 20 e1 35 09 cb 20 23 78 22 09 34 30 e0 32
08 86 84 30 85 30 92 58 09 34 10

Ele produz os números em uma ordem diferente, mas a descrição do problema não especifica, então eu vou em frente! Aqui está a saída para entrada de 16.

1
12
125
125B
2
23
237
237F
3
34
349
4
45
45B
5
56
56D
6
67
67F
7
78
8
89
9
9A
A
AB
B
BC
C
CD
D
DE
E
EF
F
0

Aqui estão os equivalentes mnemônicos para os bytes:

read-num dec save-a
range1
{
    itemize
    {
        dup 
        sum
        over length
        add

        swap right-cons

        dup last push-a le

            push-d eval
        block2 when
    }
    save-d eval
    init inits tail
} map

+ ' fold 

{
    ascii-digits
    uppercase-alphabet catenate
    lowercase-alphabet catenate
    select 
    show-line
} map

0

CJam, 46 42 40 bytes

ri:R,{Q{+_A,s'[,_el^+f=oNo__,+:+_R<}g&}*

Experimente on-line no intérprete CJam .

Como funciona

ri:R            e# Read an integer from STDIN and save it in R.
,               e# Push [0 ... R-1].
{               e# Fold; For each element but the first:
                e#   Push the element.
  Q             e#   Push an empty array (accumulator for base-R digits).
  {             e#   Do:
    +           e#     Concatenate the integer and the array on the stack.
    _           e#     Push a copy of the result.
    A,s'[,_el^+ e#     Push "0...0A...Za...z".
                e#     See: http://codegolf.stackexchange.com/a/54348
    f=          e#     Replace each base-R digit with the corresponding character.
    oNo         e#     Print the resulting string and a linefeed.
    _           e#     Push another copy of the accumulator.
    _,+         e#     Append its length to it.
    :+          e#     Add all digits (including the length).
    _R<         e#     Push a copy of the result and compare it with R.
  }g            e#   If the sum is less than R, it is a valid base-R digit,
                e#   the comparison pushes 1, and the loop is repeated.
  &             e#   Intersect the accumulator with an integer that is greater
                e#   or equal to R. This pushes an empty array.
}*              e#

No final 0 e algumas matrizes vazias são deixadas na pilha, para que o intérprete imprima 0.

boquiaberto, 111 bytes

{for(n=$0;n>c=++i;)for(j=0;n>$++j=c+=j;print"")for(c=k=0;k++<j;c+=$k)printf"%c",$k+($k>9?$k>35?61:55:48)}$0="0"

Para cada dígito inicial de 1para base-1ele calcula os próximos dígitos e, embora sejam inferiores à base, ainda temos um número de confidente. Calculando o próximo dígito durante a impressão. Finalmente imprime 0.