100+ DE Shaw Interview Questions and Answers

The task is to determine the minimum number of towers needed to stack cubes in a specific order.

• Iterate through the array of cubes and maintain a stack to keep track of towers.

• For each cube, check if it can be placed on an existing tower or start a new one.

• Update the stack based on the cube's size and count the number of towers needed.

• Return the minimum number of towers required.

• Example: For input N = 3, ARR = [3, 2, 1], the output should be 1.

Calculate uneaten carrots by rabbits with specific jumping factors.

• Iterate through each carrot and check if any rabbit jumps on it.

• Use the jumping factors to determine which carrots will be eaten.

• Subtract the eaten carrots from the total to get the uneaten carrots.

The task is to format a JSON object string with proper indentation based on specific rules.

• Iterate through the string character by character and keep track of the indentation level.

• Use a stack to keep track of opening and closing braces to determine the indentation level.

• Insert four spaces or a tab (' ') for each level of indentation.

• Handle commas to represent new lines in the output array of strings.

Given an array of coin values, determine the maximum value Wong can obtain by playing a coin game against Dr. Strange.

• Wong plays first and can remove one coin from either end of the array on each turn.

• The game ends when no coins are left, and the player with the highest total value wins.

• Consider different scenarios like having an odd or even number of coins in the array.

Generate a pattern of guest and security personnel distributions across tables for a given number of rows.

• Iterate through each row from 1 to N

• For each row, print the pattern based on the number of guests and security personnel at each table

• Tables on each end of a row are reserved for security personnel

To find the maximum number that can be formed using the digits present in a linked list.

• Traverse the linked list and store the digits in an array

• Sort the array in descending order

• Concatenate the sorted array elements to form the maximum number

Calculate the total money accumulated by Harshit in Ninja bank after N days with a specific increment strategy.

• Start with 1 rupee on the first Monday and increase by 1 rupee each day from Tuesday to Sunday.

• Each new Monday starts with an additional rupee more than the previous Monday's deposit.

• Calculate the total amount of money accumulated after N days for each test case.

• Example: For N = 2, total amount is 3 rupees; for N = 5, total amount is 15 rupees.

Identify K most frequent elements in an array and return them sorted in ascending order.

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

• Sort the elements based on their frequency in descending order.

• Return the first K elements from the sorted list.

Find the maximum profit that can be obtained by completing at most two transactions of buying and selling a stock.

• Iterate through the array of stock prices and calculate the maximum profit that can be obtained by completing at most two transactions.

• Keep track of the maximum profit that can be obtained by selling the stock on each day after buying it on a previous day.

• Consider all possible combinations of two transactions to find the maximum profit.

• Return the maximum profit fo...read more

The problem involves finding the minimum number of elements to remove from an array so that the difference between the maximum and minimum element is less than or equal to a given value.

• Iterate through the array and keep track of the minimum and maximum elements.

• Calculate the difference between the maximum and minimum elements.

• If the difference is greater than the given value, increment the count of elements to remove.

• Return the count of elements to remove as the result.

The problem involves finding the K maximum sum combinations from two arrays by adding one element from each array.

• Iterate through all possible sum combinations of elements from arrays A and B.

• Store the sums in a max heap to keep track of the K maximum sums.

• Pop the top K elements from the max heap to get the K maximum sum combinations.

Find the length of the longest common subsequence among three strings.

• Use dynamic programming to solve this problem efficiently.

• Create a 3D array to store the lengths of common subsequences.

• Iterate through the strings to fill the array and find the longest common subsequence length.

Calculate the minimum number of moves a Knight requires to reach a specified target position on a chessboard.

• Implement a function that calculates the minimum number of moves for a Knight to reach the target position on an NxN chessboard.

• Consider the possible movements of a Knight on a chessboard (2 squares in one direction and 1 square in a perpendicular direction).

• Use breadth-first search (BFS) algorithm to find the shortest path from the Knight's starting position to the ta...read more

