Question

我正在编写一个大型应用程序的一部分，我正面临着这个问题。我将通过呈现类似的普通方案来从所有细节中抽象出所有细节。

我被赋予n（在运行时形成的数字的数字的数字）。

我还会得到一份数字清单{2,4,8,9}。

我必须形成所有可能的数字，这些数字可以从上面给定长度的列表中形成。

e.g。如果n = 3且list = {4,5,6}

那么可能的数字是：

444,
445,
446,
454,
455,
456,
464,
465,
466,

依旧......

任何帮助将不胜感激！

问候

shahensha

Answer 1

您可以使用递归。假设您可以使用的数字在数组中。

C＃代码：

static int[] digits = new int[] {4, 5, 6};

static void Rec(int current, int numDigits) {
    if(numDigits==0)
        Console.WriteLine(current);
    else
        foreach(int x in digits)
            Rec(current*10+x, numDigits-1);
}

然后致电：

static void Main(string[] args){
    Rec(0, 3);
}

Answer 2

使用递归函数。这是javascript中的一个例子......

var result;
function recurse(n,lst,s){
  var i,c;  
  for (i=0; i<lst.length; i++){
    if(n>1)recurse(n-1,lst,s+lst[i]);
    else result.push(s+lst[i])
  }
}
function generate(n,lst){
  result=[];
  if(n>0 && lst.length>0){
    for(var i=0; i<lst.length; i++)lst[i]=''+lst[i];
    recurse(n,lst,'')
  }
  return result
}
generate(3,[4,5,6]);

Answer 3

我的方法如下：

list combine(list a, list b)
{
    list c;
    for ( i = 0, i < list.size(), ++i )
    {
        for ( j = 0, j < list.size(), ++j )
            c.add( a[i] * pow(10,log_10(b[j]) + 1) + b[j] );
    }
    return c;
}

然后是n位问题：

list nDigit(list a, int n)
{
    list out;
    out = combine(a, a);
    for ( i = 1, i < n, ++i )
        out = combine(a, out);
    return out;
}

这应该是神奇的。代码应该是不言自明的，如果不是，请发表评论。

如果列表项长度超过数字，则必须注意。然后，您需要在combine函数中添加以下内容：

[....]
for ( j = 0, j < list.size(), ++j )
{
    if ( log_10(a[i]) + log_10(b[j]) + 1 <= n )
        c.add( a[i] * pow(10,log_10(b[j]) + 1) + b[j] );
}
[....]

当然给n组合函数。

在nDigit的最后，您必须检查是否存在长度小于n

的组合

Answer 4

您的任务相当于以不同于10的基数计数，如下面的C ++程序所示：

#include <vector>
#include <iostream>

using std::vector;

unsigned int pow(unsigned int n, unsigned int m)
{
    unsigned int to_ret = 1;
    for (unsigned int i = 0; i < m; i++)
        to_ret *= n;
    return to_ret;
}

void print_all(vector<unsigned int> sym, unsigned int n)
{
    const unsigned int m = sym.size();
    unsigned int max = pow(m, n);
    char *text = new char[n + 1];
    text[n] = '\0';
    for (unsigned int i = 0; i < max; i++) {
        unsigned int to_print = i;
        for (unsigned int j = 1; j <= n; j++) {
            text[n - j] = sym[to_print % m];
            to_print /= m;
        }
        std::cout << text << std::endl;
    }
    delete[] text;
}

int main(int argc, char **argv)
{
    vector<unsigned int> a({'1','2','3','4','5'});
    print_all(a, 5);
    return 0;
}

这种方法的明显问题在于max容易溢出n和m足够高的值。您可以通过使用m链接列表数组来模拟计数来解决这个问题，这些链表必须代表“数字”。

Answer 5

我写了以下F＃代码来解决这个问题：

let rec variations rank xs = 
    match rank with
    | 1 -> 
        seq {
            for x in xs do
            yield [x]
        }

    | _ -> 
        seq {
            for x in xs do
            for y in variations (rank-1) xs do   
            yield x::y
        }

所以，

variations 3 (seq {4..6})
|> Seq.iter (printfn "%s")

将打印

所有27个值

如何获得可以使用给定数字形成的所有可能的n位数字？

5 个答案: