day43（2022-10-26）

给定一个整数n，通过移除其中某一位数字，找出操作之后遗留的最大数字。

【示例】
输入：152
输出：52
解释：如果移除1，得到52；如果移除5，得到12；如果移除2，得到15。因此最大方案是移除1得到52。

def solution(n: int)-> int:
    lresult=[]
    for i in range(len(str(n))):
        new_str = str(n).replace(str(n)[i], "", 1)
        lresult.append(int(new_str))
    return max(lresult)

assert solution(152) == 52
assert solution(1001) == 101
assert solution(10) == 1

day42（2022-10-25）

已知一个包含唯一数字的列表，和一个指定的左闭右开区间[from, to)，我们的任务是：首先凑对，找出存在几对元素之和在区间内，然后将这些符合区间的和加总得到最终的和值。

备注：
所有凑对的元素必须是唯一的
凑对的和值只在区间内统计一次
示例：
已知列表是 [2, 4, 6, 10]，已知区间是[6， 10)
6：可以等于 2 + 4
7：无法凑对
8：可以等于 2 + 6
9：无法凑对
最终结果：6 + 8 = 14

def isadd(nums: list, num: int) -> bool:
    for i in range(len(nums)):
        if num - nums[i] in nums[i:]:
            return True
        else:
            return False


def solution(nums: list, target: range) -> int:
    lresult = []
    for i in target:
        if isadd(nums, i) == True:
            lresult.append(i)
    return sum(lresult)


assert solution([2, 4, 6, 10], range(6, 10)) == 14

day41（2022-10-21）

子序列最大和，包括在一个数组或整数列表中查找连续子序列的最大和：最大序列（[-2，1，-3，4，-1，2，1，-5，4]）应为6:[4，-1，2，1]简单的情况是，列表仅由正数组成，最大和是整个数组的和。如果列表仅由负数组成，则返回0。空列表被视为最大和为零。请注意，空列表或数组也是有效的子列表/子数组。’

def max_sequence(arr: list) -> int:
    prenum = 0
    finnum = 0
    for i in arr:
        if prenum > finnum:
            finnum = prenum
        if i <= 0:
            if prenum + i <= 0:
                    prenum = 0
            else:
                prenum += i
        else:
            prenum += i
    if prenum > finnum:
        finnum = prenum
    return finnum

assert max_sequence([]) == 0
assert max_sequence([-2, 1, -3, 4, -1, 2, 1, -5, 4]) == 6
assert max_sequence([-2, -1, -3, -4, -1, -2, -1, -5, -4]) == 0
assert max_sequence([7, 4, 11, -11, 39, 36, 10, -6, 37, -10, -32, 44, -26, -34, 43, 43]) == 155
assert max_sequence(
    [-6, -3, 27, -22, 3, 8, 19, -7, -26, -30, -3, -26, 22, 25, -26, 27, 4, -24, -7, 20, 20, 20, 9, -23, -26, -27, -12,
     0, 1, 26, -19, -1, -15, -16, 1, 25, 4, -7, 27, 4, -22, -10, 23, 4, 2, -29, 0, -12, -21, 7]) == 90

day40（2022-10-10）

ISBN-10标识符的长度为十位数。前九个字符是数字0-9。最后一个数字可以是0-9或X，表示值为10。

如果数字之和乘以其位置模11等于零，则ISBN-10数字有效。
例如:
ISBN : 1 1 1 2 2 2 3 3 3 9
position : 1 2 3 4 5 6 7 8 9 10
它是一个合法的ISBN-10 :
(11 + 12 + 13 + 24 + 25 + 26 + 37 + 38 + 39 + 910) % 11 = 0
例子
1112223339 --> true
111222333 --> false
1112223339X --> false
1234554321 --> true
1234512345 --> false
048665088X --> true
X123456788 --> false

def valid_ISBN10(isbn: str) -> bool:
    sum = 0
    if len(isbn) == 10:
        for i in range(9):
            if isbn[i] in '0123456789':
                sum += int(isbn[i]) * (i + 1)
            else:
                return False
        if isbn[-1] == 'X':
            sum += 10 * 10
        elif isbn[-1] in '0123456789':
            sum += int(isbn[-1]) * 10
        else:
            return False
    else:
        return False
    if sum % 11 == 0:
        return True
    else:
        return False

assert valid_ISBN10('1112223339') == True
assert valid_ISBN10('048665088X') == True
assert valid_ISBN10('1293000000') == True
assert valid_ISBN10('1234554321') == True
assert valid_ISBN10('1234512345') == False
assert valid_ISBN10('1293') == False
assert valid_ISBN10('X123456788') == False
assert valid_ISBN10('ABCDEFGHIJ') == False
assert valid_ISBN10('XXXXXXXXXX') == False
assert valid_ISBN10('123456789T') == False
assert valid_ISBN10('048665088XX') == False

day39（2022-10-08）

编写一个函数，该函数接受一个括号字符串，并确定括号的顺序是否有效。如果字符串有效，则函数应返回true，如果字符串无效，则返回false。

