Magic Index
You are given a sorted array A consisting of N integers. Your task is to find the magic index in the given array.

Note :

A magic index in an array A[0 ... N - 1] is defined to be an index i such that A[i] = i. The elements in the array can be negative. The elements in the array can be repeated multiple times. There can be more than one magic index in an array.

Input Format :

The first line of the input contains an integer T denoting the number of test cases. The first line of each test case contains one integer N, as described in the problem statement. The second line of each test case contains N space-separated integers, representing the elements of the array.

Output Format :

For each test case print in a new line, one integer representing the magic index of the given array or -1 if there does not exist any magic index for the given array. In case there is more than one magic index, print any of them.

Note :

You will print the magic indices, then the runner will check whether it is a magic number or not. If your output magic numbers are correct, the runner will print "Correct", else "Incorrect".

Note :

You do not need to print anything, it has already been taken care of. Just implement the given function.

Constraints :

1

Question

Magic Index

You are given a sorted array A consisting of N integers. Your task is to find the magic index in the given array.

Note :

A magic index in an array A[0 ... N - 1] is defined to be an index i such that A[i] = i.

The elements in the array can be negative.

The elements in the array can be repeated multiple times.

There can be more than one magic index in an array.

Input Format :

The first line of the input contains an integer T denoting the number of test cases.

The first line of each test case contains one integer N, as described in the problem statement.

The second line of each test case contains N space-separated integers, representing the elements of the array.

Output Format :

For each test case print in a new line, one integer representing the magic index of the given array or -1 if there does not exist any magic index for the given array.

In case there is more than one magic index, print any of them.

Note :

You will print the magic indices, then the runner will check whether it is a magic number or not. If your output magic numbers are correct, the runner will print "Correct", else "Incorrect".

Note :

You do not need to print anything, it has already been taken care of. Just implement the given function.

Constraints :

1 <= T <= 10
1 <= N <= 10^5
-10^9 <= A[i] <= 10^9

Time Limit: 1sec

Accepted Answer

Brute Force Approach

In this brute force approach, we will check each element one by one and try to find if there is any magic index in the given array or not.
In this approach, we will initialize our answer variable (say, ans) with ans = -1.
Then we will iterate in the array one by one (say, loop variable i) from the beginning and check if there is any magic index in our array or not.
If we find any index in the array such that A[i] = i, then we will assign this current index i to our answer variable ans(i.e. ans = i ) and break this loop as we have found a magic index and our task is complete.
Finally we will print this ans variable as the answer.,

Space Complexity: O(1)Explanation:

O(1).

Since we are using constant extra space to store our answer, so the space complexity is O(1).

Time Complexity: O(n)Explanation:

O(N), where N is the number of elements in the array.

Since we iterate through the given array only once hence the time complexity will be O(N).

C++ (g++ 5.4)

/*
    Time Complexity: O(N)
    Space Complexity: O(1),

    Where N is the number of elements in the array.
*/

int magicIndex(vector& a, int n) 
{
	// Variable to store the answer
    int ans = -1;

    for (int i = 0; i < n; i++) 
    {
    	// If we find a magic index we will assign it to our answer variable
        if (a[i] == i) 
        {
            ans = i;
            // After finding the least magic index we will break from the loop
            break;
        }

    }
    // Return the answer
    return ans;
}

Java (SE 1.8)

/*
    Time Complexity: O(N)
    Space Complexity: O(1)

    Where N is the number of elements in the array.
*/
import java.util.ArrayList;

public class Solution 
{
    public static int magicIndex(ArrayList a, int n) 
    {
        // Variable to store the answer
        int ans = -1;
        for (int i = 0; i < n; i++) 
        {
            // If we find a magic index we will assign it to our answer variable
            if (a.get(i) == i) 
            {
                ans = i;

                // After finding the least magic index we will break from the loop
                break;
            }
        }

        // Return the answer
        return ans;
    }

}

Python (3.5)

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

    Where N is the number of element in the array "a".
