Program szukający i korygujący błędy w kodzie - Hamming + CRC

0

Muszę zrobić program wychwytujący i naprawiający błędy/zakłócenia w ciągu 110 bitów z pomocą kodu Hamminga i CRC. Jestem na etapie tego pierwszego.
Mam następujący problem, jak przepisać (skopiować) kilka wartości z tablicy tab[] do tablicy tabBit[]? Pierwsza ma rozmiar 110, druga 7. Tablica tabBit[] ma służyć do przechowania bitów, które w tab[] znajdują się w "szufladkach", których indeks jest kolejną wartością potęgi 2 (czyli 1,2,4,8,16,32,64). Program wypisuje mi te bity (w nawiasie podany jest indeks o wartości kolejnej potęgi 2).
[edit] Ręcznie skopiowałem tak:

int [] tabBit = new int [7];
        tabBit [0] = tab[1];
        tabBit [1] = tab[2];
        tabBit [2] = tab[4];
        tabBit [3] = tab [8];
        tabBit [4] = tab[16];
        tabBit [5] = tab[32];
        tabBit [6] = tab[64];

, ale jak to zrobić w pętli?
[/edit]
Następnie, jak w pętli zapisać, aby wypisywała co drugą, potem co czwartą (itd., aż do końca tablicy) parę bitów? Domyślam się, że służy do tego funkcja continue, lecz nie wiem jak dokładnie zapisać warunek omijania wybranej ilości iteracji. Korzystam z tego tutoriala do Hamminga

package teleinformatykalab2;

import java.sql.Array;
import java.util.Random;


public class TeleinformatykaLab2 {

    //Funkcja wypełniająca tablicę ciągiem losowych bitów 0 lub 1 //
    public static void Losowanie(int tab[]){
                      
        ////int [] tab = new int[110];
        
        for (int i = 0; i<110; i++)
        {
            Random r = new Random();
            tab[i] = r.nextInt(2);
            if (i%25==0)
            {
                System.out.println("");
            }
            System.out.print(tab[i]+"("+i+")"+", ");
            
        }
        System.out.println("");
        
}
    /////////////////
    
    
    //Funkcja wyświetla bity, których indeks w tablicy jest wartością kolejnej potęgi liczby dwa//
    public static void zamienBity(int tab[], int tabBit[])
    {
        ////System.out.println("\n"+tab[0]+tab[109]+"\n");
        
        for (int i=0; i<110; i++)
        {
            
            if (isPowerOfTwo(i))
                {
                
                //tabBit[i]=tab[i];
                System.out.print(tab[i]+"("+i+")"+", ");
                }
            if (i%50==0)
            {
                System.out.println("");
            }
            
        }
        
        System.out.println("\n");
        
            /*if (i == 1 || i == 2 || i == 4 || i == 8 || i == 16 || i == 32 || i == 64)
                    {
                        System.out.print(tab[i]+"("+i+")"+", ");
                        for (int b = 1; b<=7; b++)
                            {
                                tab[i]=tabBit[b];
                            }
                       
                    };
            
            long p = (long) Math.pow(2, i);
            long x = p;
            p = tab[i];
            
        
        if(i==p)
                {
                System.out.print(tab[i]+", ");
                }
            System.out.print(p+"("+x+")"+"("+i+")"+", ");*/
        
    }
    
    //Sprawdzenie ciągu kodem Hamminga//
    public static void sprawdzHamming(int tab[], int tabBit[])
    {
      
        for (int i = 0 ; i<7; i++)
        {
            
            System.out.print(tabBit[i]+", ");
            
        }
            
    };
    
    private static boolean isPowerOfTwo(int x)
    {
        //return (x & (x-1)) ==0;
         return (x!=0) && ((x&(x-1)) ==0);
    }
    
    public static void main(String[] args) {
        
        int [] tab = new int[110];
        int [] tabBit = new int [7]{tab[1].tab[2],tab[4],tab[8],tab[16],tab[32],tab[64]};
        
// wywołanie metody wypełniającej tablicę ciągiem losowych bitów 0 lub 1
        Losowanie(tab);
        System.out.println("\n Bity potęgi dwa: ");
        zamienBity(tab,tabBit);
        
        System.out.println("hamming");
        //sprawdzHamming(tab,tabBit);
        
       
    }
    
}
1
int [] tabBit = new int [7];
for(int i=0;i<tabBit.length;i++){
    tabBit[i] = tab[(int)Math.pow(2,i)];
}
0

Dzięki :)
Jak teraz w kolejnych pętlach wypisywać np. 4 bity, a potem 4 ominąć, znowu 4 wypisać i 4 ominąć (aż do końca tablicy)? Czyli wypisywanie co określoną ilość liczb w pętli i omijanie tej samej ilości na zmianę?
Coś takiego jak dla wypisywania co dwa:

for (int i=1; i<110; i++)
            {
                if (i%2!=0) continue;

                    System.out.print(tab[i]+", "+i);

                if (i%25==0)
                {
                    System.out.println("");
                }
            }

[edit]
Coś takiego, tylko żeby nie wypisywać potem kilkudziesięciu indeksów tablicy do wypisania w pętli

for (int i=1;i<110; i++)
            {
                if (i== 2 || i == 3 || i == 6 || i==7)
                    System.out.print(tab[i]+"("+i+")"+", ");
            }
1
int length = 4;
for(int i = 0;i<...;i++){
    if(i % (2*length) < length){
        System.out.print(tab[i]+","+i+" ");
    }
}
0

Ok, a dało by się tą metodę przerobić na bardziej uniwersalną? Czyli np.

int skip []= {2,3,6,7,10,11,14,15};
if (i == wartość_tablicy_skip[]) System.out.println(tab[i]);

Definiuje tablice, do której wpisuje wartości. W pętli zaś, jeśli iterator będzie równy jakiejkolwiek wartości z tej tablicy, to ma wypisywać wartość tablicy z bitami tab[]. To mniej automatyczne, ale prostsze, bo sam mogę zadeklarować jakie konkretnie wartości z tablicy chcę wypisywać. Tylko jakiej funkcji użyć w miejscu "wartość_tablicy_skip", aby porównywał iterator do wartości w tablicy?

[edit]
Coś takiego w wersji manualnej, czy można by to zautomatyzować? Czyli, żeby nie tworzyć oddzielnej tablicy, za pomocą której wyznaczam wartości do wypisania w pętli?

int skip []= {2,3,6,7,10,11,14,15};
for (int i : skip) {
    System.out.print(tab[i] + "("+i+")"+",");
}
0

Nie mam pojęcia co chcesz uzyskać.

Definiuje tablice, do której wpisuje wartości. W pętli zaś, jeśli iterator będzie równy jakiejkolwiek wartości z tej tablicy, to ma wypisywać wartość tablicy

Czyli, żeby nie tworzyć oddzielnej tablicy, za pomocą której wyznaczam wartości do wypisania w pętli

Czyli jednocześnie tworzymy tablice i jej nie tworzymy.

0

Tam gdzie mogłem, zrobiłem to przez tablice (metoda z postu wyżej), reszte przypadków przez if i continue w pętli.

Ogólnie wygląda to tak:

package teleinformatykalab2;

import java.util.Arrays;
import java.util.List;
import java.util.Random;


public class TeleinformatykaLab2 {

    //Funkcja wypełniająca tablicę ciągiem losowych bitów 0 lub 1 //
    public static void Losowanie(int tab[]){
                      
        ////int [] tab = new int[110];
        
        for (int i = 0; i<110; i++)
        {
            Random r = new Random();
            tab[i] = r.nextInt(2);
            if (i%25==0)
            {
                System.out.println("");
            }
            System.out.print(tab[i]+"("+i+")"+", ");
            
        }
        System.out.println("");
        
}
    /////////////////
    
    
    //Funkcja wyświetla bity, których indeks w tablicy jest wartością kolejnej potęgi liczby dwa//
    public static void zamienBity(int tab[], int tabBit[])
    {
        ////System.out.println("\n"+tab[0]+tab[109]+"\n");
        
        for (int i=0; i<110; i++)
        {
            
            if (isPowerOfTwo(i))
                {
                
                //tabBit[i]=tab[i];
                System.out.print(tab[i]+"("+i+")"+", ");
                }
            if (i%50==0)
            {
                System.out.println("");
            }
            
        }
        
        System.out.println("\n");
        
    }
    
    //Sprawdzenie ciągu kodem Hamminga//
    public static void sprawdzHamming(int tab[], int tabBit[])
    {
        // przypisanie do tabBit bitow o indeksie potęgi dwa
        for(int i=0;i<tabBit.length;i++)
        {
            tabBit[i] = tab[(int)Math.pow(2,i)];
            System.out.print(tabBit[i]+", ");
        }
        System.out.println("////\n");
           
        //sprawdzenie pierwszej pary bitów
        System.out.println("\nPierwsza para");
        
        int [] skip = {1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,36,39,41,43,45,47,49,
                        51,53,55,57,59,61,63,65,67,69,71,73,75,77,79,81,83,85,87,89,91,93,95,97,99,
                        101,103,105,107,109};    
        for (int i : skip)
        {
             System.out.print(tab[i] + "("+i+")"+",");
        
                if (i%25==0)
                {
                    System.out.println("");
                }
        }
        System.out.println("");
        
        //sprawdzenie drugiej pary bitów
        System.out.println("\nDruga para");
        
         int skip2 []= {3,6,7,10,11,14,15,18,19,22,23,26,27,30,31,34,35,38,39,42,43,46,47,
                        50,51,54,55,58,59,62,63,66,67,70,71,74,75,78,79,82,83,86,87,90,91,94,95,98,99,102,103,106,107};
          for (int j : skip2)
          {
          System.out.print(tab[j] + "("+j+")"+",");
          if (j%25==0)
                {
                    System.out.println("");
                }
          }
        System.out.println();
        
        //sprawdzenie trzeciej pary bitów
        System.out.println("\nTrzecia para");
        
         int skip3 []= {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("");
                }
          }
        System.out.println();
        
         //sprawdzenie czwartej pary bitów
        System.out.println("\nCzwarta para");
        
         int skip4 []= {9,10,11,12,13,14,15,16, 25,26,27,28,29,30,31,32, 41,42,43,44,45,46,47,48,
                       57,58,59,60,61,62,63,64, 73,74,75,76,77,78,79,80, 89,90,91,92,93,94,95,96,
                       105,106,107,108,109};
          for (int l : skip4)
          {
          System.out.print(tab[l] + "("+l+")"+",");
          if (l%8==0)
                {
                    System.out.println("");
                }
          }
        System.out.println();
        
        //sprawdzenie piątej pary bitów
        System.out.println("\nPiąta para");
         
        for (int m=17; m<110; m++)
        {
            if ((m>=32 && m<=47) && (m>=64 && m<=79) && (m>=96 && m<=111)) continue;
            System.out.print(tab[m] + "("+m+")"+",");
            if (m%16==0)
                {
                    System.out.println("");
                }
        }
        System.out.println();
        
        //sprawdzenie szóśtej pary bitów
        System.out.println("\nSzóśta para");
         
        for (int m=33; m<110; m++)
        {
            if (m>=65 && m<=96)/* && (m>=64 && m<=79) && (m>=96 && m<=111))*/ continue;
            System.out.print(tab[m] + "("+m+")"+",");
            if (m%16==0)
                {
                    System.out.println("");
                }
        }
        System.out.println();
        
        //sprawdzenie siódmej pary bitów
        System.out.println("\nSiódma para");
        
        int [] sixtyfour = new int [120];
         
        for (int m=65; m<110; m++)
        {
            //if (m>=65 && m<=96)/* && (m>=64 && m<=79) && (m>=96 && m<=111))*/ continue;
            System.out.print(tab[m] + "("+m+")"+",");
            if (m%16==0)
                {
                    System.out.println("");
                }
        }
        System.out.println("\n");
        for (int n=65; n<110; n++)    
        {    
            sixtyfour[n] = tab[n];
            System.out.print(sixtyfour[n]+". ");
            if (n%16==0)
                {
                    System.out.println("");
                }
        }
        System.out.println();
}
        
    
    private static boolean isPowerOfTwo(int x)
    {
        //return (x & (x-1)) ==0;
         return (x!=0) && ((x&(x-1)) ==0);
    }
    
    public static void main(String[] args) {
        
        int [] tab = new int[110];
        
        
    // wywołanie metody wypełniającej tablicę ciągiem losowych bitów 0 lub 1
        Losowanie(tab);
        System.out.println("\n Bity potęgi dwa: ");
        int [] tabBit = new int [7];
        
                
        zamienBity(tab,tabBit);
        
        System.out.println("////Bity potęgi 2");
        sprawdzHamming(tab,tabBit);
        
        int liczby [] = new int[120];
        System.out.println("\n");
        for (int z=1; z<120;z++)
        {
            liczby[z]=z;
            System.out.print(liczby[z]+", ");
            if (z%32==0)
                {
                    System.out.println("");
                }
        }
        
    }
}

Teraz gdy dla każdej grupy bitów utworzę oddzielną tablicę, to jak w niej policzyć ilość bitów o wartości "1"?
[edit]
Policzone:

int licznik=0;
        for (int a=65;a<110; a++)
        {
            if (tab[a]==1)
                licznik++;
        }
        System.out.println(licznik);

1 użytkowników online, w tym zalogowanych: 0, gości: 1