Как мне исправить мою интерпретацию этого алгоритма кодирования длин серий?

Question

Для школы я должен создать себе метод в java, который сжимает массив, используя RLE (кодирование по длине прогона). Я не могу найти решение онлайн, потому что мой учитель хочет, чтобы я сам решил проблему. Я, к сожалению, не могу этого сделать, потому что я занятой человек с некоторыми занятыми планами.

RLE превращает это: {1,1,1,1,2,2,3,3,6,6,6,7,8,8,8} в это: {4,1,2,2,2,3,3,6,1,7,3,8} он в основном создает новый массив, который следует этой формуле {# этого значения, этого значения, # этого значения, этого значения, продолжение ...} есть 4 1, так что {4,1} вы получите мой дрейф.

Вот что я пытался сделать (простите за мой дерьмовый код, я всего лишь школьник):

public class tester{
public static void main(String[] args){
    int[] potato = {1,1,1,2,2,4,4,4,6,6,6,6};
    printArray(compress(potato));
}

public static void printArray(int[] arr){
    for(int i = 0; i < arr.length; i++){
        System.out.println(arr[i]);
    }
}

public static int[] compress(int[] a) {
    //figure out how many different numbers there are.
    int diffNums = 1;
    for(int i = 0; i < a.length; i++){
        if(i != a.length-1 && a[i] != a[i+1]){
            diffNums++;
        }
    }

    //make compressed array at the correct length.
    int[] compressed = new int[diffNums * 2];

    //figure out what each number is. 
    int[] nums = new int[diffNums];
    nums[0] = a[0];
    int spot = 0;
    for(int i = 0; i < a.length; i++){
        if(i != a.length-1 && a[i] != a[i+1]){
            nums[spot] = a[i+1];
        }
    }

    //figure out quantity of each number.
    int[] quantities = new int[diffNums];
    int spot2 = 0;
    int spotcur = 0;
    for(int i = 0; i < diffNums; i++){
        int quant = 0;
        while(a[spotcur] == a[spot2]){
            quant++;
            spotcur++;
        }
        spot2 = spotcur;
        quantities[i] = quant;
    }

    //add them together and return compressed array
    int spotter = 0;
    for(int i = 0; i < diffNums; i++){
        compressed[spotter] = quantities[i];
        spotter++;
        compressed[spotter] = nums[i];
        spotter++;
    }
    return compressed;
  }
}

Кто-нибудь знает, как я могу исправить этот дерьмовый код? я застрял на этом

Answer 1

Я думаю, что эту проблему можно решить с помощью гораздо меньшего количества кода. Вы можете использовать конструкцию внешнего / внутреннего цикла примерно так:

public static int[] compress(int[] a) {
    List<Integer> encoded = new ArrayList<>();
    for (int i=0; i<a.length; i++) {
        int num = a[i];
        int count = 1;
        for (int j=i+1; j<a.length; j++) {
            int nextNum = a[j];
            if (nextNum != num) 
                break;
            count++;
            i++;
        }
        encoded.add(count);
        encoded.add(num);
    }
    return encoded.stream().mapToInt(i->i).toArray();
  }

Кроме того, класс Arrays содержит уже определенный полезный метод toString.

System.out.println(Arrays.toString(compress(potato)));