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 PointWe 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++
#include <bits/stdc++.h>
using namespace std;
int magicIndex(int* arr, int start, int end)
{
if (start > end)
return -1;
int midIndex = (start + end) / 2;
int midValue = arr[midIndex];
if (midIndex == midValue)
return midIndex;
int left = magicIndex(arr, start, min(midValue,
midIndex - 1));
if (left >= 0)
return left;
return magicIndex(arr, max(midValue, midIndex + 1),
end);
}
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
class GFG {
static int magicIndex(int arr[], int start, int end)
{
if (start > end)
return -1;
int midIndex = (start + end) / 2;
int midValue = arr[midIndex];
if (midIndex == midValue)
return midIndex;
int left = magicIndex(arr, start, Math.min(midValue,
midIndex - 1));
if (left >= 0)
return left;
return magicIndex(arr, Math.max(midValue,
midIndex + 1),end);
}
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);
}
}
|
Python 3
def magicIndex(arr, start, end):
if (start > end):
return -1
midIndex = int((start + end) / 2)
midValue = arr[midIndex]
if (midIndex == midValue):
return midIndex
left = magicIndex(arr, start, min(midValue,
midIndex - 1))
if (left >= 0):
return left
return magicIndex(arr, max(midValue,
midIndex + 1),
end)
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)
|
C#
using System;
class GFG {
static int magicIndex(int []arr, int start,
int end)
{
if (start > end)
return -1;
int midIndex = (start + end) / 2;
int midValue = arr[midIndex];
if (midIndex == midValue)
return midIndex;
int left = magicIndex(arr, start, Math.Min(midValue,
midIndex - 1));
if (left >= 0)
return left;
return magicIndex(arr, Math.Max(midValue,
midIndex + 1),end);
}
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);
}
}
|
PHP
<?php
function magicIndex($arr, $start, $end)
{
if ($start > $end)
return -1;
$midIndex = floor(($start + $end) / 2);
$midValue = $arr[$midIndex];
if ($midIndex == $midValue)
return $midIndex;
$left = magicIndex($arr, $start,
min($midValue, $midIndex - 1));
if ($left >= 0)
return $left;
return magicIndex($arr, max($midValue,
$midIndex + 1), $end);
}
$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;
?>
|
Javascript
<script>
function magicIndex(arr, start, end)
{
if (start > end)
return -1;
let midIndex = Math.floor((start + end) / 2);
let midValue = arr[midIndex];
if (midIndex == midValue)
return midIndex;
let left = magicIndex(arr, start, Math.min(midValue,
midIndex - 1));
if (left >= 0)
return left;
return magicIndex(arr, Math.max(midValue, midIndex + 1),
end);
}
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);
</script>
|
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.
- Initialize an integer variable n to the size of the input array.
- Traverse the array from left to right using a for loop with index variable i running from 0 to n-1.
- Check if the element at index i is equal to i.
- If it is, return i as the fixed point.
- 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
{
static int findFixedPoint(int[] arr)
{
int n = arr.length;
for (int i = 0; i < n; i++)
{
if (arr[i] == i)
{
return 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 Magic Index");
}
else {
System.out.println("Magic Index is : "
+ fixedPoint);
}
}
}
|
Python3
def findFixedPoint(arr):
n = len(arr)
for i in range(n):
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:
print("No Magic 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);
}
}
}
|
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;
}
?>
|
Javascript
function findFixedPoint(arr) {
let n = arr.length;
for (let i = 0; i < n; i++) {
if (arr[i] == i) {
return i;
}
}
return -1;
}
let arr = [-10, -5, 2, 2, 2, 3, 4, 7,
9, 12, 13];
let fixedPolet = findFixedPoint(arr);
if (fixedPolet == -1) {
console.log("No Magic Index");
} else {
console.log("Magic Index is : " + fixedPolet);
}
|
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
arr = [-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13]
fixedPoint = findFixedPoint(arr)
if fixedPoint == -1:
print("No fixed point")
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);
}
}
}
|
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;
}
?>
|
Javascript
function findFixedPoint(arr)
{
let set = new Set();
for (let i = 0; i < arr.length; i++)
{
if (set.has(arr[i]) && arr[i] == i)
{
return i;
}
set.add(arr[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);
}
|
Time Complexity: O(N)
Auxiliary Space: O(N)