Помогите решить задачу python

 def can_build_pyramid(cube_sides): 
    from collections import Counter 
     
    # Подсчитываем количество каждой стороны 
    counts = Counter(cube_sides) 
     
    # Сортируем уникальные стороны в порядке убывания 
    unique_sides = sorted(counts.keys(), reverse=True) 
     
    pyramid = [] 
     
    # Проверяем возможность построения пирамиды 
    for side in unique_sides: 
        count = counts[side] 
        if count > 0: 
            # Добавляем текущую сторону в пирамиду 
            pyramid.append(side) 
            # Уменьшаем количество для следующего уровня 
            counts[side] -= 1 
             
            # Если есть больше одного кубика на этом уровне, добавляем их на следующий уровень 
            if counts[side] > 0: 
                # Добавляем столько кубиков, сколько осталось 
                for _ in range(counts[side]): 
                    pyramid.append(side) 
                counts[side] = 0 
     
    # Проверяем, удалось ли построить устойчивую пирамиду 
    if len(pyramid) == 0 or pyramid[-1] != unique_sides[-1]: 
        return "НЕТ" 
     
    return ' '.join(map(str, pyramid)) 
 
# Чтение данных 
n = int(input("Введите количество раундов: ")) 
results = [] 
 
for _ in range(n): 
    cube_sides = list(map(int, input().split())) 
    result = can_build_pyramid(cube_sides) 
    results.append(result) 
 
# Вывод результатов 
for res in results: 
    print(res) 

 def solve_pyramids(n, rounds): 
    from functools import lru_cache 
 
    results = [] 
 
    for cubes in rounds: 
        cubes = list(map(int, cubes.split())) 
        length = len(cubes) 
 
        @lru_cache(maxsize=None) 
        def backtrack(left, right, last): 
            if left > right: 
                return [] 
            options = [] 
            # Выбор с начала 
            if cubes[left] <= last: 
                res = backtrack(left + 1, right, cubes[left]) 
                if res is not None: 
                    return [cubes[left]] + res 
            # Выбор с конца 
            if cubes[right] <= last: 
                res = backtrack(left, right - 1, cubes[right]) 
                if res is not None: 
                    return [cubes[right]] + res 
            return None 
 
        # Начинаем с бесконечного значения, чтобы первый кубик мог быть любым 
        pyramid = backtrack(0, length - 1, float('inf')) 
        if pyramid: 
            results.append(' '.join(map(str, pyramid))) 
        else: 
            results.append("НЕТ") 
 
    return results 
 
# Чтение входных данных 
if __name__ == "__main__": 
    n = int(input()) 
    rounds = [input().strip() for _ in range(n)] 
    results = solve_pyramids(n, rounds) 
    for res in results: 
        print(res)