problem solving array questions

50+ array questions with solutions (easy, medium, hard)

To ace your coding interview for a software engineering job, you’ll need to understand arrays. They come up frequently in coding interviews and are fundamental to many other data structures too.

Let’s take a look at some array questions that come up in interviews. 

6 typical array interview questions

• Given a sorted array, return the index of a given value, or -1 if the element cannot be found.
• What is the time complexity required to find if an array of sorted integers contains a given integer?
• Given an array with all integers between 1 and 100 except for one, find the missing number.
• Given a 2D array of integers, rotate clockwise without using additional memory.
• If you have two sorted arrays, how can you merge them and keep the resulting array sorted?
• Given unlimited coins in denominations of 1c, 2c, and 5c, how many different ways can you make a total of 20c? Can you solve the general version of this problem for an arbitrary target amount and a given list of denominations?

Below, we take a look at some more questions and provide you with links to high quality solutions to them. We explain how arrays work, their variations, and the most important things you need to know about them, including a useful 'cheat sheet' to remind you of the key points at a glance.

This is an overview of what we’ll cover:

• Easy array interview questions
• Medium array interview questions
• Hard array interview questions
• Array basics
• Array cheat sheet
• Mock interviews for software engineers

Click here to practice coding interviews with ex-FAANG interviewers

1. easy array interview questions.

You might be tempted to try to read all of the possible questions and memorize the solutions, but this is not feasible. Interviewers will always try to find new questions, or ones that are not available online. Instead, you should use these questions to practice the fundamental concepts of arrays.

As you consider each question, try to replicate the conditions you’ll encounter in your interview. Begin by writing your own solution without external resources in a fixed amount of time.

If you get stuck, go ahead and look at the solutions, but then try the next one alone again. Don’t get stuck in a loop of reading as many solutions as possible! We’ve analysed dozens of questions and selected ones that are commonly asked and have clear and high-quality answers.

Here are some of the easiest questions you might get asked in a coding interview. These questions are often asked during the ‘phone screen’ stage, so you should be comfortable answering them without being able to write code or use a whiteboard.

1.1 Merge two sorted arrays 

• Text guide (GeeksforGeeks)
• Video guide (TECH DOSE)

1.2 Remove duplicates from an array

• Video guide (Kevin Naughton Jr.)
• Text guide (W3Schools)
• Text guide (Javarevisted)
• Code example (LeetCode)

1.3 Count the frequency of an element in an array

• Video guide (SDET)

1.4 Two sum

• Text guide (Codeburst)

1.5 Find the minimum (or maximum) element of an array

• Text guide (Enjoy Algorithms)
• Text guide (After Academy)
• Video guide (GeeksforGeeks)

1.6 Remove duplicates from sorted array

• Text guide (Redquark)
• Video guide (Take u Forward)

1.7 Remove element in-place

• Video guide (Nick White)
• Code example (LeetCode) 

1.8 Search Insert Position

• Text guide (Codesdope)
• Video guide (NeetCode)

1.9 Maximum Subarray

• Text guide (Wikipedia)
• Text guide (Techie Delight)
• Video guide (CS Dojo)

1.10 Plus One

• Text guide (Medium/Punitkmryh)
• Video guide (Back to Back SWE)

1.11 Convert Sorted Array to Binary Search Tree (Arrays/Binary Trees)

• Text guide (GeeksForGeeks)
• Video guide (Kevin Naughton Jr)

1.12 Single Number

• Text guide (Akhilpokle)

1.13 Count Primes

• Video guide (Terrible Whiteboard)

1.14 Contains Duplicate

1.15 third largest number, 1.16 count odd even.

• Text guide (W3resource)
• Video guide (Technotip)

2. Medium array interview questions

Here are some moderate-level questions that are often asked in a video call or onsite interview. You should be prepared to write code or sketch out the solutions on a whiteboard if asked.

2.1 Move all zeros to the beginning/end of an array 

• Text guide (Educative) 
• Video guide (Programming tutorials)

2.2 Find if a given element is in a sorted array (binary search)

• Text guide (Khan academy)
• Video guide (HackerRank)

2.3 Rotate an array 

2.4 largest sum of non-adjacent numbers (dynamic programming).

• Text guide (Medium/Arun Kumar)
• Video guide (Coding Simplified)

2.5 A Product Array Puzzle 

• Text guide (TutorialCup)

2.6 Maximum Product Subarray (Dynamic programming)

2.7 shortest unsorted continuous subarray.

• Text guide (Seanpgallivan)

2.8 Maximum sum of hour glass in matrix

• Video guide (Over The Shoulder Coding)

2.9 Paint House (Dynamic programming)

• Text guide (ProgrammerSought) 

2.10 Minimum number of jumps to reach end

• Text guide (Medium/Himanshu)

2.11 Find duplicates in O(n) time and O(1) extra space

2.12 find three numbers with the maximum product.

• Video guide (Programmer Mitch)

2.13 Maximum Sum Circular Subarray

• Text Guide (Techie Delight)
• Video Guide (TECH DOSE)

2.14 Minimum number of swaps to sort an array

• Video guide (Brian Dyck)

3. Hard array interview questions

Similar to the moderate section, these more difficult questions may be asked in an onsite or video call interview. You will likely be given more time if you are expected to create a full solution.

3.1 Rotate a 2D array 

• Text guide (Jack)
• Text guide (GeeksforGeeks) 
• Video guide (Nick White) 

3.2 Create change with coins (dynamic programming)

• Video guide (Back to Back SWE) 

3.3 Sliding window maximum

• Video guide (Jessica Lin)

3.4 Find the smallest positive number missing from an unsorted array

• Text guide (Codes Dope)
• Video guide (Michael Muinos)

3.5 Find the missing number in unordered Arithmetic Progression

3.6 find the maximum j – i such that arr[j] > arr[i] (distance maximising problem).

• Video guide (Genetic Coders)

3.7 Array manipulation

• Text guide (The Poor Coder)

3.8 Median of Two Sorted Arrays

3.9 sudoku solver.

• Video guide (Back To Back SWE)

3.10 Largest Rectangle in Histogram

3.11 maximal rectangle in binary matrix, 3.12 find minimum in rotated sorted array .

• Text guide (Algorithmsandme)

3.13 Count of Smaller Numbers After Self

• Text guide (CodeStudio)
• Video guide (Happygirlzt)

3.14 Palindrome Pairs

3.15 sort an array containing 0’s, 1’s and 2’s.

• Text guide   (Techie Delight)

3.16 Longest increasing subsequence

3.17 trapping rain water , 4. array basics.

In order to crack the questions above and others like them, you’ll need to have a strong understanding of arrays, how they work, and when to use them. Let’s get into it.

4.1 What is an array?

An array is a list-like data structure that contains a collection of values , each associated with a specific index , usually with a fixed overall size. For example, the image below shows an array that has space for up to nine elements, but contains only four. This array has the integers 1, 2, 3, and 4 as its values and these are at the “zeroth”, first, second, and third indices respectively.

Arrays are one of the most fundamental data structures in programming and computer science, and many more complex data structures are built using arrays. The array itself is not always as simple as it might seem, and it forms the basis for many tricky interview questions.

4.1.1 Types of arrays (Java, Python, C++)

Interviewers often ask questions about “arrays”, as if it cleanly refers to a single concept. In reality, there are different types of arrays, and different languages implement arrays in different ways, leading to some confusion and complexity. Mainstream programming languages offer a default built-in array implementation (e.g. `list` in Python, or `int []` in Java and C++), and usually offer alternative implementations that the user can import from a standard library.

In many languages, including Java, default arrays are static and homogenous. Static means that the size of the array (the number of elements that it can hold) has to be declared upfront, when the array is created. Homogenous means that all of the elements in the array must be of the same type - e.g. an array of integers cannot contain string or float elements.

In other languages, including Python, the default array (`list`) is dynamic and heterogeneous. This means that they can be resized dynamically at run time, and can contain a mix of different types.

You will also often encounter nested or multidimensional arrays (often called a matrix). For 2D arrays, you can usually think of these as tables with rows and columns.

Because array terminology and implementation differs across languages, it’s always a good idea to check your assumptions about a specific array question with your interviewer.

4.1.2 How arrays store data

As with strings, data stored in arrays is traditionally kept in the heap of computer memory. If you store a basic integer in a variable with a statement like `int x = 1;`, that value is stored on the stack. To answer many array-related interview questions, you should understand the fundamentals of stack vs heap .

Data in the heap has to be cleared manually in languages like C, or by the garbage collector in languages such as Java. You should be prepared to answer questions about the implications of this (for example, how it could lead to a memory leak ).

Because arrays need to store data in contiguous blocks of memory, the programmer often needs to be aware of tradeoffs around space and time when it comes to using arrays. 

• If you don’t reserve enough space in your array, you waste time as you have to allocate a new array.
• If you reserve too much space, this is a waste of resources and could impact the requirements of your program, or other running programs.

Adding even a single element to a ‘full’ array is an expensive operation. A new (bigger) array has to be allocated, and every single element has to be copied across. Only then can the new element be added. 

