Find a Fixed Point (Value equal to index) in a given array | Duplicates Allowed

Given an array of n 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, -5, 0, 3, 7}
  Output: 3  // arr[3] == 3 
  Input: arr[] = {-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13}
  Output: 2  // arr[2] == 2 
  Input: arr[] = {-10, -5, 3, 4, 7, 9}
  Output: -1  // No Fixed Point

We have a solution to find fixed point in an array of distinct elements. In this post, solution for an array with duplicate values is discussed.

Consider the arr[] = {-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13}, arr[mid] = 3

If elements are not distinct, then we see arr[mid] < mid, we cannot conclude which side the fixed is on. It could be on the left side or on the right side. We know for sure that since arr[5] = 3, arr[4] couldn’t be magic index because arr[4] must be less than or equal to arr[5] (the array is Sorted). So, the general pattern of our search would be: 

• Left Side: start = start, end = min(arr[midIndex], midIndex-1)
• Right Side: start = max(arr[midIndex], midIndex+1), end = end

Below is the code for the above Algorithm.

C++

// CPP Program to find magic index.
#include <bits/stdc++.h>
using namespace std;

int magicIndex(int* arr, int start, int end)
{
    // If No Magic Index return -1;
    if (start > end)
        return -1;

    int midIndex = (start + end) / 2;
    int midValue = arr[midIndex];

    // Magic Index Found, return it.
    if (midIndex == midValue)
        return midIndex;

    // Search on Left side
    int left = magicIndex(arr, start, min(midValue,
                                     midIndex - 1));

    // If Found on left side, return.
    if (left >= 0)
        return left;

    // Return ans from right side.
    return magicIndex(arr, max(midValue, midIndex + 1),
                                                  end);
}

