关于文中的例子有点不解:
"假如说，我们要加密数字 625，根据刚才的规则，我们来试试。假设随机数我选择 590127。那百、十和个位分别加上这个随机数，就变成了 590133，590129，590132。然后，三位分别除以 7 求余后得到 5，1，4。最终，我们可以得到加密后的数字就是 415。因为加密的人知道加密的规则、求余所用的除数 7、除法的商、以及所引入的随机数 590127，所以当拿到 415 的时候，加密者就可以算出原始的数据是 625。是不是很有意思？"
正向加密可以理解.
反向解密感觉有点问题呀.
--------------
625中间的数字2: (2 + 590127)%7 = 1. 但是(9 + 590127)%7 = 1
--------------
那么625和695最终加密后的结果都是415啊.
那就不一定能还原出来原始的值了啊.
--------------
另外,如果最后一位数字加密后的结果是0, 交换位置后, 会有麻烦吧.

取模定义：
除法是被除数除以除数，结果包含商和余数，记做：a/b
只求余数的除法，叫取模。记做 a%b

应用举例：
取模运算的特点，无论a多大，只要b固定，那么a%b的余数总是在一个有限范围内。这种特点相当于将a进行了降维和分类，跟方便我们认知世界。
比如今天是星期一，10000天后是星期几。就可以通过求余数来计算。因为今天是星期一，所以相对于今天的7天后，肯定也是星期一。
那1w天中，7的整数倍日期，肯定也都是星期一，唯一要看的，就是最终余数多少，那就相当于距离星期一几天。所以1w天后是星期几变成了
公式:(星期一 + 1w%7) 由于1w%7 = 4 ，说明是星期一的四天后，于是相对于今天1w天后是星期五

取模增加随机性：
连续的整数，在取模时，其余数也是周期连续的。比如：10%7 = 3 ， 11%7=4 。余数算作一分钟分类，某些情况下，我们不希望原始数据的连续性，
在分类后也连续。为了增加几个班同学之间随机组合，增加交流。比如你不希望一个班(他们的学号相同)，被分配到连续的组里。
那可以在取模之间，对原始数据做一些规则转换，让连续的原始数据变得不连续。比如给原始数据加一个随机数。
公式为：(a + random) % b
注意在一次分类活动中，random是固定的，不是每个数来都重新来个random。random就相当于hash算的中的hash因子。
当然为了使得原始连续数据不连续还有其他很多种方式，比如数据的不同位树互换等等。


文章谬误：
    文章中所说的加密算法，再缺乏商时，无法完成解密，因为数据被降维了。

@我来也 比如621中的1用 (1+590127) %7 会得到0。 但是如果固定是三位数的话，在解密时候就可以提前给首位补0。
python 版本：（多位数，用反转 代替 对调一三位）

```
# coding:utf-8

DIVIDEND = 7
RAND = 590127

def encrypt(num):
    if not isinstance(num, int):
        raise TypeError("num is not 'int' object")
    # int转为list
    num = map(int, str(num))
    
    # 对每位加上随机数
    num = map(lambda i:i+RAND, num)
    # 保存商和求余
    quotient, num = zip(*[(i//DIVIDEND, i%DIVIDEND) for i in list(num)])
    # 反转
    num = list(num)[::-1]
    print(list(num))
    # list 转回 int
    num = map(str, num)
    # num = int(''.join(list(num)))
    num = ''.join(list(num)) # 首位余数0则会去除，所以用str

    # 返回加密数据和商
    return (num, quotient)


def decrypt(num, quotient):
    #if not isinstance(num, int):
    # raise TypeError("num is not 'int' object")
    # int转为list
    num = map(int, str(num))
    
    # 反转
    num = list(num)[::-1]
    # 商和余求值
    for i,v in enumerate(num):
        num[i] = v + quotient[i] * DIVIDEND
    # 对每位减去随机数
    num = map(lambda i:i-RAND, num)
    
    # list 转回 int
    num = map(str, num)
    num = int(''.join(list(num)))
    
    return num

if __name__ == '__main__':
    num = 8251
    print('加密', num)
    en_num, q = encrypt(num)
    print(f"加密后{en_num}, 商为{q} \n解密...")
    de_num = decrypt(en_num, q)
    print(de_num)

```

public static int encryptionNum(int num) {
        System.out.println("加密前：" + num);
        // 1.取余 并 加上随机数
        int bit = num % 10;
        int tenBit = num % 100 / 10;
        int hundredBit = num % 1000 / 100;
        System.out.println(bit + "\t" + tenBit + "\t" + hundredBit);
        bit = bit + MAX;
        tenBit = tenBit + MAX;
        hundredBit = hundredBit + MAX;
        System.out.println(bit + "\t" + tenBit + "\t" + hundredBit);
        // 2.每个位数 除以7 取余代替原来的个十百
        bit = bit % MULTIPLE;
        tenBit = tenBit % MULTIPLE;
        hundredBit = hundredBit % MULTIPLE;
        System.out.println(bit + "\t" + tenBit + "\t" + hundredBit);
        // 3.swap 第一位和第三位
        int temp;
        temp = bit;
        bit = hundredBit;
        hundredBit = temp;
        System.out.println(bit + "\t" + tenBit + "\t" + hundredBit);
        int result = bit + tenBit * 10 + hundredBit * 100;
        System.out.println("加密结果为：" + result);
        return result;
    }
  public static int decryptNum(int num) {
        System.out.println("解密前：" + num);
        // 1.取余
        int bit = num % 10;
        int tenBit = num % 100 / 10;
        int hundredBit = num % 1000 / 100;
        // 2.交互位数
        int temp;
        temp = bit;
        bit = hundredBit;
        hundredBit = temp;
        // 3.乘回7的倍数
        // 这里可能有bug 只能针对当前的MAX值 如果换了一个随机值 要考虑 是否要+1
        int temp2 = (MAX / MULTIPLE) + 1;
        bit = bit + temp2 * MULTIPLE;
        tenBit = tenBit + temp2 * MULTIPLE;
        hundredBit = hundredBit + temp2 * MULTIPLE;
        // 4.减去随机数
        bit = bit - MAX;
        tenBit = tenBit - MAX;
        hundredBit = hundredBit - MAX;
        System.out.println(bit + "\t" + tenBit + "\t" + hundredBit);
        int result = bit + tenBit * 10 + hundredBit * 100;
        System.out.println("解密结果为：" + result);
        return result;
    }