Wielokrotne wypisanie i ominięcie wyznaczonej ilości wartości z tablicy

Mam tablicę array[110], w której znajdują się losowo wygenerowane bity (1 lub 0). Teraz chcę tą tablicę podzielić na 7 grup, które zaczynać się będą od kolejnej potęgi liczby 2 (czyli 1,2,4,8,16,32,64...), a następnie będzie następowały wypisanie 2 wartości, ominięcie 2 i tak aż do końca tablicy.
Przykład (w nawiasie nr indeksu w tablicy array[110]; indeksy numeruję od 1, a nie od 0 aby łatwiej wytłumaczyć:
1(1),1(2), 0(3), 0(4), 1(5), 1(6), 1(7), 0(8), 1(9), 1(10), 0(11)...,0(109).

Dla pierwszej grupy bitów zaczynam wypisywanie od indeksu 1 (ale jako, że traktowany jest w kodzie Hamminga jako nieznany, więc go pominę), a potem omijam 1, wypisuję 1 itd.:
1(1) <-unknown(?), 1(2)<-skip, 0(3)<-output, 0(4)<-skip, 1(5)<-output, 1(6)<-skip, 1(7)<-output, 0(8)<-skip, 1(9)<-output, 1(10)<-skip, 0(11)<-output.

Druga grupa (indeks 2):
1(2)<-unknown(?), 0(3)<-output, 0(4)<-skip, 1(5)<-skip, 1(6)<-output, 1(7)<-output, 0(8)<-skip, 1(9)<-skip, 1(10)<-output, 0(11)<-output

Trzecia grupa:
0(4)<-unknown(?), 1(5)<-output, 1(6)<-output, 1(7)<-output, 0(8)<-skip, 1(9)<-skip, 1(10)<-skip, 0(11)<-skip.

Czyli, w grupie 1 wypisywany jest 1 bit, omijany 1,. itd aż do końca tablicy. W 2 grupie, wypisywanych jest 2, omijanych 2, wypisywanych 2, omijanych 2 itd.
Ja takie wypisywanie zrobiłem przez utworzenie nowej tablicy int [] wypisz = new int { tu wpisałem numery indeksów które chcę wypisać }, a w pętli te wartości wypisałem.

int wypisz3 []= {5,6,7, 12,13,14,15, 20,21,22,23, 28,29,30,31, 36,37,38,39, 44,45,46,47,
                        52,53,54,55, 60,61,62,63, 68,69,70,71, 76,77,78,79, 84,85,86,87, 92,93,94,95, 100,101,102,103, 108,109};
          for (int k : skip3)
          {
             System.out.print(tab[k] + "("+k+")"+",");
          
          if (k%18==0)
                {
                    System.out.println("");
                }
          }

Jak to wykonać z automatu w pętli? Czyli "wypisz 4 wartości, omiń 4, wypisz 4, omiń 4", a dla grupy np. o indeksie 16 = wypisz 16 bitów , omiń 16 bitów,wypisz 16, omiń 16 ,.itd.

Implementacja wydaje się prosta, jeśli w miarę dobrze zrozumiałam zadanie. Kod na pewno nie zrealizuje w pełni Twojego zadania, bo nie bardzo zrozumiałam o co chodzi z tymi grupami, ale na pewno poniższy kod w jakiś sposób Ci się przyda.

Z tablicy wypisz3 (przykładowe wartości) program pobiera 1 wartosc, 1 omija, pobiera 2, omija 2, pobiera 3, omija 3 itd.
Uściślij swój problem a zapewne da się poprawić poniższy algorytm, aby w pełni realizował Twój cel.

int wypisz3 []= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40};    
int licznik = 0;
int ilosc_grup = 7;
int exit = 0;
int g = 0;

    while(exit == 0)
    {
       for (int i=1; i<ilosc_grup; i++)
       {
           for (int j=0; j<licznik; j++){
              if (exit != 0) break;
              else{
                  System.out.println(wypisz3[g]);
                  g++;
                  if (g == wypisz3.length) {
                     exit = 1;
                     break;
                 }
              }
           }
           for (int h=0; h<licznik; h++){
              if (exit != 0) break;
              else{
                  g++;
                  if (g == wypisz3.length) {
                     exit = 1;
                     break;
                 }
              }
           }
           if (exit != 0) break;
           else licznik++;
       }   
    }

Nie zrozumiałam tego: Czyli "wypisz 4 wartości, omiń 4, wypisz 4, omiń 4", a dla grupy np. o indeksie 16 = wypisz 16 bitów , omiń 16 bitów,wypisz 16, omiń 16 ,.itd.
Te grupy to są osobne tablice czy jak?

Tak, te grupy to są mniejsze tablice czyli, grupa1[]. grupa2[]. grupa3[]...grupa7[]. Jest ich 7, bo w mojej głównej tablicy array[110] znajduje się 7 indeksów, których wartość jest kolejną potęgą liczby 2, czyli indeksy 1,2,4,8,16,32,64 (7 indeksów). I teraz chcę zrobić tak jak na tym filmiku: (początek ok.1:05). Czyli chce wypisać (w 7 oddzielnych tablicach) kolejno mniejsze ciągi, które rozpoczynają się od indeksów potęgi 2 w array[110]. Ale w każdej grupie to wypisywanie ma być na zasadzie (jeśli zaczynam w grupa3[], czyli od indeksu 4 w array[110]) - wypisać 4, ominąć 4, wypisać 4, ominąć 4, itd.; dodatkowo pierwszy bit pominąć, tak jak na filmie są znaki zapytania przy pierwszym bicie z danej grupy.