80+ Gauranga Papers Interview Questions and Answers

Find the minimum time to travel from a starting point to a destination point using direct movement and wormholes.

• Calculate the time taken for direct movement from source to destination.

• Consider using each wormhole to see if it reduces the total travel time.

• Choose the path with the minimum total time to reach the destination.

Find the minimum number of arrows needed to burst all balloons by shooting arrows from left to right.

• Sort the array in non-decreasing order to make it easier to calculate the minimum number of arrows needed.

• Iterate through the sorted array and count the number of times the height decreases compared to the previous balloon.

• The count of decreases + 1 will give the minimum number of arrows needed to burst all balloons.

• Example: For input N = 5, ARR = [2, 3, 4, 5, 1], the minimum ...read more

Calculate the total amount of rainwater that can be trapped between given elevations in an array.

• Iterate through the array and calculate the maximum height on the left and right of each bar.

• Calculate the amount of water that can be trapped above each bar by taking the minimum of the maximum heights on the left and right.

• Sum up the trapped water above each bar to get the total trapped water for the entire array.

Find the shortest path in a binary matrix from a source cell to a destination cell consisting only of 1s.

• Use Breadth First Search (BFS) algorithm to find the shortest path.

• Initialize a queue with the source cell and keep track of visited cells.

• Explore all 4 directions from each cell and update the path length accordingly.

• Return the shortest path length or -1 if no valid path exists.

Find the maximum amount of gold a miner can collect from a gold mine by moving right, up diagonally, or down diagonally.

• Use dynamic programming to keep track of the maximum gold collected at each cell.

• At each cell, consider the maximum gold collected from the cell above, below, and to the left.

• Add the current cell's gold value to the maximum gold collected from the adjacent cells to determine the maximum gold at the current cell.

• Repeat this process for each cell in the matrix...read more

Given an array of first N positive integers with one number repeating and one missing, find the repeating and missing numbers.

• Iterate through the array and keep track of the sum of elements and sum of squares to find the missing and repeating numbers.

• Use a set to identify the repeating number and calculate the missing number based on the sum of elements.

• Example: For nums = [1, 2, 3, 4, 4, 5], the repeating number is 4 and the missing number is 6.

Convert a binary tree to a sum tree by replacing each node with the sum of its left and right subtrees.

• Traverse the tree in postorder fashion.

• For each node, calculate the sum of its left and right subtrees and update the node value.

• Set leaf nodes to zero.

• Return the level order traversal of the modified tree.

Remove a specified element from a doubly linked list and return the modified list.

• Traverse the doubly linked list to find the specified element to be removed.

• Update the pointers of the previous and next nodes to skip the node to be deleted.

• Handle edge cases like removing the head or tail of the linked list.

• Return the modified linked list after removing the specified element.

The task is to determine the maximum amount of gold a miner can collect by moving in allowed directions in a gold mine represented as a 2D matrix.

• Create a 2D DP array to store the maximum gold collected at each cell

• Iterate through the matrix from left to right and update the DP array based on the allowed directions

• Return the maximum value in the last column of the DP array as the final result

The Rod Cutting Problem involves maximizing the profit obtained by cutting a rod into smaller pieces and selling them.

• Use dynamic programming to solve this problem efficiently.

• Create a table to store the maximum profit for each sub-length of the rod.

• Iterate through the rod lengths and update the table with the maximum profit.

• The final answer will be the maximum profit for the total length of the rod.

Determine the minimum number of operations needed to transform one string into another by moving characters to the end.

• Iterate through each character in str1 and check if it matches the first character in str2.

• If a match is found, calculate the number of operations needed to move the characters to the end.

• Return the minimum number of operations needed for each test case, or -1 if transformation is not possible.

Find the diameter of a binary tree, which is the longest path between any two end nodes.

• Traverse the tree to find the longest path between two nodes.

• Use recursion to calculate the diameter of the tree.

• Keep track of the maximum diameter found during traversal.

• Example: For input 1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1, the diameter is 6.

Count the total number of unique pairs in an array whose elements sum up to a given value.

• Use a hashmap to store the frequency of each element in the array.

• Iterate through the array and for each element, check if (Sum - current element) exists in the hashmap.

• Increment the count of pairs if the complement exists in the hashmap.

