day43（2022-10-26）

給定一個整數(shù)n，通過移除其中某一位數(shù)字，找出操作之后遺留的最大數(shù)字。

【示例】
輸入：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）

已知一個包含唯一數(shù)字的列表，和一個指定的左閉右開區(qū)間[from, to)，我們的任務(wù)是：首先湊對，找出存在幾對元素之和在區(qū)間內(nèi)，然后將這些符合區(qū)間的和加總得到最終的和值。

備注：
所有湊對的元素必須是唯一的
湊對的和值只在區(qū)間內(nèi)統(tǒng)計一次
示例：
已知列表是 [2, 4, 6, 10]，已知區(qū)間是[6， 10)
6：可以等于 2 + 4
7：無法湊對
8：可以等于 2 + 6
9：無法湊對
最終結(jié)果：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）

子序列最大和，包括在一個數(shù)組或整數(shù)列表中查找連續(xù)子序列的最大和：最大序列（[-2，1，-3，4，-1，2，1，-5，4]）應(yīng)為6:[4，-1，2，1]簡單的情況是，列表僅由正數(shù)組成，最大和是整個數(shù)組的和。如果列表僅由負數(shù)組成，則返回0?？樟斜肀灰暈樽畲蠛蜑榱恪Ｕ堊⒁?，空列表或數(shù)組也是有效的子列表/子數(shù)組?！?/h3>

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標識符的長度為十位數(shù)。前九個字符是數(shù)字0-9。最后一個數(shù)字可以是0-9或X，表示值為10。

如果數(shù)字之和乘以其位置模11等于零，則ISBN-10數(shù)字有效。
例如:
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）

編寫一個函數(shù)，該函數(shù)接受一個括號字符串，并確定括號的順序是否有效。如果字符串有效，則函數(shù)應(yīng)返回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）

一個數(shù)字的真除數(shù)是除了自身之外的所有整除數(shù)的集合。例如，對于100，它們是1、2、4、5、10、20、25和50。設(shè)s（n）是n的這些真除數(shù)之和。將buddy稱為兩個正整數(shù)，這樣每個數(shù)的真除數(shù)的和比另一個數(shù)多一個：（n，m）是一對伙伴，如果s（m）=n+1和s（n）=m+1

例如，48和75就是這樣一對：48的除數(shù)是：1、2、3、4、6、8、12、16、24–>和：76=75+175的除數(shù)是：1、3、5、15、25–>和：49=48+1任務(wù)
給定兩個正整數(shù)start和limit，函數(shù)buddy（start，limit）應(yīng)該返回buddy對的第一對（n m），這樣n（正整數(shù)）就在 start 和 limits 之間；m可以大于極限，并且必須大于n如果沒有滿足條件的好友數(shù)據(jù)對，則返回 “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的數(shù)字，即每四個連續(xù)數(shù)字的總和不能高于某個給定值。如果數(shù)字是num = d1d2d3d4d5d6，并且4個連續(xù)數(shù)字的最大和是max_sum，那么：

d1 + d2 + d3 + d4 <= max_sum
d2 + d3 + d4 + d5 <= max_sum
d3 + d4 + d5 + d6 <= max_sum
為此，我們需要創(chuàng)建一個函數(shù)max_sum_dig()，該函數(shù)接收n_max，作為研究間隔的最大值（范圍（1000，n_max）），以及某個值max_sum ，即每連續(xù)四位數(shù)字應(yīng)小于或等于的最大和。該函數(shù)應(yīng)輸出以下列表，其中包含詳細信息：
[(1), (2), (3)]
(1) 滿足上述約束的數(shù)字數(shù)量
(2) 最接近結(jié)果平均值的數(shù)字，如果有多個，則應(yīng)選擇最小的數(shù)字。
(3) 所有發(fā)現(xiàn)數(shù)字的總和
讓我們看看一個包含所有細節(jié)的案例：
max_sum_dig(2000, 3) -------> [11, 1110, 12555]
(1) 總共找到11 個數(shù)字: 1000, 1001, 1002, 1010, 1011, 1020, 1100, 1101, 1110, 1200 和 2000
(2) 求得所有符合的數(shù)字的平均數(shù)為:
(1000 + 1001 + 1002 + 1010 + 1011 + 1020 + 1100 + 1101 + 1110 + 1200 + 2000) /11 = 1141.36363,
所以 1110 是最符合的數(shù)字.
(3) 所有符合的數(shù)字的總和為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）

給定一個由純數(shù)字組成的字符串，每個數(shù)字之間使用空格分隔。我們的任務(wù)是，編寫一個函數(shù)，找出其中最大和最小的兩個數(shù)字。返回結(jié)果的兩個數(shù)字格式為字符串，并且逆序排列，也使用空格分隔。

示例：
輸入：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" 匹配時，第二個字符串相對短一些，然后根據(jù)詞典編纂規(guī)則 "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，現(xiàn)在給出了一系列控制指令來控制這些彩燈的開關(guān)。一開始這些彩燈都是關(guān)閉的，然后指令將逐條發(fā)出。在每條指令operation[i] 中含有兩個整數(shù) operation[i][0], operation[i][1] 。在接收到一條指令時，標號為 operation[i][0] 的彩燈會亮起，直到第 operation[i[1] 秒的時候熄滅。當燈熄滅后，下一條指令將會發(fā)出。也就是說，任何時候只會有一盞燈亮著。其中第一條指令將在第0秒的時候發(fā)出，并被立刻執(zhí)行。你的任務(wù)是找到哪個彩燈單次亮起的時間最長。

*輸入：
[[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。
所以你的答案應(yīng)該是'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）

您將獲得一個數(shù)字的素數(shù)作為數(shù)組。例如：[2,2,2,3,3,5,5,13]您需要找到該素數(shù)分解所屬的數(shù)字 n。這將是：n = 233252*13 = 23400然后，生成這個數(shù)的除數(shù)。您的函數(shù)get_num() or getNum() 將接收一個具有潛在無序素數(shù)因子的數(shù)組，并應(yīng)輸出：在索引 0 處具有找到的整數(shù) n 的數(shù)組，在索引 1 處的總除數(shù)（素數(shù)和復(fù)合數(shù)）的數(shù)量，然后是最小因子（索引 2），和最大的一個（最后一個元素）

我們將看到上面給出的示例，唯一的區(qū)別是素因子數(shù)組是無序的。
該數(shù)字 (23400) 的除數(shù)列表是：
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 有一個除數(shù)的總數(shù)。最小的除數(shù)是2 和最高的11700 。所以預(yù)期的輸出將是：
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)
            # 如果除數(shù)含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 將值輸出到返回數(shù)組
應(yīng)忽略無效字符。
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）

編寫一個函數(shù)cakes() ，它接受食譜（對象）和可用成分（也是一個對象）并返回皮特可以烘烤的最大蛋糕數(shù)量（整數(shù)）。為簡單起見，數(shù)量沒有單位（例如，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）

有些數(shù)字具有有趣的特性。

例如：
89 → 81 + 92 = 89 * 1
695 → 62 + 93 + 5?= 1390 = 695 * 2
46288 → 43 + 6?+ 2? + 8? + 8? = 2360688 = 46288 * 51

給定一個正整數(shù) n，寫成 abcd…（a, b, c, d… 是數(shù)字）和一個正整數(shù) p，我們想要找到一個正整數(shù) k，如果它存在的話，使得 n 的數(shù)字之和對 p 的連續(xù)冪等于 k n。換句話說：是否存在整數(shù) k 例如： (a ^ p + b ^ (p+1) + c ^(p+2) + d ^ (p+3) + …) = n * k,如果是這種情況，我們將返回 k，如果不是，則返回 -1。

注意 ：n 和 p 將始終作為嚴格的正整數(shù)給出。
dig_pow(89, 1) 返回值 1 因為 81 + 92 = 89 = 89 * 1
dig_pow(92, 1) 返回值 -1 因為 91 + 22=13 無法整除92
dig_pow(695, 2) 返回值 2 因為 62 + 93 + 5?= 1390 = 695 * 2
dig_pow(46288, 3) 返回值 51 因為 43 + 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）

給定一個整數(shù)列表，對于列表中的每對整數(shù)，計算指數(shù)和（包括兩者）之間的值的總和，并返回最大的結(jié)果和。

例
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

編寫一個函數(shù)，從列表中查找單詞的所有字謎。您將獲得兩個輸入一個單詞和一個帶有單詞的數(shù)組。您應(yīng)該返回一個包含所有字謎的數(shù)組，如果沒有字謎，則應(yīng)返回一個空數(shù)組。

例如：
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

我們應(yīng)該選擇所有在反轉(zhuǎn)時是不同 素數(shù)的素數(shù)（因此應(yīng)該丟棄回文素數(shù)）。

例如：13、17 是素數(shù)，反過來分別是 31、71，它們也是素數(shù)，所以 13 和 17 是“emirps”。但素數(shù) 757、787、797 是回文素數(shù)，這意味著反轉(zhuǎn)后的數(shù)與原來的數(shù)相同，因此它們不被視為“emirps”，應(yīng)該被丟棄。

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

現(xiàn)在有數(shù)字6969 和9116 。當您旋轉(zhuǎn)它們180 degrees （倒置）時，這些數(shù)字保持不變。澄清一下，如果我們將它們寫在紙上并將紙倒置，數(shù)字將是相同的。試試看！某些數(shù)字，例如2 或5 在旋轉(zhuǎn)時不產(chǎn)生數(shù)字。給定一個范圍，返回該范圍內(nèi)倒置數(shù)字的計數(shù)。

例如solve(0,10) = 3 ，因為在范圍>= 0 and < 10只有3 個顛倒的數(shù)字。他們是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）

寫一個函數(shù)，接收秒數(shù)，處理成人類友好的方式格式化持續(xù)時間。該函數(shù)必須接受一個非負整數(shù)。如果它是零，它只是返回"now" 。否則，持續(xù)時間表示為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等分量組成，一個正整數(shù)和一個有效的時間單位之一，由空格分隔。如果整數(shù)大于 1，則時間單位以復(fù)數(shù)形式使用。組件由逗號和空格 ( ", " ) 分隔。除了最后一個組件用 " and " 分隔， 就像用英文寫的一樣。
  1 second and 1 year 不是正確的，而 1 year and 1 second 是正確 的。
  不同的組件有不同的時間單位。所以 5 seconds and 1 second 這樣的重復(fù)單位寫法是錯誤的。
  如果組件的值恰好為零，則組件根本不會出現(xiàn)。因此，1 minute and 0 seconds 是無效的，應(yīng)該是1 minute 這樣編寫。
  必須“盡可能”使用一個時間單位。這意味著該函數(shù)不應(yīng)該返回61 seconds ，而是應(yīng)該返回1 minute and 1 second 。所以不要出現(xiàn)366天、24小時、60分、60秒這樣的數(shù)據(jù)。

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 是分數(shù)的分母，當且僅當 GCD（n，d）==1，則該分數(shù)被定義為最簡分數(shù)。例如，5/16是一個最簡分數(shù)，而不是6/16，因為 6和 16 都可以被 2 整除，因此分數(shù)可以簡化為3/8 ?，F(xiàn)在，如果您考慮給定的數(shù)字d，那么使用d作為分母可以構(gòu)建多少個最簡分數(shù)？

例如，假設(shè) d 是 15：你可以用它構(gòu)建 0 和 1 之間總共 8 個不同的正確分數(shù)：1/15、2/15、4/15、7/15、8/15、11/15、13/15 和 14/15。
您將構(gòu)建一個函數(shù)，該函數(shù)計算使用給定分母可以構(gòu)建多少個最簡分數(shù)
ps：數(shù)字有可能會很大，使用合適的算法減少循環(huán)次數(shù)，不然計算的時間會很長，（Codewars 給定的最大的時間為12秒）。
記錄備忘：不滿足時間要求，后期需優(yōu)化

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 的倍數(shù)的自然數(shù)，我們會得到 3、5、6 和 9。這些倍數(shù)之和是 23。設(shè)計一個方法，使其返回傳入數(shù)字以下的所有 3 或 5 的倍數(shù)之和。此外，如果數(shù)字為負數(shù)，則返回 0。

注意：如果數(shù)字是 3 和 5 的倍數(shù)， 則只計算一次。
【示例】
輸入：10
輸出：23
解釋：列出所有小于 10 且是 3 或 5 的倍數(shù)的自然數(shù)，我們會得到 3、5、6 和 9。這些倍數(shù)之和是 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）

給定一個整數(shù) n ，返回 n! 結(jié)果中尾隨零的數(shù)量。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）

完成解決方案，以便將字符串拆分為兩個字符對。如果字符串包含奇數(shù)個字符，則應(yīng)將最后一對中缺少的第二個字符替換為下劃線 (’_’)

例子：
'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）

創(chuàng)建一個函數(shù)，該函數(shù)返回以字符串形式給出的數(shù)字中 4個連續(xù)數(shù)字的最小乘積。這僅適用于數(shù)字有 4 位或更多位的情況。如果不是，則返回“數(shù)字太小”。

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）

給定非空的字符串，你需要進行排列，得到所有排列并刪除重復(fù)項（如果存在）

例子：

• 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']
  排列的順序無關(guān)緊要。

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）

創(chuàng)建一個函數(shù)，它接受一個正整數(shù)并返回下一個更大的數(shù)字，該數(shù)字可以通過重新排列其數(shù)字來形成。

例如：
12 ==> 21
513 ==> 531
2017 ==> 2071
如果無法重新排列數(shù)字以形成更大的數(shù)字，請返回-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）

題目：打印出所有的“水仙花數(shù)”，所謂“水仙花數(shù)”是指一個三位數(shù)，其各位數(shù)字立方和等于該數(shù)本身。例如：153是一個“水仙花數(shù)”，因為153=1的三次方＋5的三次方＋3的三次方。

程序分析：利用for循環(huán)控制100-999個數(shù)，每個數(shù)分解出個位，十位，百位。

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

題目：將一個正整數(shù)分解質(zhì)因數(shù)。例如：輸入90,打印出90=233*5。

def isPrime(k):
    # 判斷大于1的數(shù)是否為質(zhì)數(shù),如果是輸入，否則輸出下一個質(zhì)數(shù)
    for i in range(2, k):
        if k % i == 0:
            k += 1
    return k

# print(isPrime(20))

def num_decompose(numb=90):
    循環(huán)使用質(zhì)數(shù)除，記錄除數(shù)
    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之間有多少個素數(shù)，并輸出所有素數(shù)。

1.程序分析：判斷素數(shù)的方法：用一個數(shù)分別去除2到sqrt(這個數(shù))，如果能被整除，則表明此數(shù)不是素數(shù)，反之是素數(shù)。

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）

題目：輸入三個整數(shù)x,y,z，請把這三個數(shù)由小到大輸出。

1.程序分析：我們想辦法把最小的數(shù)放到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）

題目：一個整數(shù)，它加上100后是一個完全平方數(shù)，再加上168又是一個完全平方數(shù)，請問該數(shù)是多少？

1.程序分析：在10萬以內(nèi)判斷，先將該數(shù)加上100后再開方，再將該數(shù)加上268后再開方，如果開方后的結(jié)果滿足如下條件，即是結(jié)果。

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）

題目：企業(yè)發(fā)放的獎金根據(jù)利潤提成。利潤(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，求應(yīng)發(fā)放獎金總數(shù)？'''

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))

備注：看別人的答案另一種思路（循環(huán)）

image.png

day11 （2022-08-13）

題目：有1、2、3、4個數(shù)字，能組成多少個互不相同且無重復(fù)數(shù)字的三位數(shù)？都是多少？程序分析：可填在百位、十位、個位的數(shù)字都是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 的整數(shù)。請計算這次考試的最高分、最低分和平均分。輸入描述：輸入的第一行包含一個整數(shù) n\ (1 ≤ n ≤ 10^4)n ，表示考試人數(shù)。 接下來 n行，每行包含一個 0 至 100 的整數(shù)，表示一個學生的得分。

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）

小藍最近學習了一些排序算法，其中冒泡排序讓他印象深刻。在冒泡排序中，每次只能交換相鄰的兩個元素。小藍發(fā)現(xiàn)，如果對一個字符串中的字符排序，只允許交換相鄰的兩個字符， 則在所有可能的排序方案中，冒泡排序的總交換次數(shù)是最少的。

例如，對于字符串 lan排序，只需要 1次交換。對于字符串 qiao 排序，總共需要 4次交換。小藍找到了很多字符串試圖排序，他恰巧碰到一個字符串，需要 100次交 換，可是他忘了吧這個字符串記下來，現(xiàn)在找不到了。請幫助小藍找一個只包含小寫英文字母且沒有字母重復(fù)出現(xiàn)的字符串，對 該串的字符排序，正好需要 100次交換。如果可能找到多個，請告訴小藍最短的那個。如果最短的仍然有多個，請告訴小藍字典序最小的那個。
思路：
1、實現(xiàn)冒泡排序，記錄次數(shù)
2、實現(xiàn)字符串所有排列組合
3、循環(huán)2中的結(jié)果，找到次數(shù)等于100的排列結(jié)果
備注：實踐證明這樣不得行，窮盡所有不可取
其他童鞋的答案

條件
 最短字符串 條件1
 最小字典序 條件2
 100次交換 條件3
完全逆序交換次數(shù)  jh = n*(n-1)/2
字符串長度為15時  jh=105
所以最短字符串長度就是15
條件1 已滿足
最小字典序，從a開始，到o
條件2 已滿足
完全逆序是 o~a
少交換5次。只需要把第6位的數(shù)，往前交換五次，排在首位
相應(yīng)就是 只交換100次

print("jonmlkihgfedcba")```

import os
import sys

# 請在此輸入您的代碼
word = 'abcdefghijklmnopqrstuvwxyz'

for i in range(len(word)):
  num = int(i*(i-1)/2)       # 全逆亂序的冒泡排序次數(shù)
  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=''):
    # 這里是遞歸函數(shù)的出口，為什么呢，因為這里表示：一個長度為1的字符串，它的排列組合就是它自己。
    if len(s) <= 1:
        return [s]
    sl = []  # 保存字符串的所有可能排列組合
    for i in range(len(s)):  # 這個循環(huán)，對應(yīng) 解題思路1）確定字符串的第一個字母是誰，有n種可能（n為字符串s的長度
        for j in perm(s[0:i] + s[i + 1:]):  # 這個循環(huán)，對應(yīng) 解題思路2）進入遞歸，s[0:i]+s[i+1:]的意思就是把s中的s[i]給去掉
            sl.append(s[i] + j)  # 對應(yīng) 解題思路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千米。

小藍跑步已經(jīng)堅持了很長時間，從 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())
#運行時間太久了，需后期優(yōu)化

day 7（2022-08-06）

小藍有很多數(shù)字卡片，每張卡片上都是數(shù)字 0 到 9。 小藍準備用這些卡片來拼一些數(shù)，他想從 11 開始拼出正整數(shù)，每拼一個， 就保存起來，卡片就不能用來拼其它數(shù)了。小藍想知道自己能從 1 拼到多少。 例如，當小藍有 30 張卡片，其中 0 到 9 各 3 張，則小藍可以拼出 1 到 10，但是拼 11 時卡片 1 已經(jīng)只有一張了，不夠拼出 11。 現(xiàn)在小藍手里有 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 這幾個數(shù)字字符，最后根據(jù)需要將字符粘貼到門牌上，例如門牌 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

上圖給出了一個數(shù)字三角形。從三角形的頂部到底部有很多條不同的路徑。對于每條路徑，把路徑上面的數(shù)加起來可以得到一個和，你的任務(wù)就是找到最大的和。路徑上的每一步只能從一個數(shù)走到下一層和它最近的左邊的那個數(shù)或者右 邊的那個數(shù)。此外，向左下走的次數(shù)與向右下走的次數(shù)相差不能超過 1。

輸入描述
輸入的第一行包含一個整數(shù) N(1≤N≤100)，表示三角形的行數(shù)。下面的 N 行給出數(shù)字三角形。數(shù)字三角形上的數(shù)都是 0 至 100 之間的整數(shù)。
示例：
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
輸出：27
備注：向左下走的次數(shù)與向右下走的次數(shù)相差不能超過 1？？？

def Triangle():
  todo

day 4（2022-08-03）

給定一個 8 位數(shù)的日期，請你計算該日期之后下一個回文日期和下一個 ABABBABA 型的回文日期各是哪一天。

輸入描述：輸入包含一個八位整數(shù) NN，表示日期。對于所有評測用例，10000101 ≤N≤89991231，保證 NN 是一個合法日期的 8 位數(shù)表示。
輸出描述：輸出兩行，每行 1 個八位數(shù)。第一行表示下一個回文日期，第二行表示下一個 ABABBABA 型的回文日期。

import time


def palindrome(number):
    for i in range(number + 1, 89991231):
        i = str(i)
        if i[:4] == i[-1:-5:-1]:
            #判斷是否為合法時間，不是則跳過繼續(xù)循環(huán)
            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]:
            # 判斷是否為合法時間，不是則跳過繼續(xù)循環(huán)
            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 的整數(shù)。

如果得分至少是 60 分，則稱為及格。如果得分至少為 85 分，則稱為優(yōu)秀。請計算及格率和優(yōu)秀率，用百分數(shù)表示，百分號前的部分四舍五入保留整 數(shù)。

輸入描述：輸入的第一行包含一個整數(shù) n(1≤n≤10^ 4 )，表示考試人數(shù)。接下來 nn 行，每行包含一個 0 至 100 的整數(shù)，表示一個學生的得分。'''

思路：
1、讀取文件，只有一列數(shù)據(jù)用list接收
2、遍歷list根據(jù)業(yè)務(wù)取對應(yīng)的結(jié)果并存儲并進行計算
3、輸入時需用百分數(shù)表示，并需四舍五入

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)
    # 統(tǒng)計優(yōu)秀、及格學生
    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)
    # 計算及格率、優(yōu)秀率
    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

#測試數(shù)據(jù)
datas_A, datas_B = read_file()
print(datas_A, datas_B)
print('優(yōu)秀率為：{:.0%},及格率為：{:.0%}'.format(datas_A, datas_B))

day 2 （2022-08-01）

小藍正在學習一門神奇的語言，這門語言中的單詞都是由小寫英文字母組 成，有些單詞很長，遠遠超過正常英文單詞的長度。小藍學了很長時間也記不住一些單詞，他準備不再完全記憶這些單詞，而是根據(jù)單詞中哪個字母出現(xiàn)得最多來分辨單詞。現(xiàn)在，請你幫助小藍，給了一個單詞后，幫助他找到出現(xiàn)最多的字母和這 個字母出現(xiàn)的次數(shù)。如果有多個字母出現(xiàn)的次數(shù)相等，輸出字典序最小的那個。

思路：
1、統(tǒng)計輸入內(nèi)容出現(xiàn)的字數(shù)，聯(lián)想到用字典key唯一性可以記錄出現(xiàn)的字符，value記錄次數(shù)
2、遍歷輸入內(nèi)容，用空字典記錄接收，出現(xiàn)便+1
3、用sorted()對結(jié)果字典排序
4、輸入內(nèi)容處理，正則取小寫英文字母，后期可擴展大寫字母、數(shù)字等

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"))

問題記錄：要求如果有多個字母出現(xiàn)的次數(shù)相等，輸出字典序最小的那個。
1、不太明白字典序指的是啥
2、后期擴展value排序以后，相同value再根據(jù)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)