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＆amp;再次在索引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）。但对于三位数和＆amp;我们必须改变逻辑。

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的值（如果从0开始，则为201）。
不包括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。

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

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

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 |..

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

3 个答案: