Object Oriented Programming

GATE

Data Structures

Data Structures in Python

Power BI

Data Science

Django

Data Structure and Algorithm

Python

Recursion

Arrays

Searching

Sorting

String

Linked List

Data Structures in C

Maths

Strings

C++ Tricks

System Design

Theory of Computation

Computer Organization and Architecture

Operating System

Engineering Mathematics

Database

Digital Logic

Computer Networks

GATE 2022

Java

GeeksforGeeks School

Hashing

Competitive Programming

Problem of the Day

School

HTML

Javascript

Bootstrap

Web Development

Android

Microsoft Office

Machine Learning

Resume Builder

Miscellaneous

Gblog

TechTips

React

Advanced JavaScript

DSA Self Paced

CS-subjects

Data Structures and Algorithms

Operating Systems

C Language

DBMS

Basics of CPP

Data Structures ( Basics )

Object Oriented Design

Dynamic Programming

Data Interpretation and Logical Reasoning

Algorithms

Core Java

RESTful APIs

Spring Basics

CPP-Tricks

Basics of Java

Aptitude

GATE YT

Flutter

Application Development

Blockchain

GFG SDE Sheet

SDE Sheet

Deep Learning

Go Programming

Placement

C++ Programs

Data Visualisation

DevOps

Docker

Queue

Matrix

Trie

Stack

Graph

Tree

Magic Numbers

Divide and Conquer

React Native

React JS

Interview-Questions

Advanced Java

cloud-computing

income tax

Artificial Intelligence

Programming Languages

Computer Graphics

Cyber Security

Project Management

DSA / Placements

GATE Prep

Data Analytics / Data Science

Development

Cloud / DevOps

All Courses

Courses

ML & Data Science

Interview Corner

CS Subjects

School Learning

Software and Tools

Tutorials

Google Build with AI

Practice Coding Problems

Connect 1:1 with Experts

Practice

Apply Now!

Post Jobs

Jobs Updates

Jobs

Given an array of n elements that contains elements from 0 to n-1, with any of these numbers appearing any number of times. Find these repeating numbers in O(n) and using only constant memory space.Example:Input : n = 7 and array[] = {1, 2, 3, 6, 3, 6, 1} Output: 1, 3, 6Explanation: The numbers 1 , 3 and 6 appears more than once in the array.Find duplicates in O(n) time and O(1) extra space: <a href="https://www.geeksforgeeks.org/find-duplicates-in-on-time-and-constant-extra-space/">https://www.geeksforgeeks.org/find-duplicates-in-on-time-and-constant-extra-space/</a>

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

Print the elements of an array in the decreasing frequency if 2 numbers have same frequency then print the one which came first.Examples: &nbsp;Input: &nbsp;arr[] = {2, 5, 2, 8, 5, 6, 8, 8} Output: arr[] = {8, 8, 8, 2, 2, 5, 5, 6}Input: arr[] = {2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8} Output: arr[] = {8, 8, 8, 2, 2, 5, 5, 6, -1, 9999999}Sort elements by frequency _ Set 1: <a href="https://www.geeksforgeeks.org/sort-elements-by-frequency/">https://www.geeksforgeeks.org/sort-elements-by-frequency/</a>

Sort elements by frequency

Given an array of integers, find all combination of four elements in the array whose sum is equal to a given value X.&nbsp; For example, if the given array is {10, 2, 3, 4, 5, 9, 7, 8} and X = 23, then your function should print “3 5 7 8” (3 + 5 + 7 + 8 = 23). A Naive Solution is to generate all possible quadruples and compare the sum of every quadruple with X. The following code implements this simple method using four nested loops&nbsp; &nbsp;Find four elements that sum to a given value _ Set 1 (n^3 solution): <a href="https://www.geeksforgeeks.org/find-four-numbers-with-sum-equal-to-given-sum/">https://www.geeksforgeeks.org/find-four-numbers-with-sum-equal-to-given-sum/</a>