• Divide the count by 2 to avoid counting duplicates like (arr[i], arr[j]) and (arr[j], arr[i]) separately.

Count the number of subarrays in an array whose XOR is equal to a given value.

• Iterate through the array and keep track of XOR values and their frequencies using a hashmap.

• For each element, calculate the XOR value with all previous elements and check if the XOR value equals the given X.

• Use the hashmap to count the number of subarrays with XOR equal to X.

• Time complexity can be optimized to O(N) using a hashmap to store XOR values and their frequencies.

Count the number of leaf nodes in a binary tree.

• Traverse the binary tree and count nodes with both children as NULL.

• Use recursion to traverse the tree efficiently.

• Handle base cases where the node is NULL or a leaf node.

• Keep track of the count of leaf nodes as you traverse the tree.

Reverse a singly linked list of integers and return the head of the reversed linked list.

• Iterate through the linked list and reverse the pointers to point to the previous node.

• Use three pointers - prev, current, and next to reverse the linked list in O(N) time and O(1) space complexity.

• Update the head of the reversed linked list as the last node encountered during reversal.

Rotate a square matrix by 90 degrees in an anti-clockwise direction using constant extra space.

• Iterate through each layer of the matrix and swap elements in groups of 4

• Transpose the matrix and then reverse each row to achieve the rotation

• Ensure to handle edge cases like odd-sized matrices

The problem involves determining if it is possible to reach a destination point from a source point using specified moves.

• Iterate through each test case and check if the destination point can be reached from the source point using the given moves.

• Keep track of the current position and try all possible moves to reach the destination point.

• Return true if the destination point is reachable, otherwise return false.

The task is to find all distinct triplets in an array that sum up to a specified number.

• Iterate through the array and use nested loops to find all possible triplets.

• Use a set to store unique triplets and check if the sum equals the target sum.

• Handle edge cases like duplicate elements and no valid triplets.

• Return the triplets found or '-1' if no valid triplet exists.

Check if a given integer is a power of two or not.

• Check if the given integer is greater than 0.

• Use bitwise operations to determine if the integer is a power of two.

• Return true if the integer is a power of two, otherwise return false.

Merge K sorted arrays into a single sorted array.

• Iterate through all arrays and merge them into a single array.

• Use a priority queue to efficiently merge the arrays.

• Ensure the final array is sorted in ascending order.

Implement a stack using two queues to store integer values with specified operations.

• Create a stack class with two queue data members.

• Implement push(data) by enqueuing the data into one of the queues.

• Implement pop() by dequeuing all elements from one queue to another until the last element is reached and return it.

• Implement top() by dequeuing all elements from one queue to another until the last element is reached, return it, and then enqueue it back.

• Implement size() by retur...read more

Implement a function to return the spiral order traversal of a binary tree.

• Traverse the binary tree level by level, alternating between left to right and right to left.

• Use a queue to keep track of nodes at each level.

• Append nodes to the result list in the order they are visited.

• Handle null nodes appropriately to maintain the spiral order.

• Example: For input 1 2 3 -1 -1 4 5, the output should be 1 3 2 4 5.

Yes, the quick sort algorithm can be enhanced to achieve NlogN complexity in the worst case by using a randomized version of the algorithm.

• Randomized quick sort involves randomly selecting the pivot element to reduce the chances of worst-case scenarios.

• By choosing a random pivot, the algorithm becomes less predictable and more likely to achieve the desired time complexity.

• This enhancement helps in avoiding the worst-case scenarios where the pivot selection leads to unbalanced...read more

Given a number represented as a string, find the smallest number greater than the original with the same set of digits.

• Sort the digits in non-increasing order to find the next greater number.

• Swap the last two digits to get the smallest greater number.

• If no greater number exists, return -1.

Implement a Trie data structure to insert, search, and check for prefixes in strings.

• Create a TrieNode class with children and isEndOfWord attributes.

• Implement insert, search, and startsWith methods in the Trie class.

• Use a Trie to efficiently store and search for strings based on prefixes.

• Example: insert 'apple', search 'apple' returns true, startsWith 'app' returns true, search 'app' returns false.

Find all distinct triplets in an array that add up to a given number.

• Use three nested loops to iterate through all possible triplets.

• Sort the array first to easily skip duplicates.

• Use two-pointer technique to find the remaining element for each triplet.

