技術演算法程式碼解析與實作

def smallest_seven_zero(n):
    remainder_positions = {0: -1}
    current_remainder = 0
    digits_min, digits_max = 1, 10
    
    while True:
        for num_digits in range(digits_min, digits_max):
            current_remainder = (current_remainder * 10 + 7) % n
            if current_remainder in remainder_positions:
                # 組成七零數並傳回
                seven_zero_num = '7' * num_digits
                return int(seven_zero_num + '0' * (remainder_positions[current_remainder] - num_digits))
            remainder_positions[current_remainder] = num_digits
        digits_min, digits_max = digits_max, digits_max * 10

# 示例使用
print(smallest_seven_zero(25))   # 輸出：700
print(smallest_seven_zero(49))   # 輸出：777777

def pop_last_item(input_list):
    # 取得並移除輸入列表中的最後一個專案
    list_length = len(input_list)
    last_item = input_list[list_length - 1]
    del input_list[list_length - 1]
    return last_item

def postfix_evaluate(Postfix):
    '''
    建立一個空列表來儲存運算元和結果
    '''
    Storage = []

    '''
    遍歷字尾表示式中的每個專案
    '''
    for item in Postfix:
        '''
        如果專案是整數，將其追加到儲存列表
        '''
        if isinstance(item, int):
            Storage.append(item)
        else:
            '''
            如果專案是運算子，從儲存列表中彈出最近的兩個運算元
            '''
            Number0, Number1 = pop_last_item(Storage), pop_last_item(Storage)
            '''
            根據運算子對兩個運算元執行相應的運算
            '''
            if item == '-':
                result = Number1 - Number0
            elif item == '+':
                result = Number1 + Number0
            elif item == '*':
                result = Number1 * Number0
            elif item == '/':
                result = Number1 / Number0
            '''
            將運算結果追加到儲存列表
            '''
            Storage.append(result)
    '''
    傳回儲存列表中的最後一個專案作為求值結果
    '''
    return pop_last_item(Storage)

print(postfix_evaluate([5, 6, '+', 7, '*']))  # 輸出：77
print(postfix_evaluate([3, 7, 9, '*', '+']))  # 輸出：66
print(postfix_evaluate([3, 7, 9, '/', '+']))  # 輸出：3.0（注意：除法結果為浮點數）
print(postfix_evaluate([8, 2, '+']))  # 輸出：10

def Stable_State_in_Bulgarian_Solitaire(points, k):
    number_of_moves = 0
    equation = k * (k + 1) // 2

    def is_stable_state(points, k):
        count = [0] * (k + 1)
        for p in points:
            if p <= k:
                count[p] += 1
        for i in range(1, k + 1):
            if count[i] != 1:
                return False
        return True

    if sum(points) == equation:
        while not is_stable_state(points, k):
            points = [p - 1 for p in points]
            points = [p for p in points if p > 0]
            points.append(len(points) + sum(1 for p in points if p == 0))
            number_of_moves += 1
        return number_of_moves
    else:
        return 0

def rectangular_towers_in_manhattan_skyline(towers):
    '''
    divide_and_conquer computes the skyline for a given range of towers
    '''
    def divide_and_conquer(start, end):
        '''
        If there is only one tower in the range, return its two corners
        '''
        if start == end:
            return [[towers[start][0], towers[start][2]], [towers[start][1], 0]]

        '''
        Divide the range into two halves and recursively compute the skylines for each half
        '''
        mid = (start + end) // 2
        left = divide_and_conquer(start, mid)
        right = divide_and_conquer(mid + 1, end)

        '''
        Merge the two skylines using a merge sort-like approach
        '''
        merged = []
        i, j = 0, 0
        h1, h2 = None, None

        for _ in range(len(left) + len(right)):
            if i >= len(left):
                merged.append([right[j][0], right[j][1] if h1 is None else max(h1, right[j][1])])
                j += 1
            elif j >= len(right):
                merged.append([left[i][0], left[i][1] if h2 is None else max(h2, left[i][1])])
                i += 1
            elif left[i][0] <= right[j][0]:
                merged.append([left[i][0], left[i][1] if h2 is None else max(h2, left[i][1])])
                h1 = left[i][1]
                i += 1
            else:
                merged.append([right[j][0], right[j][1] if h1 is None else max(h1, right[j][1])])
                h2 = right[j][1]
                j += 1

        return merged

    n = len(towers)
    result = divide_and_conquer(0, n - 1)

    '''
    Compute the area enclosed by the skyline using the trapezoidal rule
    '''
    area = sum((result[i + 1][0] - result[i][0]) * result[i][1] for i in range(len(result) - 1))

    return area

towers = [(2, 6, 98), (1, 0, 9)]
print(rectangular_towers_in_manhattan_skyline(towers))  # 輸出：383

towers = [(3, 7, 1)]
print(rectangular_towers_in_manhattan_skyline(towers))  # 輸出：4

towers = [(-8, 6, 3), (6, 14, 11), (0, 4, -5)]
print(rectangular_towers_in_manhattan_skyline(towers))  # 輸出：130

towers = [(2, 550, 222), (1, 0, 4)]
print(rectangular_towers_in_manhattan_skyline(towers))  # 輸出：121652