A common approach that languages use for dynamic arrays is to double their allocated size every time they become full. So if you need to add an 11th item to an array of size 10, the library will create a new array of size 20 and copy across the existing data.

This means that as you are adding elements to an array, most inserts will be fast, but your code will slow down significantly every time it triggers a resize.

4.1.3 How arrays compare to other data structures

Because strings are usually implemented as arrays of characters, many interview questions for arrays can be phrased as string interview questions, and vice-versa. 

Arrays are also closely related to linked lists, and many questions will expect you to be able to explain the differences between them, and when one has an advantage over the other.

Finally, arrays are often contrasted with sets. When you want to get data at a specific index (e.g. “I need the fifth element in this list”), arrays perform better than sets, as you can access any given element by its index in O(1) time. 

If you need to check if a specific value is contained in the array (“Does my array contain the value 5 at any position?”), arrays are not efficient. You need to loop through every single value to see if it matches what you are looking for, while sets can provide this in O(1) time.

Need a boost in your career as a software engineer?

If you want to improve your skills as an engineer or leader, tackle an issue at work, get promoted, or understand the next steps to take in your career, book a session with one of our software engineering coaches.

5. Array cheat sheet

You can download the cheat sheet  here.

5.1 Related algorithms and techniques

• Binary search  
• Dynamic Programming  
• Converting to a Set  
• Sliding window  
• Two pointers  
• Prefix sum  
• Recursion  
• Searching  
• Looping  
• Sorting  

5.2 Related concepts

• Homogeneous (elements have same type)
• Dynamic (size can change)

5.3 Cheat sheet explained

The cheat sheet above is a summary of information you might need to know for an interview, but it’s usually not enough to simply memorize it. Instead, aim to understand each result so that you can give the answer in context.

The cheat sheet is broken into time complexity (the processing time for the various array operations) and space complexity (the amount of memory required). While you might be asked about these directly in relation to the array data structure, it’s more likely that you will need to know these in relation to specific array-related algorithms, such as searching and sorting, which is what the third section details.

For more information about time and space requirements of different algorithms, read our  complete guide to big-O notation and complexity analysis .

5.3.1 Time complexity

For time complexity, some of the results are fairly intuitive. For example, accessing any element of an array is always O(1) as arrays are stored in contiguous memory, so accessing the 100th element is no harder than accessing the first one, and this is true for updating any specific element too.

Deleting or inserting an element can require us to touch every single other element in some cases, so this is O(n) in the worst case. For example, if we have an array of size 10 and we want to add an 11th element, we need to copy each element to a new array first, and then add the new one. However, this is rare, as we would usually double the size of the array every time we run out of space, making future inserts faster. Thus the amortized complexity is still constant as we can ‘pay off’ the expensive operation over time.

The time complexity is similar when searching for an element by value, where in the worst case we need to look at every single element before finding our target, but if we ‘get lucky’ we might find it in the first place we look (probably at the start of the array), so our best case is O(1).

5.3.2 Space complexity

In most cases, the space complexity of an array is simply the number of elements, so this is O(n). In some contexts, the array might be some (small) constant size, which means the space complexity is simplified to O(1). Space complexity is almost always only relevant in the context of a specific algorithm, which we cover in the next section.

5.3.3 Array algorithms complexity

We’ve listed the algorithms that interviewers will most frequently discuss while asking about arrays, but there are dozens of other search algorithms and sorting algorithms. One of the most important aspects to understand is the tradeoff between mergesort and quicksort. Quicksort works in place, so does not require additional memory, while Mergesort uses an auxiliary array, and therefore uses more space. On the flip side, the worst time complexity of mergesort is better than that of quicksort which can in some cases (e.g. when the array is already sorted) perform as badly as a naive bubble sort.

For the search algorithms, a key insight to understand is that binary search is log(n) as we can eliminate half of the array with each operation. Therefore doubling the size of the array requires only one more operation. By contrast, a linear search looks at every element until it finds the target, so doubling the size of the array also requires, on average, twice as many operations.

For example, searching an element using binary search in an array of one million elements needs a maximum of 20 comparisons. Doubling the array (two million elements) would only add one extra comparison (a total of 21 comparisons). By contrast, a linear search would need one million comparisons and doubling the array would also double the number of comparisons (to two million).

6. Mock interviews for software engineers

Before you start practicing interviews, you’ll want to make sure you have a strong understanding of not only linked lists but also the rest of the relevant data structures. Check out our guides for questions, explanations and helpful cheat sheets.

• Linked lists
• Stacks and Queues
• Coding interview examples (with solutions)

Once you’re confident on all the topics, you’ll want to start practicing answering coding questions in an interview situation.

One way of doing this is by practicing out loud, which is a very underrated way of preparing. However, sooner or later you’re probably going to want some expert interventions and feedback to really improve your interview skills.

That’s why we recommend practicing with ex-interviewers from top tech companies. If you know a software engineer who has experience running interviews at a big tech company, then that's fantastic. But for most of us, it's tough to find the right connections to make this happen. And it might also be difficult to practice multiple hours with that person unless you know them really well.

Here's the good news. We've already made the connections for you. We’ve created a coaching service where you can practice system design interviews 1-on-1 with ex-interviewers from leading tech companies. Learn more and start scheduling sessions today.

Further reading: Best interview coaching services 2023

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

Top 50 Array Problems with Solutions A handpicked selection of array-based coding problems for interview preparation, with documented solutions in popular languages. Boost your problem-solving skills and contribute to this open-source project. Happy coding!

pranaydas1/Top-50-Array-Problems

Folders and files, repository files navigation, geeks for geeks - top 50 array problems.

Welcome to the "Geeks for Geeks - Top 50 Array Problems" repository! This collection includes problem statements and solutions for the "Top 50 Array Problems" from the Geeks for Geeks platform. These problems are a valuable resource for improving your data structures and algorithm skills and preparing for coding interviews.

Visit the Website

https://practice.geeksforgeeks.org/explore?page=1&sprint=50746f92a895c22a50504ac0c1fb9c84&sortBy=submissions&sprint_name=Top%2050%20Array%20Problems

Repository Overview

This repository is organized in a question-by-question format, with each problem statement and its corresponding solution available. Please note that these solutions are specifically designed for the Geeks for Geeks platform, as they rely on predefined input and test cases provided by Geeks for Geeks. As a result, they may not work in other code editors or environments.

Choose a Problem: Browse the repository to find a specific problem you'd like to practice.

Read the Problem Statement: Open the README file associated with the problem to read its description, constraints, and requirements.

Review the Solution: Explore the solution code provided in the accompanying code file. These solutions are tailored to work with Geeks for Geeks' predefined input and test cases.

Visit Geeks for Geeks: To practice and submit your solutions, visit the Geeks for Geeks platform ( https://www.geeksforgeeks.org/ ) and navigate to the respective problem. Use the provided solution in this repository as a reference to create your solution on the Geeks for Geeks platform.

Submit Your Solution: After solving the problem on the Geeks for Geeks platform, you can test it using their predefined test cases and submit your solution for evaluation.

Contributions

This repository is open for contributions. If you have alternative solutions, improvements, or suggestions, feel free to create a pull request. Contributions are a valuable way to enhance the quality and variety of solutions available.

Please note that the solutions provided here are intended for learning and reference purposes, specifically for use on the Geeks for Geeks platform. They may not work in other coding environments due to the platform-specific input and test cases.

Happy coding and best of luck with your Geeks for Geeks practice!

Techniques for Solving Array Problems

Array challenges and problems.

In the world of programming, arrays are versatile and essential data structures, but they often come with their own set of challenges. From searching for elements to optimizing performance, solving array problems efficiently is a valuable skill for any developer. In this guide, we will explore common array challenges and provide techniques to overcome them.

Duplicate Elements in an Array

One common challenge is identifying and handling duplicate elements within an array. Whether you're working with user data or need to remove redundant values, you can use techniques like hash sets or sorting to detect and eliminate duplicates.

Example: Removing Duplicates in Python

Finding an element in an unsorted array.

Searching for an element in an unsorted array can be inefficient. Utilize techniques like linear search to locate an element by iterating through the array one element at a time.

Example: Linear Search in C++

Optimizing Array Traversal

Efficiently traversing arrays is crucial for improving program performance. Utilize techniques like caching or parallelization to speed up array processing, especially when dealing with large datasets.

Handling Array Edge Cases

Array challenges often involve managing edge cases, such as empty arrays or arrays with a single element. Always consider these scenarios when designing your array-related algorithms.

Sorting Arrays

Sorting is a fundamental operation when working with arrays. Techniques like quicksort, mergesort, or the built-in sorting functions in your programming language can help you organize array elements efficiently.

Example: Quicksort in Python

Handling Multi-dimensional Arrays

When working with multi-dimensional arrays, techniques like nested loops and matrix operations can simplify complex tasks like matrix multiplication or image processing.

Solving array challenges and problems is a critical aspect of programming. This guide has explored various techniques, provided code examples, and offered strategies for tackling common array-related issues. By mastering these techniques, you'll become a more proficient and resourceful developer, equipped to handle a wide range of programming tasks.

As you continue your programming journey, remember that array challenges are a stepping stone to more complex data structures and problem-solving. Practice and experience will make you even more adept at handling arrays and other programming challenges.

Hi, I'm Ada, your personal AI tutor. I can help you with any coding tutorial. Go ahead and ask me anything.

I have a question about this topic

Give more examples

Ace your Coding Interview

• DSA Problems
• Binary Tree
• Binary Search Tree
• Dynamic Programming
• Divide and Conquer
• Linked List
• Backtracking

Array – Interview Questions and Practice Problems

An array is a data structure consisting of a collection of elements (values or variables), each identified by at least one array index or key. The simplest type of data structure is a linear array, also called a one-dimensional array.

Arrays are among the oldest and most important data structures and are used by almost every program. They are also used to implement many other data structures, such as lists, heaps, hash tables, deques, queues, stacks, strings.

  In this post, we have listed out commonly asked interview questions that use array data structure:

• Find a pair with the given sum in an array Easy
• Check if a subarray with 0 sum exists or not Medium
• Print all subarrays with 0 sum Medium
• Sort binary array in linear time Easy
• Find maximum length subarray having a given sum Medium
• Find maximum length subarray having an equal number of 0’s and 1’s Medium
• Find the maximum product of two integers in an array Easy
• Sort an array of 0’s, 1’s, and 2’s (Dutch National Flag Problem) Medium
• In-place merge two sorted arrays Medium
• Merge two arrays by satisfying given constraints Medium
• Find the index of 0 to be replaced to get the maximum length sequence of continuous ones Hard
• Shuffle an array using Fisher–Yates shuffle algorithm Medium
• Rearrange an array with alternate high and low elements Medium
• Find equilibrium index of an array Easy
• Find the largest subarray formed by consecutive integers Medium
• Find majority element (Boyer–Moore Majority Vote Algorithm) Easy
• Move all zeros present in an array to the end Easy
• Replace every array element with the product of every other element Medium
• Longest Bitonic Subarray Problem Medium
• Find the maximum difference between two array elements that satisfies the given constraints Medium
• Print continuous subarray with maximum sum Medium
• Maximum Sum Circular Subarray Hard
• Find all distinct combinations of a given length – I Medium
• Find the maximum sequence of continuous 1’s formed by replacing at-most k zeroes by ones Medium
• Find minimum sum subarray of size k Medium
• Maximum Product Subarray Problem Hard
• Find a subarray having the given sum in an integer array Medium
• Find the smallest subarray length whose sum of elements is greater than k Medium
• Find the smallest window in an array sorting which will make the entire array sorted Medium
• Find maximum sum path involving elements of given arrays Medium
• Find maximum profit earned by buying and selling shares any number of times Medium
• Trapping Rain Water Problem Hard
• Find minimum platforms needed to avoid delay in the train arrival Medium
• Decode an array constructed from another array Medium
• Sort an array in one swap whose two elements are swapped Easy
• Find a triplet with the given sum in an array Medium
• Find the longest continuous sequence length with the same sum in given binary arrays Hard
• Reverse every consecutive m -elements of a subarray Medium
• Maximum Product Subset Problem Easy
• Find pairs with difference k in an array Easy
• 4–Sum Problem | Quadruplets with a given sum Medium
• Print all quadruplets with a given sum | 4 sum problem extended Medium
• Quickselect Algorithm Medium
• Rearrange array such that A[A[i]] is set to i for every element A[i] Hard
• Print all triplets that form an arithmetic progression Medium
• Print all triplets that form a geometric progression Medium
• Group elements of an array based on their first occurrence Medium
• Find the minimum difference between the index of two given elements present in an array Easy
• Find the maximum absolute difference between the sum of two non-overlapping subarrays Hard
• Find all symmetric pairs in an array of pairs Medium
• Find the closest pair to a given sum in two sorted arrays Medium
• Partition an array into two subarrays with the same sum Easy
• Find the count of distinct elements in every subarray of size k Medium
• Find two numbers with maximum sum formed by array digits Easy
• Print all subarrays of an array having distinct elements Medium
• Find a triplet having the maximum product in an array Medium
• Find the minimum index of a repeating element in an array Easy
• Find a pair with a minimum absolute sum in an array Easy
• Find an index of the maximum occurring element with equal probability Easy
• Check if an array is formed by consecutive integers Medium
• Find two non-overlapping pairs having the same sum in an array Medium
• Add elements of two arrays into a new array Easy
• Find minimum product among all combinations of triplets in an array Medium
• Count distinct absolute values in a sorted array Medium
• Print all combinations of positive integers in increasing order that sums to a given number Hard
• Find all distinct combinations of a given length – II Medium
• Find subarrays with a given sum in an array Medium
• Find maximum length sequence of continuous ones (Using Sliding Window) Medium
• Find maximum length sequence of continuous ones Medium
• Find the index that divides an array into two non-empty subarrays with equal sum Easy
• Efficiently calculate the frequency of all elements present in a limited range array Medium
• Rearrange an array such that it contains alternate positive and negative numbers Medium
• Find the sorted triplet in an array Medium
• Shuffle an array according to the given order of elements Medium
• Count the number of strictly increasing subarrays in an array Medium
• Find duplicates within a range k in an array Easy
• Find a minimum range with at least one element from each of the given arrays Hard
• Find the longest subsequence formed by consecutive integers Medium
• Determine the index of an element that satisfies given constraints in an array Easy
• Find minimum moves required for converting a given array to an array of zeroes Medium
• Left rotate an array Easy
• Right rotate an array k times Easy
• Activity Selection Problem Easy
• Job Sequencing Problem with Deadlines Medium
• 3–partition problem extended | Printing all partitions Hard
• Count triplets which form an inversion in an array Easy
• Determine whether an array can be divided into pairs with a sum divisible by k Medium
• Find minimum removals required in an array to satisfy given constraints Medium
• Find a pair with the given sum in a circularly sorted array Medium
• Segregate positive and negative integers in linear time Easy
• Find the minimum and maximum element in an array using minimum comparisons Medium
• Insertion Sort Algorithm Easy
• Selection Sort Algorithm Easy
• Bubble Sort Algorithm Easy
• Merge Sort Algorithm Easy
• Iterative Merge Sort Algorithm (Bottom-up Merge Sort) Medium
• Quicksort Algorithm Medium
• Hybrid QuickSort Algorithm Medium
• Quicksort using Dutch National Flag Algorithm Medium
• Quicksort algorithm using Hoare’s partitioning scheme Medium
• Counting Sort Algorithm Easy
• Heap Sort Algorithm Medium
• Introsort Algorithm – Overview and C++ Implementation Hard
• External Merge Sort Algorithm Hard
• Inversion count of an array Hard
• Problems solved using partitioning logic of Quicksort Easy
• Sort elements by their frequency and index Medium
• Sort an array based on order defined by another array Medium
• Efficiently sort an array with many duplicated values Medium
• Find the largest number possible from a given set of numbers Medium
• Find surpasser count for each array element Hard
• Segregate positive and negative integers using merge sort Medium
• Water Jugs Problem Hard
• Sort an array using Young tableau Hard
• Find all combinations of elements satisfying given constraints Medium
• K–Partition Problem | Printing all partitions Hard
• Find all distinct combinations of a given length with repetition allowed Medium
• Print all combinations of numbers from 1 to n having sum n Medium
• Print all triplets in an array with a sum less than or equal to a given number Medium
• Difference between Subarray, Subsequence, and Subset Beginner
• Print all distinct subsets of a given set Hard
• Find the missing number in an array Easy
• Find the missing number in an array without using any extra space Easy
• Find the odd occurring element in an array in a single traversal Easy
• Find two odd occurring elements in an array without using any extra space Medium
• Find all odd occurring elements in an array having a limited range of elements Medium
• Find the duplicate element in a limited range array Medium
• Find two duplicate elements in a limited range array (using XOR) Medium
• Find the missing number and duplicate elements in an array Medium
• Merging Overlapping Intervals Medium
• Maximum Overlapping Intervals Problem Medium
• Find the next greater element for every element in a circular array Hard
• Find the next greater element for every array element Medium
• Find the previous smaller element for each array element Medium
• Reverse an array in C++ Easy
• Longest Increasing Subsequence Problem Hard
• Find all elements in an array that are greater than all elements to their right Easy
• Iterative Implementation of Quicksort Medium
• Combinations of words formed by replacing given numbers with corresponding alphabets Hard
• Replace every array element with the least greater element on its right Medium
• Print complete Binary Search Tree (BST) in increasing order Easy
• Binary Search Algorithm Easy
• Find the number of rotations in a circularly sorted array Easy
• Search an element in a circularly sorted array Medium
• Find the first or last occurrence of a given number in a sorted array Easy
• Count occurrences of a number in a sorted array with duplicates Medium
• Find the smallest missing element from a sorted array Medium
• Find floor and ceil of a number in a sorted integer array Easy
• Search in a nearly sorted array in logarithmic time Medium
• Find the number of 1’s in a sorted binary array Easy
• Find the peak element in an array Medium
• Maximum Subarray Sum using Divide and Conquer Medium
• Find the missing term in a sequence in logarithmic time Medium
• Find floor and ceil of a number in a sorted array (Recursive solution) Easy
• Find the frequency of each element in a sorted array containing duplicates Easy
• Find the odd occurring element in an array in logarithmic time Medium
• Find pairs with difference k in an array | Constant Space Solution Medium
• Find k closest elements to a given value in an array Medium
• Find the minimum and maximum element in an array using Divide and Conquer Easy
• Binary Search in C++ STL and Java Collections Beginner
• Ternary Search vs Binary search Beginner
• Exponential search Easy
• Interpolation search Easy
• Longest Increasing Subsequence using Dynamic Programming Hard
• Longest Decreasing Subsequence Problem Hard
• Longest Bitonic Subsequence Medium
• Maximum Sum Increasing Subsequence Problem Medium
• Matrix Chain Multiplication using Dynamic Programming Hard
• 0–1 Knapsack Problem Medium
• Maximize the value of an expression Hard
• Partition Problem using Dynamic Programming Medium
• Subset Sum Problem – Dynamic Programming Solution Medium
• 3–Partition Problem Medium
• Minimum Sum Partition Problem Hard
• Rod Cutting Problem Medium
• Coin change-making problem Medium
• Coin Change Problem Hard
• Longest Alternating Subsequence Problem Medium
• Weighted Interval Scheduling Problem Medium
• Box Stacking Problem Hard
• Activity Selection Problem using Dynamic Programming Medium
• Weighted Interval Scheduling – Dynamic Programming Solution Medium
• Find minimum jumps required to reach the destination Medium
• Find maximum profit earned from at most k stock transactions Hard
• Find the maximum sum of a subsequence with no adjacent elements Medium
• Minimum-weight triangulation of a convex polygon Hard
• Find maximum profit that can be earned by conditionally selling stocks Easy
• Truncate an integer array such that 2×min becomes more than max Hard
• Maximum Sum Subarray Problem (Kadane’s Algorithm) Easy
• Longest Alternating Subarray Problem Easy
• Find maximum profit earned from at most two stock transactions Hard
• Find ways to calculate a target from elements of the specified array Medium
• Find itinerary from the given list of departure and arrival airports Easy
• Introduction to Priority Queues using Binary Heaps Beginner
• Check if an array represents a min-heap or not Medium
• Convert max heap to min heap in linear time Easy
• Find k’th largest element in an array Medium
• Sort a k-sorted array Medium
• Merge M sorted lists of variable length Hard
• Find k’th smallest element in an array Medium
• Find the smallest range with at least one element from each of the given lists Hard
• Merge M sorted lists each containing N elements Hard
• Connect n ropes with minimal cost Easy
• Replace each array element by its corresponding rank Easy
• Generate the power set of a given set Medium
• Set both elements of a binary array to 0 in a single line Easy
• Generate random input from an array according to given probabilities Medium

Rate this post

Average rating 4.85 /5. Vote count: 113

No votes so far! Be the first to rate this post.

We are sorry that this post was not useful for you!

Tell us how we can improve this post?

Thanks for reading.

To share your code in the comments, please use our online compiler that supports C, C++, Java, Python, JavaScript, C#, PHP, and many more popular programming languages.

Like us? Refer us to your friends and support our growth. Happy coding :)