• Handle edge cases like empty list or no triplet summing up to K.

Detect if a singly linked list forms a cycle by checking if a node's next pointer points back to a previous node.

• Use Floyd's Cycle Detection Algorithm to determine if there is a cycle in the linked list.

• Maintain two pointers, one moving at twice the speed of the other, if they meet at any point, there is a cycle.

• Check if the next pointer of any node points to a previously visited node to detect a cycle.

Find the city from which all other cities can be reached in a network of cities connected by paths.

• Identify the city 'X' from which all other cities can be reached either directly or indirectly.

• Use depth-first search (DFS) to traverse the graph and find the mother vertex.

• If multiple options for city 'X' exist, select the city with the smallest number.

• If no such city exists, return -1.

Implement a Stack data structure using two Queues for integer data.

• Use two Queues to simulate the Stack behavior.

• Push elements by enqueueing them in one Queue.

• Pop elements by dequeueing all elements from the first Queue to the second Queue, except the last one.

• Top element can be retrieved by dequeuing all elements from the first Queue to the second Queue and then dequeuing the last element.

• Size can be obtained by returning the size of the first Queue.

• Check for isEmpty by chec...read more

Find the minimum time required to rot all fresh oranges in a grid.

• Use Breadth First Search (BFS) to simulate the rotting process of oranges.

• Keep track of the time taken to rot all oranges and the count of fresh oranges remaining.

• If all fresh oranges are not rotten after simulation, return -1.

• Handle edge cases like empty grid or no fresh oranges present.

• Example: For the given grid, the minimum time required is 4 seconds.

Detect and remove loop in a singly linked list in place with O(n) time complexity and O(1) space complexity.

• Use Floyd's Cycle Detection Algorithm to identify the loop in the linked list.

• Once the loop is detected, use two pointers approach to find the start of the loop.

• Adjust the pointers to remove the loop and return the modified linked list.

• Example: For input 5 2 and 1 2 3 4 5, return 1 2 3 4 5 without the loop.

Given a 2-D plane with stones at integer coordinate points, find the maximum number of stones that can be removed by sharing the same row or column.

• Iterate through the stones and create a graph where stones in the same row or column are connected.

• Use depth-first search (DFS) to find connected components in the graph.

• The maximum number of stones that can be removed is the total number of stones minus the number of connected components.

Generate all possible sequences of balanced parentheses using N pairs of parentheses.

• Use backtracking to generate all possible combinations of balanced parentheses.

• Keep track of the number of opening and closing parentheses used.

• Add opening parentheses if there are remaining, and add closing parentheses only if there are more opening parentheses than closing.

• Recursively generate all valid combinations.

• Return the list of valid combinations for each test case.

The task is to find the number of substrings in 'S' that differ from some substrings of 'T' by exactly one character.

• Iterate through all substrings of 'S' and 'T' and compare them character by character to find the ones that differ by exactly one character.

• Use nested loops to generate all possible substrings of 'S' and 'T'.

• Count the number of substrings that differ by exactly one character and return the total count.

Detect cycles in an undirected graph.

• Use Depth First Search (DFS) to detect cycles in the graph.

• Maintain a visited array to keep track of visited vertices.

• If a visited vertex is encountered again during DFS, a cycle exists.

• Check for cycles in each connected component of the graph.

• Example: For input N=3, Edges=[[1, 2], [2, 3], [1, 3]], output is Yes.

The problem involves determining if a given graph can be colored with at most 'M' colors without adjacent vertices sharing the same color.

• Create a function that takes the adjacency matrix, number of nodes 'N', and maximum number of colors 'M' as input.

• Implement a graph coloring algorithm such as backtracking or greedy coloring to check if the graph can be colored with at most 'M' colors.

• Check if adjacent vertices have the same color while coloring the graph.

• Return 'Yes' if th...read more

Check if given words can be rearranged to form a circle where the last character of one word matches the first character of the next.

• Create a graph where each word is a node and there is an edge between two nodes if the last character of one word matches the first character of the next.

• Check if the graph is strongly connected, meaning there is a path between every pair of nodes.

• If the graph is strongly connected, return true; otherwise, return false.

Given a string, find the longest palindromic substring within it.

• Iterate through the string and expand around each character to find palindromes

• Keep track of the longest palindrome found so far