Evaluate arithmetic expression in Reverse Polish Notation using stack.

• Use a stack to keep track of operands and perform operations when encountering an operator.

• Iterate through the array of strings and push operands onto the stack, perform operation when an operator is encountered.

• Handle division using modular division to avoid floating point precision issues.

• Return the final result modulo 10^9 + 7 as specified in the constraints.

Find the smallest sum achievable by selecting one element from each row of a matrix, following certain constraints.

• Iterate through each row and find the minimum element that can be selected without violating the constraints

• Keep track of the selected elements to avoid selecting elements directly below them in the next row

• Sum up the selected elements to get the smallest possible sum

Given a tree structure of kingdoms, determine if it's possible to conquer more kingdoms than Aragorn by strategically choosing the starting kingdom.

• Start at the kingdom adjacent to Aragorn's initial kingdom

• Choose the kingdom that allows you to capture the most number of kingdoms in subsequent turns

• Consider the tree structure to plan your conquest strategically

Count the number of people to the right with a smaller height for each person in a queue.

• Iterate through the array from right to left and maintain a sorted list of heights encountered so far.

• Use binary search to find the position where the current height should be inserted in the sorted list.

• The count of smaller people to the right for each person can be calculated based on the index of insertion in the sorted list.

Find the first petrol pump from which a truck can start its journey and complete the circle.

• Iterate through each petrol pump and calculate the remaining petrol after reaching the next pump.

• If the remaining petrol is negative at any point, reset the starting point to the next pump.

• If the total remaining petrol at the end is non-negative, return the starting point as the answer.

Given an array of water buckets, find the minimum liters of water to remove to make all buckets equal.

• Iterate through the array to find the maximum frequency of a water amount

• Calculate the total liters to be removed by subtracting the maximum frequency from the total number of buckets

• Return the total liters to be removed as the answer

Find the minimum number of taps needed to water the entire garden using given tap ranges.

• Iterate over taps and update the farthest point each tap can reach.

• Use a greedy approach to select the tap that can water the farthest point.

• If a tap can't water any point, return -1.

• Example: For ranges = [3, 4, 1, 1, 0, 0], tap at position 1 can water the entire garden.

Identify and list nodes in a Binary Tree without siblings.

• Traverse the Binary Tree in level order and keep track of nodes without siblings.

• Check if each node has a sibling by comparing with its parent's other child.

• Output the values of nodes without siblings in ascending order.

Dijkstra's algorithm is used to find the shortest path distances from a source node to all other vertices in a graph.

• Dijkstra's algorithm is a greedy algorithm that finds the shortest path from a source node to all other nodes in a graph.

• It uses a priority queue to select the node with the smallest distance and relaxes its neighbors.

• The algorithm maintains a distance array to keep track of the shortest distances from the source node.

• If a node is unreachable, the distance is s...read more

Find the Lowest Common Ancestor (LCA) of two nodes in a Binary Search Tree (BST).

• Traverse the BST from the root node to find the LCA of nodes P and Q.

• Compare the values of nodes P and Q with the current node's value to determine the LCA.

• If both nodes are on the same side of the current node, move to that side; otherwise, the current node is the LCA.

• Handle cases where one node is the ancestor of the other node.

• Example: For input 2 3 and BST 1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -...read more

Implement a phone directory search feature to suggest contacts based on a given prefix query string.

• Iterate through the contact list to find contacts with the prefix matching the query string.

• Display suggestions as the user types each character of the query.

• Handle cases where no suggestions are found for a particular prefix by printing 'No suggestions found'.

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

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

• Use a set to store unique triplets and avoid duplicates.

• Check if the sum of the triplet equals the target sum.

• Return the list of valid triplets or -1 if no such triplet exists.

Find the magic index in a sorted array where A[i] = i.

• Use binary search to efficiently find the magic index in the sorted array.

• Check the middle element of the array and compare it with its index to determine the direction to search.

