Comment produire la i-e combinaison / permutation sans itération

La troisième fois est le charme: xxx

Ce que vous faites est proche d'une conversion de la base 10 (votre numéro) à la base 6, avec ABCDEF étant vos chiffres. La seule différence est "AA" et "A" sont différentes, ce qui ne va pas si vous envisagez "a" le chiffre zéro.

Si vous ajoutez la prochaine puissance de six à votre numéro, puis effectuez une conversion de base à la base 6 à l'aide de ces chiffres et enfin de la bande du premier chiffre (qui devrait être un "B", c'est-à-dire un "1") , vous avez le résultat.

Je veux juste poster une idée ici, pas une mise en œuvre, car la question sent beaucoup comme des devoirs pour moi (je fais profiter du doute; c'est juste mon sentiment).

solution multi-rayix en bas.

import math
def get_max_value_for_digits(digits_list):
    max_vals = []

    for val in digits_list:
        val = len(val)
        if max_vals:
            val *= max_vals[-1]
        max_vals.append(val)
    return max_vals

def idx_to_length_and_value(n, digits_list):
    chars = 1
    max_vals = get_max_value_for_digits(digits_list)

    while True:
        if chars-1 >= len(max_vals):
            raise OverflowError, "number not representable"
        max_val = max_vals[chars-1]
        if n < max_val:
            return chars, n

        chars += 1
        n -= max_val

def conv_base(chars, n, digits_list):
    ret = []
    for i in range(chars-1, -1, -1):
        digits = digits_list[i]
        radix = len(digits)

        c = digits[n % len(digits)]
        ret.append(c)
        n /= radix

    return reversed(ret)

digits_list = ["ABCDEF", "ABC", "AB"]
for i in range(0, 120):
    chars, n = idx_to_length_and_value(i, digits_list)
    print "".join(conv_base(chars, n, digits_list))

Calculez d'abord la longueur en résumant les pouvoirs de six jusqu'à ce que vous dépassiez votre index (ou utilisez mieux la formule de la série géométrique).

Soustrayez la somme des plus petites puissances de l'indice.

calculer la représentation à la base 6, remplir les zéros de premier plan et la carte 0 -> A, ..., 5 -> F.

alphabet = 'ABCDEF'

def idx_to_excel_column_name(x):
  x += 1 # Make us skip "" as a valid word
  group_size = 1
  for num_letters in itertools.count():
    if x < group_size:
      break
    x -= group_size
    group_size *= len(alphabet)
  letters = []
  for i in range(num_letters):
    x, m = divmod(x, len(alphabet))
    letters.append(alphabet[m])
  return ''.join(reversed(letters))

def excel_column_name_to_idx(name):
  q = len(alphabet)
  x = 0
  for letter in name:
    x *= q
    x += alphabet.index(letter)
  return x+q**len(name)//(q-1)-1

en Perl vous convertiriez simplement votre entrée I de la base (10) à la base (longueur de "abcdef"), puis faites un tr / 012345 / abcdef / qui est identique à celui de < Code> Y / 0-5 / AF / . Sûrement Python a un ensemble de caractéristiques similaires.

oh, comme indiqué par Yariich Les combinaisons sont un peu différent, car si une représentation 0, alors il y aurait pas de combinaisons avec un dirigeant (bien qu'il l'a dit un peu différent). Il semble que je pensais que le problème soit plus trivial que cela. Vous ne pouvez pas simplement translitterrer différents numéros de base, car les numéros contenant l'équivalent de 0 seraient ignoré dans la séquence.

Alors, ce que j'ai suggéré, c'est en fait la dernière étape de ce que Starblue suggéré, ce qui est essentiellement ce que Laurence Gonsalves mise en œuvre FTW. Oh, et il n'y a pas de translittération ( tr // ou y // ) en python, quelle honte.