Цикл обрезает последние две группы моего массива, когда выводит значения

У меня есть массив вкладок [110] со случайными 1 и 0 дюймами, так что: 1001111001011110... и так до конца массива. Я пытаюсь вывести 7 различных рядов битов в соответствии с кодом Хемминга. Мой цикл работает, но только для групп, начинающихся с битов, индекс которых в массиве равен 2,4,8,16. Для 32-го цикла обрезает половину из них (поэтому начинайте вывод с 64, а не с 32), и группа 64 полностью пропускается.

int x=0;
        int sum=0;
        int pointer=0;
        boolean w = true;
        System.out.println("Grupy Bitow Parzystych");
        for  (int i=2; i<=7; i++)
        {

            System.out.println("\n"); 
            switch(i)
             {
                //case 1: pointer=1; 

                 case 2: pointer=2;
                     break;
                 case 3: pointer=4;
                     break;
                 case 4: pointer=8;
                     break;
                 case 5: pointer=16;
                     break;
                 case 6: pointer=32;
                     break;
                 case 7: pointer=64;
                     break;
                 default: System.out.println("DEFAULT SWiTCH");
                     break;
             }

            sum=0;
            x=0;
            for (int p=0; p<tab.length; p++)
             {
                if (p==0) System.out.println("Grupa bitow: "+pointer);
                if (p<=pointer-1) continue;
                x++;
                if (x == pointer)
                    {
                        x = 0;
                        w = !w;
                    }         
                if (p%20==0) System.out.println("");        
                if (w) 
                    {
                        iterator = p+1;
                        System.out.print(tab[p]+"("+iterator+")"+",");
                        sum++;
                    }
                if (p==tab.length-1) System.out.println("Suma bitow pary "+pointer+": "+sum);
            }
        }

2 ответа

Попробуйте что-то вроде этого:

System.out.println( "Grupy Bitow Parzystych" );
int pointer = 0, sum = 0;
for ( int i = 0; i < 7; i++ ) {
  pointer = 1 << i; // 1
  sum = 0;
  for ( int p = 0; p < tab.length; p++ ) {
    if ( p == 0 ) {
      System.out.println( "\n\nGrupa bitow: " + pointer );
    }
    if ( ( ( p+1 ) & pointer ) == 0 || p == pointer ) { // 2
      continue;
    }
    System.out.format( "%d(%d), ", tab[p], p + 1 ); // 3
    sum += tab[p]; // 4
    if ( p == tab.length - 1 ) {
      System.out.format( "\nSuma bitow pary %d: %d\n" , pointer , sum );
    }
  }
}

Нумерованные комментарии:

  1. Ценности вашего pointer являются показателями 2, поэтому можно использовать простой оператор "влево". (Также можно использовать "умножить на 2"...)
  2. Маскировка индекса с помощью pointer, с двоичной арифметической операцией AND.
  3. p основывается на нуле, ваши напечатанные индексы кажутся основанными, следовательно, +1,
  4. Значение tab[p] либо 1 или же 0Подводя итоги, мы получим число 1 ценности...

Редактировать:

Теперь я вижу, что вы хотите проверить код Хэмминга. Я редактировал код выше.

  1. Второе условие - пропуск паритета (pointer) биты...

Хорошо, теперь, когда я вижу, что ты делаешь... пара компонентов. Во-первых, увеличьте массив до 128 значений минимум, чтобы 64-битный случай работал. 110 слишком мало. Вот основной алгоритм, который вы хотите использовать. Я взял на себя смелость изменить имя переменной pointer в parityи удалил некоторые дополнительные переменные, такие как iterator, Это должно быть близко к тому, что вам нужно. Проверьте на "одноразовые" ошибки и тому подобное.

        switch(i)
        {
        //case 1: pointer=1; 

        case 2: parity=2;
        break;
        case 3: parity=4;
        break;
        case 4: parity=8;
        break;
        case 5: parity=16;
        break;
        case 6: parity=32;
        break;
        case 7: parity=64;
        break;
        default: System.out.println("DEFAULT SWiTCH");
        break;
        }

        System.out.println("Grupa bitow: "+parity);
        sum=0;
        int index = parity - 1;
        int blockSize = parity;
        int printCount = 0;

        while (index + blockSize < tab.length) //don't run past end of bit array
        {
            for (int j = 0; j < blockSize; j++) 
            {
                if (printCount++ % 20 == 0)
                    System.out.println("");

                System.out.print(tab[index] + "(" + (index + 1) + ")" + ",");
                sum += tab[index++];
            }
            //printing of consecutive bits complete. Now skip the next 2|4|8|16|32|64 bits
            index += blockSize;
        }
        System.out.println("\n\nSuma bitow pary " + parity  + ": " + sum);
    }

Выход:

Grupy Bitow Parzystych

Группа битов: 2

0 (2), 0 (3), 1 (6), 0 (7), 1 (10), 0 (11), 0 (14), 0 (15), 1 (18), 0 (19), 0 (22), 0 (23), 1 (26), 1 (27), 0 (30), 1 (31), 0 (34), 0 (35), 1 (38), 1 (39), 0 (42), 0 (43), 0 (46), 0 (47), 0 (50), 0 (51), 0 (54), 0 (55), 0 (58), 0 (59), 0 (62), 1 (63), 1 (66), 0 (67), 0 (70), 1 (71), 0 (74), 1 (75), 0 (78), 1 (79), 1 (82), 0 (83), 0 (86), 0 (87), 1 (90), 1 (91), 0 (94), 1 (95), 0 (98), 1 (99), 1 (102), 1 (103), 1 (106), 0 (107), 0 (110), 0 (111), 0 (114), 0 (115), 0 (118), 0 (119), 0 (122), 0 (123), 0 (126), 0 (127),

