Untitled

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

from collections import deque
class Codec:
    def __init__(self):
        self.level_delimeter = "|"

    def serialize(self, root: Optional[TreeNode]) -> str:
        """Encodes a tree to a single string.
        """
        Q = deque()
        Q.append(root)
        all_nodes_level_wise: List[str] = []
        while len(Q) > 0:
            nodes_in_current_level: List[str] = []
            for _ in range(len(Q)): 
                node = Q.popleft()
                if node:
                    Q.append(node.left)
                    Q.append(node.right)
                    nodes_in_current_level.append(str(node.val))
                else:
                    nodes_in_current_level.append("-1") # -1 is for None

            all_nodes_level_wise.append((' '.join(nodes_in_current_level) + self.level_delimeter).strip())
        print(''.join(all_nodes_level_wise))
        return ''.join(all_nodes_level_wise)

        

    def deserialize(self, data: str) -> Optional[TreeNode]:
        """Decodes your encoded data to tree.
        """
        all_nodes: str = data.split(self.level_delimeter)[:-1]
        all_nodes_level_wise: List[List[int]] = []

        for nodes_in_current_level in all_nodes:
            temp = nodes_in_current_level.split(' ')
            for i in range(len(temp)):
                temp[i] = int(temp[i])
            all_nodes_level_wise.append(temp)

        print(all_nodes_level_wise)
        

        

# Your Codec object will be instantiated and called as such:
# Your Codec object will be instantiated and called as such:
# ser = Codec()
# deser = Codec()
# tree = ser.serialize(root)
# ans = deser.deserialize(tree)
# return ans

# 2|1 3|-1 -1 -1 -1|

# ['2', '1 3', '-1 -1 -1 -1', '']

# [a, b, c, d]

# String str = ""

# for() str + item

# ['1', '2', '3']




'''
             8.  --> 2 ^ 0
         N.        16. --> 2 ^ 1 ==> 0
            .    12.   N ---> 2 ^ 2 => 4


IDEA:
 - "8 4, 16 | 3 ,5, 12, N | N, N, N, ....."
[8 4,16], [3, 5, 12, N]
              X    
          8
      4.     16

N-1 th --> 8
N th --> 16
'''