Find four elements that sum to a given value | Set 1 (n^3 solution)

Given an array of integers, find the first repeating element in it. We need to find the element that occurs more than once and whose index of first occurrence is smallest.Examples:Input: &nbsp;arr[] = {10, 5, 3, 4, 3, 5, 6} Output: 5 [5 is the first element that repeats]Input: &nbsp;arr[] = {6, 10, 5, 4, 9, 120, 4, 6, 10} Output: 6 [6 is the first element that repeats]Find the first repeating element in an array of integers : <a href="https://www.geeksforgeeks.org/find-first-repeating-element-array-integers/">https://www.geeksforgeeks.org/find-first-repeating-element-array-integers/</a>

Find the first repeating element in an array of integers

To find the time when the last ant falls off the plank, we calculate the maximum time taken by ants moving left and right. For ants moving left, we consider their positions and for ants moving right, we calculate the time to reach the right end of the plank. The time to fall off the plank for each ant is independent of collisions. The maximum time among all ants will be the time when the last ant falls off the plank. This solution efficiently handles multiple ants with time complexity O(m). For more details, check out the full article: <a href="https://www.geeksforgeeks.org/last-moment-before-all-ants-fall-out-of-a-plank/">Last Moment Before All Ants Fall Out of a Plank</a>.

Last Moment Before All Ants Fall Out of a Plank

To find the maximum length of a subarray with all ones after flipping at most k zeroes, we use a sliding window technique. The approach involves maintaining two pointers to define the current window, and counting the zeroes in that window. If the number of zeroes exceeds k, we adjust the window by moving the start pointer. This solution efficiently calculates the maximum length subarray with all ones. It ensures a time complexity of O(n) and space complexity of O(1). For more details, check out the full article: <a href="https://www.geeksforgeeks.org/find-zeroes-to-be-flipped-so-that-number-of-consecutive-1s-is-maximized/">Maximum Consecutive Ones After Flipping Zeroes</a>.

Maximum Consecutive Ones After Flipping Zeroes

To find the sum of digits of a number until it becomes a single digit, repetitively add the digits until the result is a single digit. An optimized approach involves using the mathematical formula based on modulo 9, where the result is the remainder when the number is divided by 9. If the modulo operation yields zero, the single-digit sum is 9. This method provides an efficient way to compute the repeated digital sum with constant time complexity.&nbsp; For more details, check out the full article: <a href="https://www.geeksforgeeks.org/finding-sum-of-digits-of-a-number-until-sum-becomes-single-digit/">Finding sum of digits of a number until sum becomes single digit</a>.

Finding sum of digits of a number until sum becomes single digit

To divide an array into three equal sum segments, first, check if the total sum is divisible by 3. If not, return [-1, -1]. Then, iterate through the array while maintaining a running sum. When the running sum equals one-third of the total, reset it to zero and store the index as the first segment. If another valid index is found, store it as the second segment and return the index pair. If no valid pair is found, return [-1, -1]. For more details, check out the full article: <a href="https://www.geeksforgeeks.org/split-array-three-equal-sum-subarrays/">Split array into three equal sum segments</a>.

Partition Array Into Three Parts With Equal Sum