• Return the longest palindromic substring

Check if two binary trees are mirror images of each other.

• Compare the left subtree of the first tree with the right subtree of the second tree.

• Compare the right subtree of the first tree with the left subtree of the second tree.

• Check if the roots of both trees are the same.

Find all possible paths for a rat in a maze from source to destination.

• Use backtracking to explore all possible paths in the maze.

• Keep track of visited cells to avoid revisiting them.

• Explore all possible directions ('U', 'D', 'L', 'R') from each cell.

• Return the list of valid paths sorted in alphabetical order.

Implement a Stack using Queues to store integer data with push, pop, top, size, and isEmpty functions.

• Use two queues to simulate a stack, with one queue acting as the main stack and the other for temporary storage.

• For push operation, enqueue the new element to the temporary queue, then dequeue all elements from the main queue to the temporary queue, and finally swap the queues.

• For pop operation, dequeue the top element from the main queue.

• For top operation, return the front e...read more

Calculate the total amount of rainwater that can be trapped between given elevations in an array.

• Use two-pointer approach to keep track of left and right boundaries.

• Calculate the trapped water by finding the minimum of maximum heights on left and right sides for each bar.

• Sum up the trapped water for all bars to get the total amount of rainwater trapped.

Count the number of diagonal paths in a binary tree where all nodes on the diagonal have equal values.

• Traverse the binary tree in a diagonal manner and keep track of nodes with equal values.

• Use recursion to explore all possible diagonal paths in the tree.

• Count the number of paths where all nodes on the diagonal have the same value.

The Longest Increasing Subsequence (LIS) problem is to find the length of the longest subsequence of a given sequence with increasing order.

• Use dynamic programming to solve the LIS problem efficiently.

• Maintain an array to store the length of the LIS ending at each element.

• Iterate through the array and update the LIS length based on previous elements.

• Example: For input [10, 22, 9, 33, 21, 50, 41, 60, 80], the LIS is [10, 22, 33, 50, 60, 80] with length 6.

Spiral order traversal of a binary tree involves printing nodes level by level alternating between left to right and right to left.

• Start by pushing the root node into a queue.

• While the queue is not empty, pop a node, print its value, and push its children into the queue.

• For each level, alternate between printing nodes from left to right and right to left.

• Repeat until all nodes are printed in spiral order.

Use one wire to measure 30 minutes, then ignite the other wire at one end to measure the remaining 15 minutes.

• Ignite one wire at both ends and the other wire at one end simultaneously

• After 30 minutes, the first wire will burn out completely

• At this point, ignite the other end of the second wire

• The second wire will burn for another 15 minutes before burning out completely

Structure and union are both used to group different data types, but structure allocates memory for each member separately while union shares the same memory space for all members.

• Structure allocates memory for each member separately, while union shares the same memory space for all members.

• Structures are used when each member needs its own memory space and unions are used when only one member is accessed at a time.

• Structures are typically larger in size compared to unions be...read more

Structure and union are both used to group different data types, but structure allocates memory for each member separately while union shares the same memory location for all members.

• Structure allocates memory for each member separately, while union shares the same memory location for all members.

• Structures are used when each member needs its own memory space, while unions are used when only one member is accessed at a time.

• Structures are typically larger in size compared to ...read more

Virtual memory is still needed even with large physical memory. Paging helps manage memory efficiently.

• Virtual memory allows for larger programs to run than physical memory can handle

• Paging helps manage memory efficiently by swapping out unused pages to disk

• Virtual memory also allows for memory protection and sharing between processes

• Examples of programs that require virtual memory include video editing software and large databases

Count the number of '-' characters in a string and return 1 if it matches the given number, else return 0.

• Use a loop to iterate through each character in the string and count the number of '-' characters.

• Compare the count with the given number and return 1 if they match, else return 0.

• Handle edge cases such as empty string or negative number input.

Multitasking refers to the ability of an operating system to run multiple tasks concurrently, while multithreading involves executing multiple threads within a single process.

• Multitasking allows multiple processes to run simultaneously on a single processor, switching between them quickly.

• Multithreading enables a single process to execute multiple threads concurrently, sharing resources like memory and CPU.

• Multitasking improves system efficiency by utilizing idle CPU time, wh...read more

Mutex and Semaphore are synchronization primitives used in multi-threaded environments.

