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

Posted 2023-05-08

【中文标题】使用索引逻辑面试问题数组查找价值

【英文标题】：Array find value using index logic interview questions

【发布时间】：2018-01-06 02:49:08

【问题描述】：

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

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 ;

【问题讨论】：

我读了两遍，但没有理解问题所在。不知道这是我的问题还是不清楚。

您只需要创建一个方法，该方法将 int 作为参数并返回该 int 的 10 的模数。

index = 30 会发生什么？

为什么不使用数组？

这是面试官问的一些面试问题，我们必须编写一个逻辑来找到给定索引的值。

【参考方案1】：

这个序列被称为Champernowne constant。

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

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

【参考方案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.

【参考方案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));