Сума битов пари 2: 21

Группа битов: 4

0 (4), 0 (5), 1 (6), 0 (7), 0 (12), 1 (13), 0 (14), 0 (15), 1 (20), 1 (21), 0 (22), 0 (23), 1 (28), 1 (29), 0 (30), 1 (31), 1 (36), 0 (37), 1 (38), 1 (39), 0 (44), 1 (45), 0 (46), 0 (47), 0 (52), 1 (53), 0 (54), 0 (55), 1 (60), 0 (61), 0 (62), 1 (63), 1 (68), 0 (69), 0 (70), 1 (71), 1 (76), 0 (77), 0 (78), 1 (79), 1 (84), 0 (85), 0 (86), 0 (87), 0 (92), 1 (93), 0 (94), 1 (95), 1 (100), 1 (101), 1 (102), 1 (103), 0 (108), 0 (109), 0 (110), 0 (111), 0 (116), 0 (117), 0 (118), 0 (119), 0 (124), 0 (125), 0 (126), 0 (127),

Сума битов пари 4: 25

Группа битов: 8

0 (8), 0 (9), 1 (10), 0 (11), 0 (12), 1 (13), 0 (14), 0 (15), 1 (24), 0 (25), 1 (26), 1 (27), 1 (28), 1 (29), 0 (30), 1 (31), 1 (40), 0 (41), 0 (42), 0 (43), 0 (44), 1 (45), 0 (46), 0 (47), 1 (56), 0 (57), 0 (58), 0 (59), 1 (60), 0 (61), 0 (62), 1 (63), 1 (72), 0 (73), 0 (74), 1 (75), 1 (76), 0 (77), 0 (78), 1 (79), 0 (88), 0 (89), 1 (90), 1 (91), 0 (92), 1 (93), 0 (94), 1 (95), 0 (104), 0 (105), 1 (106), 0 (107), 0 (108), 0 (109), 0 (110), 0 (111), 0 (120), 0 (121), 0 (122), 0 (123), 0 (124), 0 (125), 0 (126), 0 (127),

Сума битов пари 8: 22

Группа битов: 16

1 (16), 0 (17), 1 (18), 0 (19), 1 (20), 1 (21), 0 (22), 0 (23), 1 (24), 0 (25), 1 (26), 1 (27), 1 (28), 1 (29), 0 (30), 1 (31), 0 (48), 0 (49), 0 (50), 0 (51), 0 (52), 1 (53), 0 (54), 0 (55), 1 (56), 0 (57), 0 (58), 0 (59), 1 (60), 0 (61), 0 (62), 1 (63), 1 (80), 1 (81), 1 (82), 0 (83), 1 (84), 0 (85), 0 (86), 0 (87), 0 (88), 0 (89), 1 (90), 1 (91), 0 (92), 1 (93), 0 (94), 1 (95), 0 (112), 0 (113), 0 (114), 0 (115), 0 (116), 0 (117), 0 (118), 0 (119), 0 (120), 0 (121), 0 (122), 0 (123), 0 (124), 0 (125), 0 (126), 0 (127),

Сума битов пари 16: 22

Группа битов: 32

0 (32), 1 (33), 0 (34), 0 (35), 1 (36), 0 (37), 1 (38), 1 (39), 1 (40), 0 (41), 0 (42), 0 (43), 0 (44), 1 (45), 0 (46), 0 (47), 0 (48), 0 (49), 0 (50), 0 (51), 0 (52), 1 (53), 0 (54), 0 (55), 1 (56), 0 (57), 0 (58), 0 (59), 1 (60), 0 (61), 0 (62), 1 (63), 1 (96), 0 (97), 0 (98), 1 (99), 1 (100), 1 (101), 1 (102), 1 (103), 0 (104), 0 (105), 1 (106), 0 (107), 0 (108), 0 (109), 0 (110), 0 (111), 0 (112), 0 (113), 0 (114), 0 (115), 0 (116), 0 (117), 0 (118), 0 (119), 0 (120), 0 (121), 0 (122), 0 (123), 0 (124), 0 (125), 0 (126), 0 (127),

Сума битов пари 32: 17

Группа битов: 64

0 (64), 1 (65), 1 (66), 0 (67), 1 (68), 0 (69), 0 (70), 1 (71), 1 (72), 0 (73), 0 (74), 1 (75), 1 (76), 0 (77), 0 (78), 1 (79), 1 (80), 1 (81), 1 (82), 0 (83), 1 (84), 0 (85), 0 (86), 0 (87), 0 (88), 0 (89), 1 (90), 1 (91), 0 (92), 1 (93), 0 (94), 1 (95), 1 (96), 0 (97), 0 (98), 1 (99), 1 (100), 1 (101), 1 (102), 1 (103), 0 (104), 0 (105), 1 (106), 0 (107), 0 (108), 0 (109), 0 (110), 0 (111), 0 (112), 0 (113), 0 (114), 0 (115), 0 (116), 0 (117), 0 (118), 0 (119), 0 (120), 0 (121), 0 (122), 0 (123), 0 (124), 0 (125), 0 (126), 0 (127),

Сума битов пари 64: 23

Другие вопросы по тегам