Find the first repeating element in an array of integers (original) (raw)

Last Updated : 18 Nov, 2024

Try it on GfG Practice

Given an array of integers **arr[], The task is to find the index of first repeating element in it i.e. the element that occurs more than once and whose index of the first occurrence is the smallest.

**Examples:

**Input: arr[] = {10, 5, 3, 4, 3, 5, 6}
**Output: 5
**Explanation: 5 is the first element that repeats

**Input: arr[] = {6, 10, 5, 4, 9, 120, 4, 6, 10}
**Output: 6
**Explanation: 6 is the first element that repeats

Naive Approach – O(n^2) Time and O(1) Space

Run two nested loops, the outer loop picks an element one by one, and the inner loop checks whether the element is repeated or not. Once a repeating element is found, break the loops and print the element.

C++ `

// Cpp to find first repeating element // using Naive approach in O(n^2) Time and O(1) Space #include <bits/stdc++.h> using namespace std;

// Function to find the index of the first // repeating element in a vector int firstRepeatingElement(vector &arr) { int n = arr.size();

// Nested loop to check for repeating elements
for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
        if (arr[i] == arr[j]) {
            return i;
        }
    }
}

// If no repeating element is found, return -1
return -1;

}

int main() { vector arr = {10, 5, 3, 4, 3, 5, 6}; int index = firstRepeatingElement(arr); if (index == -1) cout << "No repeating found!" << endl; else cout << "First repeating is " << arr[index] << endl; return 0; }

Java

// Java program to find first repeating element // using Naive approach in O(n^2) Time and O(1) Space import java.util.*;

class GfG {

// Function to find the index of first repeating element in an array
static int firstRepeatingElement(int[] arr, int n) {
    // Nested loop to check for repeating elements
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // If a repeating element is found, return its index
            if (arr[i] == arr[j]) {
                return i;
            }
        }
    }
    // If no repeating element is found, return -1
    return -1;
}

// Driver code
public static void main(String[] args) {
  
    // Initializing an array and its size
    int[] arr = { 10, 5, 3, 4, 3, 5, 6 };
    int n = arr.length;
  
    // Finding the index of first repeating element
    int index = firstRepeatingElement(arr, n);

    // Checking if any repeating element is found or not
    if (index == -1) {
        System.out.println("No repeating element found!");
    }
    else {
        System.out.println("First repeating element is " + arr[index]);
    }
}

}

Python

Python program to find first repeating element

using Naive approach in O(n^2) Time and O(1) Space

Function to find the index of first repeating element in an array

def firstRepeatingElement(arr, n):

Nested loop to check for repeating elements

for i in range(n): for j in range(i+1, n):

  # If a repeating element is found, return its index
  if arr[i] == arr[j]:
    return i
  

If no repeating element is found, return -1

return -1

Driver code

if name == 'main':

Initializing an array and its size

arr = [10, 5, 3, 4, 3, 5, 6] n = len(arr)

Finding the index of first repeating element

index = firstRepeatingElement(arr, n)

Checking if any repeating element is found or not

if index == -1: print("No repeating element found!") else: print("First repeating element is", arr[index])

C#

// C# program to find first repeating element // using Naive approach in O(n^2) Time and O(1) Space using System;

class GfG { static void Main() { // Initializing an array and its size int[] arr = { 10, 5, 3, 4, 3, 5, 6 }; int n = arr.Length;

    // Initializing variables to keep track of the minimum index and
    // minimum value of the repeating element
    int minIndex = n;
    int minValue = int.MaxValue;

    // Creating a dictionary to store the last seen index of each element
    var dict = new System.Collections.Generic.Dictionary<int, int>();

    // Iterating over the array from left to right
    for (int i = 0; i < n; i++)
    {
        int val = arr[i];

        // If the element is not in the dictionary, add it with its index
        if (!dict.ContainsKey(val))
        {
            dict[val] = i;
        }
      
        // If the element is already in the dictionary, update the minimum index
        // and minimum value if necessary
        else
        {
            int index = dict[val];
            if (index < minIndex || (index == minIndex && val < minValue))
            {
                minIndex = index;
                minValue = val;
            }
        }
    }

    // Checking if any repeating element is found or not
    if (minIndex == n)
    {
        Console.WriteLine("No repeating element found!");
    }
    else
    {
      Console.WriteLine("First repeating element is " + minValue + " at index " + minIndex);
    }
}

}

JavaScript

// JavaScript program to find first repeating element // using Naive approach in O(n^2) Time and O(1) Space function firstRepeatingElement(arr) {

// Nested loop to check for repeating elements
for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
    
        // If a repeating element is found, return its index
        if (arr[i] === arr[j]) {
            return i;
        }
    }
}

// If no repeating element is found, return -1
return -1;

}

const arr = [10, 5, 3, 4, 3, 5, 6];

// Finding the index of first repeating element const index = firstRepeatingElement(arr); if (index === -1) { console.log("No repeating element found!"); } else { console.log("First repeating element is", arr[index]); }

`