Top 50 Array Interview Questions and Answers

Array Interview Questions and Answers" provides concise, insightful responses to common array-related queries, essential for aspiring programmers and interview preparation.

The comprehensive guide of Array Interview Questions and Answers is designed to help you navigate and excel in array-related interviews.

Array manipulation is a fundamental skill for coding interviews, and mastering these questions is crucial for success in technical assessments. This compilation covers a diverse range of array-related topics whether you're a beginner looking to solidify your understanding or an experienced coder aiming to polish your skills.

Dive into these Array interview questions and answers to sharpen your problem-solving abilities and boost your confidence in handling array challenges during interviews! 

Array Interview Questions for Freshers

Preparing for an array interview as a fresher is crucial for securing a strong foundation in programming. Array-related questions serve as a litmus test for problem-solving skills and algorithmic understanding.

Below are key Array interview questions for freshers are tailored to assess their proficiency in arrays, offering valuable insights into their coding aptitude and logical reasoning. Brush up on these concepts, practice diligently, and approach interviews with confidence to make a lasting impression on potential employers.

What is an array and how is it used in programming languages?

View Answer

Hide Answer

An array is a data structure in programming languages , providing a systematic way to store and organize elements of the same data type. It enables efficient storage and retrieval of values by utilizing a contiguous memory block.

Arrays are crucial for tasks such as iteration, sorting, and searching, enhancing the overall efficiency of algorithms. They serve as a fundamental building block for various data manipulation operations in programming.

How do you initialize an array in languages like Java , C++ , or Python?

Initializing an array in Java involves specifying the data type and using the new keyword, followed by the array type and size.

Declare the array type and size in C++ within square brackets.

Use a list to represent an array in Python , specifying the elements within square brackets.

Can you explain the difference between a one-dimensional and a two-dimensional array?

A one-dimensional array is a linear collection of elements, arranged sequentially in a single row, accessed by a single index. A two-dimensional array in contrast, is organized as a grid with rows and columns, requiring two indices to access a specific element.

The primary distinction lies in dimensionality, where one-dimensional arrays are unidimensional, and two-dimensional arrays are bidimensional.

What is the significance of array indexes, and how are they used?

The significance of array indexes lies in their role as numerical identifiers for elements within an array. These indexes start from zero and help locate specific data points within the array. 

Efficient manipulation and retrieval of data are facilitated by these numerical references. Array indexes in programming languages are crucial for performing operations like insertion, deletion, and updating elements.

How do you access a specific element in an array?

Use array index to access a specific element in an array. Indexing in most programming languages starts from 0, so the first element is accessed with index 0, the second with index 1, and so on. For example, in Python, accessing an element in an array named 'arr' using square brackets like this: arr[2], retrieves the third element. 

Keep in mind that exceeding the array bounds lead to errors, so it's essential to ensure the index is within the valid range.

What is a multi-dimensional array, and can you give an example of its use?

A multi-dimensional array is an array with more than one dimension, allowing storage of data in multiple levels. This structure is useful for representing tables, matrices, or other complex data sets. E011ach element stores information about a specific square, utilizing two dimensions to represent rows and columns efficiently.

How do you iterate through an array using a loop?

Employ a variety of loop constructs in programming languages such as for loops, while loops, or do-while loops to iterate through an array using a loop. These loops allow you to sequentially access each element in the array, performing operations or checks until the entire array has been traversed. Interact with each element individually utilizing the loop index or pointer, facilitating tasks like data manipulation, searching, or sorting within the array.

What are the advantages of using arrays over other data structures in certain scenarios?

Arrays offer advantages over alternative data structures due to their contiguous memory allocation and constant-time access capabilities. This compact memory arrangement allows for efficient indexing, resulting in swift retrieval and manipulation of elements. 

Arrays are well-suited for scenarios requiring fixed-size collections, ensuring predictable resource usage. This characteristic is valuable in applications where space constraints or predefined data structures are essential. Arrays exhibit straightforward implementation and ease of use, simplifying code and promoting readability. This simplicity makes arrays an optimal choice for scenarios where a balance between performance and simplicity is crucial.

Can you explain the concept of dynamic arrays?

Dynamic arrays, also known as resizable arrays or ArrayLists in certain programming languages, are data structures that allow flexible resizing during runtime. Dynamic arrays dynamically adjust their size to accommodate varying amounts of data. This is achieved by allocating memory as needed and copying the existing elements to the newly allocated space.

Dynamic arrays offer efficient random access and are used due to their ability to dynamically adapt to changing storage requirements in real-time.

Your engineers should not be hiring. They should be coding

Help your team focus on what they were hired for. Flexiple will manage your entire hiring process and scale your tech team.

What is the difference between statically-typed and dynamically-typed languages when dealing with arrays?

Statically-typed languages require declaring the data type of an array at compile-time, providing strict type checking. Dynamically-typed languages, in contrast, determine the array's type at runtime, offering more flexibility but potentially leading to runtime errors. The choice between them impacts code efficiency, type safety, and development speed.

How do you add elements to an array, and what are the limitations?

The "push" method is used in most programming languages to append items at the end for adding elements in an array. Alternatively, you can also assign values directly to specific indices in an array. It's crucial to be mindful of the array's size limitations, as exceeding its predefined capacity leads to memory overflow or runtime errors. Carefully manage the array's length to avoid performance issues and ensure optimal program execution.

What is array slicing and how is it useful?

Array slicing is the process of extracting a portion of an array in a concise manner. It allows selecting specific elements based on their indices or ranges. This feature is beneficial for efficiently manipulating and extracting subsets of data within an array, streamlining operations and enhancing code readability.

How do you remove elements from an array, and what happens to the array size?

Use methods like splice() in JavaScript or remove() in Python to remove elements from an array. These functions allow you to specify the index or value to be removed.

The array size is adjusted automatically upon removing elements. The size decreases by the number of elements removed, ensuring the array remains contiguous.

Can you explain the concept of sparse arrays?

A sparse array is a data structure that efficiently represents arrays where the majority of elements have a default value. Sparse arrays store only non-default values, reducing storage space and computational overhead. This is useful when dealing with large datasets containing mostly identical or zero values. 

Sparse arrays employ techniques like dictionaries or linked lists to store and access non-default elements, optimizing memory usage in scenarios where conventional arrays would be inefficient.

What are some common array operations in programming languages?

Some common array operations in programming languages include accessing elements, inserting values, deleting elements, and updating values.

Accessing an array element is done using its index, starting from 0. Inserting values involves adding elements at specific positions or appending at the end. Deleting elements removes them from the array, while updating involves modifying existing values.

Other operations include searching for elements, sorting the array, and finding the length or size of the array. These operations form the foundation for efficient manipulation of arrays in programming.

How do you reverse an array and what is the significance of doing so?

Iterate through half of the array length and swap elements from the beginning with those from the end to reverse an array.

This process is significant for various reasons in programming. It's a common algorithmic exercise that tests understanding of array manipulation. Reversing arrays is also practical for tasks like palindrome checking or optimizing certain algorithms. Additionally, reversing arrays is crucial in scenarios where data needs to be presented in the opposite order for better user experience or analysis.

What is the role of memory allocation in array management?

The role of memory allocation in array management is to determine the storage space assigned to an array. The allocated memory ensures that the array has sufficient contiguous space to store elements efficiently. Proper memory allocation allows for easy access and manipulation of array elements during program execution.

Additionally, it influences the overall performance of algorithms and operations involving the array. Efficient memory allocation optimizes the utilization of available resources, contributing to the effectiveness of array management.

Can you demonstrate how to sort an array using a basic algorithm?

Sorting an array is efficiently achieved through the Bubble Sort algorithm. This straightforward approach repeatedly iterates through the array, swapping adjacent elements if they are in the wrong order.

Here's a simple Python code snippet for a basic array sorting using Bubble Sort:

How do arrays interact with functions or methods in a program?

Arrays interact with functions or methods in a program through parameters and return values. The function receives a reference to the array when passing an array as a parameter, allowing it to modify the original data.

Functions also return arrays, providing a convenient way to encapsulate logic and data. Moreover, array methods, such as map, filter, and reduce, offer concise ways to manipulate arrays within functions. These methods take a function as an argument, applying it to each element of the array.

What are some common errors or issues encountered when working with arrays, and how can they be resolved?

Some common errors or issues encountered when working with arrays are discussed below along with their resolutions.

• Index Out of Bounds:

Issue: Accessing an array element with an index outside its bounds.

Resolution: Ensure index values are within the array's valid range.

• Null or Undefined Elements:

Issue: Operating on uninitialized or null elements in the array.

Resolution: Initialize array elements or handle null checks appropriately.

• Memory Overflows:

Issue: Allocating insufficient memory for array storage.

Resolution: Dynamically allocate memory or use data structures with dynamic sizing.

• Incorrect Data Types:

Issue: Storing incompatible data types within the array.

Resolution: Use consistent data types or implement type checking before operations.

• Inefficient Search Operations:

Issue: Inefficient search algorithms leading to slow performance.

Resolution: Opt for efficient search algorithms like binary search for sorted arrays.

• Unintended Mutations:

Issue: Modifying array elements unintentionally.

Resolution: Be cautious with in-place operations and consider creating a new array when needed.

• Unoptimized Loops:

Issue: Inefficient loop structures affecting array iteration.

Resolution: Optimize loops for better performance, minimizing unnecessary operations.

• Sparse Arrays:

Issue: Arrays with a significant number of unassigned or empty slots.

Resolution: Consider alternative data structures like hash tables for sparse data.

• Inadequate Error Handling:

Issue: Insufficient error handling for array-related operations.

Resolution: Implement robust error-handling mechanisms to catch and address issues.

• Multi-dimensional Array Confusion:

Issue: Confusion or errors when working with multi-dimensional arrays.

Resolution: Clearly understand and manage indices for each dimension to avoid confusion.

How Do You Implement an Array Data Structure From Scratch in a Programming Language That Does Not Provide Built-in Array Support?

Create a class or structure with properties for size and elements to implement an array data structure from scratch in a programming language lacking built-in array support. Define methods for initialization, access, insertion, and deletion operations. Use a dynamic memory allocation mechanism for flexibility. Here's a basic example in Python:

This example demonstrates a simple array implementation with methods for basic operations, maintaining bounds checks.

What are the time complexities of various array operations, and how can they be optimized?

The time complexities of various array operations are crucial considerations for optimizing performance.

• Accessing an element by index:

Time Complexity: O(1)

Optimization: No further optimization possible; constant time complexity.

• Inserting/deleting at the beginning:

Time Complexity: O(n)

Optimization: Use data structures like linked lists for constant-time insertions/deletions.

• Inserting/deleting at the end:

Time Complexity: O(1) for inserting, O(n) for deleting (due to shifting).

Optimization: Consider using a dynamic array with occasional resizing for deletions.

• Inserting/deleting in the middle:

Optimization: Use a data structure with better middle insertion/deletion performance, like a linked list.

• Searching for an element:

Optimization: Implement binary search if the array is sorted to achieve O(log n) complexity.

• Sorting the array:

Time Complexity: O(n log n) for efficient algorithms like Merge Sort or QuickSort.

Optimization: Choose the appropriate sorting algorithm based on specific requirements.

• Merging two arrays:

Optimization: Ensure sufficient space is pre-allocated to avoid resizing during the merge.

• Finding duplicates:

Optimization: Utilize hash tables or sorting to optimize duplicate detection algorithms.

Can you explain the concept of memory management in the context of array allocation and deallocation?

Memory management in the context of array allocation and deallocation refers to the efficient handling of computer memory to store and release arrays. It involves allocating contiguous memory space for arrays during creation and deallocating it when no longer needed.

Proper memory management prevents memory leaks and enhances program performance by optimizing resource utilization. Memory allocation ensures that arrays have sufficient space to accommodate elements, while deallocation releases memory when arrays go out of scope or are explicitly freed. Efficient memory management is crucial for preventing fragmentation and optimizing the use of available memory resources.

How do you handle array resizing in dynamic arrays, and what are the performance implications?

Employ strategies like doubling the array size when it reaches full capacity, to handle array resizing in dynamic arrays. This ensures efficiency in insertions. However, this approach leads to occasional over-allocation. Resizing operations have a time complexity of O(n), but the amortized time complexity remains O(1) due to infrequent resizing. This balance optimizes performance, ensuring efficient memory utilization in dynamic arrays.

What are the differences between array lists and linked lists, and when would you choose one over the other?

Array lists and linked lists differ in their underlying data structures and performance characteristics.

Array lists use a dynamic array, providing constant-time access but can involve resizing, impacting performance. Linked lists use nodes with pointers, allowing for efficient insertions and deletions but with slower random access.

Choose array lists for frequent access and minimal insertions/deletions. Opt for linked lists when dynamic size and efficient insertions/deletions are crucial.

How do you efficiently search for an element in a sorted and an unsorted array?

Efficiently search in a sorted array using binary search, halving the search space at each step until the target is found or the array is exhausted. Use linear search for an unsorted array, iterating through elements one by one until the target is located, or the entire array is traversed.

Can you discuss the implementation and advantages of multi-dimensional arrays in high-performance computing?

Multi-dimensional arrays are structures that store data in more than one dimension, organized in rows and columns.

Syntax Example in C++:

Multi-dimensional arrays are stored in contiguous memory locations, facilitating efficient access.

Iterating through multi-dimensional arrays involves nested loops, one for each dimension.

Multi-dimensional arrays are widely used in image processing, simulations, and scientific computations due to their structured representation.

The advantages of multi-dimensional arrays in High-Performance Computing are discussed below.

• Parallel Processing: Multi-dimensional arrays enable parallel processing as computations are distributed across different dimensions.
• Cache Utilization: Contiguous memory storage enhances cache locality, reducing data retrieval times and boosting performance.
• Optimized Libraries: High-performance libraries like BLAS and LAPACK are optimized for multi-dimensional arrays, enhancing computational efficiency.
• Vectorization: Supports SIMD (Single Instruction, Multiple Data) operations, enabling processors to perform multiple operations simultaneously.
• Simplified Code: Expressing complex mathematical operations becomes more concise and readable, contributing to better maintainability.
• Algorithmic Efficiency: Algorithms designed with multi-dimensional arrays exhibit better time complexity, crucial for high-performance computing.
• Data Locality: Facilitates efficient data movement within the memory hierarchy, minimizing delays caused by data access times.

How do you implement and use jagged arrays (arrays of arrays with different lengths) in programming?

Create an array of arrays to implement and use jagged arrays in programming, where each inner array can have different lengths. Jagged arrays allow flexibility in size unlike a multidimensional array.

Jagged arrays are useful when dealing with uneven data structures or when the size of each dimension is not fixed. They provide dynamic allocation for arrays within an array.

What is the role of arrays in hash table implementation, and how do they affect collision resolution?

The role of arrays in hash table implementation is to serve as the underlying data structure for storing key-value pairs. Arrays provide direct access to elements based on their indices, making them ideal for quick retrieval.

Arrays in the context of collision resolution, enable the use of separate chaining or open addressing techniques. Each array index in separate chaining, holds a linked list of collided elements. Conversely, open addressing involves placing collided elements in the next available array slot.

How do you perform matrix operations using arrays, and what are the computational considerations?

Utilize built-in functions in programming languages like NumPy in Python for efficient computation to perform matrix operations using arrays. Matrix multiplication, addition, and subtraction are accomplished through these functions. Computational considerations include time complexity, where larger matrices result in increased processing time, and space complexity, with memory usage proportional to matrix size. Optimize code by leveraging parallel processing and avoiding unnecessary nested loops for improved performance.

Can you explain the concept of array destructuring in modern programming languages?

Array destructuring in modern programming languages refers to the process of unpacking values from arrays into distinct variables simultaneously. This technique enhances code readability and conciseness by assigning array elements to variables in a single line. It streamlines assignments, making code more expressive and efficient. Popular languages like JavaScript, Python, and Ruby support array destructuring, offering a concise syntax for working with arrays and facilitating cleaner code structures. This practice simplifies the handling of array data, promoting better code organization and reducing redundancy in assignments.

How do you efficiently merge two sorted arrays?

Employ the merge operation from the merge sort algorithm to efficiently merge two sorted arrays. 

• Initialize three pointers, two for each array, and one for the merged result. 
• Compare elements at the pointers and insert the smaller one into the merged array. 
• Increment the pointer of the array from which the element was selected. Continue this process until both arrays are exhausted. 
• If any elements remain in either array, append them to the merged array.

The time complexity is O(m + n), where m and n are the sizes of the two arrays.

What are the challenges and solutions in handling large arrays that exceed memory capacity?

Handling large arrays that exceed memory capacity poses significant challenges in terms of resource management and performance optimization.

Challenge: One major challenge is the potential for memory overflow, where the array size surpasses the available system memory. This leads to crashes or degraded performance.

Solution: Implementing techniques like memory-mapping files or virtual memory to efficiently use storage resources, allowing data to be accessed without loading the entire array into memory.

Challenge: Another challenge is the increased computational cost associated with processing large arrays. This leads to slower execution times and decreased system responsiveness.

Solution: Parallel processing and distributed computing strategies are employed, distributing the workload across multiple processors or systems for improved efficiency.

Challenge: Cache locality issues arise when working with large arrays, impacting the speed of data retrieval. 

Solution: Optimizing algorithms for spatial and temporal locality enhance cache performance.

How do you implement a circular buffer using arrays, and what are its applications?

Allocate a fixed-size array and maintain two pointers: one for the head and another for the tail to implement a circular buffer using arrays. Tail wraps around to the beginning when it reaches the end of the array, creating a circular structure.

This Python code demonstrates the basic functionalities of a circular buffer, including enqueue and dequeue operations, along with checks for empty and full conditions.

Applications of circular buffers include efficient data storage in streaming scenarios, such as audio processing and real-time systems. They provide constant-time access and facilitate continuous data flow without the need for shifting elements. Circular buffers are commonly employed in embedded systems, communication protocols, and buffering mechanisms.

Can you discuss different strategies for handling multidimensional array traversal?

The different strategies for handling multidimensional array traversal are discussed below.

• Linear Traversal: One straightforward strategy for handling multidimensional array traversal is linear traversal, where elements are accessed row by row or column by column in a linear fashion.
• Nested Loops: Implementing nested loops is a common technique, where the outer loop iterates over rows, and the inner loop iterates over columns, facilitating a systematic exploration of each element.
• Row-wise vs. Column-wise: Choosing between row-wise and column-wise traversal depending on the nature of the problem, optimizes performance by leveraging cache locality.
• Zigzag Traversal: An alternate approach involves zigzag traversal, where the direction of movement alternates between rows, ensuring a different exploration pattern.
• Diagonal Traversal: Diagonal traversal is applied for specific scenarios, accessing elements along diagonals, either left to right or right to left.
• Spiral Order: Traversing a matrix in a spiral order, moving from outer layers towards the center, is another effective strategy for multidimensional arrays.
• Block-wise Traversal: Dividing the array into blocks and processing each block separately enhances parallelism and facilitates efficient traversal.
• Recursive Approach: Utilizing recursion when dealing with irregular or nested structures, allows for a flexible traversal mechanism.
• Strided Access: Employing strided access patterns, where elements are accessed with a fixed step size, is beneficial in scenarios requiring selective element retrieval.
• Parallel Processing: Leveraging parallel processing techniques, such as using SIMD (Single Instruction, Multiple Data) instructions, significantly accelerates multidimensional array traversal.

How do array pointers work in low-level languages like C or C++?

Array pointers in low-level languages like C or C++, serve as memory addresses pointing to the initial element of an array. These pointers facilitate efficient access to array elements by indicating the location in memory. They increment or decrement based on the data type, allowing seamless traversal through the array. Dereferencing these pointers provides direct access to the values stored in the array. Manipulating array pointers is fundamental for efficient memory management and array operations in low-level programming languages.

What are the implications of array immutability in functional programming languages?

Array immutability in functional programming languages, ensures that once an array is created, its elements cannot be modified. This property has profound implications for program behavior.

• Immutable arrays promote referential transparency, enhancing code predictability by eliminating side effects during array operations.
• Concurrency benefits arise as immutable arrays facilitate parallel processing without concerns of shared mutable state, reducing the risk of race conditions.
• Debugging becomes simpler with immutable arrays, as their unchanging nature makes it easier to trace the source of issues without worrying about hidden modifications.
• Functional languages leverage immutable arrays for efficient memory usage, as sharing unchanged portions between data structures reduces redundancy and optimizes performance.

Overall, array immutability in functional programming fosters code reliability, concurrency advantages, simplified debugging, and optimized memory utilization.

How do you approach the problem of finding the longest or shortest sequence within an array?

Follow the below steps to find the longest sequence within an array.

• Employ a straightforward linear approach using iteration and tracking variables. 
• Initialize a counter variable and iterate through the array. 
• Keep track of the current sequence length and update the maximum length encountered so far. 
• Reset the counter when the sequence breaks. 

Here's a basic example code in Python:

Follow the below steps to find the shortest sequence within an array.

• Iterate through the array, keeping track of the current sequence length. 
• Update the minimum length encountered so far. Reset the counter when the sequence breaks. 

Here's a concise example in Python:

These algorithms have a time complexity of O(n) where n is the length of the array.

Can you explain the use of arrays in recursive algorithms and its impact on memory usage?

Arrays in recursive algorithms serve as dynamic data structures, enabling efficient manipulation of elements during function calls. The recursive nature of these algorithms allows for iterative processes without the need for explicit loops.

Arrays in recursive algorithms in terms of memory usage, impact the call stack. Each recursive call adds a new layer to the stack, consuming additional memory. As a result, excessive recursion leads to stack overflow errors.

It's crucial to manage memory effectively when employing arrays recursively, considering the potential for stack growth. Careful implementation and termination conditions are essential to prevent memory-related issues and ensure optimal algorithm performance.

How do parallel and distributed computing techniques apply to array processing for large datasets?

Parallel computing techniques enable simultaneous execution of operations across multiple elements, significantly enhancing processing speed. This approach involves dividing the dataset into smaller chunks and processing them concurrently.

Distributed computing further amplifies efficiency by distributing the workload across multiple nodes or machines. Each node processes a subset of the array, contributing to a collective computation effort. This strategy minimizes processing time for extensive datasets by leveraging the combined power of multiple computational resources.

Parallel and distributed computing techniques, therefore, play a crucial role in optimizing array processing for large datasets, facilitating faster and more scalable operations.

Array Coding Interview Questions

Array-related problems are common in coding interviews, testing a candidate's ability to manipulate data structures efficiently. We'll explore a curated list of questions in this section to sharpen your array-handling skills from basic array operations to intricate problem-solving scenarios.

The Array coding interview questions will cover a spectrum of difficulty levels. Each question is designed to assess your understanding of array fundamentals, algorithmic efficiency, and creative problem-solving. Practice these questions to gain confidence and enhance your performance in array-centric coding interviews.

How would you write a function to rotate an array to the right by a given number of steps?

Use array slicing to rotate an array to the right by a given number of steps in Python. Here's a simple python function to achieve this:

The function rotate_array_right takes an array arr and the number of steps as parameters. We use the modulo operator (%) to calculate the effective steps to handle cases where the number of steps is greater than the array length.

The rotation is performed using array slicing. arr[-steps:] represents the last steps elements of the array, and arr[:-steps] represents the array excluding the last steps elements.

These two sliced arrays are concatenated to form the rotated array, which is then returned.

Can you code a solution to find the 'Kth' largest element in an unsorted array?

Use the QuickSelect algorithm to find the Kth largest element in an unsorted array. This algorithm is an optimized version of the QuickSort algorithm. It partitions the array based on a chosen pivot, narrowing down the search space.

The key idea is to repeatedly partition the array until the pivot is at the Kth position, meaning we have found the Kth largest element. This is achieved by choosing the pivot strategically and partitioning the array accordingly.

Here's a Python implementation using the QuickSelect algorithm:

This implementation efficiently finds the Kth largest element in an unsorted array with a time complexity close to O(n), making it suitable for large datasets.

How do you implement an algorithm to check if an array contains duplicate elements within k distance from each other?

Utilize a sliding window approach to implement an algorithm to check if an array contains duplicate elements within k distance from each other. Define a set to keep track of elements within the window and iterate through the array.

This code uses a set to store elements within the current window of size k. The set is updated accordingly as the window slides through the array. The function returns True if a duplicate is found within the window; otherwise, it returns False.

What is the most efficient way to find the intersection of two arrays?

Utilize the HashSet data structure to efficiently find the intersection of two arrays. You can identify common elements in linear time complexity by converting one array into a HashSet and then iterating through the second array.

Here's an example in Python:

This approach ensures O(n) time complexity for the intersection operation, making it a highly efficient solution.

Can you demonstrate how to flatten a multidimensional array into a single-dimensional array?

Leverage the numpy library in Python to flatten a multidimensional array into a single-dimensional array. Here's an example using Python:

The flatten() method from the numpy library is used in this example to convert the multidimensional array into a single-dimensional array. This approach simplifies the structure, making it easier to work with flat arrays in various applications.

How would you write a program to shuffle an array ensuring that each element has an equal probability of appearing in any position?

Use the Fisher-Yates shuffle algorithm to shuffle an array with equal probability for each element in any position. Below is a simple implementation in Python:

This code employs the Fisher-Yates shuffle by iteratively swapping elements in the array, ensuring that each element has an equal chance of appearing at any position. The random.randint function is used to generate a random index for swapping, maintaining uniformity in the shuffling process.

Can you develop a function to segregate even and odd numbers in an array, maintaining their relative order?

Below is a simple function in Python to segregate even and odd numbers in an array while preserving their relative order:

This function iterates through the array, segregating even and odd numbers into two separate lists. Finally, it concatenates these lists to maintain the original relative order of numbers in the array.

How do you implement a solution to find all pairs in an array that sum up to a specific number?

Use a hash set data structure to find all pairs in an array that sum up to a specific number.

This code iterates through the array, calculating the complement for each element with respect to the target sum. A valid pair is identified and added to the result if the complement is found in the set of seen numbers. The set is updated as the iteration progresses to efficiently track seen numbers.

What is the most efficient way to find the smallest and second smallest elements in an array?

Use a single traversal approach to efficiently find the smallest and second smallest elements in an array. Initialize two variables to store the smallest and second smallest elements. Iterate through the array, updating these variables accordingly.

We iterated through the array once, updating the smallest and second smallest elements based on the encountered values. This approach ensures efficiency with a time complexity of O(n), where n is the size of the array.

Can you code an efficient method for computing the running sum of a 1D array?

Below is an efficient method for computing the running sum of a 1D array:

Explanation:

• We initialize the running sum array with the first element of the input array.
• We iterate through the input array starting from the second element.
• For each element, we add it to the running sum, which is the last element in the running sum array.
• The final result is an array containing the running sum of the input 1D array.

How to Prepare for an Array Interview?

Follow the key strategies discussed below to prepare for an Array interview.

• Understand Array Fundamentals: Ensure a solid grasp of basic concepts like indexing, element access, and array manipulation.
• Practice Coding Problems: Regularly solve array-related coding challenges on platforms like LeetCode and HackerRank to enhance problem-solving skills.
• Learn Time and Space Complexity: Comprehend the time and space complexity of array operations; optimize solutions to minimize both when solving problems.
• Explore Common Array Patterns: Familiarize yourself with common array patterns such as two-pointer technique, sliding window, and prefix sum for efficient problem-solving.
• Revise Sorting and Searching: Brush up on sorting and searching algorithms, as they are frequently applied in array-related problems.
• Focus on Edge Cases: Pay special attention to edge cases and boundary conditions to ensure robust solutions.
• Master Array-related Data Structures: Understand how arrays interact with other data structures like hash tables and linked lists.
• Review Previous Interviews: Analyze past array-related interview experiences, identify areas for improvement, and refine your approach accordingly.
• Stay Updated with Language-Specific Features: Keep abreast of language-specific array functions and features that can simplify problem-solving.
• Mock Interviews: Engage in mock interviews to simulate real interview conditions and enhance confidence in solving array problems under time constraints.

Interview Resources

Want to upskill further through more interview questions and resources? Check out our collection of resources curated just for you.

Browse Flexiple's talent pool

Explore our network of top tech talent. Find the perfect match for your project.

• Programmers
• React Native
• Ruby on Rails

• Interview Preparation Kit

2D Array - DS Easy Problem Solving (Basic) Max Score: 15 Success Rate: 93.15%

Arrays: left rotation easy problem solving (basic) max score: 20 success rate: 91.21%, new year chaos medium problem solving (basic) max score: 40 success rate: 67.48%, minimum swaps 2 medium problem solving (intermediate) max score: 40 success rate: 77.88%, array manipulation hard problem solving (intermediate) max score: 60 success rate: 61.36%, cookie support is required to access hackerrank.

Seems like cookies are disabled on this browser, please enable them to open this website

• Data Analysis
• Data Visualization
• Machine Learning
• Deep Learning
• Computer Vision
• AI ML DS Interview Series
• AI ML DS Projects series
• Data Engineering
• Web Scrapping

🚀 Join GeeksforGeeks in our next DSA Course video as we delve into the fascinating world of ARRAY PRACTICE PROBLEMS!

Uncover the secrets of solving well-known array problems that are frequently asked in interviews. We'll not only walk you through the problems but also provide strategic insights on how to approach and master them.

🕵️‍♂️ Elevate your problem-solving skills and gain a deeper understanding of Arrays and Array Manipulation.  Prepare to conquer your next interview with confidence and finesse by practicing our DSA Problems.

Problems on arrays

• +1-650-461-4192
• For sales enquiry [email protected]
• For support [email protected]
• Campus Ambassadors
• Assessments
• Learning and Development
• Interview Prep
• Engineering Blog
• Privacy Policy
• © 2024 HackerEarth All rights reserved
• Terms of Service

Watch CBS News

Teens come up with trigonometry proof for Pythagorean Theorem, a problem that stumped math world for centuries

By Bill Whitaker

May 5, 2024 / 7:00 PM EDT / CBS News

As the school year ends, many students will be only too happy to see math classes in their rearview mirrors. It may seem to some of us non-mathematicians that geometry and trigonometry were created by the Greeks as a form of torture, so imagine our amazement when we heard two high school seniors had proved a mathematical puzzle that was thought to be impossible for 2,000 years. 

We met Calcea Johnson and Ne'Kiya Jackson at their all-girls Catholic high school in New Orleans. We expected to find two mathematical prodigies.

Instead, we found at St. Mary's Academy , all students are told their possibilities are boundless.

Come Mardi Gras season, New Orleans is alive with colorful parades, replete with floats, and beads, and high school marching bands.

In a city where uniqueness is celebrated, St. Mary's stands out – with young African American women playing trombones and tubas, twirling batons and dancing - doing it all, which defines St. Mary's, students told us.

Junior Christina Blazio says the school instills in them they have the ability to accomplish anything. 

Christina Blazio: That is kinda a standard here. So we aim very high - like, our aim is excellence for all students. 

The private Catholic elementary and high school sits behind the Sisters of the Holy Family Convent in New Orleans East. The academy was started by an African American nun for young Black women just after the Civil War. The church still supports the school with the help of alumni.

In December 2022, seniors Ne'Kiya Jackson and Calcea Johnson were working on a school-wide math contest that came with a cash prize.

Ne'Kiya Jackson: I was motivated because there was a monetary incentive.

Calcea Johnson: 'Cause I was like, "$500 is a lot of money. So I-- I would like to at least try."

Both were staring down the thorny bonus question.

Bill Whitaker: So tell me, what was this bonus question?

Calcea Johnson: It was to create a new proof of the Pythagorean Theorem. And it kind of gave you a few guidelines on how would you start a proof.

The seniors were familiar with the Pythagorean Theorem, a fundamental principle of geometry. You may remember it from high school: a² + b² = c². In plain English, when you know the length of two sides of a right triangle, you can figure out the length of the third.

Both had studied geometry and some trigonometry, and both told us math was not easy. What no one told  them  was there had been more than 300 documented proofs of the Pythagorean Theorem using algebra and geometry, but for 2,000 years a proof using trigonometry was thought to be impossible, … and that was the bonus question facing them.

Bill Whitaker: When you looked at the question did you think, "Boy, this is hard"?

Ne'Kiya Jackson: Yeah. 

Bill Whitaker: What motivated you to say, "Well, I'm going to try this"?

Calcea Johnson: I think I was like, "I started something. I need to finish it." 

Bill Whitaker: So you just kept on going.

Calcea Johnson: Yeah.

For two months that winter, they spent almost all their free time working on the proof.

