Codeforces Gym 100002 D"Decoding Task" 数学

Problem D"Decoding Task"

Time Limit: 1 Sec  

Memory Limit: 256 MB

题目连接

http://codeforces.com/gym/100002

Description

In the near future any research and publications about cryptography are outlawed throughout the world on the grounds of national security concerns. The reasoning for this is clear and widely accepted by all governments - if cryptography literature is public like in the old times, then everybody (even criminals and terrorists) could easily use it to hide their malicious plans from the national and international security forces. Consequently, public cryptographic algorithms and systems have ceased to exist, and everybody who needs strong protection for their secrets is forced to invent proprietary algorithms.

The ACM Corporation has lots of competitors who are eager to learn its trade secrets. Moreover, the job to protect their secrets is complicated by the fact, that they are forced to use intercontinental communication lines which are easy to eavesdrop on, unlike internal lines of the ACM Corporation which are well guarded. Therefore, the ACM Corporation have invented the Intercontinental Cryptographic Protection Code (ICPC) which they are very proud of, and which is considered unbreakable - nobody has even tried to break it yet, but that is about to change.

The group of hackers was hired by the rival company, which does not disclose its name to them, to break ICPC. As the first step, they have bribed one of the programmers who implemented the software for ICPC and have learned how ICPC works. It turns out, the ICPC uses very long key which is a sequence of bytes generated by some sophisticated and random physical process. This key is changed weekly and is used to encrypt all messages that are sent over intercontinental communication lines during the week. This programmer has also proudly told them, that ICPC is the fastest code in the world, because (having the benefit of highly sophisticated code generation) they simply perform bitwise exclusive OR (XOR) operation between the bytes of the message and the key. That is, the ith byte of the encrypted message Ei = Ki XOR Ci, where Ki is the ith byte of the key and Ci is the ith byte of the original clear-text message.

Having learned how ICPC works, they have started to look for the way to reliably obtain the key every week, which is the only thing that is still missing to listen for all intercontinental communications of the ACM Corporation (eavesdropping on the intercontinental lines themselves has indeed turned out to be an easy task). An attempt to bribe the security officers who guard and distribute the key has failed, because the security officers (having the profession with one the highest salaries of that time) have turned out to be too expensive to bribe.

During the search for alternative solutions, they have stumbled upon a clerk, who sends weekly newsletters to various employees and departments. Fortunately, these newsletters are being sent just after the change of the key and the messages are usually long enough to recover sufficient portions of the key by studying original newsletters and their encoded forms. However, they could not covertly find anyone who will disclose the newsletter contents on a weekly basis, because all the employees were bound by a Non-Disclosure Agreement (NDA) and the penalty for the disclosure of any corporate message according to this NDA is death.

Yet they were able to convince this clerk (for a small reward) to do a seemingly innocent thing. That is, while sending the copies of newsletter throughout the corporation, he was instructed to insert an extra space character in the beginning of some messages but send other copies in their original form. Now the task to recover the key is straightforward and it is you, who shall create a program for this. The program is given two ICPCed messages where the first message is N bytes, and the second one is N+1 bytes and is the result of encoding the same clear-text messages as the first one, but with one extra space character (represented by the byte with the decimal value of 32) in the beginning. The program shall find the first N+1 bytes of the key that was used to encode the messages.

Input

The input file consists of two lines. The first line consists of 2N characters and represents the encoded message N bytes long. The second line consists of 2N+2 characters and represents the encoded message N+1 bytes long. Here 1 ≤ N ≤ 10000. Each message is written on a single line in a hexadecimal form byte by byte without spaces. Each byte of the message is represented by two characters '0'-'9', 'A'-'F' that represent the hexadecimal value of the corresponding byte.

Output

Write to the output file a single line that represents N+1 bytes of the recovered key in the same hexadecimal format as in the input file.

Sample Input

05262C5269143F314C2A69651A264B

610728413B63072C52222169720B425E

Sample Output

41434D2049435043204E454552432732

HINT

 

题意

给你一个密码条，A按位异或B之后可以得到C1

现在在A的前面加了一个空格，得到了C2

然后给你C2和C1，让你求B

题解：

画画就知道每次都可以得到一个方程AxorB=C，我们知道其中两个数，很容易推出第三个数

每次都这个搞一搞就好了……

空格和C可以得到第一个B，然后一直算下去就好了

代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <queue>
#include <iomanip>
#include <string>
#include <ctime>
#include <list>
#include <bitset>
typedef unsigned char byte;
#define pb push_back
#define input_fast std::ios::sync_with_stdio(false);std::cin.tie(0)
#define local freopen("in.txt","r",stdin)
#define pi acos(-1)

using namespace std;
const int maxn = 3e4 + 2000;
char s1[maxn] , s2[maxn];
int l1,l2;
vector<int>T1,T2;
char ans[maxn];

inline int GetLetter(char x)
{
    if(x <= '9' && x >= '0') return x - '0';
    else return x-'A'+10;
}

char A(int x)
{
    if(x<=9&&x>=0) return x + '0';
    else return x - 10 +'A';
}

void output(int x)
{
    int y2 = x % 16;
    int y1 = (x- y2)/16;
    printf("%c%c",A(y1),A(y2));
}

void solve()
{
    for(int i = 0 ; i < l1 ; i += 2)
    {
        int v1 = GetLetter(s1[i]) , v2 = GetLetter(s1[i+1]);
        T1.push_back(v1*16 + v2);
    }
    for(int i = 0 ; i < l2 ; i += 2)
    {
        int v1 = GetLetter(s2[i]) , v2 = GetLetter(s2[i+1]);
        T2.push_back(v1*16 + v2);
    }
    int pre = (32) ^ T2[0];
    output(pre);
    for(int i = 0 ; i < T1.size() ; ++ i)
    {
        int xx = pre ^ T1[i];
        pre = T2[i+1] ^ xx;
        output(pre);
    }
    printf("
");
}



int main(int argc,char *argv[])
{
    freopen("decode.in","r",stdin);
    freopen("decode.out","w",stdout);
    scanf("%s%s",s1,s2);
    l1 = strlen(s1); l2 = strlen(s2);
    solve();
    return 0;
}