10+ Tripwerkz Interview Questions and Answers

The task is to distribute candies to students based on their performance while minimizing the total candies distributed.

• Iterate through the array of student ratings to determine the minimum number of candies required.

• Assign each student at least one candy.

• Adjust the number of candies based on the ratings of adjacent students to minimize the total candies distributed.

• Example: For ratings [5, 8, 1, 5, 9, 4], the optimal distribution would be [1, 2, 1, 2, 3, 1] with a total of 1...read more

Modify a boolean matrix such that if any element is 1, set its entire row and column to 1 in-place.

• Iterate through the matrix to find elements with value 1.

• Use additional arrays to keep track of rows and columns to be modified.

• Update the matrix in-place based on the identified rows and columns.

Check if all leaf nodes in a binary tree are at the same level.

• Traverse the binary tree and keep track of the level of each leaf node.

• Compare the levels of all leaf nodes at the end to determine if they are at the same level.

• Use a queue for level order traversal of the binary tree.

Given a string of lowercase English letters, find the first non-repeating character at each point in the stream.

• Iterate through the characters in the string and maintain a count of each character.

• Use a queue to keep track of the order of characters encountered.

• For each character, check if it is the first non-repeating character by looking at its count in the map.

• If a character's count is 1, it is the first non-repeating character at that point in the stream.

• Return the first n...read more

The task is to determine the number of possible ways to decode a sequence of digits back into a string of characters from 'A' to 'Z'.

• Use dynamic programming to keep track of the number of ways to decode the sequence at each position.

• Consider different cases when decoding the sequence, such as single digit decoding and double digit decoding.

• Handle edge cases like '0' and '00' appropriately.

• Return the final count modulo 10^9 + 7 as per the constraints.

Find the maximum sum of a subsequence without choosing adjacent elements in an array.

• Use dynamic programming to keep track of the maximum sum of non-adjacent elements at each index.

• At each index, the maximum sum is either the sum of the current element and the element two positions back, or the sum at the previous index.

• Iterate through the array and update the maximum sum at each index accordingly.

• Return the maximum sum found at the last index.

Find maximum sum of i * ARR[i] possible through any number of rotations in an array.

• Calculate the sum of i * ARR[i] for each rotation and find the maximum sum.

• Consider both left and right rotations.

• Optimize the solution to avoid redundant calculations.

• Handle edge cases like empty array or single element array.

Calculate the average of node values at each level in a binary tree.

• Traverse the binary tree level by level using BFS

• Calculate the sum of node values at each level and divide by the number of nodes at that level

• Print the floor value of the average for each level

Detect cycles in a directed graph and return true if a cycle exists, false otherwise.

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

• Maintain a visited array to keep track of visited vertices and a recursion stack to keep track of vertices in the current DFS traversal.

• If a vertex is visited and is present in the recursion stack, then a cycle exists.

• Example: For the input graph with vertices 0, 1, 2 and edges 0->1, 1->2, 2->0, a cycle exists among the vertices 0 -> ...read more

The problem involves rearranging a permutation of integers to generate the lexicographically next greater permutation.

• Understand the concept of lexicographically next greater permutation.

• Implement a function to find the next greater permutation.

• Handle cases where no greater permutation exists by returning the smallest permutation.

Validate if a binary tree is a Binary Search Tree (BST) or not.

• Check if the left subtree of a node contains only nodes with data less than the node's data.

• Check if the right subtree of a node contains only nodes with data greater than the node's data.

• Recursively check if both the left and right subtrees are also binary search trees.

Calculate the minimum cost to acquire a specific number of ninja blades using a given pricing mechanism.

• Iterate through each test case to determine the minimum cost needed to acquire the desired number of blades.

• Consider the cost of adding 1 blade versus doubling the current number of blades to reach the target quantity.

• Keep track of the total cost as blades are acquired based on the pricing mechanism.

• Return the minimum cost for each test case.

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.

• Recursively try moving in all directions (up, down, left, right) until reaching the destination.

• Add the path to the result list when the destination is reached.

• Sort the result list alphabetically before returning.

Find the minimum cost to reach a destination in a matrix with specified rules.

• Use BFS traversal to explore all possible paths from the starting point to the destination.

• Keep track of the cost incurred at each cell and update it accordingly.

• Return the minimum cost to reach the destination or -1 if unreachable.

Design a Least Recently Used (LRU) cache data structure that supports get and put operations with capacity constraint.

• Use a combination of hashmap and doubly linked list to implement the LRU cache.

• Keep track of the least recently used item and update it accordingly when inserting new items.

• Ensure to handle the capacity constraint by evicting the least recently used item when the cache is full.

• Implement get(key) and put(key, value) operations as per the LRU cache design requir...read more

Find the length of the longest strictly increasing subsequence in an array of integers.

• Use dynamic programming to keep track of the longest increasing subsequence ending at each element.

• Initialize an array to store the length of the longest increasing subsequence ending at each index.

• Iterate through the array and update the length of the longest increasing subsequence for each element.

• Return the maximum value in the array as the length of the longest increasing subsequence.

Use SQL Joins to find the number of employees in each department.

• Use a JOIN statement to combine the employee and department tables based on the department ID.

• Group the results by department ID and use COUNT() function to find the number of employees in each department.

• Example: SELECT department.department_id, COUNT(employee.employee_id) AS num_employees FROM department JOIN employee ON department.department_id = employee.department_id GROUP BY department.department_id;