Numeri confidenti

Sia xun numero intero di una base arbitraria, tale che Dsia una matrice delle sue cifre. xè un numero confidente se, per tutti ntra 1e la lunghezza di D:

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

Prendiamo, ad esempio, il numero 349in base 10. Se etichettiamo gli indici per questo numero, abbiamo quanto segue.

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

A partire dalla prima cifra, abbiamo 1 + 3 = 4, che produce la cifra successiva. Quindi con la seconda cifra abbiamo 3 + 4 + 2 = 9, che, di nuovo, produce la cifra successiva. Pertanto, questo numero è un numero confidente.

Dato un numero intero con una base compresa tra 1 e 62, calcola tutti i numeri confidenziali per quella base e genera un elenco di essi, separati da nuove righe. Puoi presumere che ci sia una quantità finita di numeri confidenziali per una data base.

Per le cifre superiori a 9, utilizzare i caratteri alfa A-Ze per le cifre superiori Zall'utilizzo dei caratteri alfa a-z. Non dovrai preoccuparti delle cifre oltre z.

Non devono essere emessi in alcun ordine particolare.

Input di esempio:

16

Uscita campione:

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

Questo è il codice golf, quindi vince il codice più corto. In bocca al lupo!

(Grazie a Zach per l'aiuto nella formattazione e per aver segnalato alcuni problemi.)

Pyth, 38 byte

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

Provalo online: dimostrazione

Spiegazione:

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 byte

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])

Questo utilizza la seguente osservazione: in un numero confidente, la cifra i è seguita da 2*i+1, tranne che è i+1invece per la seconda cifra. Provando tutte le prime cifre possibili e aggiungendo altre cifre finché non diventano troppo grandi, possiamo generare tutti i numeri confidenti.

Calcoliamo il carattere corrispondente al numero i come chr(48+i+(i>9)*7+i/36*6), che lo sposta nel numero, nella lettera maiuscola o nell'intervallo di lettere maiuscole per gli intervalli 0-9, 10-35, 36-61.

Quindi, aumentiamo ivia i+=i+1con due regolazioni. Per rendere questo invece i+=1dopo la prima cifra, aggiungiamo la icondizione di savere più di 1caratteri. Inoltre, dobbiamo evitare che vengano stampati numeri che iniziano con 0, consentendo allo stesso tempo 0. Per fare ciò, eseguiamo un hack che causa il i=0fallimento della condizione i<nnel ciclo successivo aggiungendola n. Questo viene fatto sostituendo 1con n**0**i, a cui associa il diritto n**(0**i), che equivale a n**(i==0)o n if i==0 else 1.

Python 3, 201 200 byte

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

Spiegazione

L'intuizione chiave qui è che data una sequenza x(come, diciamo, [1,2,5]), puoi ottenere il termine successivo nella sequenza con sum(x)+len(x), che dà 11in questo caso ( B). Controlla se questo è inferiore a n, e se lo è, aggiungi la sequenza estesa all'elenco di tutte queste sequenze (seminate da tutte le singole cifre).

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

Questo è il modo in cui associo gli elementi della sequenza ai personaggi. Questi vengono ''.joineditati insieme e quindi stampati, separati da nuove righe.

GS2, 44 byte

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

Produce i numeri in un ordine diverso, ma la descrizione del problema non specifica, quindi ci proverò! Ecco l'output per input di 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

Ecco gli equivalenti mnemonici per i byte:

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 byte

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

Provalo online nell'interprete CJam .

Come funziona

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#

Alla fine 0 e alcuni array vuoti vengono lasciati in pila, quindi l'interprete stampa 0.

stupore, 111 byte

{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"

Per ogni cifra iniziale da 1a base-1calcola le cifre successive, e mentre queste sono inferiori alla base, abbiamo ancora un numero confidente. Calcolo della cifra successiva durante la stampa. Finalmente stampa 0.