问题描述

这个问题的抽象版本

我想在变量之间和变量中生成所有可能的数字0分配。我知道有这样的分配，因此我从一个生成 numbers 的循环开始。如何将循环中的枚举数转换为实际赋值？我对 where和.n-1vv^n0..(v^n)-1n=4v=7

for (int i = 0; i < Math.pow(v, n); ++i) {
    variable0 = ...;
    variable1 = ...;
    variable2 = ...;
    ...
    variable6 = ...;
}

预期任务

i       variable
        0  1  2  3  4  5  6  
---------------------------
0       0  0  0  0  0  0  0
1       0  0  0  0  0  0  1
2       0  0  0  0  0  0  2
3       0  0  0  0  0  0  3
4       0  0  0  0  0  1  0
...
12000   2  3  2  3  2  0  0
...
16383   3  3  3  3  3  3  3

原始问题

我的目标是为每个输入分配一个方法，并为所有输入获取所有可能的方法组合。

以下是代码（在此解决方案的帮助下）

    public static final int FUNCTION_NUMBER = 3;
        public static String functionA() {
            return "A";
        }
        public static String functionB() {
            return "B";
        }
        public static String functionC() {
            return "C";
        }
        public static String callFunction(int function_index) {
            switch (function_index) {
            case 0:
                return functionA();
            case 1:
                return functionB();
            case 2:
                return functionC();
            default:
                throw new IllegalArgumentException("Incorrect value for function_index");
            }
        }

      public static void main(String[] args) {
        for (int i = 0; i <= 8; i++) {

         int name_function_index = i / FUNCTION_NUMBER;
        int phone_no_function_index = i % FUNCTION_NUMBER; }

从上面的代码中，有 3 种方法（功能 A、B、C）和 2 个输入（姓名、电话号码）。所以所有组合的可能性是 3^2 = 9。因此，输出如下。

  loop name phoneno
      0    A    A
      1    A    B
      2    A    C
      3    B    A
      4    B    B
      5    B    C
      6    C    A
      7    C    B
      8    C    C

我的问题是，如果我有 4 个方法（函数 A、B、C、D）和 7 个输入（名字、姓氏、电话号码、办公室号码、添加、街道、国家）怎么办？所以组合将是 4^7 = 16384。为了得到所有可能的组合，输入的公式是什么，如下所示？

   loop    firstname lastname phoneno officeno add street country
    0       A          A       A        A       A    A     A
    1       A          A       A        A       A    A     B
    2       A          A       A        A       A    A     C
    3       A          A       A        A       A    A     D
    ...
    12000   C          A       D        B       B    A     D
    ...
    16383   D          D       D        D       D    D     D



 public static void main(String[] args) {
        for (int i = 0; i <= 16383; i++) {
        int name_function_index= i / FUNCTION_NUMBER;
        int phone_no_function_index= i % FUNCTION_NUMBER;
        int office_no_function_index= ??
        int add_no_function_index= ??

任何帮助将不胜感激！

标签： javacombinations

解决方案

改变基数使转换变得明显

当您有v个变量var ₀到var _v-1并且想要为它们分配0和n-1之间的数字时，您可以将枚举数i转换为基数n并为每个变量选择一位数字。

例子

您有v=3 个变量和 n=2 个数字。您知道有v ^{n 个}可能的分配并用计数器i枚举它们。通常，人类以十进制（以 10 为底）计数，但这次我们以二进制（以 2 为底）计数。

    i     |   Assignment
dec   bin | var2 var1 var0 
----------+----------------
  0   000 |  0    0    0
  1   001 |  0    0    0  
  2   010 |  0    1    0
  3   011 |  0    1    1
  4   100 |  1    0    0
  5   101 |  1    0    1
  6   110 |  1    1    0
  7   111 |  1    1    1

i的二进制表示的三位数字直接对应于i枚举的变量赋值。

将枚举数i转换为赋值

为了得到一个分配，我们提取了以n为底的i的v个数字。

假设您有基数为 10（普通/十进制）的数字i=3149，并且想要提取它的四位数字。你会做

digit0 = i % 10;        // same as i / 1 % 10
digit1 = i / 10 % 10;
digit2 = i / 100 % 10;
digit3 = i / 1000 % 10;

第x位的公式是i / 10 ^x % 10。现在，如果底数n与 10 不同，那么公式将是i / n ^x % n。

例子

v=3和n=4的小示例程序：

int var0, var1, var2;
int n = 4;
System.out.println("   i | Assignment");
System.out.println("-----+-----------");
for (int i = 0; i < Math.pow(n, 3); ++i) {
    var0 = i % n;           // = i / Math.pow(n, 0) % n 
    var1 = i / n % n;       // = i / Math.pow(n, 1) % n 
    var2 = i / (n * n) % n; // = i / Math.pow(n, 2) % n
    System.out.format("%4d | %2d %2d %2d\n", i, var2, var1, var0);
}

印刷

   i | Assignment
-----+-----------
   0 |  0  0  0
   1 |  0  0  1
   2 |  0  0  2
   3 |  0  0  3
   4 |  0  1  0
     .
     .
     .
  61 |  3  3  1
  62 |  3  3  2
  63 |  3  3  3

改进

对于更短、更简洁、更可扩展的程序，您不应该编写类似

var5 = i / (n * n * n * n * n) % n

手动。使用数组和循环。

java - 根据输入和方法的数量列出所有组合