Python: imbriqué pour des boucles

Je voudrais aller à travers tous les n chiffres, par exemple que le deuxième chiffre du nombre est toujours inférieur ou égal au premier, le troisième est inférieure ou égale à la deuxième, etc. Je peux obtenir ce par la rédaction d'un horrible le code tel que:

for i in range(10):
    for j in range(i+1):
        for k in range(j+1):

etc., mais avec 10 chiffres de mon code commence à regarder horrible, et aussi que beaucoup de l'écriture, et l'indentation obtenir horrible si je veux saluer quelques-uns de ceux-ci. Est-il un bien, concise façon d'obtenir ce?

Edit: juste pour que les gens savent pourquoi je suis embêter avec cela, https://projecteuler.net/problem=74 m'a permis de vérifier les numéros de 1 à un million. Malheureusement, Il n'est pas aussi simple que je le pensais -- chiffres avec des zéros non significatifs sont traités différemment de ceux avec des zéros à l'intérieur, de sorte que certains magiques supplémentaires ont dû être effectuées. De toute façon, merci à tous pour des suggestions judicieuses.

source d'informationauteur 098799

  1. 22

    Pourrait utiliser itertools:

    >>> for comb in itertools.combinations_with_replacement(range(9, -1, -1), 3):
        print comb

(9, 9, 9)
(9, 9, 8)
(9, 9, 7)
(9, 9, 6)
...
(4, 0, 0)
(3, 3, 3)
(3, 3, 2)
(3, 3, 1)
(3, 3, 0)
(3, 2, 2)
(3, 2, 1)
(3, 2, 0)
(3, 1, 1)
(3, 1, 0)
(3, 0, 0)
(2, 2, 2)
(2, 2, 1)
(2, 2, 0)
(2, 1, 1)
(2, 1, 0)
(2, 0, 0)
(1, 1, 1)
(1, 1, 0)
(1, 0, 0)
(0, 0, 0)

    Ou de manière récursive, en ajoutant plus et plus de chiffres jusqu'à ce que suffisamment, qui peuvent plus produire directement de l' int objets au lieu de chiffres de n-uplets (pas sûr si c'est ce que vous avez réellement besoin):

    def build(enough, prefix=0):
    if prefix >= enough:
        print(prefix)
        return
    for digit in range(prefix % 10 + 1) if prefix else range(1, 10):
        build(enough, prefix * 10 + digit)

    Démo (note elle laisse "000", vous ne savez pas si vous voulez que, de toute façon):

    >>> n = 3
>>> build(10**(n-1))
100
110
111
200
210
211
220
221
222
300
310
311
320
321
322
330
331
332
333
400
410
411
420
  2. 4

    cette approche à l'aide de itertools:

    from itertools import combinations_with_replacement

N = 3

for kji in combinations_with_replacement((str(i) for i in range(10)), N):
    print(''.join(reversed(kji)))

    notez que l'ordre n'est pas le même que dans votre approche originale.

    j'ai récemment eu un ) des nouvelles question...

  3. 3

    Une simple approche récursive:

    def ordered_digits_generator(numDigits,min=1,max=9):
    for first in range(min,max+1):
        if numDigits == 1:
             yield first
        else:
             addend = first*10**(numDigits-1)
             for rest in ordered_digits(numDigits-1,min=0,max=first):
                 yield addend+rest

    Alors appelé via:

    for number in ordered_digits_generator(10):
    print number

    fonctionne comme prévu.

    Le mathématicien de l'approche

    La itertools package dispose déjà d'une logique qui, pour l'essentiel déjà implémente cette récursivité. Sans doute mieux que nous pouvons, avec beaucoup d'essais. On peut donc l'utiliser comme suit:

    import itertools
def ordered_digits_combo(numDigits):
    exponent = [10**i for i in range(0,numDigits)]

    for subset in itertools.combinations(range(0,numDigits+9),numDigits):
        if subset[numDigits-1]>numDigits-1:
            v = 0
            for i in range(0,numDigits):
                v += exponent[i]*(subset[i]-i)
            yield v

    Donné un sous-ensemble ordonné a[0]<a[1]<...<a[n-1] de {0,1,...,n+8}nous choisissons le nombre avec le ième chiffre égal à a[i]-i. Nous avons d'exclure le cas a[n-1]==n-1 parce qu'il se compose de nombre avec tous les zéros.

  4. 0

    J'ai mis en place @iFlo de la suggestion, comme a commenté à l'origine. Ce n'est pas hyper efficace mais il n'est certainement pas à prendre âges.

    def digit_test(n):
    while n > 9:
        if (n % 100 / 10) < (n % 10): return False
        n /= 10
    return True

# under a second to construct a list of all numbers below 1000000 meeting the criteria
candidates = [x for x in xrange(1,1000000) if digit_test(x)]

# should be 8001 elements, consistent with other algorithms
print len(candidates)
  5. 0

    Je serais probablement mettre en œuvre ce de manière récursive:

    def generate(max, digits):
    for d in range(max + 1):
        if digits == 1:
            yield d
        else:
            first = d * 10**(digits-1)
            for n in generate(d, digits - 1):
                yield first + n

    La sortie:

    In : list(generate(3, 3))
Out:
[0,
 100,
 110,
 111,
 200,
 210,
 211,
 220,
 221,
 222,
 300,
 310,
 311,
 320,
 321,
 322,
 330,
 331,
 332,
 333]