// Driver program
int main()
{
    int arr[] = { -10, -5, 2, 2, 2, 3, 4, 7,
                                 9, 12, 13 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int index = magicIndex(arr, 0, n - 1);
    if (index == -1)
        cout << "No Magic Index";
    else
        cout << "Magic Index is : " << index;
    return 0;
}

Java

// Java Program to find magic index.

class GFG {

    static int magicIndex(int arr[], int start, int end)
    {
        // If No Magic Index return -1;
        if (start > end)
            return -1;

        int midIndex = (start + end) / 2;
        int midValue = arr[midIndex];

        // Magic Index Found, return it.
        if (midIndex == midValue)
            return midIndex;

        // Search on Left side
        int left = magicIndex(arr, start, Math.min(midValue,
                                            midIndex - 1));

        // If Found on left side, return.
        if (left >= 0)
            return left;

        // Return ans from right side.
        return magicIndex(arr, Math.max(midValue,
                                midIndex + 1),end);
    }

    // Driver code
    public static void main (String[] args)
    {
        int arr[] = { -10, -5, 2, 2, 2, 3, 4, 7,
                    9, 12, 13 };
        int n = arr.length;
        int index = magicIndex(arr, 0, n - 1);
        if (index == -1)
            System.out.print("No Magic Index");
        else
            System.out.print("Magic Index is : "+index);
    }
}

// This code is contributed by Anant Agarwal.

Python 3

# Python 3 Program to find
# magic index.

def magicIndex(arr, start, end):

    # If No Magic Index return -1
    if (start > end):
        return -1

    midIndex = int((start + end) / 2)
    midValue = arr[midIndex]

    # Magic Index Found, return it.
    if (midIndex == midValue):
        return midIndex

    # Search on Left side
    left = magicIndex(arr, start, min(midValue,
                                midIndex - 1))

    # If Found on left side, return.
    if (left >= 0):
        return left

    # Return ans from right side.
    return magicIndex(arr, max(midValue,
                        midIndex + 1),
                                    end)

# Driver program
arr = [-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13]
n = len(arr)

index = magicIndex(arr, 0, n - 1)

if (index == -1):
    print("No Magic Index")
else:
    print("Magic Index is :", index)

# This code is contributed by Smitha Dinesh Semwal

C#

// C# Program to find magic index.
using System;

class GFG {

    static int magicIndex(int []arr, int start,
                                    int end)
    {
        // If No Magic Index return -1;
        if (start > end)
            return -1;

        int midIndex = (start + end) / 2;
        int midValue = arr[midIndex];

        // Magic Index Found, return it.
        if (midIndex == midValue)
            return midIndex;

        // Search on Left side
        int left = magicIndex(arr, start, Math.Min(midValue,
                                            midIndex - 1));

        // If Found on left side, return.
        if (left >= 0)
            return left;

        // Return ans from right side.
        return magicIndex(arr, Math.Max(midValue,
                                midIndex + 1),end);
    }

    // Driver code
    public static void Main ()
    {
        int []arr = { -10, -5, 2, 2, 2, 3,
                        4, 7, 9, 12, 13 };

        int n = arr.Length;

        int index = magicIndex(arr, 0, n - 1);

        if (index == -1)
            Console.WriteLine("No Magic Index");
        else
            Console.WriteLine("Magic Index is : " +
                                            index);
    }
}

// This code is contributed by vt_m.

Javascript

<script>
// JavaScript Program to find magic index.

function magicIndex(arr, start, end)
{
    // If No Magic Index return -1;
    if (start > end)
        return -1;

    let midIndex = Math.floor((start + end) / 2);
    let midValue = arr[midIndex];

    // Magic Index Found, return it.
    if (midIndex == midValue)
        return midIndex;

    // Search on Left side
    let left = magicIndex(arr, start, Math.min(midValue,
                                    midIndex - 1));

    // If Found on left side, return.
    if (left >= 0)
        return left;

    // Return ans from right side.
    return magicIndex(arr, Math.max(midValue, midIndex + 1),
                                                end);
}

// Driver program
    let arr = [ -10, -5, 2, 2, 2, 3, 4, 7,
                                9, 12, 13 ];
    let n = arr.length;
    let index = magicIndex(arr, 0, n - 1);
    if (index == -1)
        document.write("No Magic Index");
    else
        document.write("Magic Index is : " + index);




// This code is contributed by Surbhi Tyagi.
</script>

PHP

<?php
// PHP Program to find magic index.

function magicIndex($arr, $start, $end)
{

    // If No Magic Index return -1;
    if ($start > $end)
        return -1;

    $midIndex = floor(($start + $end) / 2);
    $midValue = $arr[$midIndex];

    // Magic Index Found, return it.
    if ($midIndex == $midValue)
        return $midIndex;

    // Search on Left side
    $left = magicIndex($arr, $start,
            min($midValue, $midIndex - 1));

    // If Found on left side, return.
    if ($left >= 0)
        return $left;

    // Return ans from right side.
    return magicIndex($arr, max($midValue,
                     $midIndex + 1), $end);
}

    // Driver Code
    $arr = array(-10, -5, 2, 2, 2, 3,
                     4, 7, 9, 12, 13);
    $n = sizeof($arr);
    $index = magicIndex($arr, 0, $n - 1);
    if ($index == -1)
        echo "No Magic Index";
    else
        echo "Magic Index is : " , $index;

// This code is contributed by nitin mittal
?>

Output

Magic Index is : 2

Time Complexity: O(N)
Auxiliary Space: O(1)

Approach 2: Using a linear search

In this approach, we use a linear search to traverse the array and check if any element is equal to its index. If we find such an element, we return its index as the fixed point. If no such element is found, we return -1 to indicate that no fixed point exists.

1. Initialize an integer variable n to the size of the input array.
2. Traverse the array from left to right using a for loop with index variable i running from 0 to n-1.
3. Check if the element at index i is equal to i.
4. If it is, return i as the fixed point.
5. If no fixed point is found in the entire array, return -1 to indicate that no fixed point exists.

C++

#include <iostream>
#include <vector>
using namespace std;

int findFixedPoint(vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n; i++) {
        if (arr[i] == i) {
            return i;
        }
    }
    return -1;
}

