Java 数组使用索引逻辑查找值访谈问题

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

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-myMethod（int-index）{
System.out.println（“索引：”+index）；
if（index此函数（在JavaScript中，将其自己转换为Java）为索引
x
提供该索引下数字的
长度和数字的
位置

例如，对于索引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 |..

我想您可以自己编写代码从数组中获取正确的值


函数查找（x）{
变量长度=0；
而（x>0）{
长度++；
x=x-（10**（长度-1））*长度*9；
}
返回{length:length，pos:（x%length）+length-1}；
}
log（find（15））；
此序列称为

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

高效算法的全部细节可以在中找到。
我要说的是，我们从1开始，而不是从0开始，以简化以下内容（您可以从索引中减去1来包含它）

让我们从一些分析开始：


有9个1位数字（1-9）占用前9*1=9*100*1=9个位置
有90个2位数字（10-99）占用接下来的90*2=9*101*2=180个位置
有900个3位数字（100-999）占用接下来的900*3=9*102*3=2700个位置
等等

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

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


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

例如：


假设我们需要得到索引200的值（或者201，如果从0开始）
排除1位数字，我们得到200-9=191
排除两位数字，我们得到191-180=11
试图排除3位数字将导致负数，因此我们知道这是一个3位数字
将11除以数字（3）得到3（向下舍入）
第三个（从0开始）三位数为100+3=103
因为11%3=2，我们在寻找第二个数字（从0开始），所以3是我们的答案

代码：

.
我读了两遍，但不明白问题所在。不知道是我的问题还是问题不清楚。你只需创建一个方法，将int作为参数，并返回该int的10模。在index=30时会发生什么？为什么不使用数组？这是面试官问的一些面试问题，我们必须编写一个逻辑来找到t给定索引的值。
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,