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

Algebra

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

Excel

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

DA / Data Science & AI

Development

DevOps Course

All Courses

Courses

ML & Data Science

CS Subjects

Software and Tools

School Learning

Tutorials

Interview Corner

Practice DSA

GfG 160

Interview Prep

Given an array of strings, the task is to group them based on shifted versions. Two strings are shifted if their characters differ by a constant value, with cyclic wrapping around. The solution involves normalizing each string by calculating the shift and using a hash map to group strings with the same shift pattern. This method efficiently groups shifted strings together.&nbsp; For more details, read the full article <a href="https://www.geeksforgeeks.org/group-shifted-string/">here</a>.

Group Shifted String

Given an array of distinct positive numbers, the task is to partition it into the minimum number of subsets such that each subset contains consecutive numbers. The problem can be solved using two approaches: sorting the array (O(n*log n) time) or hashing (O(n) time). The sorting approach counts breaks between consecutive numbers, while the hashing approach checks for consecutive subsequences and removes elements from the set. Both methods provide an efficient solution.&nbsp; For more details, read the full article <a href="https://www.geeksforgeeks.org/count-minimum-number-subsets-subsequences-consecutive-numbers/">here</a>.

Partition into minimum subsets of consecutive numbers

Given an array and a target sum, the task is to find the count of quadruplets that add up to the target. The problem can be solved using three approaches: Naive (O(n^4)), Better (O(n^3)), and Efficient (O(n^2)) with hash maps. The Efficient approach uses a hash map to store the sum of pairs and count the matching quadruplets. The time complexity and space complexity vary based on the chosen approach.&nbsp; For more details, read the full article <a href="https://www.geeksforgeeks.org/count-quadruplets-with-sum-k-from-given-array/">here</a>.

4 Sum – Count quadruplets with given sum in an array

Given an array and a positive integer k, the task is to count pairs (i, j) such that the absolute difference between arr[i] and arr[j] equals k. The solution can be implemented using a naive O(n^2) approach or an optimized O(n) approach using a hash map. The hash map approach tracks the frequency of elements and checks for the presence of complementary values. The result is the total number of such pairs.&nbsp; For more details, read the full article <a href="https://www.geeksforgeeks.org/count-pairs-difference-equal-k/">here</a>.

Count pairs with absolute difference equal to k

Find the maximum distance between two occurrences of any element in an array. If no element appears more than once, return 0. The solution can be implemented using a brute-force approach with O(n^2) time complexity or a more efficient approach using a hash map with O(n) time complexity. The hash map approach stores the first occurrence of each element and calculates the distance for subsequent occurrences.&nbsp; For more details, read the full article <a href="https://www.geeksforgeeks.org/maximum-distance-two-occurrences-element-array/">here</a>.

Max Distance Between Two Occurrences

Convert Roman numerals to integers by comparing each symbol with the next. Subtract values when a smaller symbol precedes a larger one, otherwise, add the values. The solution can be implemented using iterative comparison or a hash map. This algorithm runs in O(n) time and O(1) space.&nbsp; For more details, read the full article <a href="https://www.geeksforgeeks.org/roman-number-to-integer/">here</a>.

Roman to Integer Conversion

Given an array, the task is to find the length of the longest subsequence of consecutive integers. The naive approach sorts the array and checks for consecutive elements. The expected approach uses hashing to find the longest consecutive subsequence efficiently. By inserting elements into a hash set, it checks for consecutive sequences starting from each element. This method has O(n) time complexity and is optimal for large inputs. For more details, check the full article <a href="https://www.geeksforgeeks.org/longest-consecutive-subsequence/">here</a>.

Longest Consecutive Subsequence | Video

Given two arrays, the task is to return their union, which consists of all distinct elements present in either array. The naive approach uses nested loops with O((n+m)^2) time complexity. The expected approach leverages a Hash Set, ensuring uniqueness with O(n+m) time complexity. The final result is the union of both arrays with no duplicates. Various methods, including using Hash Sets, are explained for efficient union computation. For more details, check the full article <a href="https://www.geeksforgeeks.org/union-of-two-arrays/">here</a>.

Union of Two Array

Given two arrays, the task is to find their intersection, which consists of common elements without duplicates. Several approaches are discussed: a naive approach with triple nested loops, a better approach using nested loops with a hash set, and an optimized approach using two hash sets or one hash set. The expected time complexity for the optimized methods is O(n+m), and the space complexity is O(n). The result contains common elements in any order. For more details, check the full article <a href="https://www.geeksforgeeks.org/intersection-of-two-arrays/">here</a>.

Intersection of two Array

Given an array of integers, the task is to count the number of subarrays where the XOR of their elements equals a given number k. Two approaches are discussed: a Naive approach with O(n^2) time complexity, using two nested loops to check all subarrays, and an efficient approach with O(n) time complexity, utilizing Hash Map and Prefix XOR. The efficient approach updates the prefix XOR and uses the XOR properties to find matching subarrays. For more details, check the full article <a href="https://www.geeksforgeeks.org/count-number-subarrays-given-xor/">here</a>.

Count Subarrays with given XOR

Given an unsorted array of integers, the task is to find the number of subarrays with a sum equal to a given number k. Two approaches are discussed: a Naive approach using nested loops with O(n^2) time complexity and an efficient approach using Hash Map and Prefix Sum with O(n) time complexity. The second approach stores the frequency of prefix sums and checks if the difference of current sum and k exists in the map. The result is incremented accordingly. For more details, check the full article <a href="https://www.geeksforgeeks.org/number-subarrays-sum-exactly-equal-k/">here</a>.

Count Subarrays having Sum K

Given an array of words, the task is to group anagrams together. Two approaches are used: one involves sorting the words and using the sorted version as a key, and the other uses character frequency as a key. The second approach is more efficient, with a time complexity of O(n*k). The frequency approach uses a hash map to store words based on their character frequencies. For more details, check the full article <a href="https://www.geeksforgeeks.org/given-a-sequence-of-words-print-all-anagrams-together/">here</a>.

Group Anagrams Together