使用索引逻辑面试问题数组查找价值

Question

下面给出了无限长的数组，它具有自然数，因为它可以是无限长的：

int[] myArray = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0, 1, 1, 1, 2, 1, 3 ......}; 

// 在 10 的位置将需要 1、0，在 11 的位置将需要 1、1，在 12 的位置将需要 1、2 以此类推.....

index 0 = >  value 0 = >  number 0
index 1 = >  value 1 = >  number 1
index 2 = >  value 2 = >  number 2
index 3 = >  value 3 = >  number 3
index 4 = >  value 4 = >  number 4
index 5 = >  value 5 = >  number 5
index 6 = >  value 6 = >  number 6
index 7 = >  value 7 = >  number 7
index 8 = >  value 8 = >  number 8
index 9 = >  value 9 = >  number 9
index 10 = > value 1 = > number 10
index 11 = > value 0 = > number 10
index 12 = > value 1 = > number 11
index 13 = > value 1 = > number 11
index 14 = > value 1 = > number 12
index 15 = > value 2 = > number 12

....
....
....

对于索引 9 的值应该是 9，但是在索引 10 而不是值 10 它应该是 1 并且在索引 11 的值应该是 0 ，然后在索引 12 的值应该是 1 等等...

假设索引值为 10 我们得到一个结果为 1，对于值 11 我们得到一个结果值为 0。

我们必须编写逻辑通过传递索引值来获取值，索引可以从0到10000000。

我们不能直接使用数组来获取特定索引处的值，我们必须编写如下逻辑：

public int getValue(int index){

    int value = 0;

    //  logic to find the the value 

    return value;
}

我尝试了以下方法来获取传递索引的结果，但它可以工作到两位数字，即 99。（直到索引 189）。但是对于三位数，我们必须改变逻辑。

public static int myMethod(int index){
    System.out.println("index : " + index);

    if(index <= 9){
        return index;
    }

    boolean even = (index % 2) == 0;

    int num = 0 ;
    char res = 0;
    if(even){
        num = index - ((index - 10) / 2);
        System.out.println("num " + num);

        res = new Integer(num).toString().charAt(0);            
    }else{

        index = index -1;
        num = index - ((index - 10) / 2);
        System.out.println("num 22 : " + num);
        res = new Integer(num).toString().charAt(1);            
    }

    int result = new Integer(res+"");

    System.out.println(result);
    return result ;
}

Answer 1

这个序列被称为Champernowne constant。

基本的方法是计算出所有1位、2位、3位数字等的总长度。一旦知道了哪个数字范围是合适的，就可以确定该范围内的确切数字，然后数字中的确切数字。

高效算法的完整细节可以在this pdf中找到。

Answer 2

我会说我们从 1 而不是 0 开始，以使下面的内容更简单（您可以从索引中减去 1 来包含它）。

让我们从一些分析开始：

• 有 9 个 1 位数字 (1-9) 占用前 9*1 = 9*10⁰*1 = 9 个位置。
• 有 90 个 2 位数字 (10-99) 占用接下来的 90*2 = 9*10¹*2 = 180 个位置。
• 有 900 个 3 位数字 (100-999) 占用接下来的 900*3 = 9*10²*3 = 2700 个位置。
• 等

从上面可以看出，n位数字占据了9*10^n-1*n个位置。

从这里开始，通过以下方式将索引转换为对应的数字并不难：

• 循环遍历上述每种情况（使用简单的 for 循环），从我们的索引中减去相应的位置数，直到这样做会得到一个负数。
• 将我们的索引除以我们当前所在的位数以获得偏移量，然后使用该位数（是 10 的倍数）添加第一个值以找到我们正在寻找的数字。
• 要确定我们要查找的数字（如果不是查找整数），我们可以取上述除法的余数来给出我们的答案。

例如：

• 假设我们需要获取索引 200（或 201，如果从 0 开始）的值。
• 排除 1 位数字后得到 200-9 = 191。
• 排除 2 位数字后得到 191-180 = 11。
• 尝试排除 3 位数会导致负数，因此我们知道它是 3 位数。
• 将 11 除以位数 (3) 得到 3（向下取整）。
• 第 3 个（从 0 开始）3 位数字是 100+3 = 103。
• 由于 11%3 = 2，我们正在寻找第二个数字（从 0 开始），因此 3 是我们的答案。

代码：

final int[] POWERS_OF_10 = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000};
int getValue(int index){
    if (index-- == 0) // remove this if-statement to start from 1
        return 0;
    int digits = 0;
    int positions = 0;
    while (positions <= index)
    {
        index -= positions;
        digits++;
        positions = 9 * digits * POWERS_OF_10[digits-1];
    }
    int number = index / digits + POWERS_OF_10[digits-1];
    int digit = index % digits;
    int value = Integer.toString(number).charAt(digit) - '0'; // lazy approach
    // int value = number / POWERS_OF_10[digits-digit-1] % 10; // non-lazy approach
    return value;
}

这个：

for (int i = 0; i < 20; i++)
    System.out.print(getValue(i) + ", ");

将打印出来：

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0, 1, 1, 1, 2, 1, 3, 1, 4, 

Live demo.

Answer 3

此函数（在 JavaScript 中将其自己转换为 Java）为索引 x 提供数字的 length 和该索引下数字的 position。

例如。对于索引 15，它将返回 {length: 2, pos: 1}，因为在索引 15 下有 12 的 2，因此 2 相对于 12 的索引是 1，而 12 的长度是 2 位数。

index: 0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|..
value: 0|1|2|3|4|5|6|7|8|9|1 |0 |1 |1 |1 |2 |..

我猜你可以自己编写代码从数组中获取正确的值。

function find(x){
  var length = 0;
  while(x > 0){
    length++;
    x = x - (10**(length-1)) * length * 9;
  }
  return {length: length, pos: (x % length) + length -1};
}

console.log(find(15));