• Repeat the process on the left or right half of the array until the magic index is found or no more elements to search.

Find the peak element in an array of integers.

• Iterate through the array and check if the current element is greater than its neighbors.

• Handle edge cases for the first and last elements of the array.

• Return the peak element found.

The task is to determine the maximum profit that can be achieved by performing up to two buy-and-sell transactions on a given set of stock prices.

• Iterate through the stock prices to find the maximum profit that can be achieved by buying and selling stocks at different points.

• Keep track of the maximum profit after the first transaction and the maximum profit overall after the second transaction.

• Consider edge cases where no profit can be made or where only one transaction is po...read more

Find the length of the longest increasing path in a 2D matrix by moving in four directions.

• Use dynamic programming to keep track of the longest increasing path starting from each cell.

• Explore all four directions from each cell and recursively find the longest increasing path.

• Optimize the solution by storing the length of the longest increasing path starting from each cell.

Convert a binary tree into its mirror tree by interchanging left and right children of non-leaf nodes.

• Traverse the binary tree in postorder fashion and swap the left and right children of each non-leaf node.

• Use recursion to solve the problem efficiently.

• Remember to handle null child nodes represented by -1 in the input.

Find the maximum sum of any contiguous subarray within an array in O(N) time complexity.

• Iterate through the array and keep track of the maximum sum of subarrays encountered so far

• At each index, decide whether to include the current element in the subarray or start a new subarray

• Update the maximum sum if a new maximum is found

• Example: For array [34, -50, 42, 14, -5, 86], the maximum sum subarray is [42, 14, -5, 86] with sum 137

Determine the minimum number of platforms needed at a railway station so that no train has to wait.

• Sort the arrival and departure times arrays in ascending order.

• Initialize two pointers for arrival and departure times, and a variable to keep track of the maximum number of platforms needed.

• Increment the platform count when a train arrives and decrement when a train departs.

• Update the maximum platform count as needed.

• Return the maximum platform count as the minimum number of pl...read more

Find the minimum number of fountains to activate to water the entire garden.

• Iterate through the array to find the coverage of each fountain.

• Keep track of the farthest coverage reached by each activated fountain.

• Activate the fountain that covers the farthest distance not yet covered.

• Repeat until the entire garden is watered.

Find the size of the largest subtree in a binary tree that is also a Binary Search Tree (BST).

• Traverse the binary tree in a bottom-up manner to check if each subtree is a BST.

• Keep track of the size of the largest BST subtree encountered so far.

• Use the properties of a BST to determine if a subtree is a valid BST.

• Consider edge cases such as empty tree or single node tree.

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

Implement a function to delete a node from a linked list at a specified position.

• Traverse the linked list to find the node at the specified position.

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

• Handle cases where the position is at the beginning or end of the linked list.

• Ensure to free the memory of the deleted node to avoid memory leaks.

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

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

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

• Ensure that both the left and right subtrees are also binary search trees.

• Return true if the tree is a BST, false otherwise.

• Handle cases with duplicate elements in either subtree.

No, it is not possible for the cops to catch the robber.

• The robber can always stay equidistant from the cops by moving along the diagonal of the cube.

• The cops can never cut off the robber's path without colliding with each other.

• This problem is known as the '3 Cops and a Robber' problem in graph theory.

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 instead of the next node.

• Use three pointers to keep track of the current, previous, and next nodes while reversing the linked list.

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

The problem involves arranging balls of different types in a straight line without having two adjacent balls of the same type.

• Use recursion to try all possible arrangements while keeping track of the previous ball type.

• Handle edge cases where one or more types of balls have a count of 0.

• Consider using dynamic programming to optimize the solution by storing intermediate results.

• For the given example input (2 1 1), the output is 6 as there are 6 valid arrangements.

• For the input...read more

The task is to find the total number of ways to make change for a specified value using given denominations.

• Use dynamic programming to solve this problem efficiently.

• Create a 2D array to store the number of ways to make change for each value up to the specified value.

