human
I found an interesting problem on https://www.codewars.com/kata/5aa859ad4a6b3408920002be:
# The Kata
Your task is to transform an input nested list into an hypercube list, which is a special kind of nested list where each level must have the very same size,
This Kata is an exercise on recursion and algorithms. You will need to visualize many aspects of this question to be able to solve it efficiently, as such there is a section on definitions of the terms that will be used in the Kata, make sure to fully understand them before attempting. A naive brute-force-ish answer will most likely fail the tests. There will be tests on  nested lists of dimension and size up to 10. Good luck.

# Definitions
### Nested List
A nested list is a list that may contain either non-list items or more nested lists as items in the list. Here are a few examples of nested lists.

    [[2, 3], 4, 5, 6, [2, [2, 3, 4, 5], 2, 1, 2], [[[[1]]]], []]
    [[[]]]
    [1, 2]
    [[], []]
    [4, 5, 6, 7, [], 2]
    []

- A *basic element* refers to any non-list element of a nested list.

- A nested list's *dimension* is defined as the deepest the list goes.  

- A nested list's *size* is defined as the longest the list or any of its sublists go.  

For example, the *dimension* and *size* of the above nested lists is as follows.

    [[2, 3], 4, 5, 6, [2, [2, 3, 4, 5], 2, 1, 2], [[[[1]]]], []]  # dimension: 5, size: 7
    [[[]]]                                                        # dimension: 3, size: 1
    [1, 2]                                                        # dimension: 1, size: 2
    [[], []]                                                      # dimension: 2, size: 2
    [4, 5, 6, 7, [], 2]                                           # dimension: 2, size: 6
    []                                                            # dimension: 1, size: 0

### Hypercube List
- A `1`-dimensional **hypercube list** of size `n` is a nested list of dimension `1` and size `n`.  

- A `d`-dimensional hypercube list of size `n` is a nested list of dimension `d` and size `n` such that the nested list has `n` elements each of which...

I tried it in Python, but could not do it. Can you solve it?

Can you provide a the Python program you requested?
assistant
#Here is the Python program you requested.

from itertools import zip_longest

def normalize(lst: List, growing: int = 0) -> List:
    """Convert the given nested list to hypercube format with the given <growing_value> and return it.
    """
    
    def seeker(lst, d = 1):
        yield len(lst), d
        for elt in lst:
            if isinstance(elt, list):
                yield from seeker(elt, d + 1)
                
    def grower(lst, d = 1):
        return [ grower(o if isinstance(o, list) else [o] * size, d + 1)
                   if d != depth else o
                 for o, _ in zip_longest(lst, list(range(size)), fillvalue=growing) ]
    
    size, depth = list(map(max, list(zip(*seeker(lst)))))
    return grower(lst)