Skip to content
Related Articles

Related Articles

Improve Article

Find a Fixed Point in an array with duplicates allowed

  • Difficulty Level : Hard
  • Last Updated : 09 Apr, 2021

Given an array of n duplicates or distinct integers sorted in ascending order, write a function that returns a Fixed Point in the array, if there is any Fixed Point present in the array, else returns -1. Fixed Point in an array is an index i such that arr[i] is equal to i. Note that integers in the array can be negative.
Examples : 
 

Input : arr[] = {-10, -1, 3, 3, 10, 30, 30, 50, 100} 
Output: 3  
Note : arr[3] == 3 

Input: arr[] = {0, 2, 5, 8, 17}
Output: 0  

Input: arr[] = {-10, -5, 3, 4, 7, 9}
Output: -1  
No Fixed Point

We have already discussed find a Fixed Point in a given array of n distinct integers
 

If elements are not distinct, then previously discussed algorithm fails. Consider the following array: 
 

 // with duplicates value 
 Input : arr[] = {-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13}; 
 Wrong Output : -1  // but arr[2] == 2 

When we see that A [mid] < mid, we cannot conclude which side the fixed index is on. It could be on the right side, as before. Or, it could be on the left side (as it, in fact, is). 
Could it be anywhere on the left side? Not exactly. Since A[ 5] = 3, we know that A[ 4] couldn’t be a fixed index. A[ 4] would need to be 4 to be the fixed index, but A[ 4] must be less than or equal to A[ 5]. 
In fact, when we see that A[ 5] = 3, we’ll need to recursively search the right side as before. But, to search the left side, we can skip a bunch of elements and only recursively search elements A [ 0] through A [ 3]. A[ 3] is the first element that could be a fixed index. 
The general pattern is that we compare mid Index and midValue for equality first. Then, if they are not equal, we recursively search the left and right sides as follows: 
code below implements this algorithm.
 

C++




// C++ implementation to find fixed
// index using binary search
#include<bits/stdc++.h>
 
using namespace std;
 
// Main Function to find fixed
// index using binary search
int binarySearch(int arr[], int low,
                        int high)
{
    if (high < low)
        return -1;
     
    // low + (high - low) / 2
    int mid = (low + high) / 2;
    int midValue = arr[mid];
 
    if (mid == arr[mid])
        return mid;
 
    // Search left
    int leftindex = min(mid - 1, midValue);
    int left = binarySearch(arr, low, leftindex);
 
    if (left >= 0)
        return left;
 
    // Search right
    int rightindex = max(mid + 1, midValue);
    int right = binarySearch(arr, rightindex, high);
 
    return right;
}
 
// Driver code
int main()
{
    // input 1
    int arr[] = {-10, -5, 2, 2, 2, 
                 3, 4, 7, 9, 12, 13};
                  
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Fixed Point is "
         << binarySearch(arr, 0, n - 1);
 
    // input 2
    int arr1[] = {-10, -1, 3, 3, 10,
                    30, 30, 50, 100};
                     
    int n1 = sizeof(arr) / sizeof(arr1[0]);
     
    cout << "\nFixed Point is "
         << binarySearch(arr1, 0, n1 - 1);
 
    return 0;
}

Java




// Java implementation of find fixed
// index using binary search
class GFG
{
    // Main Function to find fixed
    // index using binary search
    static int binarySearch(int arr[], int low,
                                      int high)
    {
        if (high < low)
            return -1;
     
        // low + (high - low) / 2
        int mid = (low + high) / 2;
        int midValue = arr[mid];
     
        if (mid == arr[mid])
            return mid;
     
        // Search left
        int leftindex = Math.min(mid - 1, midValue);
        int left = binarySearch(arr, low, leftindex);
     
        if (left >= 0)
            return left;
     
        // Search right
        int rightindex = Math.max(mid + 1, midValue);
        int right = binarySearch(arr, rightindex, high);
 
        return right;
    }
     
    // Driver code
    public static void main(String[] args)
    {
        // input 1
        int arr[] = {-10, -5, 2, 2, 2,
                     3, 4, 7, 9, 12, 13};
                      
        System.out.println("Fixed Point is " +
            binarySearch(arr, 0, arr.length - 1));
         
        // input 2
        int arr1[] = {-10, -1, 3, 3, 10,
                        30, 30, 50, 100};
                         
        System.out.println("Fixed Point is " +
            binarySearch(arr1, 0, arr1.length - 1));
    }
}

Python3




# Python 3 implementation to find fixed
# index using binary search
 
# Main Function to find fixed
# index using binary search
def binarySearch(arr, low, high):
    if (high < low):
        return -1
     
    # low + (high - low) / 2
    mid = int((low + high) / 2)
    midValue = arr[mid]
 
    if (mid == arr[mid]):
        return mid
 
    # Search left
    leftindex = min(mid - 1, midValue)
    left = binarySearch(arr, low, leftindex)
 
    if (left >= 0):
        return left
 
    # Search right
    rightindex = max(mid + 1, midValue)
    right = binarySearch(arr, rightindex, high)
 
    return right
 
