400+ Google Interview Questions and Answers

Determine the minimum time required to paint all boards with given constraints.

• Use binary search to find the minimum and maximum possible time to paint all boards.

• Iterate through the boards and assign them to painters based on the time constraints.

• Calculate the total time taken to paint all boards with the assigned painters.

Count the total number of special numbers within a given range by rotating digits 180 degrees.

• Create a function to check if a number is a special number by rotating its digits.

• Iterate through the range from 1 to MAXVAL and count the special numbers.

• Handle the digit rotation mapping for 0, 1, 6, 8, 9.

• Return the count of special numbers for each test case.

Distribute chocolates among students to minimize the difference between the largest and smallest number of chocolates.

• Sort the array of chocolates.

• Use sliding window technique to find the minimum difference between the largest and smallest number of chocolates.

• Return the minimum difference as the output.

Write a select statement to retrieve work of all users who belong to my team.

• Join USERS and WORK tables on user_id

• Join MANAGERS and USERS tables on team

• Filter by manager_id

I will troubleshoot the router by checking the power supply, resetting the router, and checking the network settings.

• Check if the router is properly plugged in and receiving power

• Reset the router by turning it off and on again

• Check the network settings and make sure they are correct

• Try connecting to the router with a different device

• If all else fails, contact the internet service provider for assistance

Find minimum and maximum cost to purchase all candies with special offer of free candies.

• Iterate through the candy costs array and sort it in ascending order.

• For minimum cost, start from the lowest cost candy and take free candies until reaching the next higher cost candy.

• For maximum cost, start from the highest cost candy and take free candies until reaching the next lower cost candy.

Find the minimum number of steps to reduce a positive integer to 1 using given operations.

• Use dynamic programming to store the minimum steps for each number from 1 to N.

• Iterate through each number from 1 to N and calculate the minimum steps based on the given operations.

• Consider the cases where you can either subtract 1, divide by 2, or divide by 3 to find the minimum steps.

• Return the minimum steps needed to reduce the number to 1 for each test case.

Given an array of integers and an integer K, minimize the difference between the maximum and minimum elements after adjusting each element by +/- K.

• Sort the array in non-decreasing order.

• For each element, calculate the difference between the current element and the next element.

• Adjust the element by adding or subtracting K to minimize the difference.

• Return the minimum possible difference between the maximum and minimum elements.

Identify the longest palindromic substring in a given string.

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

• Keep track of the longest palindrome found

• Return the longest palindrome with the smallest start index

Given a sequence of room bookings and freeings, find the room that is booked the most times.

• Create a hashmap to store the count of each room booking.

• Iterate through the sequence of bookings and freeings, updating the count in the hashmap.

• Find the room with the highest count and return it. In case of a tie, return the lexicographically smaller room.

• Example: For input n = 6, Arr[] = {"+1A", "+3E", "-1A", "+4F", "+1A", "-3E"}, the output would be "1A".

Calculate the number of ways Preeti can purchase items within budget, considering distinct ways.

• Use dynamic programming to calculate the number of ways to purchase items within budget

• Consider different scenarios where Preeti buys different quantities of each item

• Return the result modulo 10^9 + 7 to handle large answers

Implement a spell checker function that suggests correct spellings from a dictionary for a given query string.

• Iterate through the dictionary to check for matching prefixes with the query string.

• Return a list of suggestions if the query string is misspelled, otherwise return an empty list.

• Ensure all strings are in lowercase and within the specified constraints.

• Handle multiple test cases as per the input format.