'''

def magicIndex(a, n):
    n = len(a)

    # Variable to store the answer
    ans = -1

    for i in range(n):

        # If we find a magic index we will assign it to our answer variable
        if a[i] == i:
            ans = i

            # After finding the least magic index we will break from the loop
            break

    # Return the answer
    return ans

Accepted Answer

Binary Search Approach(This Approach will only work when the given input contains distinct elements)

In this approach, we will be using binary search as the given array is always sorted.
We can apply binary search in this problem because of the fact that if at any index say ‘i’ we find that A[i] < i, then it is not possible to find the answer to the left of this index i and then we will only try to find the answer towards the right (Because if A[i] < i then say there is any index j such that j
Similarly, if A[i] > i, we can not find the answer towards the right of this index i.
So we will initialize our answer variable, say ans with -1 i.e. ans = -1.
Then we will try to find the answer using binary search in the entire array with the range of left = 0 and right = N - 1, which will be as follows:
mid = (left + right)/2
Check if A[mid] = mid, if yes then assign ans = mid and right = mid - 1 because we can still find an answer to the left of this point.
If A[mid] < mid, then left = mid + 1 and continue finding the answer.
If A[mid] > mid, then right = mid - 1 and continue finding the answer.
Finally, we will print our ans variable as the answer.

Space Complexity: O(1)Explanation:
O(1)

Since we are using constant extra space to store our answer, so the space complexity is O(1).
Time Complexity: O(logn)Explanation:
O(log(N)), where N is the number of elements in the array.

Since we are using binary search on the array the time complexity will be O(log(N)).

Accepted Answer

Modified Binary Search

When the given array has duplicate elements in it, then the normal binary search approach will fail, therefore we need a modified solution.
In this approach, we will again be using binary search but this time we will be searching towards the left as well as the right of the current mid index.
We will be trying to find the answer in left = 0 and right = N - 1 range.
We will try to find the answer using binary search in the entire array with the range of left = 0 and right = N - 1, which will be as follows:
- mid = (left + right)/2 and midVal = A[mid]
- Check if A[mid] = mid, if yes then return mid as the answer.
- We will search towards the left of the current mid in the range newLeft = left and newRight = min(mid-1,midVal). If we successfully find the answer here then we will return it as the answer, or else
- We will search towards the right of the current mid in the range of newLeft = max(mid + 1,midVal) and newRight = right.
- Finally, we will return -1 if we couldn’t find the answer or return the found answer.

Space Complexity: O(1)Explanation:

O(1)

Since we are using constant extra space to store our answer, so the space complexity is O(1).

Time Complexity: O(n)Explanation:

O(N), where N is the number of elements in the array.

Since in the worst case, we will have to search the entire array, therefore the time complexity is O(N).

C++ (g++ 5.4)

/*
    Time Complexity: O(N)
    Space Complexity: O(1),

    Where N is the number of elements in the array.
*/

int findMagicIndex(vector& a, int left, int right) 
{
    if (left > right) 
    {
        return -1;
    }

    int mid = (left + right) / 2;
    int midVal = a[mid];
    if (midVal == mid) 
    {
        return mid;
    }

    // Trying to find the answer towards left
    int leftAns = findMagicIndex(a, left, min(mid - 1, midVal));
    if (leftAns >= 0) 
    {
        return leftAns;
    }

    // If we couldn't find the answer towards left then trying to find the answer towards right
    int rightAns = findMagicIndex(a, max(mid + 1, midVal), right);
    return rightAns;
}

int magicIndex(vector& a, int n) 
{
    return findMagicIndex(a, 0, n - 1);
}

Java (SE 1.8)

/*
    Time Complexity: O(N)
    Space Complexity: O(1),

    Where N is the number of elements in the array.
*/

import java.util.ArrayList;

public class Solution 
{
    public static int findMagicIndex(ArrayList a, int left, int right) 
    {
        if (left > right) 
        {
            return -1;
        }

        int mid = (left + right) / 2;
        int midVal = a.get(mid);

        if (midVal == mid) 
        {
            return mid;
        }

        // Trying to find the answer towards left
        int leftAns = findMagicIndex(a, left, Math.min(mid - 1, midVal));
        if (leftAns >= 0) 
        {
            return leftAns;
        }

        // If we couldn't find the answer towards left then trying to find the answer towards right
        int rightAns = findMagicIndex(a, Math.max(mid + 1, midVal), right);
        return rightAns;
    }
    public static int magicIndex(ArrayList a, int n) 
    {
        return findMagicIndex(a, 0, n - 1);
    }

}

Python (3.5)

'''

    Time Complexity: O(N)

    Space Complexity: O(1),



    Where N is the number of elements in the array.

'''



def findMagicIndex(a, left, right):

    if (left > right) :

        return -1



    mid = (left + right) // 2

    midVal = a[mid]

    if (midVal == mid) :

        return mid

    

    # Trying to find the answer towards left

    leftAns = findMagicIndex(a, left, min(mid - 1, midVal))

    if (leftAns >= 0) :

        return leftAns

    

    # If we couldn't find the answer towards left then trying to find the answer towards right

    rightAns = findMagicIndex(a, max(mid + 1, midVal), right)

    return rightAns



def magicIndex(a, n):

    return findMagicIndex(a, 0, n - 1)

You are given a sorted array A consisting of N integers. Your task is to find the magic index in the given array.

Note :

Input Format :

Output Format :

Note :

Note :

Constraints :

Top Info Edge Front end Developer interview questions & answers

Popular interview questions of Front end Developer