<h2>Array Practice Problems&nbsp;</h2>In this tutorial, we will explore various Array Practice Problems that will help you strengthen your understanding of arrays and improve your problem-solving skills in programming. Arrays are one of the fundamental data structures, and practicing with them is essential for mastering concepts in algorithms and data manipulation.<h3>Key Features of Practice Problems</h3><ul><li>Diverse Problems: The problems cover a wide range of topics, including searching, sorting, manipulation, and mathematical operations, allowing you to explore different aspects of array usage.</li><li>Incremental Difficulty:</li><li>The problems are designed to progress in complexity, starting from basic tasks to more challenging scenarios that require deeper understanding and application of array concepts.</li><li>Real-World Applications:</li><li>Many of the problems reflect real-world situations where arrays are commonly used, helping you understand how to apply your knowledge practically.</li></ul><h3>Types of Practice Problems</h3><ul><li>Basic Array Operations: Problems that involve simple operations like insertion, deletion, and traversal of array elements.</li><li>Searching Algorithms: Tasks that require you to implement algorithms like linear search and binary search to find elements within an array.</li><li>Sorting Algorithms: Challenges that involve sorting an array using different algorithms such as bubble sort, selection sort, and quicksort.</li><li>Manipulation Problems: Problems that require you to modify the array, such as reversing an array, rotating it, or merging two arrays.</li><li>Mathematical Problems: Challenges that involve calculating statistics (like the mean and median), finding duplicates, or solving puzzles like finding pairs with a specific sum.</li></ul><h3>Why Practice Array Problems?</h3>Practicing array problems is crucial for several reasons:<ul><li>Strengthen Fundamentals: Solidifying your understanding of arrays will enhance your grasp of more advanced data structures and algorithms.</li><li>Improve Problem-Solving Skills: Working through various problems will help you develop critical thinking and analytical skills necessary for effective programming.</li><li>Prepare for Interviews: Many technical interviews focus on data structures and algorithms, making it essential to be well-prepared with practice problems involving arrays.</li></ul><h3>Tips for Solving Array Problems</h3><ul><li>Understand the Problem Statement: Carefully read and analyze the problem requirements before diving into coding. Identify the input and expected output.</li><li>Plan Your Approach: Before implementing the solution, sketch out your approach and consider edge cases. This can save time and prevent errors.</li><li>Optimize Your Solution: After finding a solution, consider ways to optimize it for better performance in terms of time and space complexity.</li><li>Test Thoroughly: Test your solution with various inputs, including edge cases, to ensure correctness and robustness.</li></ul><h3>Conclusion</h3>Practicing array problems is an excellent way to improve your programming skills and understanding of data structures. By solving these problems, you will gain confidence in your ability to handle arrays in various contexts, preparing you for more complex programming challenges.<h3>Topics Covered</h3><ul><li>Basic Array Operations: Learn fundamental array operations through practical problems.</li><li>Searching Algorithms: Explore searching techniques with hands-on challenges.</li><li>Sorting Algorithms: Practice sorting methods and understand their applications.</li><li>Manipulation and Mathematical Problems: Tackle problems that involve modifying arrays and performing calculations.</li></ul>For more details and a variety of practice problems, check out the full article on GeeksforGeeks: <a href="https://www.geeksforgeeks.org/array-data-structure-guide/">Array Practice Problems</a>.

Array Practice Problems

