一、密钥格式化

def Key_formatting(s, k):
    # 获取字符串s，删除其中的"-"，并将字符串小写字母变为大写，然后将其反转
    newStr = s.replace("-", "").upper()[:: -1]
    strlen = len(newStr); # 获取字符串长度
    res = "" # 结果使用字符串拼接
    for num in range(0, strlen, k):
        res = res + newStr[num:num + k]
        if num + k < strlen :
            res += "-"

    return res[:: -1]


s = str(input("请输入密钥字符串S："))
k = int(input("请输入数字："))
print(Key_formatting(s, k))

二、旋转函数

class Test02 :
    def Rotating_function(self, array):
        length = len(array)
        maxCount = 0
        tmp = 0
        for num in range(0, length, 1):
            for i in range(1, length, 1):
                tmp += (i * array[(i - num + length) % length])
            print("F(%d) = %d" % (num, tmp))
            maxCount = max(tmp, maxCount)
            tmp = 0
        print(maxCount)


test = Test02().Rotating_function([4, 3, 2, 6])

""" 
   num i: 0, 1, 2, 3  
    0:    0, 1, 2, 3  
    1:    3, 0, 1, 2  (i - num + length) % length
    2:    2, 3, 0, 1
    3:    1, 2, 3, 0  
"""

三、密码宝箱

class PasswordBox:

    '''
    初始化这个密码宝箱：
    M是一个数组（原组），如果输入的M的值值符合，以M的值-1为下标的那个空间更新为1，表示这个数据(这一位)可用
    '''
    def passwordBox(self):
        self.M = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        self.T = int(input("输入一个T，表示有T组测试数据，(T≤500):"))
        self.N = int(input("给定十进制整数N(0 ≤ N ≤ 5000) :"))
        self.C = int(input("请输入数字C(2 ≤ C ≤ 16), 密码将被确定为C进制:"))
        print("请输入数，表示密码中含有哪些数字(1 ≤ M ≤ 16),用A来表示10, B来表示11, C来表示12 , D来表示13, E来表示14, F来表示15：");
        self.M_tmp = [str(n) for n in input("请输入一维数组，并用空格区分它:").split()]
        for i in range(0, len(self.M_tmp), 1) :
            self.M[self.strToNum(self.M_tmp[i]) % self.C] = 1
        self.test();

    '''
    处理测试数据：
        先将字符串进行反转，从个位依次取值，如果取的值不属于规定输入的数，直接返回0，且如果不能整除N，也返回0
        如果结果res ！= 0， 返回值，res是十进制的
    '''
    def systemExchange(self, strT):
        tmpStr = strT[:: -1]
        res = 0
        for i in range(0, len(strT), 1):
            tmpNum = self.strToNum(tmpStr[i])
            if(self.M[tmpNum % self.C] == 0) :
                return 0
            res += tmpNum * pow(self.C, i)
        if(res % self.N != 0) :
            return 0
        return res

    '''
    处理字符数据：
        将字符型的数据装换为数值型
        如字符型数据范围不在规定范围之内，抛出错误
    '''
    def strToNum(self, str):
        if str >= '0' and str <= '9':
            return int(str)
        elif str >= 'A' and str < 'F' :
            return ord(str) - ord('A') + 10
        elif str >= 'a' and str < 'f' :
            return ord(str) - ord('a') + 10
        else:
            raise Exception('错误：str只能是0-9或者a-f或A-F。str的值为:{}'.format(str))

    '''
    测试数据的执行方法：
        根据T获取T次数据
        每一次得到测试数据的结果，如果结果为0，跳过继续执行下一次循环，
        如果是第一次得到结果，更新minres，
        如果下次的结果比现在的minres还小，更新minres和resStr，否则不做处理
        resStr是返回的结果，表示这个测试数据是符号条件的最小数据
    '''
    def test(self):
        minres = 0
        isFirst = 1
		
        print("请输入T组测试数据：");
        for i in range(self.T):
            instr = str(input("请输入测试数据:"))
            tmpres = self.systemExchange(instr)
            if tmpres == 0:
                continue
            if isFirst == 1:
                minres = tmpres
                resStr = instr
                isFirst = 0
            if tmpres < minres :
                minres = tmpres
                resStr = instr
        if(minres == 0) :
            print("so sorry")
        else:
            print(resStr)