示例
“()” => 真
“)(()))” => 假
“(” => 假
“(())((()())())” => 真
制约因素0 <= 输入长度 <= 100除了左括号 “(” 和右括号 “)” 之外，输入可以包含任何有效的ASCII字符。此外，输入字符串可能为空和/或根本不包含任何括号。不要将其他形式的括号视为括号（例如[ ]、{ }、< >）。

def valid_parentheses(s: str) -> bool:
    ss = 0
    for i in s:
        if i == '(':
            ss += 1
        elif i == ')':
            ss -= 1
        if ss < 0:
            return False
    if ss == 0:
        return True
    else:
        return False


assert valid_parentheses("  (") == False
assert valid_parentheses(")test") == False
assert valid_parentheses("") == True
assert valid_parentheses("hi())(") == False
assert valid_parentheses("hi(hi)()") == True

day38（2022-09-28）

一个数字的真除数是除了自身之外的所有整除数的集合。例如，对于100，它们是1、2、4、5、10、20、25和50。设s（n）是n的这些真除数之和。将buddy称为两个正整数，这样每个数的真除数的和比另一个数多一个：（n，m）是一对伙伴，如果s（m）=n+1和s（n）=m+1

例如，48和75就是这样一对：48的除数是：1、2、3、4、6、8、12、16、24–>和：76=75+175的除数是：1、3、5、15、25–>和：49=48+1任务
给定两个正整数start和limit，函数buddy（start，limit）应该返回buddy对的第一对（n m），这样n（正整数）就在 start 和 limits 之间；m可以大于极限，并且必须大于n如果没有满足条件的好友数据对，则返回 “Nothing”
示例：
buddy（10，50）返回[48，75]
buddy（48，50）返回[48，75]

from typing import Union

def isdivisor(num):
    lresult = []
    for i in range(1, num // 2 + 1):
        if num % i == 0:
            lresult.append(i)
    return lresult

def buddy(start: int, limit: int) -> Union[list, str]:
    for i in range(start, limit):
        lresult1 = isdivisor(i)
        lsum = sum(lresult1) - 1
        lresult2 = isdivisor(lsum)
        if sum(lresult2) - 1 == i and i < lsum:
            return [i, lsum]
    return "Nothing"


assert buddy(10, 50) == [48, 75]
assert buddy(2177, 4357) == "Nothing"
assert buddy(57345, 90061) == [62744, 75495]
assert buddy(1071625, 1103735) == [1081184, 1331967]

day37（2022-09-27）

我们希望找到高于或等于1000的数字，即每四个连续数字的总和不能高于某个给定值。如果数字是num = d1d2d3d4d5d6，并且4个连续数字的最大和是max_sum，那么：

d1 + d2 + d3 + d4 <= max_sum
d2 + d3 + d4 + d5 <= max_sum
d3 + d4 + d5 + d6 <= max_sum
为此，我们需要创建一个函数max_sum_dig()，该函数接收n_max，作为研究间隔的最大值（范围（1000，n_max）），以及某个值max_sum ，即每连续四位数字应小于或等于的最大和。该函数应输出以下列表，其中包含详细信息：
[(1), (2), (3)]
(1) 满足上述约束的数字数量
(2) 最接近结果平均值的数字，如果有多个，则应选择最小的数字。
(3) 所有发现数字的总和
让我们看看一个包含所有细节的案例：
max_sum_dig(2000, 3) -------> [11, 1110, 12555]
(1) 总共找到11 个数字: 1000, 1001, 1002, 1010, 1011, 1020, 1100, 1101, 1110, 1200 和 2000
(2) 求得所有符合的数字的平均数为:
(1000 + 1001 + 1002 + 1010 + 1011 + 1020 + 1100 + 1101 + 1110 + 1200 + 2000) /11 = 1141.36363,
所以 1110 是最符合的数字.
(3) 所有符合的数字的总和为12555
1000 + 1001 + 1002 + 1010 + 1011 + 1020 + 1100 + 1101 + 1110 + 1200 + 2000 = 12555

def max_sum_dig(n_max: int, max_sum: int) -> list:
    lresult = []
    for i in range(1000, n_max + 1):
        ll = [int(a) for a in str(i)]
        for j in range(len(ll) - 3):
            if ll[j] + ll[j + 1] + ll[j + 2] + ll[j + 3] > max_sum:
                break
            else:
                lresult.append(i)
    countnum = len(lresult)
    sumunm = sum(lresult)
    avgnum = sumunm / countnum
    for i in range(len(lresult) - 1):
        if abs(avgnum - lresult[i]) < abs(avgnum - lresult[i + 1]):
            lresult[i], lresult[i + 1] = lresult[i + 1], lresult[i]
    minnum = lresult[-1]
    # return lresult
    return [countnum, minnum, sumunm]


assert max_sum_dig(2000, 3) == [11, 1110, 12555]
assert max_sum_dig(2000, 4) == [21, 1120, 23665]
assert max_sum_dig(2000, 7) == [85, 1200, 99986]
assert max_sum_dig(3000, 7) == [141, 1600, 220756]
assert max_sum_dig(4000, 4) == [35, 2000, 58331]

day36（2022-09-26）

给定一个由纯数字组成的字符串，每个数字之间使用空格分隔。我们的任务是，编写一个函数，找出其中最大和最小的两个数字。返回结果的两个数字格式为字符串，并且逆序排列，也使用空格分隔。

示例：
输入：1 2 3 4 5，输出：5 1。

def solution(nums: str) -> str:
    numl = nums.split(" ")
    numl = [int(i) for i in numl]
    return (str(max(numl)) + " " + str(min(numl)))

assert solution("1 2 3 4 5") == "5 1"
assert solution("1 2 -3 4 5") == "5 -3"
assert solution("1 9 3 4 -5") == "9 -5"
assert solution("1 2 3") == "3 1"
assert solution("8 3 -5 42 -1 0 0 -9 4 7 4 -4") == "42 -9"

day35（2022-09-23）

某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。 给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。

举例
样例1：
输入：
words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
输出：
true
解释：
在该语言的字母表中，'h' 位于 'l' 之前，所以单词序列是按字典序排列的。
样例2：
输入：
words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
输出：
false
解释：
在该语言的字母表中，'d' 位于 'l' 之后，那么 words[0] > words[1]，因此单词序列不是按字典序排列的。
样例3：
输入：
words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
输出：
false
解释：
当前三个字符 "app" 匹配时，第二个字符串相对短一些，然后根据词典编纂规则 "apple" > "app"，因为 'l' > '∅'，其中 '∅' 是空白字符，定义为比任何其他字符都小（更多信息）。

def words_order(words, order):
    minlenth = len(min(words))
    lresult = []
    for i in range(len(words)):
        for j in range(len(words) - i - 1):
            if len(words[j]) > len(words[j + 1]):
                return "false"
        else:
            lresult.append(words[i][0:minlenth])
    for i in range(len(lresult)):
        for j in range(len(lresult[0])):
            if order.index(lresult[i][j]) > order.index(lresult[i + 1][j]):
                return "false"
            else:
                return "true"


assert words_order(words=["hello", "leetcode"], order="hlabcdefgijkmnopqrstuvwxyz") == "true"
assert words_order(words=["apple", "app"], order="abcdefghijklmnopqrstuvwxyz") == "false"
assert words_order(words=["apple", "app"], order="abcdefghijklmnopqrstuvwxyz") == "false"

day34（2022-09-16）

有一排 26 个彩灯，编号从 0 到 25，现在给出了一系列控制指令来控制这些彩灯的开关。一开始这些彩灯都是关闭的，然后指令将逐条发出。在每条指令operation[i] 中含有两个整数 operation[i][0], operation[i][1] 。在接收到一条指令时，标号为 operation[i][0] 的彩灯会亮起，直到第 operation[i[1] 秒的时候熄灭。当灯熄灭后，下一条指令将会发出。也就是说，任何时候只会有一盏灯亮着。其中第一条指令将在第0秒的时候发出，并被立刻执行。你的任务是找到哪个彩灯单次亮起的时间最长。

*输入：
[[0,2],[1,5],[0,9],[2,15]]
输出：
'c'
说明：
operation = [[0, 2], [1, 5], [0, 9], [2, 15]]
在第0秒的时候，接收到指令[0, 2]，此时标号为 0 的灯亮起，第 2 秒的时候熄灭。此时 0号灯 的单次亮起时间为2-0 = 2 秒。
在第2秒的时候，接收到指令[1, 5]，此时标号为 1 的灯亮起，第 5 秒的时候熄灭。此时 1号灯 的单次亮起时间为 5-2 = 3 秒。
在第5秒的时候，接收到指令[0, 9]，此时标号为 0 的灯亮起，第 9 秒的时候熄灭。此时 0号灯 的单次亮起时间为 9-5 = 4 秒。
在第9秒的时候，接收到指令[2, 15]，此时标号为 2 的灯亮起，第 15 秒的时候熄灭。此时 2号灯 的单次亮起时间为 15-9 = 6 秒。
所以单次亮起的最长时间为 max(2, 3, 4, 6) = 6 秒，是标号为 2 的彩灯。

你需要返回一个小写英文字母代表这个编号。如 'a' 代表 0，'b' 代表 1，'c' 代表 2 ... 'z' 代表 25。
所以你的答案应该是'c'*

import copy


def longest_lighting_time(operation: list) -> str:
    result = copy.deepcopy(operation)
    for i in range(1, len(operation)):
        result[i][1] = operation[i][1] - operation[i - 1][1]
    result = sorted(result, key=(lambda x: x[1]), reverse=True)
    char = [chr(i) for i in range(97, 123)]
    return char[result[0][0]]

assert longest_lighting_time([[0, 2], [1, 5], [0, 9], [2, 15]]) == 'c'

day33（2022-09-15）

您将获得一个数字的素数作为数组。例如：[2,2,2,3,3,5,5,13]您需要找到该素数分解所属的数字 n。这将是：n = 2³3²5²*13 = 23400然后，生成这个数的除数。您的函数get_num() or getNum() 将接收一个具有潜在无序素数因子的数组，并应输出：在索引 0 处具有找到的整数 n 的数组，在索引 1 处的总除数（素数和复合数）的数量，然后是最小因子（索引 2），和最大的一个（最后一个元素）

我们将看到上面给出的示例，唯一的区别是素因子数组是无序的。
该数字 (23400) 的除数列表是：
2, 3, 4, 5, 6, 8, 9, 10, 12, 13, 15, 18, 20, 24, 25, 26, 30, 36, 39, 40, 45, 50, 52, 60, 65, 72, 75, 78, 90, 100, 104, 117, 120, 130, 150, 156, 180, 195, 200, 225, 234, 260, 300, 312, 325, 360, 390, 450, 468, 520, 585, 600, 650, 780, 900, 936, 975, 1170, 1300, 1560, 1800, 1950, 2340, 2600, 2925, 3900, 4680, 5850, 7800, 11700 (不包含23400本身)
71 有一个除数的总数。最小的除数是2 和最高的11700 。所以预期的输出将是：
get_num([2,13,2,5,2,5,3,3]) == [23400, 71, 2, 11700]

def get_num(arr: list) -> list:
    fresult = {}
    lresult = []
    sum_num = 1
    for i in arr:
        if i not in fresult.keys():
            fresult[i] = 1
        else:
            fresult[i] += 1
    for i in fresult:
        sum_num *= pow(i, fresult[i])
    for i in range(2, sum_num):
        if sum_num % i == 0:
            lresult.append(i)
            # 如果除数含1，需加1，不含1则不需要加1
    return [sum_num, len(lresult) + 1, min(lresult), max(lresult)]


assert get_num([2, 3, 5, 5]) == [150, 11, 2, 75]
assert get_num([2, 3, 3, 3, 7]) == [378, 15, 2, 189]
assert get_num([3, 3, 3, 11]) == [297, 7, 3, 99]
assert get_num([2, 13, 2, 5, 2, 5, 3, 3]) == [23400, 71, 2, 11700]

day32（2022-09-14）

编写一个简单的解析器来解析和运行 Deadfish。

Deadfish 有 4 个命令，每个 1 个字符长：
i 增加值（最初0 ）
d 递减值
s 平方值
o 将值输出到返回数组
应忽略无效字符。
parse("iiisdoso") ==> [8, 64]

def parse(s: str) -> list:
    result = []
    initial = 0
    for i in s:
        if i == "i":
            initial += 1
        elif i == 'd':
            initial -= 1
        elif i == 's':
            initial = pow(initial, 2)
        elif i == 'o':
            result.append(initial)
    return result


assert parse("ooo") == [0,0,0]
assert parse("ioioio") == [1,2,3]
assert parse("idoiido") == [0,1]
assert parse("isoisoiso") == [1,4,25]
assert parse("hogwarts") == [0]

day31（2022-09-13）

编写一个函数cakes() ，它接受食谱（对象）和可用成分（也是一个对象）并返回皮特可以烘烤的最大蛋糕数量（整数）。为简单起见，数量没有单位（例如，1 磅面粉或 200 克糖只是 1 或 200）。对象中不存在的成分可以视为 0。

例子：

# must return 2
cakes({flour: 500, sugar: 200, eggs: 1}, {flour: 1200, sugar: 1200, eggs: 5, milk: 200})
# must return 0
cakes({apples: 3, flour: 300, sugar: 150, milk: 100, oil: 100}, {sugar: 500, flour: 2000, milk: 2000})

def cakes(recipe, available):
    result = []
    for i in recipe:
        if i not in available.keys():
            return 0
        else:
            result.append(available[i] // recipe[i])
    return min(result)


recipe = {"flour": 500, "sugar": 200, "eggs": 1}
available = {"flour": 1200, "sugar": 1200, "eggs": 5, "milk": 200}
assert cakes(recipe, available) == 2

recipe = {"apples": 3, "flour": 300, "sugar": 150, "milk": 100, "oil": 100}
available = {"sugar": 500, "flour": 2000, "milk": 2000}
assert cakes(recipe, available) == 0

day30（2022-09-09）

有些数字具有有趣的特性。

例如：
89 → 8¹ + 9² = 89 * 1
695 → 6² + 9³ + 5⁴= 1390 = 695 * 2
46288 → 4³ + 6⁴+ 2⁵ + 8⁶ + 8⁷ = 2360688 = 46288 * 51

给定一个正整数 n，写成 abcd…（a, b, c, d… 是数字）和一个正整数 p，我们想要找到一个正整数 k，如果它存在的话，使得 n 的数字之和对 p 的连续幂等于 k n。换句话说：是否存在整数 k 例如： (a ^ p + b ^ (p+1) + c ^(p+2) + d ^ (p+3) + …) = n * k,如果是这种情况，我们将返回 k，如果不是，则返回 -1。

注意 ：n 和 p 将始终作为严格的正整数给出。
dig_pow(89, 1) 返回值 1 因为 8¹ + 9² = 89 = 89 * 1
dig_pow(92, 1) 返回值 -1 因为 9¹ + 2²=13 无法整除92
dig_pow(695, 2) 返回值 2 因为 6² + 9³ + 5⁴= 1390 = 695 * 2
dig_pow(46288, 3) 返回值 51 因为 4³ + 6⁴+ 2⁵ + 8⁶ + 8⁷ = 2360688 = 46288 * 51

def dig_pow(n: int, p: int) -> int:
    sum = 0
    for i in str(n):
        sum += pow(int(i), p)
        p = p + 1
    if sum % n == 0:
        return sum // n
    else:
        return -1


assert dig_pow(89, 1) == 1
assert dig_pow(92, 1) == -1
assert dig_pow(46288, 3) == 51
assert dig_pow(2646798, 1) == 1
assert dig_pow(3456789, 1) == -1
assert dig_pow(63761, 3) == 1
assert dig_pow(132921, 3) == 4
assert dig_pow(10383, 6) == 12933

day29（2022-09-06）

给定一个整数列表，对于列表中的每对整数，计算指数和（包括两者）之间的值的总和，并返回最大的结果和。

例
A = [1, -2, 3, 4, -5, -4, 3, 2, 1]
ranges = [(1, 3), (0, 4), (6, 8)]
result = 6
因为总和是ranges[0] = (1, 3) A[1] + A[2] + A[3] = 5
因为总和是ranges[1] = (0, 4) A[0] + A[1] + A[2] + A[3] + A[4] = 1
因为总和是ranges[2] = (6, 8) A[6] + A[7] + A[8] = 6
最大总和是6

def max_sum(a: list, ranges: list) -> int:
    lresult = []
    for i in ranges:
        sum = 0
        for j in range(i[0], i[-1] + 1):
            sum += a[j]
        lresult.append(sum)
    return max(lresult)


assert max_sum([1, -2, 3, 4, -5, -4, 3, 2, 1], [(1, 3), (0, 4), (6, 8)]) == 6
assert max_sum([1, -2, 3, 4, -5, -4, 3, 2, 1], [(1, 3)]) == 5
assert max_sum([1, -2, 3, 4, -5, -4, 3, 2, 1], [(1, 4), (2, 5)]) == 0
assert max_sum([4, 77, 17, 6, -74, -26, 95, 99, -21, -93, 38, 36, 64, 78, 19, 73, -26, -94, 0, 1],
               [(2, 15), (0, 8), (8, 17), (1, 19), (5, 14), (1, 19), (5, 16), (1, 13), (8, 11), (0, 19), (3, 15),
                (4, 18), (10, 17), (5, 17), (2, 18), (3, 19), (5, 18), (1, 19), (0, 17), (8, 11)]) == 336

day28（2022-09-05）

什么是字谜？如果两个单词都包含相同的字母，则它们是彼此的字谜。

例如：
'abba' & 'baab' == true
'abba' & 'bbaa' == true
'abba' & 'abbba' == false
'abba' & 'abca' == false

编写一个函数，从列表中查找单词的所有字谜。您将获得两个输入一个单词和一个带有单词的数组。您应该返回一个包含所有字谜的数组，如果没有字谜，则应返回一个空数组。

例如：
anagrams('abba', ['aabb', 'abcd', 'bbaa', 'dada']) => ['aabb', 'bbaa']
anagrams('racer', ['crazer', 'carer', 'racar', 'caers', 'racer']) => ['carer', 'racer']
anagrams('laser', ['lazing', 'lazy', 'lacer']) => []

def anagrams(word: str, words: list) -> list:
    lresult = words.copy()
    for i in words:
        if len(i) != len(word):
            lresult.remove(i)
        else:
            if sorted(i) != sorted(word):
                lresult.remove(i)
    return lresult


assert anagrams('abba', ['aabb', 'abcd', 'bbaa', 'dada']) == ['aabb', 'bbaa']
assert anagrams('racer', ['crazer', 'carer', 'racar', 'caers', 'racer']) == ['carer', 'racer']
assert anagrams('laser', ['lazing', 'lazy', 'lacer']) == []

day27（2022-09-04）-2

我们应该选择所有在反转时是不同 素数的素数（因此应该丢弃回文素数）。

例如：13、17 是素数，反过来分别是 31、71，它们也是素数，所以 13 和 17 是“emirps”。但素数 757、787、797 是回文素数，这意味着反转后的数与原来的数相同，因此它们不被视为“emirps”，应该被丢弃。

def isprime(n):
    for i in range(2, n):
        if n % i == 0:
            return False
    return True


def find_emirp(n: int) -> list:
    fresult = [i for i in range(2, n) if isprime(i)]
    ffresult = fresult.copy()
    for i in fresult:
        if str(i) == str(i)[::-1]:
            ffresult.remove(i)
        elif isprime(int(str(i)[::-1])) != True:
            ffresult.remove(i)
    largest_emirp_below_n = lambda x: max(x) if len(x) > 0 else 0
    result = [len(ffresult), largest_emirp_below_n(ffresult), sum(ffresult)]
    return result



assert find_emirp(10) == [0, 0, 0]
assert find_emirp(50) == [4, 37, 98]
assert find_emirp(100) == [8, 97, 418]

day27（2022-09-04）-1

现在有数字6969 和9116 。当您旋转它们180 degrees （倒置）时，这些数字保持不变。澄清一下，如果我们将它们写在纸上并将纸倒置，数字将是相同的。试试看！某些数字，例如2 或5 在旋转时不产生数字。给定一个范围，返回该范围内倒置数字的计数。

例如solve(0,10) = 3 ，因为在范围>= 0 and < 10只有3 个颠倒的数字。他们是0, 1, 8 。

def solve(a: int, b: int) -> int:
    dict_num = {
        "0": "0",
        "1": "1",
        "6": "9",
        "9": "6",
        "8": "8"
    }
    count = 0
    for i in range(a, b):
        num = ''
        for j in str(i):
            if j not in dict_num.keys():
                break
            else:
                num += dict_num[j]
        if str(i) == num[::-1]:
            count += 1
    return count


assert solve(0, 10) == 3
assert solve(10, 100) == 4
assert solve(100, 1000) == 12
assert solve(1000, 10000) == 20
assert solve(10000, 15000) == 6
assert solve(15000, 20000) == 9
assert solve(60000, 70000) == 15
assert solve(60000, 130000) == 55

day26（2022-08-31）

写一个函数，接收秒数，处理成人类友好的方式格式化持续时间。该函数必须接受一个非负整数。如果它是零，它只是返回"now" 。否则，持续时间表示为years 、days 、hours 、minutes 和seconds 的组合 。举个例子就更容易理解了：

• For seconds = 62, your function should return
  "1 minute and 2 seconds"
• For seconds = 3662, your function should return
  "1 hour, 1 minute and 2 seconds"
  就本题而言，一年是 365 天，一天是 24 小时。请注意，空格很重要。细则
  生成的表达式由 4 seconds、 1 year等分量组成，一个正整数和一个有效的时间单位之一，由空格分隔。如果整数大于 1，则时间单位以复数形式使用。组件由逗号和空格 ( ", " ) 分隔。除了最后一个组件用 " and " 分隔， 就像用英文写的一样。
  1 second and 1 year 不是正确的，而 1 year and 1 second 是正确 的。
  不同的组件有不同的时间单位。所以 5 seconds and 1 second 这样的重复单位写法是错误的。
  如果组件的值恰好为零，则组件根本不会出现。因此，1 minute and 0 seconds 是无效的，应该是1 minute 这样编写。
  必须“尽可能”使用一个时间单位。这意味着该函数不应该返回61 seconds ，而是应该返回1 minute and 1 second 。所以不要出现366天、24小时、60分、60秒这样的数据。

def format_duration(seconds: int) -> str:
    if seconds <= 0:
        return "now"
    else:
        fcontent = ''
        content = {
            0: 0,
            1: 0,
            2: 0,
            3: 0,
            4: 0
        }
        ltime1 = [365 * 24 * 60 * 60, 24 * 60 * 60, 60 * 60, 60, 1]
        ltime2 = ["year", "day", "hour", "minute", "second"]
        for i in range(len(ltime1)):
            content[i] = seconds // ltime1[i]
            seconds -= content[i] * ltime1[i]
        for j in range(len(ltime2)):
            if content[j] > 1:
                fcontent += str(content[j]) + " " + ltime2[j] + "s" + ", "
            elif content[j] == 1:
                fcontent += str(content[j]) + " " + ltime2[j] + ", "
        fcontent = fcontent[:-2][::-1]
        fcontent = fcontent.replace(",", 'dna ', 1)
        fcontent = fcontent[::-1]
        return fcontent



assert format_duration(0) == "now"
assert format_duration(1) == "1 second"
assert format_duration(62) == "1 minute and 2 seconds"
assert format_duration(120) == "2 minutes"
assert format_duration(3600) == "1 hour"
assert format_duration(3662) == "1 hour, 1 minute and 2 seconds"
assert format_duration(15731080) == "182 days, 1 hour, 44 minutes and 40 seconds"
assert format_duration(132030240) == "4 years, 68 days, 3 hours and 4 minutes"
assert format_duration(205851834) == "6 years, 192 days, 13 hours, 3 minutes and 54 seconds"
assert format_duration(253374061) == "8 years, 12 days, 13 hours, 41 minutes and 1 second"
assert format_duration(242062374) == "7 years, 246 days, 15 hours, 32 minutes and 54 seconds"
assert format_duration(101956166) == "3 years, 85 days, 1 hour, 9 minutes and 26 seconds"
assert format_duration(33243586) == "1 year, 19 days, 18 hours, 19 minutes and 46 seconds"

day25（2022-08-30）

如果 n 是分子，d 是分数的分母，当且仅当 GCD（n，d）==1，则该分数被定义为最简分数。例如，5/16是一个最简分数，而不是6/16，因为 6和 16 都可以被 2 整除，因此分数可以简化为3/8 。现在，如果您考虑给定的数字d，那么使用d作为分母可以构建多少个最简分数？

例如，假设 d 是 15：你可以用它构建 0 和 1 之间总共 8 个不同的正确分数：1/15、2/15、4/15、7/15、8/15、11/15、13/15 和 14/15。
您将构建一个函数，该函数计算使用给定分母可以构建多少个最简分数
ps：数字有可能会很大，使用合适的算法减少循环次数，不然计算的时间会很长，（Codewars 给定的最大的时间为12秒）。
记录备忘：不满足时间要求，后期需优化

def prime_list(n):
    plist = []
    while n != 1:
        w = 0
        for i in range(1, n + 1):
            for j in range(1, i):
                if i % j == 0:
                    w = 1
            if w == 1:
                if n % i == 0:
                    plist.append(i)
                    n = n // i
    return plist


def proper_fractions(n):
    lrsult = [i for i in range(1, n)]
    lprime = prime_list(n)
    for i in range(1, n):
        for j in lprime:
            if i % j == 0 and i in lrsult:
                lrsult.remove(i)
                break
    ll = list((set(lrsult)))
    return len(ll)

assert proper_fractions(1) == 0
#print(proper_fractions(15))
assert proper_fractions(2) == 1
assert proper_fractions(5) == 4
assert proper_fractions(15) == 8
assert proper_fractions(25) == 20
# assert proper_fractions(9999999) == 6637344
# assert proper_fractions(500000003) == 500000002
# assert proper_fractions(1532420) == 608256
# assert proper_fractions(123456789) == 82260072
# assert proper_fractions(9999999999) == 5890320000

day24（2022-08-28）

如果我们列出所有小于 10 且是 3 或 5 的倍数的自然数，我们会得到 3、5、6 和 9。这些倍数之和是 23。设计一个方法，使其返回传入数字以下的所有 3 或 5 的倍数之和。此外，如果数字为负数，则返回 0。

注意：如果数字是 3 和 5 的倍数， 则只计算一次。
【示例】
输入：10
输出：23
解释：列出所有小于 10 且是 3 或 5 的倍数的自然数，我们会得到 3、5、6 和 9。这些倍数之和是 23。

def solution(number):
    if number <= 0:
        return 0
    else:
        result = 0
        for i in range(number):
            if i % 3 == 0 or i % 5 == 0:
                result += i
        return result


assert solution(10) == 23
assert solution(-1) == 0
assert solution(15) == 45
assert solution(200) == 9168

day23（2022-08-27）

给定一个整数 n ，返回 n! 结果中尾随零的数量。0 <= n <= 10^4

备注： n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1

class Solution:
    def trailingZeroes(self, n: int) -> int:
        if n == 0:
            return 0
        else:
            result = 1
            for i in range(n, 0, -1):
                result *= i
            result = str(result)
            sum = 0
            for i in range(len(result) - 1, 0, -1):
                if result[i] == '0':
                    sum += 1
                else:
                    break
            return sum


ss = Solution().trailingZeroes(5)
print(ss)
ss = Solution().trailingZeroes(0)
print(ss)
ss = Solution().trailingZeroes(3)
print(ss)

day22（2022-08-26）

完成解决方案，以便将字符串拆分为两个字符对。如果字符串包含奇数个字符，则应将最后一对中缺少的第二个字符替换为下划线 (’_’)

例子：
'abc' => ['ab', 'c_']
'abcdef' => ['ab', 'cd', 'ef']

#answer1
def solution(s: str) -> list:
    if len(s) % 2 != 0:
        s = s + '_'
    lresult = []
    while len(s) > 0:
        result = ''
        for i in range(2):
            result += s[i]
        s = s[2:]
        lresult.append(result)
    return lresult


# answer2
def solution(s: str) -> list:
    if len(s) % 2 != 0:
        s = s + '_'
    lresult = []
    for i in range(0, len(s), 2):
        result = s[i:i + 2]
        lresult.append(result)
    return lresult


assert solution("asdfadsf") == ['as', 'df', 'ad', 'sf']
assert solution("asdfads") == ['as', 'df', 'ad', 's_']
assert solution("") == []
assert solution("x") == ['x_']

day21（2022-08-25）

创建一个函数，该函数返回以字符串形式给出的数字中 4个连续数字的最小乘积。这仅适用于数字有 4 位或更多位的情况。如果不是，则返回“数字太小”。

def lowest_product(input: str) -> int:
    if len(input) >= 4:
        if '0' in input:
            return 0
        else:
            lresult = []
            while len(input) - 3 > 0:
                result = 1
                for i in range(4):
                    result *= int(input[i])
                lresult.append(result)
                input = input[1:]
                #print(lresult)
            return min(lresult)
    else:
        return "Number is too small"


#print(lowest_product("123456789"))
assert lowest_product("123456789") == 24
assert lowest_product("987654321") == 24
assert lowest_product("234567899") == 120
assert lowest_product("2345611117899") == 1
assert lowest_product("2305611117899") == 0
assert lowest_product("9999998999999") == 5832
assert lowest_product("333") == "Number is too small"
assert lowest_product("1234111321") == 3

day20（2022-08-24）

给定非空的字符串，你需要进行排列，得到所有排列并删除重复项（如果存在）

例子：

• With input 'a'
• Your function should return: ['a']
• With input 'ab'
• Your function should return ['ab', 'ba']
• With input 'aabb'
• Your function should return ['aabb', 'abab', 'abba', 'baab', 'baba', 'bbaa']
  排列的顺序无关紧要。

def permutations(string: str) -> list:
    path = ''
    road = []
    if len(string) == 1:
        return list(string)

    def proad(string, path):
        if string == '':
            road.append(path)
        for i in range(len(string)):
            item = string[i]
            proad(string[:i] + string[i + 1:], path + item)

    proad(string, path)

    return list(set(road))


assert sorted(permutations('a')) == ["a"]
#print(permutations('ab'))
assert sorted(permutations('ab')) == ["ab", "ba"]
#print(permutations('aabb'))
assert sorted(permutations('aabb')) == ['aabb', 'abab', 'abba', 'baab', 'baba', 'bbaa']
assert sorted(permutations('ababc')) == ['aabbc', 'aabcb', 'aacbb', 'ababc', 'abacb', 'abbac', 'abbca', 'abcab',
'abcba', 'acabb', 'acbab', 'acbba', 'baabc', 'baacb', 'babac', 'babca',
'bacab', 'bacba', 'bbaac', 'bbaca', 'bbcaa', 'bcaab', 'bcaba', 'bcbaa',
'caabb', 'cabab', 'cabba', 'cbaab', 'cbaba', 'cbbaa']

day19（2022-08-23）

创建一个函数，它接受一个正整数并返回下一个更大的数字，该数字可以通过重新排列其数字来形成。

例如：
12 ==> 21
513 ==> 531
2017 ==> 2071
如果无法重新排列数字以形成更大的数字，请返回-1 ：
9 ==> -1
111 ==> -1
531 ==> -1

def nextBigger(num: int):
    num1 = list(str(num))
    num2 = num1.copy()
    num2.sort(reverse=True)
    result = 0
    if num1 == num2:
        return -1
    else:
        num2.sort(reverse=False)
        for i in range(len(num2)):
            result1 = int(num2[i]) * pow(10, i)
            result += result1
        return result


print(nextBigger(513))
print(nextBigger(111))
print(nextBigger(5))
print(nextBigger(23456))

day18（2022-08-22）

题目：求1+2!+3!+...+20!的和

fresult = 0
for i in range(1, 21):
    result = 1
    for j in range(1, i + 1):
        result *= j
    fresult +=result
print(fresult)

day17（2022-08-20）

题目：打印出所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个“水仙花数”，因为153=1的三次方＋5的三次方＋3的三次方。

程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。

for i in range(100, 1000):
     if pow(i // 100, 3) + pow(i // 10 % 10, 3) + pow(i % 10, 3) == i:
         print(i)

题目：将一个正整数分解质因数。例如：输入90,打印出90=233*5。

def isPrime(k):
    # 判断大于1的数是否为质数,如果是输入，否则输出下一个质数
    for i in range(2, k):
        if k % i == 0:
            k += 1
    return k

# print(isPrime(20))

def num_decompose(numb=90):
    循环使用质数除，记录除数
    ldivisor = []
    k = 2
    if numb == k:
        ldivisor.append(k)
    elif numb > k:
        while numb >= k:
            if numb % k == 0:
                numb = numb / k
                ldivisor.append(k)
            else:
                k = k + 1
                isPrime(k)

    return ldivisor

#print(num_decompose(90))
#按照要求输出
a = ''
for i in num_decompose(90):
    a += str(i)+'*'
print('90='+a[:-1])

day16（2022-08-19）

题目：判断101-200之间有多少个素数，并输出所有素数。

1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。

lreslut = []
for i in range(101, 201):
    for j in range(2,i):
        if i % j == 0:
            lreslut.append(i)
            break
freslut=[i for i in range(101,201) if i not in lreslut]

print(freslut)

day15（2022-08-17）

题目：输出9*9口诀。

1.程序分析：分行与列考虑，共9行9列，i控制行，j控制列。

for i in range(1, 10):
    for j in range(1,i+1):
        print(f'{i}*{j}={i * j}', end=' ')
    print()

day14（2022-08-16）

题目：输入三个整数x,y,z，请把这三个数由小到大输出。

1.程序分析：我们想办法把最小的数放到x上，先将x与y进行比较，如果x>y则将x与y的值进行交换，然后再用x与z进行比较，如果x>z则将x与z的值进行交换，这样能使x最小。

def ranknumber(*number):
    number = list(number)
    for i in range(len(number)):
        for j in range(len(number) - i - 1):
            if number[j] > number[j + 1]:
                number[j], number[j + 1] = number[j + 1], number[j]

    return number


print(ranknumber(10,123, 9, 7, 8))

day13（2022-08-15）

题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？

1.程序分析：在10万以内判断，先将该数加上100后再开方，再将该数加上268后再开方，如果开方后的结果满足如下条件，即是结果。

for i in range(1, 100000):
    temp1 = pow(i + 100, 0.5)
    temp2 = pow(i + 268, 0.5)
    if temp1 == int(temp1) and temp2 == int(temp2):
        #print(temp1, temp2)
        print(i)

注：

image.png

day12（2022-08-14）

题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？'''

def sumbonus(i):
    if i <= 10:
        return i * 0.1
    elif i < 20:
        return 1 + (i - 10) * 0.075
    elif i < 40:
        return 1 + 0.75 + (i - 20) * 0.05
    elif i<60:
        return 1 + 0.75 + (40 - 20) * 0.05+(i - 40) * 0.03
    elif i<100:
        return 1 + 0.75 + (40 - 20) * 0.05+(60 - 40) * 0.03+(i - 60) * 0.015
    else:
        return 1 + 0.75 + (40 - 20) * 0.05 + (60 - 40) * 0.03 + (100 - 60) * 0.015+(i - 100) * 0.001

print(sumbonus(10))
print(sumbonus(20))
print(sumbonus(40))

备注：看别人的答案另一种思路（循环）

image.png

day11 （2022-08-13）

题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去掉不满足条件的排列。

nlist=[1,2,3,4]
result=[]
for i in nlist:
    for j in nlist:
        for k in nlist:
            if i!=j and i!=k and j!=k:
                print(i*100+j*10+k)

day10 （2022-08-11）

小蓝给学生们组织了一场考试，卷面总分为 100 分，每个学生的得分都是一个 0 到 100 的整数。请计算这次考试的最高分、最低分和平均分。输入描述：输入的第一行包含一个整数 n\ (1 ≤ n ≤ 10^4)n ，表示考试人数。 接下来 n行，每行包含一个 0 至 100 的整数，表示一个学生的得分。

def computational_results():
    lresult = []
    with open('./score.txt') as fin:
        for line in fin:
            line = int(line[:-1])
            lresult.append(line)
        #print(lresult)
    max_result = max(lresult[1:])
    min_result = min(lresult[1:])
    avg_result = round(sum((lresult[1:])) / len(lresult[1:]), 2)
    return max_result, min_result, avg_result

print(computational_results())

day9 （2022-08-10）

小蓝最近学习了一些排序算法，其中冒泡排序让他印象深刻。在冒泡排序中，每次只能交换相邻的两个元素。小蓝发现，如果对一个字符串中的字符排序，只允许交换相邻的两个字符， 则在所有可能的排序方案中，冒泡排序的总交换次数是最少的。

例如，对于字符串 lan排序，只需要 1次交换。对于字符串 qiao 排序，总共需要 4次交换。小蓝找到了很多字符串试图排序，他恰巧碰到一个字符串，需要 100次交 换，可是他忘了吧这个字符串记下来，现在找不到了。请帮助小蓝找一个只包含小写英文字母且没有字母重复出现的字符串，对 该串的字符排序，正好需要 100次交换。如果可能找到多个，请告诉小蓝最短的那个。如果最短的仍然有多个，请告诉小蓝字典序最小的那个。
思路：
1、实现冒泡排序，记录次数
2、实现字符串所有排列组合
3、循环2中的结果，找到次数等于100的排列结果
备注：实践证明这样不得行，穷尽所有不可取
其他童鞋的答案

条件
 最短字符串 条件1
 最小字典序 条件2
 100次交换 条件3
完全逆序交换次数  jh = n*(n-1)/2
字符串长度为15时  jh=105
所以最短字符串长度就是15
条件1 已满足
最小字典序，从a开始，到o
条件2 已满足
完全逆序是 o~a
少交换5次。只需要把第6位的数，往前交换五次，排在首位
相应就是 只交换100次

print("jonmlkihgfedcba")```

import os
import sys

# 请在此输入您的代码
word = 'abcdefghijklmnopqrstuvwxyz'

for i in range(len(word)):
  num = int(i*(i-1)/2)       # 全逆乱序的冒泡排序次数
  if num > 100:
    cha = num - 100
    s = i
    break

result = word[s-1::-1]
print(result[cha]+result[:cha]+result[cha+1:])

分隔符*******************************************************************************************

import string


def alphabetic_string(sString='lan'):
    # 冒泡排序
    aString = list(sString)
    count = 0
    for i in range(len(aString)):
        for j in range(len(aString) - i - 1):
            if aString[j] > aString[j + 1]:
                # print(a[j]>a[j+1])
                aString[j], aString[j + 1] = aString[j + 1], aString[j]
                count += 1
    return count, sString


def perm(s=''):
    # 这里是递归函数的出口，为什么呢，因为这里表示：一个长度为1的字符串，它的排列组合就是它自己。
    if len(s) <= 1:
        return [s]
    sl = []  # 保存字符串的所有可能排列组合
    for i in range(len(s)):  # 这个循环，对应 解题思路1）确定字符串的第一个字母是谁，有n种可能（n为字符串s的长度
        for j in perm(s[0:i] + s[i + 1:]):  # 这个循环，对应 解题思路2）进入递归，s[0:i]+s[i+1:]的意思就是把s中的s[i]给去掉
            sl.append(s[i] + j)  # 对应 解题思路2）问题就从“返回字符串中的字母排列组合” **变成了** “返回 第一个字母+除去第一个字母外的字符串的排列组合”
    return sl


def generate_random_string(letters=string.ascii_lowercase):
    for i in range(len(letters)):
        rand_string = ''.join(random.sample(letters, i + 1))
        print(rand_string)
        for i in perm(rand_string):
            print(i)
            if alphabetic_string(i)[0] ==100:
                return i



# print(alphabetic_string())
# print(alphabetic_string('qiao')[0])
print(generate_random_string())

day8 （2022-08-08）

正常情况下，小蓝每天跑 11千米。如果某天是周一或者月初（1 日），为了激励自己，小蓝要跑 22千米。如果同时是周一或月初，小蓝也是跑 22千米。

小蓝跑步已经坚持了很长时间，从 20002年 1月 1日周六（含）到 2020年 10月 1日周四（含）。请问这段时间小蓝总共跑步多少千米？

import time


def count_kilometer(start_time=20000101, end_time=20201001):
    count_kilometer = 0
    for i in range(start_time, end_time + 1):
        i = str(i)
        try:
            dt=time.strptime(i, '%Y%m%d')
            if dt.tm_mday == 1 or dt.tm_wday ==0:
                count_kilometer += 2
            else:
                count_kilometer += 1
        except:
            pass
        continue
    return count_kilometer

print(count_kilometer())
#运行时间太久了，需后期优化

day 7（2022-08-06）

小蓝有很多数字卡片，每张卡片上都是数字 0 到 9。 小蓝准备用这些卡片来拼一些数，他想从 11 开始拼出正整数，每拼一个， 就保存起来，卡片就不能用来拼其它数了。小蓝想知道自己能从 1 拼到多少。 例如，当小蓝有 30 张卡片，其中 0 到 9 各 3 张，则小蓝可以拼出 1 到 10，但是拼 11 时卡片 1 已经只有一张了，不够拼出 11。 现在小蓝手里有 0 到 9 的卡片各 2021 张，共 20210 张，请问小蓝可以从 1 拼到多少？提示：建议使用计算机编程解决问题

def number_count(x=20210):
    number_dict = {key: 2021 for key in range(10)}
    for i in range(1, x):
        for j in str(i):
            number_dict[int(j)] -= 1
            #print(number_dict)
        if sorted(number_dict.values(), reverse=False)[0] == 0:
            return i


print(number_count())

day 6（2022-08-05）

小蓝要为一条街的住户制作门牌号。这条街一共有 2020位住户，门牌号从 11 到 2020 编号。小蓝制作门牌的方法是先制作 0到 9 这几个数字字符，最后根据需要将字符粘贴到门牌上，例如门牌 1017 需要依次粘贴字符 1、0、1、7，即需要 1 个字符 0，2 个字符 1，1 个字符 7。请问要制作所有的 1 到 2020 号门牌，总共需要多少个字符 2？

def number_count(n='2'):
  result=0
  for i in range(1,2021):
    i_result=str(i).count(n)
    result +=i_result

  return result

print(number_count())

day 5（2022-08-04）

image.png

上图给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。路径上的每一步只能从一个数走到下一层和它最近的左边的那个数或者右 边的那个数。此外，向左下走的次数与向右下走的次数相差不能超过 1。

输入描述
输入的第一行包含一个整数 N(1≤N≤100)，表示三角形的行数。下面的 N 行给出数字三角形。数字三角形上的数都是 0 至 100 之间的整数。
示例：
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
输出：27
备注：向左下走的次数与向右下走的次数相差不能超过 1？？？

def Triangle():
  todo

day 4（2022-08-03）

给定一个 8 位数的日期，请你计算该日期之后下一个回文日期和下一个 ABABBABA 型的回文日期各是哪一天。

输入描述：输入包含一个八位整数 NN，表示日期。对于所有评测用例，10000101 ≤N≤89991231，保证 NN 是一个合法日期的 8 位数表示。
输出描述：输出两行，每行 1 个八位数。第一行表示下一个回文日期，第二行表示下一个 ABABBABA 型的回文日期。

import time


def palindrome(number):
    for i in range(number + 1, 89991231):
        i = str(i)
        if i[:4] == i[-1:-5:-1]:
            #判断是否为合法时间，不是则跳过继续循环
            try:
                time.strptime(i, '%Y%m%d')
                return i
            except:
                pass
            continue


def cyclic_palindrome(number):
    for i in range(number + 1, 89991231):
        i = str(i)
        if i[:4] == i[-1:-5:-1] and i[0] == i[2] and i[1] == i[3]:
            # 判断是否为合法时间，不是则跳过继续循环
            try:
                time.strptime(i, '%Y%m%d')
                return i
            except:
                pass
            continue


print(palindrome(20200240))
print(cyclic_palindrome(20210245))

day 3（2022-08-02）

小蓝给学生们组织了一场考试，卷面总分为 100 分，每个学生的得分都是一个 0 到 100 的整数。

如果得分至少是 60 分，则称为及格。如果得分至少为 85 分，则称为优秀。请计算及格率和优秀率，用百分数表示，百分号前的部分四舍五入保留整 数。

输入描述：输入的第一行包含一个整数 n(1≤n≤10^ 4 )，表示考试人数。接下来 nn 行，每行包含一个 0 至 100 的整数，表示一个学生的得分。'''

思路：
1、读取文件，只有一列数据用list接收
2、遍历list根据业务取对应的结果并存储并进行计算
3、输入时需用百分数表示，并需四舍五入

def read_file():
    result = []
    result_A = {"countA": 0, "sumA": 0}
    result_B = {"countB": 0, "sumB": 0}
    # 读取文件
    with open("./score.txt") as fi:
        for line in fi:
            line = line[:-1]
            result.append(line)
    # 统计优秀、及格学生
    for i in result[1:]:
        if int(i) >= 85:
            result_A["countA"] += 1
            result_A["sumA"] += int(i)
        elif int(i) >= 60:
            result_B["countB"] += 1
            result_B["sumB"] += int(i)
    # 计算及格率、优秀率
    percent_A = round(result_A["countA"] / len(result[1:]), 3)
    percent_B = round(result_B["countB"] / len(result[1:]), 3)
    return percent_A, percent_B

#测试数据
datas_A, datas_B = read_file()
print(datas_A, datas_B)
print('优秀率为：{:.0%},及格率为：{:.0%}'.format(datas_A, datas_B))

day 2 （2022-08-01）

小蓝正在学习一门神奇的语言，这门语言中的单词都是由小写英文字母组 成，有些单词很长，远远超过正常英文单词的长度。小蓝学了很长时间也记不住一些单词，他准备不再完全记忆这些单词，而是根据单词中哪个字母出现得最多来分辨单词。现在，请你帮助小蓝，给了一个单词后，帮助他找到出现最多的字母和这 个字母出现的次数。如果有多个字母出现的次数相等，输出字典序最小的那个。

思路：
1、统计输入内容出现的字数，联想到用字典key唯一性可以记录出现的字符，value记录次数
2、遍历输入内容，用空字典记录接收，出现便+1
3、用sorted()对结果字典排序
4、输入内容处理，正则取小写英文字母，后期可扩展大写字母、数字等

import re

def getmaxnum(input_content):
    dict_num = {}
    result = re.findall('[a-z]', input_content)
    # print(result)
    for i in result:
        if i not in dict_num:
            dict_num.setdefault(i)
            dict_num[i] = 0
        dict_num[i] += 1
    result_reverse = sorted(dict_num.items(), key=lambda x: x[1], reverse=True)
    return result_reverse



print(getmaxnum("lanqiao"))
print(getmaxnum("longlonglongistoolong"))
print(getmaxnum("lognlonglongtisoolong"))

问题记录：要求如果有多个字母出现的次数相等，输出字典序最小的那个。
1、不太明白字典序指的是啥
2、后期扩展value排序以后，相同value再根据key排序一次
***********************************分割线*****************************************************************

day 1 （2022-07-30）

2000 年的 1 月 1 日，是那一年的第 1 天。那么，2000年的 5 月 4日，是那一年的第几天？

思路：
1、时间日期需要用到标准库datetime
2、计算出两个时间的差值
3、题目中开始时间为第1天，差值+1
https://docs.python.org/zh-cn/3/library/datetime.html?highlight=datetime#datetime.datetime

import datetime
d1=datetime.date(2000,1,1)
d2=datetime.date(2000,5,4)
print((d2-d1).days+1)