• Mutex is used to provide mutual exclusion to a shared resource, allowing only one thread to access it at a time.

• Semaphore is used to control access to a shared resource, allowing multiple threads to access it at a time.

• Mutex is binary, meaning it has only two states - locked and unlocked, while Semaphore can have multiple states.

• Mutex is typically faster and simpler to use than Semaphore.

• We...read more

Early binding is resolved at compile time while late binding is resolved at runtime in C++.

• Early binding is also known as static binding, where the function call is resolved at compile time based on the type of the object.

• Late binding is also known as dynamic binding, where the function call is resolved at runtime based on the actual type of the object.

• Early binding is faster as the function call is directly linked to the function address during compilation.

• Late binding allow...read more

Diamond Problem is a multiple inheritance issue in C++ where a class inherits from two classes that have a common base class.

• Diamond Problem occurs when a class inherits from two classes that have a common base class, leading to ambiguity in accessing members.

• It can be resolved in C++ using virtual inheritance, where the common base class is inherited virtually to avoid duplicate copies of base class members.

• Example: class A is inherited by classes B and C, and class D inheri...read more

DFS is a graph traversal algorithm that explores as far as possible along each branch before backtracking.

• Start at a node and explore as far as possible along each branch before backtracking

• Use a stack to keep track of nodes to visit

• Mark visited nodes to avoid revisiting them

• Recursive implementation is common

Mutex is used for exclusive access to a resource by only one thread at a time, while semaphore can allow multiple threads to access a resource simultaneously.

• Mutex is binary semaphore with ownership, used for mutual exclusion.

• Mutex is typically used to protect critical sections of code.

• Semaphore is a signaling mechanism, used for synchronization between multiple threads.

• Semaphore can have a count greater than 1, allowing multiple threads to access a resource.

• Example: Mutex is...read more

It depends on the specific use case and input size.

• For small input sizes, simple algorithms like insertion sort or selection sort may be sufficient.

• For larger input sizes, more complex algorithms like merge sort or quicksort may be more efficient.

• For nearly sorted input, insertion sort may be the fastest.

• For input with many duplicates, counting sort or radix sort may be the best choice.

• For input with a known range, bucket sort may be the most efficient.

• Overall, there is no on...read more

Virtual addressing is a memory management technique that allows a process to use a range of memory addresses independent of physical memory.

• Virtual addresses are mapped to physical addresses by the memory management unit (MMU)

• Virtual addresses are allocated to a process during its execution

• Virtual addressing allows for efficient use of physical memory by allowing multiple processes to share the same physical memory

• Examples of virtual addressing include paging and segmentation

Yes, constant and volatile can be used together.

• Constant variables are read-only and cannot be modified.

• Volatile variables are used to indicate that the value may change unexpectedly.

• Using both together can be useful in multi-threaded environments.

• For example, a constant pointer to a volatile variable can be used to ensure thread safety.

Program to find the only duplicate in an array

• Create a hash set to store elements as they are encountered

• If an element is already in the hash set, it is a duplicate

• Return the duplicate element

Functions to create and delete nodes in a stack

• To create a stack, initialize a top pointer to null

• To push a node, create a new node and set its next to the current top, then set top to the new node

• To pop a node, set top to its next and return the popped node

• To delete the stack, pop all nodes until top is null

JAVA is a versatile programming language used for developing various software applications.

• JAVA is platform-independent and can run on any operating system

• It is object-oriented and supports multithreading

• JAVA is widely used for developing web applications, mobile applications, and enterprise software

• It provides a vast library of pre-built classes and APIs for developers to use

• JAVA is also used for developing games, scientific applications, and financial applications

To find the middle of a linked list, use two pointers - one moving at twice the speed of the other.

• Initialize two pointers - slow and fast

• Move the slow pointer one step at a time and the fast pointer two steps at a time

• When the fast pointer reaches the end of the list, the slow pointer will be at the middle

C++ supports polymorphism through virtual functions and inheritance.

• C++ supports polymorphism through virtual functions and inheritance

• Virtual functions allow a function to be overridden in a derived class

• Base class pointers can point to derived class objects, allowing for dynamic binding

• Example: class Animal { virtual void speak() { cout << 'Animal speaks'; } }; class Dog : public Animal { void speak() { cout << 'Dog barks'; } };

