以数字升序显示所有可能的数字

Question

编写一个程序，该程序可以显示给定两个数字之间的所有可能数字，并且其数字按升序排列。

例如：-

1. 输入：5000至6000

    Output: 5678 5679 5689 5789 

2. 输入：90至124

    Output: 123 124 

蛮力方法可以使它计数到所有数字，并检查每个数字。 但是我想要可以跳过一些数字并且带来比O（n）小的复杂性的方法。 是否存在可以为该问题提供更好方法的解决方案？

Answer 1

我提供了Python解决方案。 它仅考虑相关数字，因此非常有效。 基本思想是向上计数，但处理溢出有些不同。 通常我们将溢出数字设置为0，但在这里我们将溢出数字设置为前一个数字+1。 请检查嵌入式注释以获取更多详细信息。 您可以在这里使用它： http : //ideone.com/ePvVsQ

def ascending( na, nb ):
    assert nb>=na
    # split each number into a list of digits
    a = list( int(x) for x in str(na))
    b = list( int(x) for x in str(nb))

    d = len(b) - len(a)

    # if both numbers have different length add leading zeros 
    if d>0:
        a = [0]*d + a  # add leading zeros
    assert len(a) == len(b)
    n = len(a)


    # check if the initial value has increasing digits as required,
    # and fix if necessary
    for x in range(d+1, n):
        if a[x] <= a[x-1]:
            for y in range(x, n):
                a[y] = a[y-1] + 1
            break

    res = [] # result set

    while a<=b:
        # if we found a value and add it to the result list
        # turn the list of digits back into an integer
        if max(a) < 10:
            res.append( int( ''.join( str(k) for k in a ) ) )

        # in order to increase the number we look for the
        # least significant digit that can be increased
        for x in range( n-1, -1, -1): # count down from n-1 to 0
            if a[x] < 10+x-n:
                break
        # digit x is to be increased
        a[x] += 1
        # all subsequent digits must be increased accordingly
        for y in range( x+1, n ):
            a[y] = a[y-1] + 1

    return res

print( ascending( 5000, 9000 ) )

Answer 2

听起来像来自Euler项目的任务。 这是C ++中的解决方案。 它不短，但是简单有效。 哦，嘿，它使用backtracking 。

// Higher order digits at the back
typedef std::vector<int> Digits;

// Extract decimal digits of a number
Digits ExtractDigits(int n)
{
  Digits digits;

  while (n > 0)
  {
    digits.push_back(n % 10);
    n /= 10;
  }

  if (digits.empty())
  {
    digits.push_back(0);
  }

  return digits;
}

// Main function
void PrintNumsRec(
  const Digits& minDigits,  // digits of the min value
  const Digits& maxDigits,  // digits of the max value
  Digits& digits,  // digits of current value
  int pos,         // current digits with index greater than pos are already filled
  bool minEq,      // currently filled digits are the same as of min value
  bool maxEq)      // currently filled digits are the same as of max value
{
  if (pos < 0)
  {
    // Print current value. Handle leading zeros by yourself, if need
    for (auto pDigit = digits.rbegin(); pDigit != digits.rend(); ++pDigit)
    {
      if (*pDigit >= 0)
      {
        std::cout << *pDigit;
      }
    }
    std::cout << std::endl;
    return;
  }

  // Compute iteration boundaries for current position
  int first = minEq ? minDigits[pos] : 0;
  int last = maxEq ? maxDigits[pos] : 9;

  // The last filled digit
  int prev = digits[pos + 1];

  // Make sure generated number has increasing digits
  int firstInc = std::max(first, prev + 1);

  // Iterate through possible cases for current digit
  for (int d = firstInc; d <= last; ++d)
  {
    digits[pos] = d;

    if (d == 0 && prev == -1)
    {
      // Mark leading zeros with -1
      digits[pos] = -1;
    }

    PrintNumsRec(minDigits, maxDigits, digits, pos - 1, minEq && (d == first), maxEq && (d == last));
  }
}

// High-level function
void PrintNums(int min, int max)
{
  auto minDigits = ExtractDigits(min);
  auto maxDigits = ExtractDigits(max);

  // Make digits array of the same size
  while (minDigits.size() < maxDigits.size())
  {
    minDigits.push_back(0);
  }

  Digits digits(minDigits.size());

  int pos = digits.size() - 1;

  // Placeholder for leading zero
  digits.push_back(-1);

  PrintNumsRec(minDigits, maxDigits, digits, pos, true, true);
}

void main()
{
  PrintNums(53, 297);
}

它使用递归来处理任意数量的数字，但与嵌套循环方法基本相同。 这是(53, 297)的输出：

056
057
058
059
067
068
069
078
079
089
123
124
125
126
127
128
129
134
135
136
137
138
139
145
146
147
148
149
156
157
158
159
167
168
169
178
179
189
234
235
236
237
238
239
245
246
247
248
249
256
257
258
259
267
268
269
278
279
289

更有趣的问题是要对所有这些数字进行计数而不进行显式计算。 为此，可以使用动态编程。

Answer 3

可以匹配您的定义的数字非常有限（最多9位数字），并且可以非常快速地生成这些数字。 但是，如果您确实需要速度，则只需缓存树或生成的列表，并在需要结果时进行查找。

using System;
using System.Collections.Generic;

namespace so_ascending_digits
{
  class Program
  {
    class Node
    {
        int digit;
        int value;
        List<Node> children;

        public Node(int val = 0, int dig = 0)
        {
            digit = dig;
            value = (val * 10) + digit;
            children = new List<Node>();
            for (int i = digit + 1; i < 10; i++)
            {
                children.Add(new Node(value, i));
            }
        }

        public void Collect(ref List<int> collection, int min = 0, int max = Int16.MaxValue)
        {
            if ((value >= min) && (value <= max)) collection.Add(value);
            foreach (Node n in children) if (value * 10 < max) n.Collect(ref collection, min, max);
        }
    }

    static void Main(string[] args)
    {
        Node root = new Node();
        List<int> numbers = new List<int>();
        root.Collect(ref numbers, 5000, 6000);
        numbers.Sort();
        Console.WriteLine(String.Join("\n", numbers));
    }
  }
}

Answer 4

为什么蛮力算法可能效率很低。

对输入进行编码的一种有效方法是提供两个数字：范围的下限a和范围内的值数ba-1 。 可以用O（lg a + lg（ b - a ））位进行编码，因为在base-2中表示一个数字所需的位数大约等于该数字的base-2对数。 我们可以将其简化为O（lg b ），因为从直觉上来说，如果b - a小，则a = O（ b ），如果b - a大，则b - a = O（ b ）。 无论哪种方式，总输入大小为O（2 lg b ）= O（lg b ）。

现在，蛮力算法仅检查从a到b的每个数字，并输出以10为底的数字递增的数字。 在该范围内，有b - a + 1个可能的数字。 但是，当用输入大小表示时，您会发现b - a + 1 = 2 ^{lg（ b - a + 1）} = 2 ^{O（lg b ）}具有足够大的间隔。

这意味着对于输入大小n = O（lg b ），可能需要检查最坏情况下的O（2 ⁿ ）值。

更好的算法

无需检查间隔中的每个可能数字，您可以直接直接生成有效数字。 这是一个大概的概述。 数量为N可以被认为是作为一个数字序列N + ₁ ... N _k，其中k被再次大致登录_为 10N。

对于a和一个四位数的数字b ，迭代看起来像

for w in a1 .. 9:
  for x in w+1 .. 9:
    for y in x+1 .. 9:
      for x in y+1 .. 9:
         m = 1000 * w + 100 * x + 10 * y + w
         if m < a:
            next
         if m > b:
            exit
         output w ++ x ++ y ++ z  (++ is just string concatenation)

其中 ₁可以被认为是0，如果一个具有除B个数字。

对于更大的数字，您可以想象只是添加更多嵌套的for循环。 通常，如果b具有d位数字，则需要d = O（lg b ）个循环，每个循环最多重复10次。 因此，运行时间为O（10 lg b ）= O（lg b ），这比通过检查每个数字是否经过排序而获得的O（2 ^{lg b} ）运行时间要好得多。

---

我已经掩盖了另一个细节，它实际上会影响运行时间。 如所写，该算法需要考虑生成m所需的时间。 在不赘述的情况下，您可以假定这至少会使运行时间增加O（lg b ）倍，从而产生O（lg ² b ）算法。 但是，在每个for循环的顶部使用一些额外的空间来存储部分乘积将节省大量的冗余乘法，从而使我们能够保留最初声明的O（lg b ）运行时间。

Answer 5

一种方式（伪代码）：

for (digit3 = '5'; digit3 <= '6'; digit3++)
  for (digit2 = digit3+1; digit2 <= '9'; digit2++)
    for (digit1 = digit2+1; digit1 <= '9'; digit1++)
      for (digit0 = digit1+1; digit0 <= '9'; digit0++)
        output = digit3 + digit2 + digit1 + digit0; // concatenation