# Amazon Interview Experience

Round: I
An Array arr={7, 7, 8, 8, 9, 1, 1, 4, 2, 2} has numbers appearing twice or once. Duplicates appear side by side everytime. Might be few numbers can be occur one time and just assume this is a right rotating array (just say an array can rotate k times towards right). Aim is to identify numbers that occured once in array.

 `#include ` ` `  `int` `main() ` `{ ` `    ``int` `a[] = { 7, 7, 8, 8, 9, 1, 1, 4, 2, 2 }, i = 1, m = 10; ` `    ``// int a[]={7, 8, 8, 9, 1, 1, 4, 2, 2, 7}, i=1, m=10; ` ` `  `    ``if` `(a[0] == a[m - 1]) { ` `        ``i = 2; ` `        ``m = m - 1; ` `    ``} ` `    ``else` `        ``printf``(``"%d\n"``, a[m - 1]); ``// For cases like { 7, 7, 8, 8, 9, 1, 1, 4, 2, 3 }, a[] = { 7, 7, 8, 8, 9, 1, 1, 4, 4, 2 } ` `    ``for` `(; i < m; i++) ` `        ``if` `(a[i] == a[i - 1]) ` `            ``i++; ` `        ``else` `            ``printf``(``"%d\n"``, a[i - 1]); ` ` `  `    ``return` `0; ` `} `

Input:
7, 7, 8, 8, 9, 1, 1, 4, 2, 2
Output:
9
4

Round II:
In second round a question asked was asked regarding BST. Sum of key elements in individual path of BST (just say this sum as path_ weight) and threshold path weight is given as input. If any of the pathweight is less than oversold path weight then that should be deleted from the tree.

Example :
Input:
Consider the below tree as input and threshold path weight is 110.

Output:
Below are the no of paths the input tree can make
path 1 : 50 -> 30 -> 20, Sum = 100
path 1 : 50 -> 30 -> 40, Sum = 120
path 1 : 50 -> 70 -> 60, Sum = 180
path 1 : 50 -> 70 -> 80, Sum = 200

