Я не понимаю, почему этот код работает (Codingbat Array2 tenRun)

Question

Для каждого кратного 10 в данном массиве измените все следующие за ним значения на кратное 10, пока не встретите еще одно кратное 10. Итак, {2, 10, 3, 4, 20, 5} приводит к {2, 10, 10, 10, 20, 20}.

Я не понимаю, почему это работает. По моему мнению, вывод для {1, 10, 2, 2} должен быть {1, 10, 10, 2}, потому что для l oop должен обнаруживать% 10 == 0 только один раз, а затем l oop назад и не обнаружить его в следующий раз. Почему он делает это более одного раза?

public int[] tenRun(int[] nums) {
   for (int i = 0; i < nums.length-1; i++) {
      if (nums[i] % 10 == 0) {
          if (nums[i+1] % 10 != 0) {
              nums[i+1] = nums[i];
          }
      }
   }
   return nums;
}

Answer 1

Когда вы обнаруживаете кратное 10, а затем не кратное 10, ваш алгоритм обновляет следующее значение. На следующей итерации l oop вы встретите это обновленное значение. Учитывая, что теперь это должно быть кратно 10, последующее значение затем обновляется.

Если мы рассмотрим состояние i и nums в start каждой итерации находим:

0: 1, 10,  2,  2
1: 1, 10,  2,  2
2: 1, 10, 10,  2

Итак, на этой последней итерации (l oop завершается, когда i == 3), nums[2] == 10, следовательно, nums[3] также установлен на 10.

Answer 2

На каждой итерации, когда условие nums[i] % 10 == 0 оценивается как true (т.е. nums[i] кратно 10), оно проверяет, не является ли следующий элемент кратным 10, т. Е. nums[i + 1] % 10 != 0, и если это так, он устанавливает следующий элемент на nums[i], который кратен 10. Надеюсь, это поможет вам понять, как это работает. Не стесняйтесь комментировать в случае каких-либо дальнейших сомнений.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        System.out.println(Arrays.toString(tenRun(new int[] { 2, 10, 3, 4, 20, 5 })));
    }

    public static int[] tenRun(int[] nums) {
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i] % 10 == 0) {
                if (nums[i + 1] % 10 != 0) {
                    nums[i + 1] = nums[i];
                }
            }
        }
        return nums;
    }
}

Вывод:

[2, 10, 10, 10, 20, 20]

Answer 3

for для l oop только циклы nums.length-1 раз, и он просматривает все перекрывающиеся пары элементов в массиве: nums[i] (который я назову a) и nums[i+1] (который я назову b).

Значение l oop изменится только b и никогда a. Он только проверяет, является ли a кратным 10. Если это так, установите b на a. Посмотрите на последнюю пару в массиве, b вот последний элемент. Следовательно, последний элемент будет потенциально изменен на l oop.

l oop в какой-то момент будет смотреть на nums[1] и nums[2], и после установки nums[2] 10, теперь он смотрит на последнюю пару, то есть nums[2] (a) и nums[3] (b). Обратите внимание, что nums[2] только что было установлено значение 10, , так что , nums[3] можно также установить на 10.

С другой стороны, l oop никогда не установит первый элемент, который является a первой пары. Это правильно, так как после десятикратных значений не будет.