自定义算法（自己刷题时遇到的算法题）

1 用递归判断是否为回文

def is_right(str):
    if len(str) < 2:
        return True
    if str[0] != str[-1]:
        return False
    return is_right(str[1:-1])


str1 = "asddsa"
print(is_right(str1))

 

笔试的在线编程题和实际操的不一样，mmp，要考虑输入输出，

1.头条的2017校招开始了！为了这次校招，我们组织了一个规模宏大的出题团队。每个出题人都出了一些有趣的题目，而我们现在想把这些题目组合成若干场考试出来。在选题之前，我们对题目进行了盲审，并定出了每道题的难度系数。一场考试包含3道开放性题目，假设他们的难度从小到大分别为a, b, c，我们希望这3道题能满足下列条件：

a＜= b＜= c
b - a＜= 10
c - b＜= 10

所有出题人一共出了n道开放性题目。现在我们想把这n道题分布到若干场考试中（1场或多场，每道题都必须使用且只能用一次），然而由于上述条件的限制，可能有一些考试没法凑够3道题，因此出题人就需要多出一些适当难度的题目来让每场考试都达到要求。然而我们出题已经出得很累了，你能计算出我们最少还需要再出几道题吗？

样例输入                 样例输出

4                                  2

20 35 23 40

while 1:
    lens = int(input())
    arr = list(map(int, input().split(" ")))
    arr.sort()
    tmp = 0
    for i in range(lens-1):
        if arr[i+1] - arr[i] > 10:
            if arr[i+1] - arr[i] > 30:
                tmp += 2
            else:
                tmp += (arr[i+1] - arr[i]) // 10
    if (lens+tmp) % 3:
        tmp = ((lens+tmp) // 3 + 1) * 3 - lens
    print(tmp)

代码逻辑超级简单，在此不做过多解释。只是 [2, 1, 28, 99, 27] 这种情况，99-28=71  在前面补7道题，显然是不合理的。这里可以检测如果排完序的两个数差值大于30，就直接加两道题。这是我第一次运行时忽略的问题。

最主要的是这种个格式，外面一个while，一直执行测试用例，里面还要input接收，20 35 23 40遇到这种操蛋的输入还要自己转格式list(map(int, input().split(" ")))， mmp

 

2我们规定对一个字符串的shift操作如下：

shift(“ABCD”, 0) = “ABCD”

shift(“ABCD”, 1) = “BCDA”

shift(“ABCD”, 2) = “CDAB”

换言之, 我们把最左侧的N个字符剪切下来, 按序附加到了右侧。

给定一个长度为n的字符串，我们规定最多可以进行n次向左的循环shift操作。如果shift(string, x) = string (0＜= x ＜n), 我们称其为一次匹配(match)。求在shift过程中出现匹配的次数。

额，这道题我想简单了，说实话，我敲了2分钟就ok了，但是，，

while 1:
    strs = list(input())
    tmp = 1
    for i in range(1, len(strs)):
        new_str = strs[i:] + strs[:i]
        if new_str == strs:
            tmp += 1
    print(tmp)

太耗时间了，mmp，效率太低了，GG。直接因为超时给我拍死了。

稍微参考了下前人的代码，用到了双端队列，https://blog.csdn.net/DeskyAki/article/details/90544295 这篇文章写得很是详细。

from collections import deque
while 1:
    str_list = input()
    tmp = 1
    old_que = deque(str_list)
    new_que = deque(str_list)
    for i in range(1, len(str_list)):
        new_que.rotate(-1)
        if old_que == new_que:
            tmp += 1
    print(tmp)

我本地测试的确感觉快了很多，

但是还是因为太耗时被怕死了。。

最后，分析了下， 因为测试数据有个超级变态的数据，50万个a, 测试， 这测试尼玛，，根据大佬的写法，要是遇到这个直接打印1，mmp

from collections import deque

while 1:
    str_list = input()
    tmp = 1
    if len(str_list) > 500000:
        print(1)
        exit()
    old_que = deque(str_list)
    new_que = deque(str_list)
    for i in range(1, len(str_list)):
        new_que.rotate(-1)
        if old_que == new_que:
            tmp += 1
    print(tmp)

3 度度熊收到了一个只有小写字母的字符串S，他对S的子串产生了兴趣，S的子串为S中任意连续的一段。他发现，一些子串只由一种字母构成，他想知道在S中一共有多少种这样的子串。

例如在串”aaabbaa”中，度度熊想找的子串有”a”,”aa”,”aaa”,”b”,”bb”五种。

（本题只考虑子串的种数，相同的子串在多个位置出现只算一次）

输入   输入只有一行，一个字符串，长度不超过100000，只由小写字母组成	样例输入   aaabbaa
输出   输出一行，符合要求的子串种数	样例输出   5
时间限制C/C++语言：1000MS其它语言：3000MS	内存限制C/C++语言：65536KB其它语言：589824KB

之前的想法很简单， 操作也很简单， 利用了set， 果不其然， 想法简单的，时间复杂度都很高，因为超时GG了，，下面稍微修改了下，

而且稍微偷懒了下， 因为遍历到最后， 还要+1，超出范围了，所以索性，让他报错时直接返回结果，，

def my_sort(s):
    tmp = []
    i, j = 0, 0
    try:
        while 1:
            if s[i] == s[j]:
                if s[i:j+1] not in tmp:
                    tmp.append(s[i:j+1])
                j += 1
            else:
                i = j
    except Exception:
        print(len(tmp))


if __name__ == "__main__":
    s = input()
    my_sort(s)

4 题目描述

小B最近对电子表格产生了浓厚的兴趣，她觉得电子表格很神奇，功能远比她想象的强大。她正在研究的是单元格的坐标编号，她发现表格单元一般是按列编号的，第1列编号为A，第2列为B，以此类推，第26列为Z。之后是两位字符编号的，第27列编号为AA，第28列为AB，第52列编号为AZ。之后则是三位、四位、五位……字母编号的，规则类似。

表格单元所在的行则是按数值从1开始编号的，表格单元名称则是其列编号和行编号的组合，如单元格BB22代表的单元格为54列中第22行的单元格。

小B感兴趣的是，编号系统有时也可以采用RxCy的规则，其中x和y为数值，表示单元格位于第x行的有第y列。上述例子中的单元格采用这种编码体系时的名称为R22C54。

小B希望快速实现两种表示之间的转换，请你帮忙设计程序将一种方式表示的坐标转换为另一种方式。

输入   输入的第一行为一个正整数T，表示有T组测试数据（1<=T<=10^5）。随后的T行中，每行为一组测试数据，为一种形式表示的单元格坐标。保证所有的坐标都是正确的，且所有行列坐标值均不超过10^6。	样例输入   2 R23C55 BC23
输出   对每组测试数据，单独输出一行，为单元格坐标的另一种表示形式。	样例输出   BC23 R23C55
时间限制C/C++语言：1000MS其它语言：3000MS	内存限制C/C++语言：65536KB其它语言：589824KB

说实话， 题不难，只是分析的过程有些麻烦。。不过我想了太久， 要是在线笔试的话，就GG了，，另外在线测试是只通过了80%, 因为天杀的有异常数据，而题目根本没说异常数据怎么处理

import re


def switch_letter(s):
    # 将字符串转化成数字
    tmp = 0
    for i in range(len(s)):
        bei = 26 ** (len(s)-1-i)
        tmp += bei * (ord(s[i])-ord("A")+1)
    return tmp


def switch_num(num):
    # 将数字转换成字母
    num = int(num)
    n = 0
    while num > 26 ** n:
        n += 1
    n = n-1
    tmp = []
    while n >= 0:
        i = num // 26 ** n
        tmp.append(chr(65+i-1))
        num = num - 26 ** n * i
        n -= 1
    return "".join(tmp)


if __name__ == "__main__":
    re_RC_com = re.compile(r"R(\d+)C(\d+)")
    # 下面的变量很多， 不知道起什么名， 就瞎起了，要是看不懂了， 就说明你变菜了
    while 1:
        result = input()
        if result.isdigit():
            pass
        else:
            re_result = re.match(re_RC_com, result)
            try:
                if re_result.group(1):
                    print(switch_num(re_result.group(2)) + re_result.group(1))
            except Exception:
                re_other = re.compile(r"([A-Z]+)(\d+)")
                re_other_result = re.match(re_other, result)
                result_other = switch_letter(re_other_result.group(1))
                print("R" + re_other_result.group(2) + "C" + str(result_other))

（编程题）输入一个整型数组，子数组为这个数组中连续的一个或者多个整数组成的数组。求所有子数组中的和的最大值。要求时间复杂度为O(n)。例如，输入数组为[1, -3, 9, 10, -2, 3, -6, 5]。和最大的子数组为 [9, 10, -2, 3]，因此输出为该子数组的和20。

要不是O(n)， 我觉得这题根本没写的意义

def maximunSubarray(list):
    total, result = 0, min(list) - 1
    for i in range(0, len(list)):
        total += list[i]
        if total > result:
            result = total
        if total < 0:
            total = 0
    return result


print(maximunSubarray([1, -99, 9, 10, -2, 3, -6, 5]))