生成数字严格递减的数字

Question

I am trying to generate numbers of maximum length n whose all digits are strictly decreasing.

If ‍‍ n = 5‍ , then numbers would be :

54321
5432
543
54
5421
542
541
5321
532
53
521
52
51
5

4321
432
43
431
421
42
41
4
...

Any hints on how to proceed?

Thank you in advance

Edit - My current code looks like this and I am not getting all the results.

def func(arr):
for x in arr:
    token=x[-1]
    k=int(token)-1
    while k>1:
        for i in range(1,k):
            f.write(x)
            for j in range(k,i,-1):
                f.write(str(j))
        k-=1

f = open ("demo.txt", "w")

arr = ["987"]
for i in range(986,321,-1):
    tens = i
    units = i%10
    tens = int(tens)/10
    hundreds = int(tens)/10 
    tens%=10
    hundreds%=10
    if tens >= hundreds or units>= tens:
        continue
    arr.append(str(i))

func(arr)
f.close()

Answer 1

Here is a recursive generator function:

def nums(n):
    if n:
        yield from (int(f"{n}{num}") for num in nums(n-1))
        yield n
        yield from nums(n-1)
       

[*nums(1)]
# [1]
[*nums(2)]
# [21, 2, 1]
[*nums(3)]
# [321, 32, 31, 3, 21, 2, 1]
[*nums(4)]
# [4321, 432, 431, 43, 421, 42, 41, 4, 321, 32, 31, 3, 21, 2, 1]

Or using the itertools.combinations approach:

from itertools import combinations

def nums(n):
    for l in range(n, 0, -1):
        for c in combinations(range(n, 0, -1), l):
            yield int("".join(map(str, c)))

[*nums(2)]
# [21, 2, 1]
[*nums(3)]
# [321, 32, 31, 21, 3, 2, 1]
[*nums(4)]
# [4321, 432, 431, 421, 321, 43, 42, 41, 32, 31, 21, 4, 3, 2, 1]

Answer 2

all digits are strictly decreasing.

this code generate descending digits series with custom lenght:

import itertools


def generate(lenght):
    arr = [range(10)] * lenght
    for digits_tuple in itertools.product(*arr):
        if all(current_item > next_item for current_item, next_item in zip(digits_tuple, digits_tuple[1:])):
            print(digits_tuple)


generate(5)

If you want the length to be 5 or less:

for i in range(5):
   generate(i+1)

The question is a bit vague, but you can change this part of code to get your goal:

all(current_item > next_item for current_item, next_item in zip(digits_tuple, digits_tuple[1:])):

Answer 3

It is actually not complicated, you can generate combinations of numbers with itertools.combinations , then apply a factor with zip and take the product per item and sum .

For example [1,2,4,5] with factors [1,10,100,1000] would give 1+20+400+5000 = 5421.

The trick is that combinations always produces the combinations ina defined order (first to last), so combinations([1,2,3], 2) would give [(1, 2), (1, 3), (2, 3)]

from math import prod
n = 5
factors = [10**i for i in range(n)]
[sum(map(prod, zip(factors, c)))
 for i in range(n,0,-1)
 for c in combinations(range(1,n+1), i)]

output:

[54321,
 4321,
 5321,
 5421,
 5431,
 5432,
 321,
 421,
 521,
 431,
 531,
 541,
 432,
 532,
 542,
 543,
 21,
 31,
 41,
 51,
 32,
 42,
 52,
 43,
 53,
 54,
 1,
 2,
 3,
 4,
 5]

If you need a strict order of the output, use the following (slightly less efficient):

[sum(map(prod, zip(factors, c)))
 for i in range(n,0,-1)
 for c in list(combinations(range(1,n+1), i))[::-1]]

output:

[54321,
 5432,
 5431,
 5421,
 5321,
 4321,
 543,
 542,
 532,
 432,
 541,
 531,
 431,
 521,
 421,
 321,
 54,
 53,
 43,
 52,
 42,
 32,
 51,
 41,
 31,
 21,
 5,
 4,
 3,
 2,
 1]