# Driver code
if __name__ == '__main__':
     
    # input 1
    arr = [-10, -5, 2, 2, 2, 3,
               4, 7, 9, 12, 13]
                 
    n = len(arr)
    print("Fixed Point is",
           binarySearch(arr, 0, n - 1))
 
    # input 2
    arr1 = [-10, -1, 3, 3, 10,
              30, 30, 50, 100]
                     
    n1 = len(arr)
     
    print("Fixed Point is",
           binarySearch(arr1, 0, n1 - 1))
     
# This code is contributed by
# Shashank_Sharma

C#




// C# implementation of find fixed
// index using binary search
using System;
 
class GFG
{
    // Main Function to find fixed
    // index using binary search
    static int binarySearch(int []arr, int low,
                                      int high)
    {
        if (high < low)
            return -1;
     
        // low + (high - low) / 2
        int mid = (low + high) / 2;
        int midValue = arr[mid];
     
        if (mid == arr[mid])
            return mid;
     
        // Search left
        int leftindex = Math.Min(mid - 1, midValue);
        int left = binarySearch(arr, low, leftindex);
     
        if (left >= 0)
            return left;
     
        // Search right
        int rightindex = Math.Max(mid + 1, midValue);
        int right = binarySearch(arr, rightindex, high);
     
        return right;
    }
     
    // Driver Code
    public static void Main()
    {
        // input 1
        int []arr = {-10, -5, 2, 2, 2, 
                     3, 4, 7, 9, 12, 13};
                      
        Console.WriteLine("Fixed Point is " +
            binarySearch(arr, 0, arr.Length - 1));
         
        // input 2
        int []arr1 = {-10, -1, 3, 3, 10,
                       30, 30, 50, 100};
                        
        Console.Write("Fixed Point is " +
            binarySearch(arr1, 0, arr1.Length - 1));
    }
}
 
// This code is contributed by nitin mittal.

PHP




<?php
// PHP implementation to
// find fixed index using
// binary search
 
// Main Function to find fixed
// index using binary search
function binarySearch($arr,
                      $low,
                      $high)
{
    if ($high < $low)
        return -1;
     
    // low + (high - low) / 2
    $mid = floor(($low + $high) / 2);
    $midValue = $arr[$mid];
 
    if ($mid == $arr[$mid])
        return $mid;
 
    // Search left
    $leftindex = min($mid - 1,
                     $midValue);
    $left = binarySearch($arr, $low,
                         $leftindex);
 
    if ($left >= 0)
        return $left;
 
    // Search right
    $rightindex = max($mid + 1,
                      $midValue);
    $right = binarySearch($arr,
                          $rightindex,
                          $high);
 
    return $right;
}
 
// Driver code
 
// input 1
$arr = array(-10, -5, 2, 2, 2, 3,
                4, 7, 9, 12, 13);
             
$n = sizeof($arr) / sizeof($arr[0]);
echo "Fixed Point is ",
      binarySearch($arr, 0, $n - 1);
 
// input 2
$arr1 = array(-10, -1, 3, 3, 10,
               30, 30, 50, 100);
                 
$n1 = sizeof($arr) / sizeof($arr1[0]);
 
echo "\nFixed Point is ",
     binarySearch($arr1, 0, $n1 - 1);
 
// This code is contributed by nitin mittal.
?>

Javascript




<script>
 
// Javascript implementation to find fixed
// index using binary search
 
// Main Function to find fixed
// index using binary search
function binarySearch(arr, low, high)
{
    if (high < low)
        return -1;
     
    // low + (high - low) / 2
    var mid = parseInt((low + high) / 2);
    var midValue = arr[mid];
 
    if (mid == arr[mid])
        return mid;
 
    // Search left
    var leftindex = Math.min(mid - 1, midValue);
    var left = binarySearch(arr, low, leftindex);
 
    if (left >= 0)
        return left;
 
    // Search right
    var rightindex = Math.max(mid + 1, midValue);
    var right = binarySearch(arr, rightindex, high);
 
    return right;
}
 
// Driver code
 
// input 1
var arr = [-10, -5, 2, 2, 2,
            3, 4, 7, 9, 12, 13];
             
var n = arr.length;
document.write("Fixed Point is "
    + binarySearch(arr, 0, n - 1));
// input 2
var arr1 = [-10, -1, 3, 3, 10,
                30, 30, 50, 100];
                 
var n1 = arr1.length;
 
document.write("<br>Fixed Point is "
    + binarySearch(arr1, 0, n1 - 1));
 
// This code is contributed by rrrtnx.
</script>

Output : 
 



Fixed Point is  2
Fixed Point is  3

Algorithmic Paradigm : Divide & Conquer 
Time Complexity : O(Logn)
This article is contributed by Mr. Somesh Awasthi. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :