Индексирование В Java массивы

Question

я должен написать метод в Java, где наличие на входе массив a чисел и номер x возвращает массив элементов, который следует за последнее вхождение x в a.

Например, при входе {0,1,2,3,4,5,6,7,8,9} и x=6 метод должен возвращать {7,8,9} того времени с {4,1,4,2} и x=4 метод должен возвращать {2} и если x не в a, то она должна возвращать пустой массив {} (или массив с 0 длиной)

так что я получил этот ответ:

int idx = -1; 
for (int i = 0; i < s.length; i++) { 
    if (s[i] == x) 
     idx = i; 
} 

/* After you found this index, create a new array starting 
* from this element. It can be done with a second (not nested) for loop, or you can 
* use Arrays.copyOfRange() 
*/ 

//make sure idx != -1 
int[] t = new int[s.length - idx - 1]; 
for (int i = idx + 1; i < s.length; i++) 
    t[i - idx - 1] = s[i]; 

, который был очень полезным, но я не мог понять, почему это работает: (РЕДАКТИРОВАНИЕ, Хорошо, теперь я понять, почему это работает, но даже если на мой взгляд, в сочетании для петли ideea был более менее сложным для чтения)

t[i - idx - 1] = s[i]; 

и это не делает:

int[] t = new int[a.length - indx - 1]; 
for (int j = indx + 1; j < a.length; j++) { 
    for (int i = 0; i < t.length; i++) { 
     t[i]=a[j]; 
    } 
} 
return t; 

Редакцией: Чтобы уточнить это все код

int[] dopoX(int[] a, int x) { 
    int n = a.length; 
    int[] c = new int[0]; 
    int indx = 0; 
    int nrx = 0; 
    for (int j = 0; j < a.length; j++) { 
     if (a[j] == x) 
      nrx++; 
     if (a[j] == x) 
      indx=j; 
    } 
    if (nrx == 0) 
     return c; 
    int[] t = new int[n - indx - 1]; 
    for (int j = indx + 1; j < n; j++) { 
     for (int i = 0; i < t.length; i++) { 
      t[i] = a[j]; /* it returns just 1 number of a[] like t{2,2,2,2,2,2,2,2} which is 
          not correct */   
     } 
    } 
    return t; 
} 

Answer 1

Ну вы хотите, чтобы скопировать все остальные значения, и создать массив индекса t. Таким образом, вам нужно начать с i=0. Однако вы можете выполнить сдвиг-операции: увеличение i где-то, и когда вы его используете, переложить его обратно, так:

for (int i = idx+1; i < s.length; i++) 
    t[i-idx-1] = s[i]; 

значения будут сброшены:

for (int i = 0; i < t.length; i++) 
    t[i] = s[i+idx+1]; 

(который был бы более читаемым, а)

---

О втором вопросе:

здесь вы используете nested loop: вторая петля for будет повторяться каждую итерацию первой.

В результате, таким образом, что во втором for -loop, j всегда фиксирована, с входом {1,2,...,9} и 6 в первой итерации, вы бы заполнить ваш массив с 7 с, следующих 8 с и, наконец, 9 с.

Однако можно использовать в сочетании for петлю:

int []t=new int[n-indx-1]; 
//  /-- grouped initializers  /-- grouped increments 
//  |        | 
for(int i=0, j= indx+1; i < t.length; i++, j++){ 
    t[i]=a[j]; 
} 
return t; 

Answer 2

Первая строка кода находит последний индекс х внутри массива.

Вторая строка использует встроенную функцию массивов для копирования диапазона из массива в новую копию.

И мы копируем значения после последнего x до длины массива a.

Первую строку можно переписать для поиска с конца и назад в массиве с перерывом. Это даст повышение производительности, но делает код менее легким для чтения.

for(int i=0; i<a.length;i++) if(a[i]==x) idx=i; 

int[] b = Arrays.copyRangeTo(a, idx+1, a.length); 

Answer 3

Давайте предположим, что вы берете на себя случай, когда a[] = {1,2,3,4,5,6,7,8,9} и x = 6. Запуск этого:

int idx = -1; 
for (int i = 0; i < s.length; i++) { 
if (s[i] == x) idx = i; 
} 

Вы получили idx = 5 в s[5] == x.

Теперь мы хотим скопировать массив после последнего экземпляра x в новый массив t[].

Очевидно, что вам нужно исходить из индекса idx + 1, так как idx содержит последние данные о x.

Следовательно, этот код:

int[] t = new int[s.length - idx - 1]; 
for (int i = idx+1; i < s.length; i++) 
    t[i-idx-1] = s[i]; 

Что вы здесь делаете?

Вы построить новый массив, имеющий длину t[]s.length - idx - 1, в нашем случае s.length = 9 и idx = 5 следовательно, мы имеем s.length - idx - 1 как 3 и мы можем проверить, что это число элементов после x = 6.

Теперь мы начинаем итератор i из idx + 1 (Reason описано выше) к s.length

Мы t[i - idx - 1], потому что когда i = idx + 1, i - idx - 1 = 0. Следовательно, как i увеличивается, ваш i - idx - 1 также увеличивается.

Надеюсь, это было убедительно. Прошу прокомментировать, если у вас все еще есть сомнения.

Answer 4

Попробуйте это:

int j=0; 
int i=idx+1; 
while (j<t.length) { 
    t[j] = s[i]; 
    j++; 
    i++; 
}