UVaOJ-213 Message Decoding

/* Message Decoding

Some message encoding schemes require that an encoded message be sent in two parts. The first part, called the header, contains the characters of the message. The second part contains a pattern that represents the message. You must write a program that can decode messages under such a scheme.

The heart of the encoding scheme for your program is a sequence of ``key" strings of 0's and 1's as follows:

displaymath26

The first key in the sequence is of length 1, the next 3 are of length 2, the next 7 of length 3, the next 15 of length 4, etc. If two adjacent keys have the same length, the second can be obtained from the first by adding 1 (base 2). Notice that there are no keys in the sequence that consist only of 1's.

The keys are mapped to the characters in the header in order. That is, the first key (0) is mapped to the first character in the header, the second key (00) to the second character in the header, the kth key is mapped to the kth character in the header. For example, suppose the header is:

AB#TANCnrtXc

Then 0 is mapped to A, 00 to B, 01 to #, 10 to T, 000 to A, ..., 110 to X, and 0000 to c.

The encoded message contains only 0's and 1's and possibly carriage returns, which are to be ignored. The message is divided into segments. The first 3 digits of a segment give the binary representation of the length of the keys in the segment. For example, if the first 3 digits are 010, then the remainder of the segment consists of keys of length 2 (00, 01, or 10). The end of the segment is a string of 1's which is the same length as the length of the keys in the segment. So a segment of keys of length 2 is terminated by 11. The entire encoded message is terminated by 000 (which would signify a segment in which the keys have length 0). The message is decoded by translating the keys in the segments one-at-a-time into the header characters to which they have been mapped.

Input

The input file contains several data sets. Each data set consists of a header, which is on a single line by itself, and a message, which may extend over several lines. The length of the header is limited only by the fact that key strings have a maximum length of 7 (111 in binary). If there are multiple copies of a character in a header, then several keys will map to that character. The encoded message contains only 0's and 1's, and it is a legitimate encoding according to the described scheme. That is, the message segments begin with the 3-digit length sequence and end with the appropriate sequence of 1's. The keys in any given segment are all of the same length, and they all correspond to characters in the header. The message is terminated by 000.

Carriage returns may appear anywhere within the message part. They are not to be considered as part of the message.

Output

For each data set, your program must write its decoded message on a separate line. There should not be blank lines between messages.

Sample input

TNM AEIOU
0010101100011
1010001001110110011
11000
$#**\
0100000101101100011100101000
Sample output

TAN ME
##*\$*/



#include<stdio.h>
#include<math.h>
int main()
{
    //int ending=1;
   	int trans(int n);
   	while(1)
    {
        int rt[10][130]={},i=0,flag=1,cnt=0,temp,m,len;
        char c;
        for(len=1;len<=7&&flag;len++)
        {
            do
            {
                if((c=getchar())!='\n')
                {
                    if(c==-1) return 0;   // 这是一个大胆的尝试，return 0；程序执行到一半return 0，程序终止。已ac还是1A不错。
                    rt[len][i++]=c;
                    cnt++;
                }
                else {flag=0;break;}
            }
           while(cnt<int(pow(2.0,float(len))-1));
           cnt=0;i=0;
        }
        while((len=trans(3))!=0)
        {
            temp=floor(pow(2.0,double(len))+0.5)-1;      //这步实在是蠢，pow降低了效率不说，运算出来的还是浮点型。怕转化成int有误差又用了floor，可见效率多低，lrj直接一个1<<len就搞定了。
            while((m=trans(len))!=temp)
            printf("%c",rt[len][m]);     //用putchar直接操作效率会高一点。
        }
        putchar('\n');
        c=getchar();


    }


}
int trans(int n)
{
    double sum=0;
    int ans;
    char c=0;
    while(n--)
    {
        do
            c=getchar();
        while(c=='\n');
        if(c=='0') continue;
        else sum+=pow(2.0,double(n));  //效率低了。

    }
    c=sum;
    ans=floor(c+0.5);
    return ans;
}

//lrj标准代码：比我原代码提高了300ms。


#include<stdio.h>
#include<string.h>
int readchar()                                        //我用了do while也同样达到了这种效果，优劣差不多。
{
	for(;;){
		int ch=getchar();
		if(ch!='\n'&&ch!='\r') return ch;                    //对于操作系统有关的程序最好体现出较强的鲁棒性。
	}

}
int readint(int c){
	int v=0;
	while(c--) v=v*2+ readchar()-'0';              //  lrj用递推式把二进制转换成十进制，而我用了pow 函数用2的n次方转化效率明显降低了。
	return v;

}
int code[8][1<<8];                             //值得学习，1<<8,表示了2的八次方避免了自己计算时间，而且直观。
int readcodes()
{
	memset(code,0,sizeof(code));
	code[1][0]=readchar();
	for(int len=2;len<=7;len++){
		for(int i=0;i<(1<<len)-1;i++){
			int ch=getchar();
			if(ch==EOF) return 0;
			if(ch=='\n'||ch=='\r') return 1;
			code[len][i]=ch;
		}
	}
	return 1;
}

int main()
{
	while(readcodes())                       //这是最精巧之处，循环的条件是recodes（）的返回值，在循环判断的同时执行了把字符存在数组中的作用。
	{										//这样做的好处是在结束时读到eof，返回0，循环结束跳出来执行了 return 0 main结束。而我写的代码一直纠结这个问题，
		for(;;){						   //如何让它读到文末就自动结束程序，结果我在主函数的中途用了return 0；显得反常规和不自然。
			int len=readint(3);
			if(len==0) break;
			for(;;){
				int v=readint(len);
				if(v==(1<<len)-1) break;          //有用了左移位来运算2的n次方方便。
				putchar(code[len][v]);               	//要学会用putchar。
			}
		}
		putchar('\n');

	}
	return 0;
}