• Iterate through each denomination and update the array accordingly.

• The final answer will be stored in the last cell of the array.

• Example: For N=3, D=[1, 2, 3], V=4, the output is 4 as explained in the example.

Find the length of the longest common subsequence among three strings.

• Use dynamic programming to solve this problem efficiently.

• Create a 3D array to store the lengths of common subsequences.

• Iterate through the strings to fill the array and find the longest common subsequence length.

The task is to determine the maximum profit achievable with at most K transactions by buying and selling stocks.

• Iterate through the array and keep track of the minimum price to buy and maximum profit for each transaction.

• Use dynamic programming to store the maximum profit at each day with each possible number of transactions.

• Consider edge cases like when K is 0 or when the array is empty.

• Example: For input N = 6, PRICES = [3, 2, 6, 5, 0, 3], K = 2, the output would be 7.

Find the position of the only '1' bit in the binary representation of a given non-negative integer.

• Iterate through the bits of the integer to find the position of the lone '1' bit.

• Use bitwise operations to check if there is exactly one '1' bit in the binary representation.

• Return the position of the lone '1' bit or -1 if there isn't exactly one '1'.

Find next smallest and previous largest integers with same number of set bits as given integer.

• Count the number of set bits in the given integer using bitwise operations.

• For next smallest integer, find the next number with same number of set bits by iterating through numbers greater than the given integer.

• For previous largest integer, find the previous number with same number of set bits by iterating through numbers smaller than the given integer.

Detect if an array contains a Pythagorean triplet by checking if x^2 + y^2 = z^2.

• Iterate through all possible triplets of numbers in the array and check if they form a Pythagorean triplet.

• Use a nested loop to generate all possible combinations of three numbers from the array.

• Check if the sum of squares of two numbers is equal to the square of the third number.

Find the length of the longest strictly increasing subsequence of heights of students in a row.

• Iterate through the heights array and for each student, find the length of the longest increasing subsequence ending at that student.

• Use dynamic programming to keep track of the longest increasing subsequence length for each student.

• Return the maximum length found in the dynamic programming array as the result.

• Example: For heights [10, 20, 10, 30, 40], the longest increasing subsequ...read more

Find the first negative integer in every window of size K in an array.

• Iterate through the array using a sliding window approach of size K

• For each window, find the first negative integer and add it to the result array

• If no negative integer is found in a window, add 0 to the result array

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

• Create an array to store the minimum candies required for each student.

• Iterate through the students' ratings array to determine the minimum candies needed based on the adjacent ratings.

• Consider both left-to-right and right-to-left passes to ensure fair distribution.

• Calculate the total candies required by summing up the values in the array.

• Example: For rating...read more

Validate if a given 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 left and right subtrees are also binary search trees

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.

• Ensure that both the left and right subtrees are also binary search trees.

• Traverse the tree in an inorder manner and check if the elements are in sorted order.

• Use recursion to validate each node and its subtrees.

Find the duplicate number in an array of integers from 0 to (N-2).

• Iterate through the array and keep track of the count of each number using a hashmap.

• Return the number with a count greater than 1 as the duplicate number.

• Alternatively, use Floyd's Tortoise and Hare algorithm to find the duplicate number in O(N) time and O(1) space.

139 teams in a knock-out tournament, find the number of matches to choose the champion.

• In a knock-out tournament, each team plays only one match per round.

• The number of matches required to choose the champion is one less than the number of teams.

• Therefore, the number of matches required is 138.

The problem involves counting the number of distinct ways to climb N stairs by taking 1 or 2 steps at a time.

• Use dynamic programming to solve the problem efficiently.

• The number of ways to reach the Nth stair is the sum of the number of ways to reach the (N-1)th stair and the (N-2)th stair.

• Handle base cases where N=0 and N=1 separately.

• Consider using modulo operation to avoid overflow when dealing with large numbers.

