zoukankan      html  css  js  c++  java
  • 分析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 == -1throw 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根据字节数组得到字符串,也就是逆向计算了。

  • 相关阅读:
    HashMap按键排序和按值排序
    LeetCode 91. Decode Ways
    LeetCode 459. Repeated Substring Pattern
    JVM
    LeetCode 385. Mini Parse
    LeetCode 319. Bulb Switcher
    LeetCode 343. Integer Break
    LeetCode 397. Integer Replacement
    LeetCode 3. Longest Substring Without Repeating Characters
    linux-网络数据包抓取-tcpdump
  • 原文地址:https://www.cnblogs.com/nnhy/p/979648.html
Copyright © 2011-2022 走看看