5 задач с собеседований Amazon для Python-разработчиков

			'''
    Time Complexity  = O(N)
    Space Complexity = O(N)

    Where N is the length of the string.
'''

def reverseString(str: str) -> str:
    
    # if the string is " " then return "".
    if(str == "" or str == " "):
        return ""
    ans = ''

    start = len(str) - 1

    while(start >= 0):
        
        # Skip multiple spaces.
        if(str[start] == ' '):
            start-=1
        else:
            
            # Add space between words.
            if(len(ans) > 0):
                ans += (' ')

            j = start

            while(j >= 0 and str[j] != ' '):
                j-=1

            # add current word to ans.
            ans +=  (str[j+1: j+1+start-j])
            start = j

    return ans
		

			'''
    Time Complexity : O(1)
    Space Complexity : O(1)
'''

def evenSumTillN(n):

    # Calculate the sum.
    sum = (n // 2) * (n // 2 + 1)

    return sum
		

			from sys import stdin

class Node:
    def __init__(self,data):
        
        self.data = data
        self.next = None

def isPalindrome(head):
    
    # It stores the Linked List node value.
    st = []
    
    # Creating temporary Node.
    temp = head
        
    while temp is not None:
        
        # Add the current node value to stack.
        st.append(temp.data)
        
        # Move current pointer to next node.
        temp = temp.next
        
    while head is not None:
        
        # Get the top most element of stack.
        top = st.pop()
        
        if top != head.data:
            
            return False
        
        head = head.next
        
    return True

def takeinput():
    
    inputlist=[int(ele) for ele in input().split()]
    
    head=None
    tail=None
    
    for currentData in inputlist:
        
        if currentData == -1:
            break
        
        Newnode=Node(currentData)
        
        if head is None:
            head=Newnode
            tail=Newnode
        else:
            tail.next=Newnode
            tail=Newnode
            
    return head

#Main
t = int(stdin.readline().rstrip())

while t > 0:
    
    head = takeinput()
    
    if isPalindrome(head):
        print('true')
    else:
        print('false')
        
   
    t -= 1
		

			def replaceSpaces(str):
	# String to store result.
	res = ""
	
	# Variable to store length of string.
	leng = len(str)

	#  Iterate the length of the string.
	for i in range(leng):
		# Add "@40" in place of space.
		if(str[i] == ' '):
			res += "@40"
		# Add character to result.
		else:
			res += str[i]
		
	# Return result.
	return res
		

			from sys import stdin, setrecursionlimit
from queue import Queue
setrecursionlimit(10**7)

#   Binary tree node class for reference
class BinaryTreeNode:
    def __init__(self, data):
        self.val = data
        self.left = None
        self.right = None

def getLevelOrder(root):

    output = []

    #   If given tree is empty
    if (root == None):
        return output

    #   To traverse level by level
    level = Queue()

    #   Append root to the queue
    level.put(root)

    #   Iterater until queue does not become empty
    while (not level.empty()):

        #   Get the size of current level
        levelSize = level.qsize()

        #   Visit all node which are at current level and append their children if they exist
        while (levelSize != 0):

            #   Get the front node from queue
            curr = level.get()

            #   Store in output
            output.append(curr.val)

            #   Append left child into queue if it exist
            if (curr.left != None):
                level.put(curr.left)

            #   Append right child into queue if it exist
            if (curr.right != None):
                level.put(curr.right)

            levelSize = levelSize - 1

    #   Return the output
    return output

#   Take input
def takeInput():

    arr = list(map(int, stdin.readline().strip().split(" ")))

    rootData = arr[0]

    n = len(arr)

    if(rootData == -1):
        return None

    root = BinaryTreeNode(rootData)
    q = Queue()
    q.put(root)
    index = 1
    while(q.qsize() > 0):
        currentNode = q.get()

        leftChild = arr[index]

        if(leftChild != -1):
            leftNode = BinaryTreeNode(leftChild)
            currentNode.left = leftNode
            q.put(leftNode)

        index += 1
        rightChild = arr[index]

        if(rightChild != -1):
            rightNode = BinaryTreeNode(rightChild)
            currentNode .right = rightNode
            q.put(rightNode)

        index += 1

    return root

def printAns(ans):
    for x in ans:
        print(x, end=" ")
    print()

# main
T = int(stdin.readline().strip())
for i in range(T):
    root = takeInput()
    ans = getLevelOrder(root)
    printAns(ans)