int main() {
    vector<int> arr = { -10, -5, 2, 2, 2, 3, 4, 7,
                                 9, 12, 13 };
    int fixedPoint = findFixedPoint(arr);
    if (fixedPoint == -1) {
       cout << "No Magic Index";
    } else {
         cout << "Magic Index is : " << fixedPoint << endl;
    }
    return 0;
}

Java

import java.util.*;

class Main
{

  // Define a function to find the magic index in an array
  static int findFixedPoint(int[] arr)
  {

    // Get the length of the array
    int n = arr.length;

    // Loop through the array
    for (int i = 0; i < n; i++)
    {

      // If the value at the current index is equal to
      // the index itself
      if (arr[i] == i)
      {

        // Return the index
        return i;
      }
    }
    // If no magic index is found, return -1
    return -1;
  }

  public static void main(String[] args)
  {

    // Create an array
    int[] arr
      = { -10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13 };

    // Call the findFixedPoint function to find the
    // magic index
    int fixedPoint = findFixedPoint(arr);

    // If no magic index is found, print "No Magic
    // Index"
    if (fixedPoint == -1) {
      System.out.println("No Magic Index");
    }
    // If a magic index is found, print the index
    else {
      System.out.println("Magic Index is : "
                         + fixedPoint);
    }
  }
}

Python3

# Define a function to find the magic index in an array
def findFixedPoint(arr):
    # Get the length of the array
    n = len(arr)
    # Loop through the array
    for i in range(n):
        # If the value at the current index is equal to the index itself
        if arr[i] == i:
            # Return the index
            return i
    # If no magic index is found, return -1
    return -1


# Create an array
arr = [-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13]
# Call the findFixedPoint function to find the magic index
fixedPoint = findFixedPoint(arr)
# If no magic index is found, print "No Magic Index"
if fixedPoint == -1:
    print("No Magic Index")
# If a magic index is found, print the index
else:
    print(f"Magic Index is : {fixedPoint}")

C#

using System;
using System.Collections.Generic;

class Program {
    static int FindFixedPoint(List<int> arr)
    {
        int n = arr.Count;
        for (int i = 0; i < n; i++) {
            if (arr[i] == i) {
                return i;
            }
        }
        return -1;
    }

    static void Main(string[] args)
    {
        List<int> arr = new List<int>{ -10, -5, 2, 2,  2, 3,
                                       4,   7,  9, 12, 13 };
        int fixedPoint = FindFixedPoint(arr);
        if (fixedPoint == -1) {
            Console.WriteLine("No Magic Index");
        }
        else {
            Console.WriteLine("Magic Index is: "
                              + fixedPoint);
        }
    }
}

Javascript

// Define a function to find the magic index in an array
function findFixedPoint(arr) {

    // Get the length of the array
    let n = arr.length;

    // Loop through the array
    for (let i = 0; i < n; i++) {

        // If the value at the current index is equal to
    // the index itself
        if (arr[i] == i) {

            // Return the index
            return i;
        }
    }

    // If no magic index is found, return -1
    return -1;
}

let arr = [-10, -5, 2, 2, 2, 3, 4, 7,
    9, 12, 13];

    // Call the findFixedPoint function to find the
    // magic index
let fixedPolet = findFixedPoint(arr);

// If no magic index is found, print "No Magic
    // Index"
if (fixedPolet == -1) {
    console.log("No Magic Index");
} else {
    console.log("Magic Index is : " + fixedPolet);
}

// This code is contributed by akashish__

PHP

<?php

function findFixedPoint($arr) {
    $n = count($arr);
    for ($i = 0; $i < $n; $i++) {
        if ($arr[$i] == $i) {
            return $i;
        }
    }
    return -1;
}

$arr = [-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13];
$fixedPoint = findFixedPoint($arr);
if ($fixedPoint == -1) {
    echo "No fixed point";
} else {
    echo "Fixed point is : " . $fixedPoint;
}

?>

Output

Magic Index is : 2

Time Complexity: O(N)
Auxiliary Space: O(1)

Approach 3: Using Hashing

• Create a set of the input array.
• Loop through the array and check if the current element is present in the set and also equal to its index. If yes, return the index.
• If no fixed point is found, return -1.

Here is the implementation of above approach:

C++

#include <iostream>
#include <unordered_set>
#include <vector>

int findFixedPoint(std::vector<int>& arr) {
    std::unordered_set<int> s;
    for (int i = 0; i < arr.size(); i++) {
        if (s.find(arr[i]) != s.end() || arr[i] == i) {
            return i;
        }
        s.insert(arr[i]);
    }
    return -1;
}

int main() {
    std::vector<int> arr = {-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13};
    int fixedPoint = findFixedPoint(arr);
    if (fixedPoint == -1) {
        std::cout << "No fixed point" << std::endl;
    } else {
        std::cout << "Fixed point is : " << fixedPoint << std::endl;
    }
    return 0;
}

Java

import java.util.HashSet;

public class FixedPoint {
    public static int findFixedPoint(int[] arr) {
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < arr.length; i++) {
            if (set.contains(arr[i]) || arr[i] == i) {
                return i;
            }
            set.add(arr[i]);
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13};
        int fixedPoint = findFixedPoint(arr);
        if (fixedPoint == -1) {
            System.out.println("No fixed point");
        } else {
            System.out.println("Fixed point is : " + fixedPoint);
        }
    }
}

Python3

def findFixedPoint(arr):
    s = set(arr)
    for i in range(len(arr)):
        if arr[i] in s and arr[i] == i:
            return i
    return -1

# Create an array
arr = [-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13]
# Call the findFixedPoint function to find the fixed point
fixedPoint = findFixedPoint(arr)
# If no fixed point is found, print "No fixed point"
if fixedPoint == -1:
    print("No fixed point")
# If a fixed point is found, print the index
else:
    print(f"Fixed point is : {fixedPoint}")

C#

using System;
using System.Collections.Generic;

class Program
{
    static int FindFixedPoint(int[] arr)
    {
        HashSet<int> set = new HashSet<int>();
        for (int i = 0; i < arr.Length; i++)
        {
            if (set.Contains(arr[i]) || arr[i] == i)
            {
                return i;
            }
            set.Add(arr[i]);
        }
        return -1;
    }

    static void Main(string[] args)
    {
        int[] arr = {-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13};
        int fixedPoint = FindFixedPoint(arr);
        if (fixedPoint == -1)
        {
            Console.WriteLine("No fixed point");
        }
        else
        {
            Console.WriteLine("Fixed point is : " + fixedPoint);
        }
    }
}

Javascript

function findFixedPoint(arr)
{
    let set = new Set();
    for (let i = 0; i < arr.length; i++)
    {
        set.add(arr[i]);
        if (set.has(arr[i]) && arr[i] == i)
        {
            return i;
        }
    }
    return -1;
}

let arr = [-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13];
let fixedPoint = findFixedPoint(arr);
if (fixedPoint == -1)
{
    console.log("No fixed point");
}
else
{
    console.log("Fixed point is : " + fixedPoint);
}

PHP

<?php
    function findFixedPoint($arr)
{
    $set = array();
    for ($i = 0; $i < count($arr); $i++)
    {
        if (in_array($arr[$i], $set) || $arr[$i] == $i)
        {
            return $i;
        }
        $set[] = $arr[$i];
    }
    return -1;
}

$arr = array(-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13);
$fixedPoint = findFixedPoint($arr);
if ($fixedPoint == -1)
{
    echo "No fixed point";
}
else
{
    echo "Fixed point is : " . $fixedPoint;
}

?>

Output

Fixed point is : 2

Time Complexity: O(N)
Auxiliary Space: O(N)