• Example: For DICTIONARY[] = {"ninja", "ninjas", "nineteen", "ninny"...read more

Implement Boyer Moore Algorithm to find all occurrences of a pattern in a text string.

• Implement Boyer Moore Algorithm for efficient pattern searching.

• Iterate through the text string and compare the pattern with each substring of the text.

• Return an array of indexes where the pattern is found in the text.

• If pattern not found, return an array containing -1.

Find the water cell farthest from land in a binary matrix using Manhattan distance.

• Iterate through the matrix to find all land cells and water cells

• Calculate the Manhattan distance of each water cell to the nearest land cell

• Return the maximum distance found

Find all the bridges in an undirected graph.

• Use Tarjan's algorithm to find bridges in the graph.

• A bridge is an edge whose removal increases the number of connected components.

• Check for bridges by removing each edge and checking the number of connected components.

• Return the edges that are bridges in non-decreasing order.

Calculate and print the median after each new integer is added to the stream.

• Use two heaps - a max heap to store the smaller half of the numbers and a min heap to store the larger half.

• Keep the sizes of the two heaps balanced or differ by at most 1 to get the median efficiently.

• When a new integer is added, compare it with the current median and insert it into the appropriate heap.

• If the sizes of the heaps differ by more than 1, rebalance them by moving an element from one hea...read more

Compute the skyline of given rectangular buildings in a 2D city, eliminating hidden lines and forming the outer contour of the silhouette.

• Iterate through the buildings and create a list of critical points (x, y) where the height changes.

• Sort the critical points based on x-coordinate and process them to form the skyline.

• Merge consecutive horizontal segments of equal height into one to ensure no duplicates in the output.

The task is to compute the shortest path from node '0' to each node in a directed graph with alternating colored edges.

• Create a graph using the given red and blue edges.

• Use Breadth First Search (BFS) to find the shortest path from node '0' to each node with alternating colored edges.

• If no such path exists, set the answer to -1.

• Return the array of shortest path lengths for each node.

Given constraints, find max vaccines administered on a specific day during a vaccination drive.

• Iterate through each test case and calculate the maximum number of vaccines distributed on the specified day.

• Distribute vaccines evenly across days while maximizing the number on the specified day.

• Ensure that the sum of vaccines administered does not exceed the maximum allowed.

• Consider edge cases like when the number of days is equal to the maximum number of vaccines available.

Given a sorted alien dictionary, determine the character order of the alien language.

• Create a graph data structure to represent the relationships between characters based on the given dictionary.

• Perform a topological sort on the graph to determine the character order of the alien language.

• Return the character array obtained from the topological sort as the final output.

Count the number of distinct ways to climb to the Nth stair by climbing one or two 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.

• Apply modulo 10^9+7 to avoid overflow in the final result.

Determine the minimum length of instruction sequence for a robot to reach a given target on an infinite number line.

• Start at position 0 with speed +1, update position and speed based on 'A' and 'R' instructions

• For each test case, find the shortest sequence of instructions to reach the target

• Consider both positive and negative positions for the robot

Find the maximum sum of absolute differences between adjacent elements in a circular array by rearranging the elements.

• Sort the array in non-decreasing order.

• Alternate between picking the smallest and largest elements to maximize the sum of absolute differences.

• Calculate the sum of absolute differences between adjacent elements in the rearranged array.

Find the longest palindromic substring in a given string, returning the rightmost one if multiple exist.

• Use dynamic programming to check for palindromes within the string.

• Keep track of the longest palindromic substring found so far.

• Return the rightmost longest palindromic substring if multiple exist.

Given a pattern and a list of words, determine if the words align with the pattern.

• Create a mapping between characters in the pattern and words in the list.

• Check if the mapping preserves the order of characters in the pattern.

• Return 'True' if the sequence of words matches the order of characters in the pattern, otherwise return 'False'.

Multiple data structures are used to print nodes in a specific order. One data structure cannot be used alone.

• The given order suggests a depth-first search traversal of a tree-like structure.

• A stack can be used to keep track of the nodes to be visited.

• A queue can be used to store the children of a node in the order they are visited.

• An array can be used to store the nodes in the required order.

• A linked list can be used to connect the nodes in the required order.

• Using just one ...read more

Business decisions are made by analyzing data, considering goals and objectives, and evaluating potential risks and benefits.

• Gather and analyze relevant data

• Consider company goals and objectives

• Evaluate potential risks and benefits

• Consult with stakeholders and experts

• Use frameworks and models to guide decision-making

• Continuously monitor and evaluate decisions for effectiveness

Connect ropes with minimum cost by merging two smallest ropes at a time.

• Sort the array of rope lengths in ascending order.

• Merge the two smallest ropes at a time and update the cost.

• Repeat until all ropes are merged into one.

• Return the total cost as the minimum cost to connect all ropes.

Find median of integers in a data stream as they are read. Return medians after each new element.

• Use a min heap to store the larger half of the numbers and a max heap to store the smaller half.

• Keep the sizes of the two heaps balanced to efficiently find the median.

• If the total number of elements is odd, the median is the top element of the max heap.

• If the total number of elements is even, the median is the average of the top elements of both heaps.

Designing Google Suggest system

• I would start by analyzing user search patterns and frequently searched keywords

• Then, I would create a database of these keywords and their associated search results

• I would use indexing services to quickly retrieve relevant results for each keyword

• I would also implement machine learning algorithms to improve the accuracy of suggestions over time

Find largest pen using minimum comparisons with tops.

• Divide pens into two groups and compare largest pen from each group with largest top.

• Repeat the process with the group containing the largest pen until only one pen is left.

• The remaining pen is the largest pen.

• Total number of comparisons required is 2n-3.

Check if a number is a power of 2 and odd.

• To check if a number is a power of 2, use bitwise AND operator with the number and its predecessor. If the result is 0, it is a power of 2.

• To check if a number is odd, use modulus operator with 2. If the result is 1, it is odd.

• Example code in Python:

• def is_power_of_two(num):

• return num & (num - 1) == 0

• def is_odd(num):

• return num % 2 == 1

Implement a function to find the shortest path in an unweighted graph from house 'S' to house 'T'.

• Use Breadth First Search (BFS) algorithm to find the shortest path in an unweighted graph.

• Create a queue to store the current house and its neighbors, and a visited set to keep track of visited houses.

• Start BFS from house 'S' and stop when reaching house 'T'.

• Return the path from 'S' to 'T' once 'T' is reached.

• If multiple shortest paths exist, any one can be returned.

• Example: For ...read more

Algorithm to find 2 numbers in an array whose sum is equal to a target integer

• Use a hash table to store the difference between target and each element in the array

• Iterate through the array and check if the current element exists in the hash table

• Return the pair of elements that sum up to the target integer

Given n dice with 'a' sides and sum b, return no. of ways to obtain b. Optimize time and space complexity.

• Use dynamic programming to reduce time complexity

• Create a 2D array to store the number of ways to obtain each sum for each number of dice

• Use rolling arrays to optimize space complexity

• Example: n=2, a=6, b=7 -> 6 ways to obtain sum 7

• Example: n=3, a=4, b=8 -> 21 ways to obtain sum 8

Given an array, remove K elements from beginning or end to maximize sum of remaining elements.

• Iterate through all possible combinations of removing K elements from beginning and end

• Calculate sum of remaining elements for each combination

• Return the maximum sum obtained

Assign subjects to friends to minimize maximum workload, find minimum time for most loaded friend.

• Sort subjects in descending order

• Assign subjects to friends one by one until all subjects are assigned

• The maximum workload will be the sum of problems assigned to the friend with the most problems

• Return the maximum workload as the minimum time required

The technical skills required to program efficiently include programming languages, algorithms, data structures, debugging, and problem-solving.

• Proficiency in programming languages such as Java, Python, C++, etc.

• Knowledge of algorithms and their efficiency, including sorting, searching, and graph algorithms.

• Understanding of data structures like arrays, linked lists, stacks, queues, trees, and hash tables.

• Ability to debug and troubleshoot code to identify and fix errors.

• Strong...read more

Calculate and print the sum of least common multiples (LCM) for each integer from 1 to N with N.

• Iterate from 1 to N and calculate LCM of each number with N

• Sum up all the calculated LCMs to get the final result

• Implement a function to calculate LCM of two numbers

Hashtable is faster for finding an item than a sorted list.

• Hashtable has constant time complexity O(1) for finding an item.

• Sorted list has logarithmic time complexity O(log n) for finding an item.

• Hashtable uses hashing to directly access the item's location.

• Sorted list requires binary search to find the item's location.

• Hashtable is ideal for large datasets with frequent lookups.

• Sorted list is ideal for datasets that require frequent insertions and deletions.

Sort 128 GB data on 2 machines with 64 GB RAM each. Extend to 1000 machines.

• Use external sorting algorithm like merge sort or quick sort

• Divide data into smaller chunks and sort them individually

• Merge sorted chunks using additional RAM

• For 1000 machines, use distributed sorting algorithms like MapReduce or Hadoop

• Ensure data consistency and fault tolerance in distributed sorting

ArrayList is preferred for frequent retrieval operations, while LinkedList is suitable for frequent insertions/deletions.

• Use ArrayList when you need fast random access and retrieval operations, such as searching for elements in a list.

• Choose LinkedList when you need fast insertions/deletions, especially at the beginning or end of the list.

• Consider memory overhead and performance trade-offs when deciding between ArrayList and LinkedList.

• For example, if you have a list of stude...read more

To find the highest floor an egg can be dropped without breaking using 2 identical eggs and a 100-story building.

• Start by dropping the first egg from the 50th floor, if it breaks, use the second egg to test floors below 50, if it doesn't break, test floors above 50.

• If the first egg doesn't break, drop it from a higher floor and repeat the process until it breaks.

• The highest floor tested without breaking the egg is the answer.

• This problem can be solved using binary search algo...read more

In the face of a deficit in achieving sales targets, I would approach the situation by analyzing the reasons behind the shortfall and taking appropriate actions to address them.

• Identify the reasons for the deficit by analyzing sales data, market trends, and customer feedback.

• Develop a plan to address the identified issues, such as revising sales strategies, offering incentives to the sales team, or targeting new customer segments.

• Communicate the revised plan to the sales team...read more

Determining the state of switches/junctions after N trains have passed through them.

• Create an array to represent the state of each switch/junction

• Iterate through each train and update the state of the corresponding switch/junction

• Use a loop to simulate the passing of trains and updating of switches/junctions

• Return the final state of the switches/junctions

ReentrantLock should be used instead of synchronized when more flexibility and control over locking mechanisms is needed.

• Use ReentrantLock when you need to implement custom locking strategies or require advanced features like tryLock() and lockInterruptibly()

• ReentrantLock supports fair locking mechanisms, ensuring that threads acquire the lock in the order they requested it

• ReentrantLock allows for more fine-grained control over locking and unlocking, reducing the chances of d...read more

In Java, == checks for reference equality while equals() checks for value equality. Misuse of == can lead to logical errors.

• Override equals() when you want to compare the actual content of objects in user-defined classes.

• Override hashCode() alongside equals() to ensure consistent behavior in hash-based collections.

• Implement Comparable interface and override compareTo() for natural ordering of objects.

Garbage collection in Java automatically reclaims memory occupied by unused objects using different algorithms and memory regions.

• Force garbage collection in Java using System.gc() or Runtime.getRuntime().gc()

• Not recommended to force garbage collection as it can cause performance issues and disrupt the JVM's optimization

• Example: System.gc();

Lambda expressions in Java 8 improve readability and maintainability by allowing concise and functional-style programming.

• Lambda expressions reduce boilerplate code by providing a more compact syntax for implementing functional interfaces.

• They make code more readable by focusing on the behavior being passed as an argument, rather than the mechanics of how it is implemented.

• Lambda expressions enable developers to write more modular and reusable code, leading to better maintain...read more

Dijkstra's algorithm is used to find the shortest path from a source node to all other nodes in a graph with weighted edges.

• Implement Dijkstra's algorithm to find the shortest path distances from the source node to all other nodes

• Use a priority queue to efficiently select the next node with the shortest distance

• Update the distances of neighboring nodes if a shorter path is found

• Handle disconnected vertices by assigning a large value (e.g., 2147483647) as the distance

• Ensure no...read more

Reviewing 30 million ads from 42 languages in Google AdWords and rejecting non-compliant ads requires a systematic approach.

• Create a set of specific rules and guidelines for ad compliance

• Use automated tools to filter out ads that violate the rules

• Assign a team of reviewers to manually check the remaining ads

• Ensure that the reviewers are fluent in the languages of the ads they are reviewing

• Regularly update the rules and guidelines to keep up with changes in the industry

• Provide...read more

Improving location accuracy for Google Maps as a Product Manager

• Collect more data from GPS and Wi-Fi signals

• Use machine learning algorithms to improve accuracy

• Partner with mobile network providers to access cell tower data

• Implement crowd-sourced data collection from users

• Prioritize solutions based on cost, feasibility, and impact on user experience

Find the path from a leaf node to the root node in a binary tree with the maximum sum.

• Traverse the binary tree from leaf to root while keeping track of the sum along the path.

• Compare the sums of all root-to-leaf paths and return the path with the maximum sum.

• Use recursion to traverse the tree efficiently and update the sum as you go.

• Consider edge cases like null nodes and negative values in the tree.

Use a script to iterate through each HTML page, locate phone numbers, and update their format.

• Write a script using a programming language like Python or JavaScript to iterate through each HTML page

• Use regular expressions to locate phone numbers in the pages

• Update the format of the phone numbers as needed (e.g. adding country code, changing separators)

• Save the updated HTML pages with the new phone number format

Probability and clock angle calculation

• Use probability formula to calculate probability of observing a car in 10 minutes

• To calculate clock angle, use the formula: |(30*H) - (11/2)*M| where H is hour and M is minute

• Answer to clock angle question is 7.5 degrees

BFS traversal of an undirected and disconnected graph starting from vertex 0.

• Implement BFS algorithm to traverse the graph starting from vertex 0.

• Use a queue to keep track of visited nodes and their neighbors.

• Ensure to print the nodes in numerical sort order when multiple neighbors are present.

• Handle disconnected components by checking for unvisited nodes.

• Output the BFS traversal sequence for each test case in a separate line.

JSON and XML are the most popular data interchange formats when using APIs.

• JSON (JavaScript Object Notation) is a lightweight format that is easy to read and write. It is widely used in web APIs.

• XML (Extensible Markup Language) is a more complex format that is also widely used in web APIs.

• Other formats include CSV (Comma Separated Values), YAML (YAML Ain't Markup Language), and Protocol Buffers.

The maximum distance that can be reached if one instruction in a string of L, M, R is wrong.

• The maximum distance can be reached by following the correct instructions and then taking the opposite direction of the wrong instruction.

• For example, if the string is 'LMRM', the correct path would be 'LMR' and then taking a step in the opposite direction of 'M'.

• Calculate the distance by summing up the steps taken in the correct path and subtracting the step taken in the wrong directi...read more

Delete all leaf nodes with value X in a binary tree until no such leaves exist.

• Traverse the tree in postorder fashion to delete leaf nodes with value X

• Recursively call the function on left and right subtrees

• Update the root of the tree after removing leaf nodes with value X

Given a string representing time with some digits as '?', fill in '?' to get maximum time.

• Iterate through each digit of the input string and replace '?' with the maximum possible digit based on the position.

• For the first digit (hours), if it is '?', replace it with '2' if the second digit is also '?', else replace it with '1'.

• For the second digit (hours), if it is '?', replace it with '3' if the first digit is '2', else replace it with '9'.

• For the third digit (minutes), if it...read more

Calculate sum of bit differences among all pairs in an array of integers.

• Iterate through all pairs of elements in the array

• Convert each pair of elements to binary representation

• Count the differing bits in the binary representations

• Sum up the differing bits for all pairs to get the final result

Search for integers in a rotated sorted array efficiently using binary search.

• Use binary search to efficiently find the index of each query integer in the rotated sorted array.

• Handle the rotation of the array by finding the pivot point first.

• Check which half of the array the query integer falls into based on the pivot point.

• Return the index of the query integer if found, else return -1.

My strength lies in my problem-solving skills and ability to work well in a team. My long term goal is to become a lead developer and contribute to innovative projects.

• Strong problem-solving skills

• Effective team player

• Long term goal of becoming a lead developer

• Contribute to innovative projects

In a country where families keep having children until they have a boy, what is the proportion of boys to girls?

• The proportion of boys to girls is not 50:50

• The probability of having a boy or a girl is always 50%

• The more girls a family has, the higher the probability of having a boy in the next pregnancy

• The proportion of boys to girls will depend on the number of families and their fertility rates

Determine the number of good quality bulbs remaining after 'N' rounds of a unique technique.

• In each round, bulbs are toggled based on their position (e.g. every second bulb, every third bulb, etc.)

• At the end of 'N' rounds, count the bulbs that remain on to determine the number of good quality bulbs.

• Example: For N = 4, bulbs 1 and 4 remain on, so the output is 2.

Given a dictionary and queries with wildcard characters, determine how many words in the dictionary can match each query.

• Iterate through each query and dictionary word to check for matches

• Replace '?' with all possible lowercase letters and compare with dictionary words

• Count the number of matches for each query

By introducing new menu items, optimizing pricing strategy, and improving the overall dining experience.

• Conduct a survey to understand the preferences of employees

• Introduce healthy and affordable meal options

• Offer discounts for bulk orders or loyalty programs

• Partner with local vendors to source fresh ingredients

• Improve the ambiance and seating arrangements

• Implement online ordering and delivery services

Given a singly linked list of integers and a reference to a node, delete the specified node from the linked list.

• Traverse the linked list to find the node to be deleted.

• Update the pointers to skip over the node to be deleted.

• Print the modified linked list after deletion.

• Ensure the node to be deleted is not the tail node.

Find the maximum sum of a contiguous subarray within an array of integers.

• Use Kadane's algorithm to find the maximum subarray sum efficiently.

• Initialize two variables: maxEndingHere and maxSoFar.

• Iterate through the array and update the variables accordingly.

• Return the maxSoFar as the result.

Find the size of the smallest subset with maximum OR value among all subsets of an array of positive integers.

• Iterate through all possible subsets of the array

• Calculate the OR value for each subset

• Track the size of the smallest subset with maximum OR value

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.

• Initialize the array with base cases and then iterate through the denominations to fill up the array.

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

• Example: For N=3, D=[1, 2, 3], V=4, the output should be...read more

Find all possible paths for a rat in a maze to reach its destination, given a matrix representation of the maze.

• Use backtracking to explore all possible paths from the starting position to the destination.

• Keep track of the current path and explore all possible directions at each step.

• Terminate the exploration when reaching the destination and add the path to the result list.

• Sort the result list of paths in alphabetical order before returning.

Count distinct values obtained by applying bitwise OR operation on all possible subarrays of an array of positive integers.

• Use a set to store distinct values obtained by bitwise OR operation on all subarrays.

• Iterate through all subarrays efficiently to calculate distinct values.

• Optimize the solution to handle large input sizes efficiently.

House Robber problem - determine maximum amount of money to rob without triggering alarm in circular arrangement of houses.

• Use dynamic programming to keep track of maximum money robbed at each house.

• Consider two cases: robbing the first house and not robbing the first house.

• Handle circular arrangement by considering the first and last house separately.

• Example: For arr[] = {2, 3, 2}, the output is 3. Mr. X robs house 2.

• Example: For arr[] = {1, 2, 3, 1}, the output is 4. Mr. X ...read more

Linked List is the best-suited data structure for chain type data.

• Linked List is a dynamic data structure that can grow or shrink during runtime.

• It allows efficient insertion and deletion operations.

• Each node in the linked list contains a reference to the next node.

• Examples of chain type data include a list of songs in a playlist or a list of tasks in a to-do list.

Popular APIs for Social Commerce services

• Facebook Graph API for social media integration

• Instagram API for photo sharing and tagging

• Twitter API for real-time updates and customer engagement

• Pinterest API for product discovery and sharing

• Google Maps API for location-based services

• PayPal API for secure payment processing

The problem involves finding the maximum element in each sliding window of size 'K' in an array of integers.

• Use a deque to store indices of elements in the current window in decreasing order of their values.

• Remove indices that are out of the current window from the front of the deque.

• Add the maximum element (at the front of the deque) to the result for each window.

Validate if a binary tree is a Binary Search Tree (BST) based on given properties.

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

• Verify 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 level order form to validate the BST properties.

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

Implement a Sudoku solver for a 9x9 grid with constraints on row, column, and 3x3 grid.

• Create a recursive function to solve the Sudoku puzzle by trying out different numbers in empty slots.

• Use backtracking to backtrack and try different numbers if a conflict is encountered.

• Ensure each number appears only once in each row, column, and 3x3 grid.

• Implement a function to check if a number can be placed in a particular position based on Sudoku rules.

• Test the solver with different S...read more

Count the number of palindrome words in a given string.

• Split the string into words using whitespace as delimiter.

• Check each word if it is a palindrome by comparing it with its reverse.

• Increment a counter for each palindrome word found.

• Output the final count of palindrome words for each test case.

Java is platform independent due to its bytecode and JVM implementation.

• Java code is compiled into bytecode, which can run on any platform with a Java Virtual Machine (JVM)

• JVM acts as an interpreter, translating bytecode into machine code specific to the underlying platform

• This allows Java programs to be written once and run anywhere, without the need for recompilation

Java is a high-level, object-oriented programming language that is platform-independent and widely used for developing applications, websites, and games.

• Developed by Sun Microsystems

• Collection of objects

• High performance and multi-threaded

• Used for developing Android apps, enterprise applications, and web applications

Stay calm, grab onto the side of the blender and wait for someone to rescue you.

• Stay calm and don't panic

• Grab onto the side of the blender

• Wait for someone to rescue you

• Try to make noise to attract attention

Software engineering is the process of designing, developing, testing, and maintaining software.

• It involves using engineering principles to create high-quality software

• It includes various stages such as requirements gathering, design, coding, testing, and maintenance

• Theoretical knowledge includes understanding of algorithms, data structures, programming languages, and software design patterns

• Examples of software engineering practices include Agile, Waterfall, and DevOps metho...read more

A pirate must divide 100 gold coins among 5 pirates, but if fewer than half agree, he gets killed. How can he maximize his share and live?

• The top pirate should offer 1 coin to the lowest ranked pirate, and keep 99 for himself.

• The second-lowest ranked pirate will vote for this plan, as he will get nothing if the top pirate is killed.

• The third-lowest ranked pirate will also vote for this plan, as he will get nothing if the second-lowest ranked pirate's plan is chosen.

• The top pi...read more

Static binding is resolved at compile time, while dynamic binding is resolved at runtime.

• Static binding is also known as early binding, where the method call is resolved at compile time based on the type of the object.

• Dynamic binding is also known as late binding, where the method call is resolved at runtime based on the actual type of the object.

• Example of static binding: method overloading.

• Example of dynamic binding: method overriding.

Adding an element at the end of a singly linked list takes more time based on the length of the list.

• Adding an element at the end requires traversing the entire list to reach the last element.

• Adding an element at the first only requires updating the next pointer of the new element and the head pointer.

• Exchanging the first two elements and deleting the element from the end can be done in constant time.

Use a balance to find the heavier ball among eight balls with only two weighings.

• Divide the eight balls into three groups of three, three, and two balls.

• Weigh the two groups of three balls against each other.

• If the two groups weigh the same, the heavier ball is in the group of two balls.

• If one group of three balls weighs more, select two balls from that group and weigh them against each other.

• If they weigh the same, the heavier ball is the remaining one. If they don't, the he...read more