In the current scenario path is less than the threshold path weight (100 < 110), So we have to destroy the path 1.
Tree after destroying the path 1.

 `#include ` `#include ` ` `  `struct` `node { ` `    ``int` `key; ` `    ``struct` `node *left, *right; ` `}; ` ` `  `struct` `node* newnode(``int` `element) ` `{ ` `    ``struct` `node* temp = (``struct` `node*)``malloc``(``sizeof``(``struct` `node)); ` `    ``temp->key = element; ` `    ``temp->left = temp->right = NULL; ` `    ``return` `temp; ` `} ` ` `  `struct` `node* insert(``struct` `node* root, ``int` `element) ` `{ ` `    ``if` `(root == NULL) ` `        ``return` `newnode(element); ` ` `  `    ``if` `(element < root->key) ` `        ``root->left = insert(root->left, element); ` `    ``else` `if` `(element > root->key) ` `        ``root->right = insert(root->right, element); ` ` `  `    ``return` `root; ` `} ` ` `  `void` `inorder(``struct` `node* mynode) ` `{ ` `    ``if` `(mynode != NULL) { ` `        ``inorder(mynode->left); ` `        ``printf``(``"%d\t"``, mynode->key); ` `        ``inorder(mynode->right); ` `    ``} ` `} ` ` `  `struct` `node* minValueNode(``struct` `node* node) ` `{ ` `    ``struct` `node* current = node; ` ` `  `    ``/* loop down to find the leftmost leaf */` `    ``while` `(current->left != NULL) ` `        ``current = current->left; ` ` `  `    ``return` `current; ` `} ` ` `  `struct` `node* deleteNode(``struct` `node* root, ``int` `key) ` `{ ` `    ``// base case ` `    ``if` `(root == NULL) ` `        ``return` `root; ` ` `  `    ``// If the key to be deleted is smaller than the root's key, ` `    ``// then it lies in left subtree ` `    ``if` `(key < root->key) ` `        ``root->left = deleteNode(root->left, key); ` ` `  `    ``// If the key to be deleted is greater than the root's key, ` `    ``// then it lies in right subtree ` `    ``else` `if` `(key > root->key) ` `        ``root->right = deleteNode(root->right, key); ` ` `  `    ``// if key is same as root's key, then This is the node ` `    ``// to be deleted ` `    ``else` `{ ` ` `  `        ``// node with only one child or no child ` `        ``if` `(root->left == NULL) { ` `            ``struct` `node* temp = root->right; ` `            ``free``(root); ` `            ``return` `temp; ` `        ``} ` `        ``else` `if` `(root->right == NULL) { ` `            ``struct` `node* temp = root->left; ` `            ``free``(root); ` `            ``return` `temp; ` `        ``} ` ` `  `        ``// node with two children: Get the inorder successor (smallest ` `        ``// in the right subtree) ` `        ``struct` `node* temp = minValueNode(root->right); ` ` `  `        ``// Copy the inorder successor's content to this node ` `        ``root->key = temp->key; ` ` `  `        ``// Delete the inorder successor ` `        ``root->right = deleteNode(root->right, temp->key); ` `    ``} ` `    ``return` `root; ` `} ` ` `  `/** Function : checkpathCost(int pathweight, int thresoldPathWeight,  ` `                         ``struct node *currentNode, struct node *root) ` `    ``This function will sum the all individual elements in a every  ` `    ``path and lets say it as pathweight and if the sum less than  ` `    ``key then the path will be deleted. ` `     `  `    ``Arguments:  ` `    ``pathweight         : Sum of all elements in a path. As we are ` `                         ``traversing in recursive mode we the sum of  ` `                         ``previews elements. ` `    ``thresoldPathWeight : Threshold value to compare the path weight ` `    ``currentNode        : CUrrent node in the tree. ` `    ``root               : root of the tree, used while deleting the node.   ` ` `  `    ``Output : will delete paths which not satisfy the condition  ` `             ``(pathweightkey; ` ` `  `    ``// Check the conditionh if current node is a leaf node. ` `    ``if` `((currentNode->left == NULL) && (currentNode->right == NULL)) { ` ` `  `        ``// If pathweight is less that thresoldPathWeight delete the path ` `        ``if` `(pathweight < thresoldPathWeight) { ` ` `  `            ``// we need to delete the node, so there is no necessity ` `            ``// in maintaining the current->key in pathweight. ` `            ``pathweight = pathweight - currentNode->key; ` `            ``printf``(``"need to Delete %d.\n"``, currentNode->key); ` `            ``deleteNode(root, currentNode->key); ` `            ``checkpathCost(0, thresoldPathWeight, root, root); ` `        ``} ` `        ``else` ` `  `            ``// If currentNode->key satisfies the condition ` `            ``// (pathweight > thresoldPathWeight), need to backtrack ` `            ``// back to check with other paths and no necessity in ` `            ``// maintaining the current->key in pathweight. ` `            ``pathweight = pathweight - currentNode->key; ` `    ``} ` ` `  `    ``// If currentNode is not a leaf traverse all the ` `    ``// possible paths. ` `    ``if` `(currentNode->left != NULL) { ` `        ``checkpathCost(pathweight, thresoldPathWeight, ` `                      ``currentNode->left, root); ` `    ``} ` `    ``if` `(currentNode->right != NULL) { ` `        ``checkpathCost(pathweight, thresoldPathWeight, ` `                      ``currentNode->right, root); ` `    ``} ` `} ` ` `  `int` `main() ` `{ ` ` `  `    ``int` `thresoldPathWeight = 110; ` ` `  `    ``/* Let us create following BST ` `              ``50 ` `           ``/     \ ` `          ``30      70 ` `         ``/  \    /  \ ` `       ``20   40  60   80 */` ` `  `    ``struct` `node* root = NULL; ` `    ``root = insert(root, 50); ` `    ``root = insert(root, 30); ` `    ``root = insert(root, 20); ` `    ``root = insert(root, 40); ` `    ``root = insert(root, 70); ` `    ``root = insert(root, 60); ` `    ``root = insert(root, 80); ` ` `  `    ``printf``(``"Inorder traversal of the given tree \n"``); ` `    ``inorder(root); ` `    ``printf``(``"\n"``); ` ` `  `    ``checkpathCost(0, thresoldPathWeight, root, root); ` ` `  `    ``printf``(``"Inorder traversal of the given tree \n"``); ` `    ``inorder(root); ` `    ``printf``(``"\n"``); ` ` `  `    ``return` `0; ` `} `

In addition to the existing code for BST in geeksforgeeks and below function will implement the above task.
https://www.geeksforgeeks.org/binary-search-tree-set-2-delete/

Write your Interview Experience or mail it to contribute@geeksforgeeks.org

Join Free Interview Preparation Course

My Personal Notes arrow_drop_up