<h2>What is an Array?&nbsp;</h2>In this tutorial, we will explore Arrays, a fundamental data structure used in programming to store collections of elements. Arrays provide a convenient way to manage multiple items of the same type, making them essential for data manipulation and organization in various applications.<h3>Key Features of Arrays</h3><ul><li>Fixed Size: An array has a predefined size, meaning that the number of elements it can hold is specified at the time of its creation. Once declared, the size cannot be changed.</li><li>Homogeneous Elements: Arrays can only contain elements of the same data type, which ensures that all items are treated uniformly. This homogeneity simplifies operations performed on the array.</li><li>Contiguous Memory Allocation: Elements in an array are stored in contiguous memory locations, enabling efficient access and manipulation. This allows for quick retrieval of elements using their index.</li></ul><h3>Types of Arrays</h3><ul><li>One-Dimensional Arrays: These are the simplest form of arrays, representing a linear sequence of elements. For example, an array of integers can be defined to hold a list of numbers.</li><li>Multi-Dimensional Arrays: Arrays can have more than one dimension, such as two-dimensional arrays (often used to represent matrices) and three-dimensional arrays. Multi-dimensional arrays are useful for complex data structures and organization.</li></ul><h3>How Arrays Work</h3>Arrays allow you to store multiple values under a single name, with each value accessible via its index, which starts from zero. For example, if you have an array of size 5, the valid indices will be 0 through 4. You can access, modify, or iterate through the elements using loops, making arrays highly versatile for data management.<h3>Common Operations on Arrays</h3><ul><li>Declaration and Initialization: Arrays must be declared with a specific size and data type. They can be initialized at the time of declaration or later in the code.</li><li>Accessing Elements: Use the index to access or modify elements in the array. For example, array[0] accesses the first element.</li><li>Iterating Through Arrays: You can loop through arrays to process each element, which is useful for operations like searching, sorting, or transforming data.</li></ul><h3>Common Mistakes to Avoid</h3><ul><li>Out-of-Bounds Access: Accessing elements outside the bounds of the array can lead to undefined behavior or runtime errors. Always ensure that your indices are within the valid range.</li><li>Not Initializing Arrays: If arrays are not initialized, they may contain garbage values, leading to unexpected results.</li><li>Confusing Array Sizes: Be aware of the fixed size of arrays. If you need a resizable collection, consider using data structures like vectors or lists.</li></ul><h3>Applications of Arrays</h3><ul><li>Data Storage: Arrays are commonly used to store collections of related data, such as lists of numbers, characters, or objects.</li><li>Mathematical Computations: Arrays facilitate mathematical operations on multiple data points, such as in algorithms for linear algebra or statistical analysis.</li><li>Implementing Data Structures: Many data structures, such as stacks, queues, and heaps, are built using arrays as their underlying storage mechanism.</li></ul><h3>Why Learn About Arrays?</h3>Understanding arrays is essential for effective programming. By mastering arrays, you will:<ul><li>Enhance Your Programming Skills: Gain proficiency in one of the most fundamental data structures used in various programming languages.</li><li>Write More Efficient Code: Learn to handle and process collections of data efficiently, improving the performance of your applications.</li><li>Develop Practical Applications: Create applications that utilize arrays for data management, algorithm implementation, and more.</li></ul><h3>Topics Covered</h3><ul><li>Introduction to Arrays: Understand the basics and significance of arrays in programming.</li><li>Types of Arrays: Explore the differences between one-dimensional and multi-dimensional arrays.</li><li>Common Operations: Learn about the fundamental operations associated with arrays, including declaration, initialization, and access.</li><li>Performance Characteristics: Discuss the time complexity and performance considerations when using arrays.</li></ul>For more details and complete code examples, check out the full article on GeeksforGeeks: <a href="https://www.geeksforgeeks.org/array-data-structure-guide/">What is an Array?</a>.

What is Array

Given an unsorted array arr of nonnegative integers and an integer sum, find a continuous subarray which adds to a given sum. There may be more than one subarrays with sum as the given sum, print first such subarray.&nbsp; Examples :Input: arr[] = {1, 4, 20, 3, 10, 5}, sum = 33 Output: Sum found between indexes 2 and 4 Sum of elements between indices 2 and 4 is 20 + 3 + 10 = 33Find subarray with given sum :<a href=" https://www.geeksforgeeks.org/find-subarray-with-given-sum/"> https://www.geeksforgeeks.org/find-subarray-with-given-sum/</a>

Find subarray with given sum

To rotate by one, store arr[0] in a temporary variable temp, move arr[1] to arr[0], arr[2] to arr[1] …and finally temp to arr[n-1] Let us take the same example arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2&nbsp; Rotate arr[] by one 2 times&nbsp; We get [2, 3, 4, 5, 6, 7, 1] after first rotation and [ 3, 4, 5, 6, 7, 1, 2] after second rotation.Array Rotation: <a href="https://www.geeksforgeeks.org/array-rotation/">https://www.geeksforgeeks.org/array-rotation/</a>

Array Rotation

Practice Problems

JavaScript

Linux