Как получить диапазон до первого индекса, когда l oop достигает конца?

Question

У меня есть List<List<Integer>> с несколькими объектами. Каждый внутренний элемент содержит, например, случайно перемешанные индексы (это только часть индексов).

[1, 4, 5, 2, 0, 3, 6]
[4, 2, 5, 3, 1, 6, 0]
[0, 3, 6, 1, 2, 4, 5]

У меня также есть массив с некоторыми значениями (массив int [] [])

И мне нужно сделать al oop для каждого элемента, чтобы получить значение из индексов и двигаться вперед на 1 индекс, а когда я достигну последнего индекса, мне нужно получить значение из этого индекса и первого. После этого l oop конечные и суммарные значения. Это может выглядеть сложно, но картинка покажет, что я имею в виду. Но я не знаю, как это сделать (для каждого элемента требуется l oop, у меня будет огромный список List<Integer> внутри, и у каждого объекта будет несколько индексов.

Я читаю данные из файла и записываю их в массив

List<String> result = new ArrayList<>();
        int[][] array = new int[][]{};

        try (Scanner sc = new Scanner(theFile)) {
            while (sc.hasNext()) {
                result.add(sc.nextLine());
            }
            int max = Integer.parseInt(result.get(0).trim());
            array = new int[max][max];
            for (int i = 1; i < result.size(); i++) {
                String[] tmp = result.get(i).trim().split(" ");
                for (int j = 0; j < tmp.length; j++) {
                    array[i - 1][j] = Integer.parseInt(tmp[j]);
                    array[j][i - 1] = array[i - 1][j];
                }
            }

 List<List<Integer>> collectionWithSubjects = new ArrayList<>();

        for (int i = 0; i < 40; i++) {
            List<Integer> sub = new ArrayList<>();
            sub = sequence(0,51);
            Collections.shuffle(sub);
            collectionWithSubjects.add(sub);
        }

Answer 1

Вы достойно объяснили проблему. Звучит так, будто вы пытаетесь сделать все в одном для l oop, а не разбиваете проблему на две части.

Это ваше утверждение:

Мне нужно сделать al oop для каждого элемента, чтобы получить значение из индексов и двигаться вперед на 1 индекс, а когда я достигну последнего индекса, мне нужно получить значение из этого индекса и первого.

Это можно разделить на две части:

Мне нужно сделать al oop для каждого элемента, чтобы получить значение из индексов и продвинуться вперед на 1 индекс

Это для l oop, который повторяется от 0 -> size () - 1. Если мы go из 0 -> size (), мы получаем переполнение.

for(int i = 0; i < list.size() - 1; i++) {
    int firstCoord = list.get(i);
    int secondCoord = list.get(i+1);

    //do stuff
}

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

Это получение последнего элемента и первого элемента.

int firstCoord = list.get(list.size() - 1);
int secondCoord = list.get(0);

---

Объедините оба вместе, и вы получите структуру для получения координат.

for(int i = 0; i < list.size() - 1; i++) {
    int firstCoord = list.get(i);
    int secondCoord = list.get(i+1);

    //do stuff
}

int firstCoord = list.get(list.size() - 1);
int secondCoord = list.get(0);

//do stuff

Я оставлю фактические реализация до вас.

Answer 2

Вы можете перебирать имена каждого List<Integer>, а затем просматривать их по паре (используйте % до go в начале) и использовать их для индексации 2d массива

for (List<Integer> l : list) {
    int sum = 0;
    for (int i = 0; i < l.size(); i++) {
        int p1 = l.get(i % l.size());
        int p2 = l.get((i + 1) % l.size());
        sum += values[p1][p2];
    }
    System.out.println(sum);
}

С этими исходными данными

List<List<Integer>> list = List.of(List.of(1, 4, 5, 2, 0, 3, 6), List.of(4, 2, 5, 3, 1, 6, 0));

int[][] values = new int[][]{new int[]{31, 21, 34, 22, 67, 14, 41}, new int[]{17, 42, 31, 57, 26, 23, 52}, new int[]{5, 92, 52, 52, 31, 22, 62},
                 new int[]{17, 42, 31, 57, 26, 23, 52}, new int[]{5, 92, 52, 52, 31, 22, 62}, new int[]{31, 21, 34, 22, 67, 14, 41}, new int[]{5, 92, 52, 52, 31, 22, 62},};

будет напечатано

253
262

Answer 3

// given array
int[][] array = [[31, 21, 34, 22, 67, 14, 41], 
                 [17, 42, 31, 57, 26, 23, 52], 
                 [5,  92, 52, 52, 31, 22, 62],
                 [17, 42, 31, 57, 26, 23, 52], 
                 [5,  92, 52, 52, 31, 22, 62], 
                 [31, 21, 34, 22, 67, 14, 41], 
                 [5,  92, 52, 52, 31, 22, 62]];
// given list of lists of randomly-ordered indices
List<List<Integer>> indexList = Arrays.toList([
                                    Arrays.toList([1, 4, 5, 2, 0, 3, 6]),
                                    Arrays.toList([4, 2, 5, 3, 1, 6, 0]),
                                    Arrays.toList([0, 3, 6, 1, 2, 4, 5])
                                ]);
// first, create a place to store the sums corresponding to each random list
List<Integer> sums = new ArrayList<Integer>();
// iterate over each of the lists of random elements
for(List<Integer> randomIndices: indexList){
    // create a running sum for this list
    int randomSum = 0;
    // iterate over each element of the randomized index list
    for(int j = 0; j < randomIndices.size(); j++){  
        // read the current and next index (using modulo to wrap around)
        current = randomIndices.get(j);
        next = randomIndices.get((j + 1) % randomIndices.size());
        // add the relevant index in array to the running sum
        randomSum += array[current][next];
    }
    // add the recorded randomSum to the sums list.
    // Its index is the same as the random list we just iterated over
    sums.add(randomSum);
}
System.out.println(sums);