Numéros confidentiels

Soit xun entier d'une base arbitraire, tel qu'un Dtableau de ses chiffres. xest un nombre confidentiel si, pour tous nentre 1et la longueur de D:

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

Prenons, par exemple, le nombre 349en base 10. Si nous étiquetons les indices de ce nombre, nous avons ce qui suit.

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

À partir du premier chiffre, nous avons 1 + 3 = 4, ce qui donne le chiffre suivant. Ensuite, avec le deuxième chiffre que nous avons 3 + 4 + 2 = 9, qui, encore une fois, donne le chiffre suivant. Ainsi, ce nombre est un nombre confidentiel.

Étant donné un entier dont la base est comprise entre 1 et 62, calculez tous les nombres confidentiels pour cette base et affichez-en une liste, séparés par des retours à la ligne. Vous pouvez supposer qu'il existe une quantité finie de nombres confidentiels pour une base donnée.

Pour les chiffres supérieurs à 9, utilisez les caractères alpha A-Zet pour les chiffres supérieurs à, Zutilisez les caractères alpha a-z. Vous n'aurez pas à vous soucier des chiffres au-delà z.

Ils ne doivent pas être sortis dans un ordre particulier.

Exemple d'entrée:

16

Exemple de sortie:

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

C'est le golf de code, donc le code le plus court gagne. Bonne chance!

(Merci à Zach d'avoir aidé au formatage et signalé quelques problèmes.)

Pyth, 38 octets

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

Essayez-le en ligne: Démonstration

Explication:

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 octets

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

Cela utilise l'observation suivante: dans un nombre confidentiel, le chiffre iest suivi 2*i+1, sauf qu'il s'agit i+1plutôt du deuxième chiffre. En essayant tous les premiers chiffres possibles et en ajoutant plus de chiffres jusqu'à ce qu'ils deviennent trop gros, nous pouvons générer tous les numéros confidentiels.

Nous calculons le caractère correspondant au nombre ias chr(48+i+(i>9)*7+i/36*6), ce qui le déplace dans le nombre, la lettre majuscule ou la plage de lettres majuscules pour les intervalles 0-9, 10-35, 36-61.

Ensuite, nous augmentons ivia i+=i+1avec deux ajustements. Pour faire cela à la place i+=1après le premier chiffre, nous ajoutons la icondition d' savoir plus de 1caractères. De plus, nous devons éviter que les nombres commençant par 0 ne soient imprimés, tout en permettant 0. Pour ce faire, nous faisons un hack qui provoque l' i=0échec de la condition i<nsur la boucle suivante en l'ajoutant n. Cela se fait en remplaçant 1par n**0**i, qui s'associe à droite à n**(0**i), qui est égal à n**(i==0)ou n if i==0 else 1.

Python 3, 201 200 octets

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

Explication

L'idée clé ici est que, étant donné une séquence x(comme, disons, [1,2,5]), vous pouvez obtenir le terme suivant dans la séquence avec sum(x)+len(x), ce qui donne 11dans ce cas ( B). Vérifiez si cela est inférieur à n, et si c'est le cas, ajoutez la séquence étendue à la liste de toutes ces séquences (ensemencée par tous les chiffres).

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

C'est ainsi que je mappe des éléments de séquence à des personnages. Ceux-ci sont ''.joinédités ensemble puis imprimés, séparés par des retours à la ligne.

GS2, 44 octets

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

Il produit les nombres dans un ordre différent, mais la description du problème ne le précise pas, alors j'y vais! Voici la sortie pour l'entrée 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

Voici les équivalents mnémoniques des octets:

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 octets

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

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

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#

À la fin, 0 et quelques tableaux vides sont laissés sur la pile, donc l'interprète imprime 0.

gawk, 111 octets

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

Pour chaque chiffre de départ de 1to, base-1il calcule les chiffres suivants, et bien qu'ils soient inférieurs à la base, nous avons toujours un numéro confidentiel. Calcul du chiffre suivant lors de l'impression. Imprime enfin 0.