Find a Fixed Point (Value equal to index) in a given array | Duplicates Allowed
Last Updated :
02 Jan, 2024
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++
// 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 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 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# 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.
<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 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
?>
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;
}
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);
}
}
}
# 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}")
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);
}
}
}
// 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
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;
}
?>
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;
}
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);
}
}
}
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}")
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);
}
}
}
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
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;
}
?>
Time Complexity: O(N)
Auxiliary Space: O(N)
Similar Reads
DSA Tutorial - Learn Data Structures and Algorithms DSA (Data Structures and Algorithms) is the study of organizing data efficiently using data structures like arrays, stacks, and trees, paired with step-by-step procedures (or algorithms) to solve problems effectively. Data structures manage how data is stored and accessed, while algorithms focus on
7 min read
Quick Sort QuickSort is a sorting algorithm based on the Divide and Conquer that picks an element as a pivot and partitions the given array around the picked pivot by placing the pivot in its correct position in the sorted array. It works on the principle of divide and conquer, breaking down the problem into s
12 min read
Merge Sort - Data Structure and Algorithms Tutorials Merge sort is a popular sorting algorithm known for its efficiency and stability. It follows the divide-and-conquer approach. It works by recursively dividing the input array into two halves, recursively sorting the two halves and finally merging them back together to obtain the sorted array. Merge
14 min read
SQL Commands | DDL, DQL, DML, DCL and TCL Commands SQL commands are crucial for managing databases effectively. These commands are divided into categories such as Data Definition Language (DDL), Data Manipulation Language (DML), Data Control Language (DCL), Data Query Language (DQL), and Transaction Control Language (TCL). In this article, we will e
7 min read
Data Structures Tutorial Data structures are the fundamental building blocks of computer programming. They define how data is organized, stored, and manipulated within a program. Understanding data structures is very important for developing efficient and effective algorithms. What is Data Structure?A data structure is a st
2 min read
Bubble Sort Algorithm Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not suitable for large data sets as its average and worst-case time complexity are quite high.We sort the array using multiple passes. After the fir
8 min read
Breadth First Search or BFS for a Graph Given a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ 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). Binary Search AlgorithmConditions to apply Binary Searc
15 min read
Insertion Sort Algorithm Insertion sort is a simple sorting algorithm that works by iteratively inserting each element of an unsorted list into its correct position in a sorted portion of the list. It is like sorting playing cards in your hands. You split the cards into two groups: the sorted cards and the unsorted cards. T
9 min read
Array Data Structure Guide In this article, we introduce array, implementation in different popular languages, its basic operations and commonly seen problems / interview questions. An array stores items (in case of C/C++ and Java Primitive Arrays) or their references (in case of Python, JS, Java Non-Primitive) at contiguous
4 min read