Java异或运算

Question

杰克和丹尼尔是朋友。他们想加密他们的谈话，这样他们就可以避免被侦探机构拦截。所以他们发明了一种新的密码。每个消息都被编码为其长度为n的二进制表示形式B，然后被记录K次，移动0,1,...,K-1位。如果b=1001010，k=4，它看起来像：

1001010
 1001010
  1001010
   1001010

然后在每一列计算XOR并写下来。这个数字称为s。例如，对上面示例中的数字进行异或运算，结果是

1110100110

然后将编码的消息S和K发送给Daniel。

null

null

   7 4
   1110100110

   1001010

   6 2
   1110001

   101111

1001010
 1001010
  1001010
   1001010
----------
1110100110

101111
 101111
-------
1110001 

import java.io.*;

public class Solution {

    public static void solve(Input in, PrintWriter out) throws IOException {
        int n = in.nextInt();
        int k = in.nextInt();
        char[] c = in.next().toCharArray();
        int x = 0;
        char[] ans = new char[n];
        for (int i = 0; i < n; ++i) {
            ans[i] = (char) (((c[i] - '0') ^ x) + '0');// I understand we are converting the character into integer (c[i] - '0') then xoring it with x which is holding 0 and then again adding '0' to convert back it into character.
            x ^= ans[i] - '0';// But why are we doing this!!. From this line onward things are not clear.
            if (i >= k - 1) {
                ****FILL THE MISSING LINE HERE****

            }
        }
        out.println(ans);
    }

    public static void main(String[] args) throws IOException {
        PrintWriter out = new PrintWriter(System.out);
        solve(new Input(new BufferedReader(new InputStreamReader(System.in))), out);
        out.close();
    }

    static class Input {
        BufferedReader in;
        StringBuilder sb = new StringBuilder();

        public Input(BufferedReader in) {
            this.in = in;
        }

        public Input(String s) {
            this.in = new BufferedReader(new StringReader(s));
        }

        public String next() throws IOException {
            sb.setLength(0);
            while (true) {
                int c = in.read();
                if (c == -1) {
                    return null;
                }
                if (" \n\r\t".indexOf(c) == -1) {
                    sb.append((char)c);
                    break;
                }
            }
            while (true) {
                int c = in.read();
                if (c == -1 || " \n\r\t".indexOf(c) != -1) {
                    break;
                }
                sb.append((char)c);
            }
            return sb.toString();
        }

        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }
    }
}

Answer 1

注意：请阅读解释，简单地通过复制粘贴答案来解决挑战是没有用的。

可以利用的限制是

第一位未被加密算法触及。

第三位与第一位和第二位进行异或，所以我们所做的基本上是保持一个值，这个值是所有已经获得的值的异或，并与下一个值异或。在内部，该值为零。

示例：

接受第一个示例输入：

1110100110

       1110100110
mask    1????????
result 10

       1110100110
mask    11???????
result 100

index      0123456789       
data       1110100110
submasks    1001010
             1001010
              1001010
mask       0111??????
result     1001??????

index      0123456789
data       1110100110
submasks    1001010
             1001010
              1001010
mask       01111?????
result     10010?????

现在我们对最后一个结果位(0)和第二个结果位(0)进行异或：

index      0123456789
data       1110100110
submasks    1001010
             1001010
              1001010
mask       011111????
result     100101????

对于下一个，我们与最后一个(1)和第三个(0)进行异或，从而交换状态。通过继续执行此过程，我们最终以：

index      0123456789
data       1110100110
submasks    1001010
             1001010
              1001010
mask       0111110???
result     1001010???

现在我们不再对剩余的比特感兴趣，所以我们终止。

if (i >= k - 1) {
    x ^= ans[i-(k-1)] - '0';
}