Output

First repeating is 5

Expected Approach – Hash Set – O(n) Time and O(n) Space

Follow the steps below to implement the idea:

• Initialize an empty Hash Set **s
• Run a for loop for each index i
  • If the current element is present in the hash set, then return i
  • Else insert arr[i] in s.
• Return -1 if no repeating element found

Below is the implementation of the above approach.

C++ `

// Cpp program to find first repeating element // using Hash Set in O(n) Time and O(n) Space #include #include #include #include using namespace std;

int firstRepeatingElement(const vector& arr) { unordered_set s;

// If an element is already present, return it
// else insert it
  int minEle = INT_MAX;
for (int i = arr.size() - 1; i >= 0; i--) {
    if (s.find(arr[i]) != s.end()) {
        minEle = min(minEle, i);
    }
    s.insert(arr[i]);
}

// If no element repeats
return minEle == INT_MAX? -1: minEle;

}

int main() { vector arr = {10, 5, 3, 4, 3, 5, 6}; int index = firstRepeatingElement(arr); if (index == -1) cout << "No repeating found!" << endl; else cout << "First repeating is " << arr[index] << endl; return 0; }

Java

// Java program to find first repeating element // using Hash Set in O(n) Time and O(n) Space import java.util.*;

class GfG { static int firstRepeatingElement(int[] arr) { HashSet s = new HashSet<>();

    // If an element is already present, return it
    // else insert it
    int minEle = Integer.MAX_VALUE;
    for (int i = arr.length - 1; i >= 0; i--) {
        if (s.contains(arr[i])) {
            minEle = Math.min(minEle, i);
        }
        s.add(arr[i]);
    }
    
    // If no element repeats
    return minEle == Integer.MAX_VALUE ? -1 : minEle;
}

public static void main(String[] args) {
    int[] arr = {10, 5, 3, 4, 3, 5, 6};
    int index = firstRepeatingElement(arr);
    if (index == -1)
        System.out.println("No repeating found!");
    else
        System.out.println("First repeating is " + arr[index]);
}

}

Python

Python program to find first repeating element

using Hash Set in O(n) Time and O(n) Space

import sys

def firstRepeatingElement(arr): s = set()

# If an element is already present, return it
# else insert it
minEle = sys.maxsize
for i in range(len(arr) - 1, -1, -1):
    if arr[i] in s:
        minEle = min(minEle, i)
    s.add(arr[i])

# If no element repeats
return -1 if minEle == sys.maxsize else minEle

arr = [10, 5, 3, 4, 3, 5, 6] index = firstRepeatingElement(arr) if index == -1: print("No repeating found!") else: print("First repeating is", arr[index])

C#

// C# program to find first repeating element // using Hash Set in O(n) Time and O(n) Space using System; using System.Collections.Generic;

class GfG { static int firstRepeatingElement(int[] arr) { HashSet s = new HashSet();

    // If an element is already present, return it
    // else insert it
    int minEle = int.MaxValue;
    for (int i = arr.Length - 1; i >= 0; i--)
    {
        if (s.Contains(arr[i]))
        {
            minEle = Math.Min(minEle, i);
        }
        s.Add(arr[i]);
    }
    
    // If no element repeats
    return minEle == int.MaxValue ? -1 : minEle;
}

static void Main()
{
    int[] arr = {10, 5, 3, 4, 3, 5, 6};
    int index = firstRepeatingElement(arr);
    if (index == -1)
        Console.WriteLine("No repeating found!");
    else
        Console.WriteLine("First repeating is " + arr[index]);
}

}

JavaScript

// JavaScript program to find first repeating element // using Hash Set in O(n) Time and O(n) Space

function firstRepeatingElement(arr) { let s = new Set();

// If an element is already present, return it
// else insert it
let minEle = Number.MAX_SAFE_INTEGER;
for (let i = arr.length - 1; i >= 0; i--) {
    if (s.has(arr[i])) {
        minEle = Math.min(minEle, i);
    }
    s.add(arr[i]);
}

// If no element repeats
return minEle === Number.MAX_SAFE_INTEGER ? -1 : minEle;

}

let arr = [10, 5, 3, 4, 3, 5, 6]; let index = firstRepeatingElement(arr); if (index === -1) console.log("No repeating found!"); else console.log("First repeating is " + arr[index]);

`

Output

First repeating is 3

Similar Reads

• Searching Algorithms Searching algorithms are essential tools in computer science used to locate specific items within a collection of data. In this tutorial, we are mainly going to focus upon searching in an array. When we search an item in an array, there are two most common algorithms used based on the type of input 3 min read

Most Common Searching Algorithms

• Linear Search Algorithm Given an array, arr of n integers, and an integer element x, find whether element x is present in the array. Return the index of the first occurrence of x in the array, or -1 if it doesn't exist. Input: arr[] = [1, 2, 3, 4], x = 3Output: 2Explanation: There is one test case with array as [1, 2, 3 4] 9 min read

• Binary Search Algorithm - Iterative and Recursive Implementation Binary Search Algorithm is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). Conditions to apply Binary Search Algorithm in a Data S 15+ min read

Other Searching Algorithms

• Sentinel Linear Search Sentinel Linear Search as the name suggests is a type of Linear Search where the number of comparisons is reduced as compared to a traditional linear search. In a traditional linear search, only N comparisons are made, and in a Sentinel Linear Search, the sentinel value is used to avoid any out-of-b 7 min read

• Meta Binary Search | One-Sided Binary Search Meta binary search (also called one-sided binary search by Steven Skiena in The Algorithm Design Manual on page 134) is a modified form of binary search that incrementally constructs the index of the target value in the array. Like normal binary search, meta binary search takes O(log n) time. Meta B 9 min read

• Ternary Search Computer systems use different methods to find specific data. There are various search algorithms, each better suited for certain situations. For instance, a binary search divides information into two parts, while a ternary search does the same but into three equal parts. It's worth noting that tern 15+ min read

