詞形詞高顏色組合機器實作

def word_shape_from_a_text_corpus(words, shape):
    output = []
    for word in words:
        if len(word) == len(shape) + 1:
            if word_shape(word) == shape:
                output.append(word)
    return output

def word_shape(word):
    shape = [None] * (len(word) - 1)
    for i in range(len(shape)):
        a = ord(word[i])
        b = ord(word[i + 1])
        if a < b:
            shape[i] = 1
        elif a == b:
            shape[i] = 0
        elif a > b:
            shape[i] = -1
    return shape

def word_height_from_a_text_corpus(words, word, memo={}):
    if word in memo:
        return memo[word]
    
    index = binary_search(words, word)
    if index == -1:
        return 0
    
    valid_splits = []
    for i in range(1, len(word)):
        left, right = word[:i], word[i:]
        if binary_search(words, left) != -1 and binary_search(words, right) != -1:
            valid_splits.append((left, right))
    
    if not valid_splits:
        return 1
    
    max_height = max(1 + max(word_height_from_a_text_corpus(words, left, memo), word_height_from_a_text_corpus(words, right, memo)) for left, right in valid_splits)
    memo[word] = max_height
    return max_height

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

def binary_search(lst, x):
    left = 0
    right = len(lst) - 1
    while left <= right:
        mid = (left + right) // 2
        if lst[mid] < x:
            left = mid + 1
        else:
            right = mid - 1
    return left

def Word_Height_From_a_Text_Corpus(words, word, memo=None):
    if memo is None:
        memo = {}
    
    if word in memo:
        return memo[word]
    
    def Search(l, x):
        i = binary_search(l, x)
        return i if i != len(l) and l[i] == x else -1
    
    if Search(words, word) == -1:
        return 0
    
    validList = []
    for s in range(1, len(word)):
        ls = word[0:s]
        rs = word[s:]
        if Search(words, ls) != -1 and Search(words, rs) != -1:
            validList.append((ls, rs))
    
    if not validList:
        return 1
    
    hs = []
    for (ls, rs) in validList:
        left = memo.get(ls, None) or Word_Height_From_a_Text_Corpus(words, ls, memo)
        right = memo.get(rs, None) or Word_Height_From_a_Text_Corpus(words, rs, memo)
        hs.append(max(left, right) + 1)
    
    memo[word] = max(hs)
    return max(hs)

def combine(a, b):
    ColorFinder = {"b":{"y": "r", "r": "y"}, "y":{"b": "r", "r": "b"}, "r":{"b": "y", "y": "b"}}
    if a == b:
        return a
    else:
        return ColorFinder[a][b]

def combine_adjacent_colors(colors):
    memo = {}
    def helper(colors):
        if tuple(colors) in memo:
            return memo[tuple(colors)]
        if len(colors) == 1:
            return colors[0]
        new_colors = [combine(colors[i], colors[i+1]) for i in range(len(colors)-1)]
        result = helper(new_colors)
        memo[tuple(colors)] = result
        return result
    return helper(colors)

def combine(color1, color2):
    # 假設這是一個簡單的顏色混合函式，實際情況可能更複雜
    return color1 + color2

def color_combination(colors):
    cache = {}
    while len(colors) > 1:
        TemparrayColors = [None] * (len(colors) - 1)
        for i in range(len(TemparrayColors)):
            if (colors[i], colors[i+1]) in cache:
                TemparrayColors[i] = cache[(colors[i], colors[i+1])]
            else:
                result = combine(colors[i], colors[i+1])
                cache[(colors[i], colors[i+1])] = result
                TemparrayColors[i] = result
        colors = TemparrayColors
    return colors[0]

def remove_first_digit(X):
    return X[1:]

def slice_and_append_2(X):
    return mcculloch(X[1:]) + '2' + mcculloch(X[1:])

def reverse(X):
    return mcculloch(X[1:])[::-1]

def double(X):
    return mcculloch(X[1:]) + mcculloch(X[1:])

def mcculloch(X):
    functions = {
        '2': remove_first_digit,
        '3': slice_and_append_2,
        '4': reverse,
        '5': double,
    }
    if X[0] in functions:
        return functions[X[0]](X)
    else:
        return X