Yes, we can solve this problem using a time complexity of O(max(N, M)) by using a two-pointer approach.

• Use two pointers to iterate through both arrays simultaneously.

• Compare the elements at the pointers and move the pointers accordingly to find the intersection.

• This approach ensures linear time complexity based on the size of the larger array.

Calculate the minimum number of candies needed to distribute to students based on their performance grades.

• Create an array to store the minimum candies needed for each student.

• Iterate through the students' ratings from left to right, comparing each student with the previous one to determine the candy count.

• Iterate through the students' ratings from right to left, comparing each student with the next one to ensure the correct candy count.

• Sum up the total candies needed for all...read more

Calculate the time in minutes required to completely burn a binary tree starting from a given node.

• Start burning from the given node and spread fire to adjacent nodes each minute

• Track the time taken for each node to burn and return the maximum time taken

• Use a queue to keep track of nodes to be burned next

Count the number of '1's in the binary form of a given integer.

• Convert the given integer to binary representation

• Count the number of '1's in the binary representation

• Return the count of '1's as output

Find the minimum amount of water to be removed to equalize water in buckets.

• Iterate through the array to find the average water level.

• Calculate the total amount of water that needs to be removed to equalize the buckets.

• Keep track of the excess water in each bucket and sum them up to get the final result.

Implement in-order traversal of a binary tree without recursion.

• Use a stack to simulate the recursive in-order traversal process.

• Start with the root node and keep traversing left until reaching a null node, pushing nodes onto the stack.

• Pop nodes from the stack, print the value, and move to the right child if it exists.

• Continue this process until the stack is empty and all nodes have been visited.

Diamond Problem is a common issue in multiple inheritance 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 clas...read more

Garbage collection in OOP refers to automatic memory management by deallocating memory of objects no longer in use.

• Garbage collection is a process of automatically reclaiming memory occupied by objects that are no longer in use.

• It helps prevent memory leaks and ensures efficient memory usage.

• Languages like Java, C#, and Python have built-in garbage collection mechanisms.

• Garbage collection can be done using different algorithms like mark and sweep, reference counting, and gene...read more

Internal fragmentation occurs when memory is allocated in fixed-size blocks, leading to wasted space within a block. External fragmentation occurs when free memory is fragmented into small chunks, making it difficult to allocate contiguous blocks.

• Internal fragmentation is caused by allocating fixed-size blocks of memory, leading to wasted space within a block.

• External fragmentation occurs when free memory is fragmented into small chunks, making it difficult to allocate contig...read more

Default constructor is provided by the compiler if no constructor is defined. Copy constructor creates a new object by copying an existing object.

• Default constructor initializes member variables to default values.

• Copy constructor creates a new object with the same values as an existing object.

• Default constructor is called automatically by the compiler if no constructor is defined.

• Copy constructor is called when an object is passed by value or when a new object is initialized ...read more

Primary key uniquely identifies a record in a table, while unique key ensures that all values in a column are distinct.

• Primary key can't have null values, while unique key can have one null value.

• A table can have only one primary key, but multiple unique keys.

• Primary key is used as a foreign key in other tables, while unique key is not.

• Example: Primary key - employee ID, Unique key - email address.

Truncate removes all data from a table while Delete removes specific data from a table.

• Truncate is faster than Delete as it doesn't log individual row deletions.

• Truncate resets the identity of the table while Delete doesn't.

• Truncate can't be rolled back while Delete can be.

• Truncate doesn't fire triggers while Delete does.

Processes are instances of programs in execution, while threads are smaller units within a process that can execute independently.

• Processes are independent entities that contain program code, data, and resources.

• Threads are lightweight units within a process that share the same resources but can execute independently.

• Processes have their own memory space, while threads share the same memory space.

• Processes communicate with each other through inter-process communication mechan...read more

Default Constructor is a constructor that is automatically called when an object is created without any arguments. Copy Constructor is used to create a new object as a copy of an existing object.