• Jump Search Like Binary Search, Jump Search is a searching algorithm for sorted arrays. The basic idea is to check fewer elements (than linear search) by jumping ahead by fixed steps or skipping some elements in place of searching all elements.For example, suppose we have an array arr[] of size n and a block (t 11 min read

• Interpolation Search Given a sorted array of n uniformly distributed values arr[], write a function to search for a particular element x in the array. Linear Search finds the element in O(n) time, Jump Search takes O(n) time and Binary Search takes O(log n) time. The Interpolation Search is an improvement over Binary Se 15+ min read

• Exponential Search The name of this searching algorithm may be misleading as it works in O(Log n) time. The name comes from the way it searches an element. Given a sorted array, and an element x to be searched, find position of x in the array. Input: arr[] = {10, 20, 40, 45, 55} x = 45Output: Element found at index 3I 15+ min read

• Fibonacci Search Given a sorted array arr[] of size n and an integer x. Your task is to check if the integer x is present in the array arr[] or not. Return index of x if it is present in array else return -1. Examples: Input: arr[] = [2, 3, 4, 10, 40], x = 10Output: 3Explanation: 10 is present at index 3. Input: arr 11 min read

• The Ubiquitous Binary Search | Set 1 We are aware of the binary search algorithm. Binary search is the easiest algorithm to get right. I present some interesting problems that I collected on binary search. There were some requests on binary search. I request you to honor the code, "I sincerely attempt to solve the problem and ensure th 15+ min read

Comparisons between Searching Algorithms

• Linear Search vs Binary Search Prerequisite: Linear SearchBinary SearchLINEAR SEARCH Assume that item is in an array in random order and we have to find an item. Then the only way to search for a target item is, to begin with, the first position and compare it to the target. If the item is at the same, we will return the position 11 min read

• Interpolation search vs Binary search Interpolation search works better than Binary Search for a Sorted and Uniformly Distributed array. Binary Search goes to the middle element to check irrespective of search-key. On the other hand, Interpolation Search may go to different locations according to search-key. If the value of the search-k 7 min read

• Why is Binary Search preferred over Ternary Search? The following is a simple recursive Binary Search function in C++ taken from here. C/C++ Code // CPP program for the above approach #include <bits/stdc++.h> using namespace std; // A recursive binary search function. It returns location of x in // given array arr[l..r] is present, otherwise -1 11 min read

• Is Sentinel Linear Search better than normal Linear Search? Sentinel Linear search is a type of linear search where the element to be searched is placed in the last position and then all the indices are checked for the presence of the element without checking for the index out of bound case. The number of comparisons is reduced in this search as compared to 8 min read

Library implementations of Searching algorithms

• Binary Search functions in C++ STL (binary_search, lower_bound and upper_bound) In C++, STL provide various functions like std::binary_search(), std::lower_bound(), and std::upper_bound() which uses the the binary search algorithm for different purposes. These function will only work on the sorted data. There are the 3 binary search function in C++ STL: Table of Content binary_ 3 min read

• Arrays.binarySearch() in Java with Examples | Set 1 In Java, the Arrays.binarySearch() method searches the specified array of the given data type for the specified value using the binary search algorithm. The array must be sorted by the Arrays.sort() method before making this call. If it is not sorted, the results are undefined. Example: Below is a s 3 min read

• Arrays.binarySearch() in Java with examples | Set 2 (Search in subarray) Arrays.binarySearch()| Set 1 Covers how to find an element in a sorted array in Java. This set will cover "How to Search a key in an array within a given range including only start index". Syntax : public static int binarySearch(data_type[] arr, int fromIndex, int toIndex, data_type key) Parameters 5 min read

• Collections.binarySearch() in Java with Examples java.util.Collections.binarySearch() method is a java.util.Collections class method that returns the position of an object in a sorted list. // Returns index of key in a sorted list sorted in// ascending orderpublic static int binarySearch(List slist, T key)// Returns index of key in a sorted list s 4 min read

Easy problems on Searching algorithms

• Find the Missing Number Given an array arr[] of size n-1 with distinct integers in the range of [1, n]. This array represents a permutation of the integers from 1 to n with one element missing. Find the missing element in the array. Examples: Input: arr[] = [8, 2, 4, 5, 3, 7, 1]Output: 6Explanation: All the numbers from 1 12 min read

• Find the first repeating element in an array of integers Given an array of integers arr[], The task is to find the index of first repeating element in it i.e. the element that occurs more than once and whose index of the first occurrence is the smallest. Examples: Input: arr[] = {10, 5, 3, 4, 3, 5, 6}Output: 5 Explanation: 5 is the first element that repe 8 min read

• Missing and Repeating in an Array Given an unsorted array of size n. Array elements are in the range of 1 to n. One number from set {1, 2, ...n} is missing and one number occurs twice in the array. The task is to find these two numbers. Examples: Input: arr[] = {3, 1, 3}Output: 3, 2Explanation: In the array, 2 is missing and 3 occur 15+ min read

• Count 1's in a sorted binary array Given a binary array arr[] of size n, which is sorted in non-increasing order, count the number of 1's in it. Examples: Input: arr[] = [1, 1, 0, 0, 0, 0, 0]Output: 2Explanation: Count of the 1's in the given array is 2. Input: arr[] = [1, 1, 1, 1, 1, 1, 1]Output: 7 Input: arr[] = [0, 0, 0, 0, 0, 0, 8 min read

• Two Sum - Pair Closest to 0 Given an integer array arr[], the task is to find the maximum sum of two elements such that sum is closest to zero. Note: In case if we have two of more ways to form sum of two elements closest to zero return the maximum sum.Examples: Input: arr[] = [-8, 5, 2, -6]Output: -1Explanation: The min absol 15+ min read

• Pair with the given difference Given an unsorted array and an integer x, the task is to find if there exists a pair of elements in the array whose absolute difference is x. Examples: Input: arr[] = [5, 20, 3, 2, 50, 80], x = 78Output: YesExplanation: The pair is {2, 80}. Input: arr[] = [90, 70, 20, 80, 50], x = 45Output: NoExplan 14 min read

• Kth smallest element in a row-wise and column-wise sorted 2D array Given an n x n matrix, every row and column is sorted in non-decreasing order. Given a number K where K lies in the range [1, n*n], find the Kth smallest element in the given 2D matrix. Example: Input: mat ={{10, 20, 30, 40}, {15, 25, 35, 45}, {24, 29, 37, 48}, {32, 33, 39, 50 }}K = 3Output: 20Expla 15+ min read

• Find common elements in three sorted arrays Given three sorted arrays in non-decreasing order, print all common elements in non-decreasing order across these arrays. If there are no such elements return an empty array. In this case, the output will be -1. Note: In case of duplicate common elements, print only once. Examples: Input: arr1[] = [ 12 min read

• Ceiling in a sorted array Given a sorted array and a value x, find index of the ceiling of x. The ceiling of x is the smallest element in an array greater than or equal to x. Note: In case of multiple occurrences of ceiling of x, return the index of the first occurrence. Examples : Input: arr[] = [1, 2, 8, 10, 10, 12, 19], x 13 min read

• Floor in a Sorted Array Given a sorted array and a value x, find the element of the floor of x. The floor of x is the largest element in the array smaller than or equal to x. Examples: Input: arr[] = [1, 2, 8, 10, 10, 12, 19], x = 5Output: 1Explanation: Largest number less than or equal to 5 is 2, whose index is 1 Input: a 9 min read

• Bitonic Point - Maximum in Increasing Decreasing Array Given an array arr[] of integers which is initially strictly increasing and then strictly decreasing, the task is to find the bitonic point, that is the maximum value in the array. Note: Bitonic Point is a point in bitonic sequence before which elements are strictly increasing and after which elemen 11 min read

• Given Array of size n and a number k, find all elements that appear more than n/k times Given an array of size n and an integer k, find all elements in the array that appear more than n/k times. Examples: Input: arr[ ] = [3, 4, 2, 2, 1, 2, 3, 3], k = 4Output: [2, 3]Explanation: Here n/k is 8/4 = 2, therefore 2 appears 3 times in the array that is greater than 2 and 3 appears 3 times in 15+ min read

Medium problems on Searching algorithms

• 3 Sum - Find All Triplets with Zero Sum Given an array arr[], the task is to find all possible indices {i, j, k} of triplet {arr[i], arr[j], arr[k]} such that their sum is equal to zero and all indices in a triplet should be distinct (i != j, j != k, k != i). We need to return indices of a triplet in sorted order, i.e., i < j < k. E 11 min read

• Find the element before which all the elements are smaller than it, and after which all are greater Given an array, find an element before which all elements are equal or smaller than it, and after which all the elements are equal or greater. Note: Print -1, if no such element exists. Examples: Input: arr[] = [5, 1, 4, 3, 6, 8, 10, 7, 9]Output: 6 Explanation: 6 is present at index 4. All elements 14 min read

• Largest pair sum in an array Given an unsorted of distinct integers, find the largest pair sum in it. For example, the largest pair sum is 74. If there are less than 2 elements, then we need to return -1. Input : arr[] = {12, 34, 10, 6, 40}, Output : 74 Input : arr[] = {10, 10, 10}, Output : 20 Input arr[] = {10}, Output : -1 [ 10 min read

• K’th Smallest Element in Unsorted Array Given an array arr[] of N distinct elements and a number K, where K is smaller than the size of the array. Find the K'th smallest element in the given array. Examples: Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 3 Output: 7 Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 4 Output: 10 Table of Content [Naive 15+ min read

• Search in a Sorted and Rotated Array Given a sorted and rotated array arr[] of n distinct elements, the task is to find the index of given key in the array. If the key is not present in the array, return -1. Examples: Input: arr[] = [5, 6, 7, 8, 9, 10, 1, 2, 3], key = 3Output: 8Explanation: 3 is present at index 8 in arr[]. Input: arr[ 15+ min read

• Minimum in a Sorted and Rotated Array Given a sorted array of distinct elements arr[] of size n that is rotated at some unknown point, the task is to find the minimum element in it. Examples: Input: arr[] = [5, 6, 1, 2, 3, 4]Output: 1Explanation: 1 is the minimum element present in the array. Input: arr[] = [3, 1, 2]Output: 1Explanation 9 min read

• Find a Fixed Point (Value equal to index) in a given array Given an array of n distinct integers sorted in ascending order, the task is to find the First Fixed Point in the array. Fixed Point in an array is an index i such that arr[i] equals i. Note that integers in the array can be negative. Note: If no Fixed Point is present in the array, print -1. Exampl 7 min read

• K Mmost Frequent Words in a File Given a book of words and an integer K. Assume you have enough main memory to accommodate all words. Design a dynamic data structure to find the top K most frequent words in a book. The structure should allow new words to be added in main memory. Examples: Input: fileData = "Welcome to the world of 15+ min read

• Find k closest elements to a given value Given a sorted array arr[] and a value x, find the k closest elements to x in arr[]. Note that if the element is present in array, then it should not be in output, only the other closest elements are required. Examples: Input: k = 4, x = 35, arr[] = {12, 16, 22, 30, 35, 39, 42, 45, 48, 50, 53, 55, 5 15+ min read

• 2 Sum - Pair Sum Closest to Target using Binary Search Given an array arr[] of n integers and an integer target, the task is to find a pair in arr[] such that it’s sum is closest to target. Note: Return the pair in sorted order and if there are multiple such pairs return the pair with maximum absolute difference. If no such pair exists return an empty a 10 min read

• Find the closest pair from two sorted arrays Given two arrays arr1[0...m-1] and arr2[0..n-1], and a number x, the task is to find the pair arr1[i] + arr2[j] such that absolute value of (arr1[i] + arr2[j] - x) is minimum. Example: Input: arr1[] = {1, 4, 5, 7}; arr2[] = {10, 20, 30, 40}; x = 32Output: 1 and 30Input: arr1[] = {1, 4, 5, 7}; arr2[] 15+ min read

• Find three closest elements from given three sorted arrays Given three sorted arrays A[], B[] and C[], find 3 elements i, j and k from A, B and C respectively such that max(abs(A[i] - B[j]), abs(B[j] - C[k]), abs(C[k] - A[i])) is minimized. Here abs() indicates absolute value. Example : Input : A[] = {1, 4, 10} B[] = {2, 15, 20} C[] = {10, 12} Output: 10 15 15+ min read

• Search in an Array of Rational Numbers without floating point arithmetic Given a sorted array of rational numbers, where each rational number is represented in the form p/q (where p is the numerator and q is the denominator), the task is to find the index of a given rational number x in the array. If the number does not exist in the array, return -1. Examples: Input: arr 9 min read

Hard problems on Searching algorithms

• Median of two sorted arrays of same size Given 2 sorted arrays a[] and b[], each of size n, the task is to find the median of the array obtained after merging a[] and b[]. Note: Since the size of the merged array will always be even, the median will be the average of the middle two numbers. Input: a[] = [1, 12, 15, 26, 38], b[] = [2, 13, 1 15+ min read

• Search in an almost sorted array Given a sorted integer array arr[] consisting of distinct elements, where some elements of the array are moved to either of the adjacent positions, i.e. arr[i] may be present at arr[i-1] or arr[i+1].Given an integer target. You have to return the index ( 0-based ) of the target in the array. If targ 7 min read

• Find position of an element in a sorted array of infinite numbers Given a sorted array arr[] of infinite numbers. The task is to search for an element k in the array. Examples: Input: arr[] = [3, 5, 7, 9, 10, 90, 100, 130, 140, 160, 170], k = 10Output: 4Explanation: 10 is at index 4 in array. Input: arr[] = [2, 5, 7, 9], k = 3Output: -1Explanation: 3 is not presen 15+ min read

• Pair Sum in a Sorted and Rotated Array Given an array arr[] of size n, which is sorted and then rotated around an unknown pivot, the task is to check whether there exists a pair of elements in the array whose sum is equal to a given target value. Examples : Input: arr[] = [11, 15, 6, 8, 9, 10], target = 16Output: trueExplanation: There i 10 min read

• K’th Smallest/Largest Element in Unsorted Array | Worst case Linear Time Given an array of distinct integers arr[] and an integer k. The task is to find the k-th smallest element in the array. For better understanding, k refers to the element that would appear in the k-th position if the array were sorted in ascending order. Note: k will always be less than the size of t 15 min read

• K'th largest element in a stream Given an infinite stream of integers, find the Kth largest element at any point of time. Note: Here we have a stream instead of a whole array and we are allowed to store only K elements. Examples: Input: stream[] = {10, 20, 11, 70, 50, 40, 100, 5, . . .}, K = 3Output: {_, _, 10, 11, 20, 40, 50, 50, 14 min read

• Best First Search (Informed Search) Best First Search is a heuristic search algorithm that selects the most promising node for expansion based on an evaluation function. It prioritizes nodes in the search space using a heuristic to estimate their potential. By iteratively choosing the most promising node, it aims to efficiently naviga 13 min read