Java 循环在输出值时剪切数组的最后两组
我有随机1和0整数的tab[110]数组，所以：1001111001011110。。。依此类推，直到数组结束。 我试图根据汉明码输出7行不同的比特。 我的循环工作，但只适用于从位开始的组，数组中的索引是2,4,8,16。对于第32个循环，它将剪切其中的一半（所以从64开始输出，而不是从32开始），第64个组将被完全跳过Java 循环在输出值时剪切数组的最后两组,java,arrays,for-loop,hamming-code,Java,Arrays,For Loop,Hamming Code,我有随机1和0整数的tab[110]数组，所以：1001111001011110。。。依此类推，直到数组结束。 我试图根据汉明码输出7行不同的比特。 我的循环工作，但只适用于从位开始的组，数组中的索引是2,4,8,16。对于第32个循环，它将剪切其中的一半（所以从64开始输出，而不是从32开始），第64个组将被完全跳过 int x=0; int sum=0; int pointer=0; boolean w = true; Syst
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);
}
}
intx=0；
整数和=0；
int指针=0；
布尔值w=真；
System.out.println（“Grupy-Bitow-Parzystych”）；
对于（int i=2；i好的，现在我知道你在做什么了……几个命令。首先，将数组扩展到最小128个值以使64位的case工作。110太小了。这是你要使用的主要算法。我冒昧地将变量名指针更改为奇偶校验，并删除了一些额外的变量，如它erator
。这应该接近您所需要的。检查是否存在“一次性”错误等
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);
}
开关（一）
{
//情况1：指针=1；
情况2：奇偶性=2；
打破
情况3：奇偶性=4；
打破
情况4：奇偶性=8；
打破
情况5：奇偶校验=16；
打破
情况6：奇偶校验=32；
打破
案例7：奇偶校验=64；
打破
默认值：System.out.println（“默认开关”）；
打破
}
System.out.println（“Grupa bitow:+奇偶校验”）；
总和=0；
整数指数=奇偶校验-1；
int blockSize=奇偶校验；
int printCount=0；
while（index+blockSize
输出：
肮脏的比托干酪
格鲁帕·比托：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
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 );
}
}
}
System.out.println（“Grupy-Bitow-Parzystych”）；
int指针=0，和=0；
对于（int i=0；i<7；i++）{
指针=1您的问题到底是什么？当指针设置为64（所以当我想从64输出位直到数组末尾）时，内部for循环不知何故跳过了组中的所有位，而组中的一半位从第32位开始。迭代器在哪里定义的？它不会按原样编译。迭代器被定义为“int iterator=0”。您对我的理解不够好。我希望输出位，但包括跳过每个X位（当X为1、2、4、8、16、32或64时），所以我想在示例中从第32位开始，输出32位，然后跳过32位，再输出32位。这适用于1-16位的gourp，但正如我所说的，当涉及到32组，然后是64位时，它不能正确地输出。在您的输出中，第32位组以上的位应该从65位跳过位，直到97位（所以32位），然后从98输出到数组[110]的末尾。在第64组中