• Example: Animal* a = new Dog(); a->speak(); //...read more

Time complexity of building a heap using linked list and arrays

• Building a heap using linked list takes O(nlogn) time complexity

• Building a heap using arrays takes O(n) time complexity

• Linked list implementation is slower than array implementation

Deadlock is a situation where two or more processes are unable to proceed because they are waiting for each other to release resources.

• Prevent deadlock by using a proper resource allocation strategy

• Avoid holding onto resources for too long

• Use timeouts to release resources if they are not being used

• Implement a deadlock detection and recovery mechanism

• Avoid circular wait by imposing a total ordering of all resource types

OOPs properties and examples with applications

• Encapsulation: bundling of data and methods within a class. Example: Java class. Application: data hiding and security.

• Inheritance: creating a new class from an existing class. Example: subclass. Application: code reusability and extensibility.

• Polymorphism: ability of an object to take on many forms. Example: method overloading. Application: flexibility and modularity.

• Abstraction: hiding implementation details and showing only nec...read more

Friend functions in C++ are functions that are not members of a class but have access to its private and protected members.

• Friend functions are declared inside a class with the keyword 'friend'.

• They can access private and protected members of the class.

• They are not member functions of the class, but have the same access rights as member functions.

• Friend functions are useful for implementing operators that are not part of the class.

• Example: friend int add(const MyClass& obj1, ...read more

Thrashing in operating systems occurs when the system is spending more time swapping data between memory and disk than actually executing tasks.

• Occurs when the system is constantly swapping data between memory and disk

• Causes a decrease in system performance as it spends more time on swapping than executing tasks

• Usually happens when the system does not have enough physical memory to handle the workload efficiently

Yes, static variables can be defined in header files.

• Static variables defined in header files have global scope within the file.

• They can be accessed by any function within the file.

• However, if the header file is included in multiple source files, each file will have its own copy of the static variable.

• This can lead to unexpected behavior if the variable is modified in one file and then accessed in another.

• It is generally recommended to define static variables in source files ...read more

Code for producer-consumer problem using mutex

• Create a shared buffer with a fixed size

• Create a mutex to control access to the buffer

• Create a semaphore to keep track of the number of items in the buffer

• Create a producer thread that adds items to the buffer

• Create a consumer thread that removes items from the buffer

• Use mutex to lock the buffer while adding or removing items

• Use semaphore to signal when the buffer is full or empty

Bi-directional linked list allows traversal in both directions, making it useful for certain algorithms.

• Each node in the list has a reference to both the previous and next nodes.

• Insertion and deletion operations are more complex than in a singly linked list.

• Examples of use include implementing a browser's back and forward buttons or a text editor's undo and redo functionality.

Android is a mobile operating system developed by Google, based on the Linux kernel and designed primarily for touchscreen devices.

• Developed by Google

• Based on Linux kernel

• Designed for touchscreen devices

Check if a string is palindrome or not

• Reverse the string and compare with original

• Compare first and last characters and move towards center

• Use recursion to check if first and last characters are equal

Permutations of an array

• Permutations are all possible arrangements of elements in an array

• Number of permutations for an array of length n is n!

• Use recursion to generate all permutations

• Swap elements to generate different permutations

Double pointers are used to store the address of a pointer variable.

• Double pointers are useful in dynamic memory allocation.

• They are used to modify the value of a pointer passed to a function.

• They can be used to create linked lists and trees.

• Example: int **ptr; //declares a double pointer to an integer

DFS and BFS are two popular graph traversal algorithms used in computer science.

• DFS stands for Depth First Search and explores as far as possible along each branch before backtracking.

• BFS stands for Breadth First Search and explores all the vertices at the present depth before moving on to the next level.

• DFS uses a stack data structure to keep track of visited nodes while BFS uses a queue.

• DFS is useful for finding paths between two nodes while BFS is useful for finding the sh...read more

Calculate the sum of elements in an array that are closest to a given target value.

• Iterate through the array and calculate the absolute difference between each element and the target value.

• Keep track of the element with the smallest difference and update the sum accordingly.

• Return the sum of elements closest to the target value.

Insert a node in a N-array tree

• Traverse the tree to find the parent node where the new node will be inserted

• Add the new node as a child of the parent node

• Update the parent node's child array to include the new node