CeCe Johnson: She was like, "Mom, this is a little bit too much."

CeCe and Cal Johnson are Calcea's parents.

CeCe Johnson:   So then I started looking at what she really was doing. And it was pages and pages and pages of, like, over 20 or 30 pages for this one problem.

Cal Johnson: Yeah, the garbage can was full of papers, which she would, you know, work out the problems and-- if that didn't work she would ball it up, throw it in the trash. 

Bill Whitaker: Did you look at the problem? 

Neliska Jackson is Ne'Kiya's mother.

Neliska Jackson: Personally I did not. 'Cause most of the time I don't understand what she's doing (laughter).

Michelle Blouin Williams: What if we did this, what if I write this? Does this help? ax² plus ….

Their math teacher, Michelle Blouin Williams, initiated the math contest.

Bill Whitaker: And did you think anyone would solve it?

Michelle Blouin Williams: Well, I wasn't necessarily looking for a solve. So, no, I didn't—

Bill Whitaker: What were you looking for?

Michelle Blouin Williams: I was just looking for some ingenuity, you know—

Calcea and Ne'Kiya delivered on that! They tried to explain their groundbreaking work to 60 Minutes. Calcea's proof is appropriately titled the Waffle Cone.

Calcea Johnson: So to start the proof, we start with just a regular right triangle where the angle in the corner is 90°. And the two angles are alpha and beta.

Bill Whitaker: Uh-huh

Calcea Johnson: So then what we do next is we draw a second congruent, which means they're equal in size. But then we start creating similar but smaller right triangles going in a pattern like this. And then it continues for infinity. And eventually it creates this larger waffle cone shape.

Calcea Johnson: Am I going a little too—

Bill Whitaker: You've been beyond me since the beginning. (laughter) 

Bill Whitaker: So how did you figure out the proof?

Ne'Kiya Jackson: Okay. So you have a right triangle, 90° angle, alpha and beta.

Bill Whitaker: Then what did you do?

Ne'Kiya Jackson: Okay, I have a right triangle inside of the circle. And I have a perpendicular bisector at OP to divide the triangle to make that small right triangle. And that's basically what I used for the proof. That's the proof.

Bill Whitaker: That's what I call amazing.

Ne'Kiya Jackson: Well, thank you.

There had been one other documented proof of the theorem using trigonometry by mathematician Jason Zimba in 2009 – one in 2,000 years. Now it seems Ne'Kiya and Calcea have joined perhaps the most exclusive club in mathematics. 

Bill Whitaker: So you both independently came up with proof that only used trigonometry.

Ne'Kiya Jackson: Yes.

Bill Whitaker: So are you math geniuses?

Calcea Johnson: I think that's a stretch. 

Bill Whitaker: If not genius, you're really smart at math.

Ne'Kiya Jackson: Not at all. (laugh) 

To document Calcea and Ne'Kiya's work, math teachers at St. Mary's submitted their proofs to an American Mathematical Society conference in Atlanta in March 2023.

Ne'Kiya Jackson: Well, our teacher approached us and was like, "Hey, you might be able to actually present this," I was like, "Are you joking?" But she wasn't. So we went. I got up there. We presented and it went well, and it blew up.

Bill Whitaker: It blew up.

Calcea Johnson: Yeah. 

Ne'Kiya Jackson: It blew up.

Bill Whitaker: Yeah. What was the blowup like?

Calcea Johnson: Insane, unexpected, crazy, honestly.

It took millenia to prove, but just a minute for word of their accomplishment to go around the world. They got a write-up in South Korea and a shout-out from former first lady Michelle Obama, a commendation from the governor and keys to the city of New Orleans. 

Bill Whitaker: Why do you think so many people found what you did to be so impressive?

Ne'Kiya Jackson: Probably because we're African American, one. And we're also women. So I think-- oh, and our age. Of course our ages probably played a big part.

Bill Whitaker: So you think people were surprised that young African American women, could do such a thing?

Calcea Johnson: Yeah, definitely.

Ne'Kiya Jackson: I'd like to actually be celebrated for what it is. Like, it's a great mathematical achievement.

Achievement, that's a word you hear often around St. Mary's academy. Calcea and Ne'Kiya follow a long line of barrier-breaking graduates. 

The late queen of Creole cooking, Leah Chase , was an alum. so was the first African-American female New Orleans police chief, Michelle Woodfork …

And judge for the Fifth Circuit Court of Appeals, Dana Douglas. Math teacher Michelle Blouin Williams told us Calcea and Ne'Kiya are typical St. Mary's students.  

Bill Whitaker: They're not unicorns.

Michelle Blouin Williams: Oh, no no. If they are unicorns, then every single lady that has matriculated through this school is a beautiful, Black unicorn.

Pamela Rogers: You're good?

Pamela Rogers, St. Mary's president and interim principal, told us the students hear that message from the moment they walk in the door.

Pamela Rogers: We believe all students can succeed, all students can learn. It does not matter the environment that you live in. 

Bill Whitaker: So when word went out that two of your students had solved this almost impossible math problem, were they universally applauded?

Pamela Rogers: In this community, they were greatly applauded. Across the country, there were many naysayers.

Bill Whitaker: What were they saying?

Pamela Rogers: They were saying, "Oh, they could not have done it. African Americans don't have the brains to do it." Of course, we sheltered our girls from that. But we absolutely did not expect it to come in the volume that it came.  

Bill Whitaker: And after such a wonderful achievement.

Pamela Rogers: People-- have a vision of who can be successful. And-- to some people, it is not always an African American female. And to us, it's always an African American female.

Gloria Ladson-Billings: What we know is when teachers lay out some expectations that say, "You can do this," kids will work as hard as they can to do it.

Gloria Ladson-Billings, professor emeritus at the University of Wisconsin, has studied how best to teach African American students. She told us an encouraging teacher can change a life.

Bill Whitaker: And what's the difference, say, between having a teacher like that and a whole school dedicated to the excellence of these students?

Gloria Ladson-Billings: So a whole school is almost like being in Heaven. 

Bill Whitaker: What do you mean by that?

Gloria Ladson-Billings: Many of our young people have their ceilings lowered, that somewhere around fourth or fifth grade, their thoughts are, "I'm not going to be anything special." What I think is probably happening at St. Mary's is young women come in as, perhaps, ninth graders and are told, "Here's what we expect to happen. And here's how we're going to help you get there."

At St. Mary's, half the students get scholarships, subsidized by fundraising to defray the $8,000 a year tuition. Here, there's no test to get in, but expectations are high and rules are strict: no cellphones, modest skirts, hair must be its natural color.

Students Rayah Siddiq, Summer Forde, Carissa Washington, Tatum Williams and Christina Blazio told us they appreciate the rules and rigor.

Rayah Siddiq: Especially the standards that they set for us. They're very high. And I don't think that's ever going to change.

Bill Whitaker: So is there a heart, a philosophy, an essence to St. Mary's?

Summer Forde: The sisterhood—

Carissa Washington: Sisterhood.

Tatum Williams: Sisterhood.

Bill Whitaker: The sisterhood?

Voices: Yes.

Bill Whitaker: And you don't mean the nuns. You mean-- (laughter)

Christina Blazio: I mean, yeah. The community—

Bill Whitaker: So when you're here, there's just no question that you're going to go on to college.

Rayah Siddiq: College is all they talk about. (laughter) 

Pamela Rogers: … and Arizona State University (Cheering)

Principal Rogers announces to her 615 students the colleges where every senior has been accepted.

Bill Whitaker: So for 17 years, you've had a 100% graduation rate—

Pamela Rogers: Yes.

Bill Whitaker: --and a 100% college acceptance rate?

Pamela Rogers: That's correct.

Last year when Ne'Kiya and Calcea graduated, all their classmates went to college and got scholarships. Ne'Kiya got a full ride to the pharmacy school at Xavier University in New Orleans. Calcea, the class valedictorian, is studying environmental engineering at Louisiana State University.

Bill Whitaker: So wait a minute. Neither one of you is going to pursue a career in math?

Both: No. (laugh)

Calcea Johnson: I may take up a minor in math. But I don't want that to be my job job.

Ne'Kiya Jackson: Yeah. People might expect too much out of me if (laugh) I become a mathematician. (laugh)

But math is not completely in their rear-view mirrors. This spring they submitted their high school proofs for final peer review and publication … and are still working on further proofs of the Pythagorean Theorem. Since their first two …

Calcea Johnson: We found five. And then we found a general format that could potentially produce at least five additional proofs.

Bill Whitaker: And you're not math geniuses?

Bill Whitaker: I'm not buying it. (laughs)

Produced by Sara Kuzmarov. Associate producer, Mariah B. Campbell. Edited by Daniel J. Glucksman.

Bill Whitaker is an award-winning journalist and 60 Minutes correspondent who has covered major news stories, domestically and across the globe, for more than four decades with CBS News.

More from CBS News

How two high school students solved a 2,000-year-old math puzzle

Workers get a stake in their company under employee ownership model

Leader Hakeem Jeffries on Israel, House Republicans and the election

Can workers prosper with employee ownership?