• Default Constructor has no parameters, while Copy Constructor takes an object of the same class as a parameter.

• Default Constructor initializes the object with default values, while Copy Constructor creates a new object with the same values as the existing object.

• Example: Default Const...read more

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

• Ignite one wire at both ends and the other wire at one end. The first wire will burn out in 30 minutes.

• At the same time, ignite the second wire at one end and the middle point. It will take 15 minutes for the fire to reach the middle point from one end.

• When the first wire burns out, ignite the other end of the second wire. It will take another 15 minutes for th...read more

Algorithm to find absolute max subsequence of an array with positive and negative numbers in O(n) time.

• Initialize max_so_far and max_ending_here as 0

• Loop through the array and for each element, add it to max_ending_here

• If max_ending_here becomes negative, reset it to 0

• If max_ending_here is greater than max_so_far, update max_so_far

• Return max_so_far

Design a class hierarchy for director, HOD, Professor and students reporting to their respective heads.

• Create a base class for all employees with common attributes and methods

• Create derived classes for director, HOD, Professor and students

• Implement reporting hierarchy using pointers or references

• Display hierarchy structure on the site using a tree or graph

• Consider adding additional attributes and methods as needed

Abstract class can have both abstract and non-abstract methods, while interface can only have abstract methods.

• Abstract class can have constructor, member variables, and methods with implementation.

• Interface can only have abstract methods and constants.

• A class can implement multiple interfaces but can only extend one abstract class.

• Example: Abstract class - Animal with abstract method 'eat' and non-abstract method 'sleep'. Interface - Flyable with method 'fly'.

Primary Key uniquely identifies each record in a table, while Unique Key ensures that all values in a column are distinct.

• Primary Key does not allow NULL values, while Unique Key allows one NULL value.

• A table can have only one Primary Key, but multiple Unique Keys.

• Primary Key is automatically indexed, while Unique Key may or may not be indexed.

• Primary Key is used to establish relationships between tables, while Unique Key is used to enforce data integrity.

• Example: In a table ...read more

C++ is an extension of C with object-oriented programming features.

• C++ supports classes and objects while C does not.

• C++ has better support for polymorphism and inheritance.

• C++ has a standard template library (STL) which C does not have.

• C++ allows function overloading while C does not.

• C++ has exception handling while C does not.

System calls provide a way for user-level processes to interact with the operating system kernel.

• System calls allow user programs to request services from the operating system.

• They provide a secure and controlled way for applications to access system resources.

• System calls enable processes to perform tasks such as file operations, network communication, and process management.

• Examples of system calls include open(), read(), write(), fork(), and exec().

DDL is used to define the structure of database objects, while DML is used to manipulate data within those objects.

• DDL is used to create, modify, and delete database objects like tables, indexes, etc.

• DML is used to insert, update, delete, and retrieve data from database tables.

• DDL statements include CREATE, ALTER, DROP, TRUNCATE, etc.

• DML statements include INSERT, UPDATE, DELETE, SELECT, etc.

Find the next largest int with same number of 1's in binary.

• Count the number of 1's in the binary representation of the given int.

• Increment the given int until a number with the same number of 1's is found.

• Return the next largest int with same number of 1's.

DML is Data Manipulation Language used to manipulate data in a database. DLL is Data Definition Language used to define database schema.

• DML is used to insert, update, delete data in a database.

• DLL is used to create, alter, drop database objects like tables, views, indexes.

• DML statements include INSERT, UPDATE, DELETE.

• DLL statements include CREATE, ALTER, DROP.

• DML affects data in a database, DLL affects the structure of a database.

DBMS is a software system to manage databases while RDBMS is a type of DBMS that uses a relational model.

• DBMS stands for Database Management System while RDBMS stands for Relational Database Management System.

• DBMS can manage any type of database while RDBMS uses a relational model to manage data.

• DBMS does not enforce any specific data model while RDBMS enforces a relational data model.