PasswordBox().passwordBox()

'''
T : 3
N : 18
C : 8
M : 3 5
44 22
'''

四、基因编码

class Genetic_code :
    '''
    模仿主函数，程序从这里进入
    '''
    def genetic(self):
        charstr = str(input("请输入一个长为 n = 2 ^k,(k≤8）01串s"))
        res = self.judegStr(charstr)
        print(res)

    '''
    str.count('0')的意思是0在这个字符串str中出现了几次：
    如果出现的次数等于charstr的长度，则返回A
    如果'1'出现的次数等于charstr的长度，返回B
    否则返回 'C' + self.judegStr(charstr[:length//2]) + self.judegStr(charstr[-length//2:])
    charstr[:length//2]等价于charstr[0 : length // 2]  length//2的作用是整数除法
    charstr[-length//2:]等价于charstr[length // 2:]  即从字符串的一半到字符串的结尾
    '''
    def judegStr(self, charstr):
        length = len(charstr)
        if charstr.count('0') == length:
            return 'A'
        elif charstr.count('1') == length:
            return 'B'
        else:
            return  'C' + self.judegStr(charstr[:length//2]) + self.judegStr(charstr[-length//2:])

Genetic_code().genetic()

五、法雷数列

class Farley_sequence :
    '''
    法雷数列采用二分法
    1.刚开始时确定下界 a/b = 0/1,上界 c/d = 1/1
    2.计算出上界和下界之间的值 p/q = (a+c)/(b+d)
    3.若q>n,计算终止
    此时重新调用这个函数，将p/q设为上界，重复步骤2和3
    上面执行完后，重新调用这个函数，将p/q设为下界，重复步骤2和3
    '''
    def farley_sequence(self, n):
        self.count = 2
        print("%d / %d" % (0, 1))
        self.Produce(0, 1, 1, 1, n)
        print("%d / %d" % (1, 1))
        print("%d阶法雷数列的元素个数有%d个" % (n, self.count))
        return

    def Produce(self, a, b, c, d, n):
        if (b + d) > n:
            return
        self.Produce(a, b, a + c, b + d, n)
        print("%d / %d" % (a + c, b + d))
        self.count += 1
        self.Produce(a + c, b + d, c, d, n)


Farley_sequence().farley_sequence(6)

'''
0/1 1/1                         a/b c/d
0/1 1/2 1/1                     a/b (a+c)/(b+d) c/d
0/1 1/3 1/2 2/3 1/1
0/1 1/4 1/3 2/5 1/2 3/5 2/3 3/4 1/1
0/1 1/5 1/4 1/3 2/5 1/2 3/5 2/3 3/4 4/5 1/1
'''

六、折叠加密

class Fold() :
    def folding(self):
        charStr = str(input("请输入长度为2^k的字符串"))
        reg = [int(n) for n in input("请输入长度为k的01数组,将输入每个数以空格键隔开").split()]
        for i in range(len(reg)) :
            if reg[i] == 0:
                charStr = self.leftToRigth(charStr, i)
            elif reg[i] == 1 :
                charStr = self.rigthToLeft(charStr, i)
            else :
                raise Exception("数组输入非法")
            print(charStr)
        return charStr

    def leftToRigth(self, charStr, i):
        group = pow(2, i + 1)
        step = len(charStr) // group
        left = 0
        right = step
        lestStr = ''
        rightStr = ''
        for index in range(pow(2, i)):
            leftStr += charStr[left : right][:: -1]
            left = right
            right = right + step
            rightStr += charStr[left : right]
            left = right 
            right = right + step

        return leftStr + rightStr

    def rigthToLeft(self, charStr, i):
        group = pow(2, i + 1)
        step = len(charStr) // group
        left = 0
        right = step
        leftStr = ""
        rightStr = ""
        for index in range(pow(2, i)):
            leftStr += charStr[left : right ]
            left = right 
            right = right + step
            rightStr += charStr[left : right][:: -1]
            left = right 
            right = right+ step

        return rightStr + leftStr


print(Fold().folding())
# print(Fold().rigthToLeft((Fold().leftToRigth("abcdefgh", 1)), 1))
# print((Fold().leftToRigth("abcdefgh", 1))[:: -1])