分析midea0978的《一個C#演算法分析求解》（二）

一、準備工作
首先處理以下Calc函數，以方便查看。其實就是變數重新命名工作，此時多虧了VS2005的幫忙。
輸入字串str，輸入是位元組數組引用；
i是位元組數組的迴圈變數；在後面的正式的程式中，將使用大K做為位元組數組的定位變數。
k限定了最大字串是18，原文是k<90,k+=5，縮小5倍就是了；
n其實就是字元在字元表中的位置，這個字元表其實可以說是一個密碼錶了；
j，莫名其妙的j，其實它也正好是這個演算法的關鍵。

 1public static void Calc(string str, ref byte[] bts)
 2{
 3    ushort j = 11;
 4    uint i = 0;
 5    uint k = 0;// (uint)Math.Min(bts.Length, 18);
 6    int m = 0;
 7    while (i < bts.Length && k < 18)
 8    {
 9        if (!jlist.Contains(j)) jlist.Add(j);
10
11        int n = CalcNum(str[m++]);
12        if (n == -1) throw new Exception("Error");
13        //n = n << (j % 32);
14        //j最大可能(8-1)+3=10，開始的時候是10，所以實際最大是11
15        //n = n << j;
16        //bts[i] = Convert.ToByte(bts[i] | (n / 256));
17        //bts[i + 1] = Convert.ToByte(bts[i + 1] | (n % 256));
18        if (j < 8)
19        {
20            //j=3～7，n=0~31,n<<j = 0~31<<7, n/256=n>>8=0~15
21            n = n << j;
22            bts[i] = Convert.ToByte(bts[i] | (n / 256));
23            bts[i + 1] = Convert.ToByte(bts[i + 1] | (n % 256));
24            j += 3;
25            i++;
26        }
27        else
28        {
29            //n = n << j;
30            //bts[i] = Convert.ToByte(bts[i] | (n / 256));
31            n = n << (j - 8);
32            //n=0~31<<3=0~255
33            bts[i] = Convert.ToByte(bts[i] | n);
34            //左移超過8位，所以右邊8位一定是0，然後bts[i+1]又是0
35            //bts[i + 1] = Convert.ToByte(bts[i + 1] | (n % 256));
36            j -= 5;
37        }
38        k += 1;
39    }
40}

 

二、常數序列J
從代碼看J不斷變大又變小，必然存在一個迴圈過程，下面先說明這一點：
J的變化，就好像一個自迭代函數，只要知道任意一個J，就可以得到下一個；
並且，對於兩個相同的J，下一個J必然相等；
同時，J被限定在一個有限的區間內，3～10（8-5＝3，(8-1)+3=10），
所以，隨著個數增多，J必然迴圈。
計算得到，初始向量是11，迴圈節是[6, 9, 4, 7, 10, 5, 8, 3]。
從以下資料表可以看出：
ID    -N    N     J     K
0     21    43008 11    0
1     11    704   6     0
2     27    13824 9     1
3     19    304   4     1
4     1     128   7     2
5     25    25600 10    3
6     18    576   5     3
7     17    4352  8     4
8     12    96    3     4
9     16    1024  6     5
10    4     2048  9     6
11    3     48    4     6
12    28    3584  7     7
13    5     5120  10    8
14    9     288   5     8
15    0     0     8     9
16    10    80    3     9
17    22    1408  6     10

三、從J看字串和位元組數組的關係
而已發現，對於J來說，小於8和大於等於8是兩種截然不同的情況。
只有J小於8時，位元組數組的位置變數才會增加，而大於等於8是不加的，
所以，這就是字元數比位元組數多的關鍵所在了。
因為J的序列已經確定了，只要指定字元的個數，它們對應的J也就確定了，
然後哪個字元對應第幾個位元組（位置K）也就容易確定了。
上面的資料表中可以看到J和K的關係

四、代碼簡化
源碼中的CalcNum其實就是尋找一個字串在字元表中的位置，其實使用字串的IndexOf函數就可以了。
把三個核心語句拆分到if(i<8)中去：
n = n << (j & 0x1f);
bts[i] = Convert.ToByte(bts[i] | ((n & 0xff00) >> 8));
bts[i + 1] = Convert.ToByte(bts[i + 1] | (n & 0xff));
當j>=8時，n先左移j位，所以第三句的 n & 0xff必然為0，所以修改bts[i+1]的這一句對於j>=8沒有意義

五、構造類對象
為了建立各種參數間的關係，特建立了一個CharObject類，對應字串的一個字元。
成員：ID（序號），Next（下一對象），J（常數序列），N（字元在密碼錶中的位置），
N_Hight（高位），N_Lower（低位），C（字元），Bts（對應的數組），K（對應數組中的位置）。
各種計算邏輯，都已經融入到屬性當中。
指定Next屬性時，馬上就可以計算得到下一對象的J和K；
指定K屬性的時候，就可以根據當前N計算Bts[K]和Bts[K+1]了；
如果N改變了，也可以調用Cal重新計算Bts[K]和Bts[K+1]。
靜態方法Calc是根據字串得到位元組數組的；ReCalc根據位元組數組得到字串，也就是逆向計算了。