• Examples of DBMS include MongoDB, Cassandra, and Redis while examples of RDBMS include MySQL...read more

Find minimum cost to make heights of N piles of coins equal by adding or removing one coin from a pile with different costs.

• Use dynamic programming to keep track of the minimum cost for each pile height.

• Consider the cost of adding and removing coins from each pile.

• Iterate through all possible combinations of adding and removing coins to find the minimum cost.

Different types of semaphores include binary semaphores, counting semaphores, and mutex semaphores.

• Binary semaphores: Can only have two states - 0 or 1. Used for mutual exclusion.

• Counting semaphores: Can have multiple states. Used for resource allocation and synchronization.

• Mutex semaphores: Similar to binary semaphores but with additional features like priority inheritance and deletion safety.

Eliminate duplicates in an array of strings and print it in linear time complexity.

• Use a hash set to keep track of unique elements

• Iterate through the array and add non-duplicate elements to the hash set

• Print the hash set elements to get the final array

Five operating systems derived from UNIX are...

• Linux

• macOS

• Solaris

• FreeBSD

• Android

Inheritance is a concept in object-oriented programming where a class inherits properties and behaviors from another class.

• Allows for code reusability by creating a new class based on an existing class

• Child class inherits attributes and methods of the parent class

• Can have multiple levels of inheritance (e.g. grandparent, parent, child classes)

• Example: class Dog extends Animal, where Dog inherits properties and methods from Animal class

Normalization in database management systems aims to reduce data redundancy, improve data integrity, and optimize database performance.

• Eliminate data redundancy by breaking down data into smaller tables

• Reduce update anomalies by ensuring data is stored in a logical and consistent manner

• Improve data integrity by enforcing referential integrity constraints

• Optimize database performance by reducing the amount of redundant data stored

The select() system call is used in Unix-like operating systems to monitor multiple file descriptors for activity.

• select() allows a program to wait for multiple I/O operations to complete on multiple file descriptors.

• It takes three sets of file descriptors as arguments - readfds, writefds, and errorfds.

• The function will block until an activity is detected on one of the file descriptors or until a timeout occurs.

• select() is commonly used in networking applications to handle mu...read more

No, social media influencers are here to stay.

• Social media has become an integral part of our lives and will continue to be so.

• Influencers have a huge impact on consumer behavior and brand marketing.

• The industry is constantly evolving and adapting to changes.

• Influencers are diversifying their content and expanding their reach.

• Brands are investing more in influencer marketing than ever before.

• Examples: Kylie Jenner, PewDiePie, Huda Kattan, etc.

Normalisation is the process of organizing data in a database to reduce redundancy and improve data integrity.

• Normalisation helps to eliminate data redundancy and inconsistencies

• It ensures that each piece of data is stored in only one place

• It helps to improve data integrity and accuracy

• It makes it easier to maintain and update the database

• There are different levels of normalisation, each with its own set of rules and guidelines

Defending oneself for downloading torrents

• Explain that downloading torrents is illegal but common

• Admit to the mistake and show remorse

• Explain that you were not aware of the consequences

• Promise to delete all downloaded content and not repeat the mistake

• Offer to pay any fines or penalties

• Consult a lawyer for legal advice

SQL query to find the employee with the nth highest salary

• Use the ORDER BY clause to sort salaries in descending order

• Use the LIMIT clause to select the nth highest salary

• Join the employee table with the salary table to get the employee details

Static loading is done at compile time while dynamic loading is done at runtime in operating systems.

• Static loading involves loading all the necessary libraries and dependencies at compile time.

• Dynamic loading involves loading libraries and dependencies at runtime when they are needed.

• Static loading is faster but consumes more memory, while dynamic loading is slower but more memory efficient.

• Examples of static loading include C/C++ programs, while examples of dynamic loading ...read more

The types of access modifiers in C++ are public, private, and protected.

• Public: accessible from outside the class

• Private: only accessible within the class

• Protected: accessible within the class and its subclasses