Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Minimum index i such that all the elements from index i to given index are equal

  • Last Updated : 05 Nov, 2021

Given an array arr[] of integers and an integer pos, the task is to find the minimum index i such that all the elements from index i to index pos are equal.

Examples: 

Input: arr[] = {2, 1, 1, 1, 5, 2}, pos = 3 
Output:
Elements in index range [1, 3] are all equal to 1.

Input: arr[] = {2, 1, 1, 1, 5, 2}, pos = 5 
Output:
 

Simple Approach: Starting from index pos – 1, traverse the array in reverse and for the first index i such that arr[i] != arr[pos] print i + 1 which is the required index.

Below is the implementation of the above approach: 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the minimum required index
int minIndex(int arr[], int n, int pos)
{
    int num = arr[pos];
  
    // Start from arr[pos - 1]
    int i = pos - 1;
    while (i >= 0) {
        if (arr[i] != num)
            break;
        i--;
    }
  
    // All elements are equal
    // from arr[i + 1] to arr[pos]
    return i + 1;
}
  
// Driver code
int main()
{
    int arr[] = { 2, 1, 1, 1, 5, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int pos = 4;
      
      // Function Call
    cout << minIndex(arr, n, pos);
    return 0;
}

Java




// Java implementation of the approach
class GFG {
  
    // Function to return the minimum required index
    static int minIndex(int arr[], int n, int pos)
    {
        int num = arr[pos];
  
        // Start from arr[pos - 1]
        int i = pos - 1;
        while (i >= 0) {
            if (arr[i] != num)
                break;
            i--;
        }
  
        // All elements are equal
        // from arr[i + 1] to arr[pos]
        return i + 1;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 2, 1, 1, 1, 5, 2 };
        int n = arr.length;
        int pos = 4;
          
          // Function Call
        System.out.println(minIndex(arr, n, pos));
    }
}
  
// This code is contributed by Code_Mech.

Python3




# Python3 implementation of the approach
  
# Function to return the minimum
# required index
def minIndex(arr, n, pos):
  
    num = arr[pos]
  
    # Start from arr[pos - 1]
    i = pos - 1
    while (i >= 0):
        if (arr[i] != num):
            break
        i -= 1
      
    # All elements are equal
    # from arr[i + 1] to arr[pos]
    return i + 1
  
# Driver code
arr = [2, 1, 1, 1, 5, 2 ]
n = len(arr)
pos = 4
  
# Function Call
print(minIndex(arr, n, pos))
  
# This code is contributed by 
# Mohit Kumar 29

C#




// C# implementation of the approach
using System;
class GFG {
  
    // Function to return the minimum required index
    static int minIndex(int[] arr, int n, int pos)
    {
        int num = arr[pos];
  
        // Start from arr[pos - 1]
        int i = pos - 1;
        while (i >= 0) {
            if (arr[i] != num)
                break;
            i--;
        }
  
        // All elements are equal
        // from arr[i + 1] to arr[pos]
        return i + 1;
    }
  
    // Driver code
    public static void Main()
    {
        int[] arr = { 2, 1, 1, 1, 5, 2 };
        int n = arr.Length;
        int pos = 4;
          
          // Function Call
        Console.WriteLine(minIndex(arr, n, pos));
    }
}
  
// This code is contributed
// by Akanksha Rai

PHP




<?php
// PHP implementation of the approach 
  
// Function to return the minimum 
// required index 
function minIndex($arr, $n, $pos
    $num = $arr[$pos]; 
  
    // Start from arr[pos - 1] 
    $i = $pos - 1; 
    while ($i >= 0) 
    
        if ($arr[$i] != $num
            break
        $i--; 
    
  
    // All elements are equal 
    // from arr[i + 1] to arr[pos] 
    return $i + 1; 
  
// Driver code 
$arr = array(2, 1, 1, 1, 5, 2 ); 
$n = sizeof($arr); 
$pos = 4; 
  
echo minIndex($arr, $n, $pos); 
  
// This code is contributed by Ryuga
?>

Javascript




<script>
  
// Javascript implementation of the approach
  
// Function to return the minimum required index
function minIndex(arr, n, pos)
{
    var num = arr[pos];
  
    // Start from arr[pos - 1]
    var i = pos - 1;
    while (i >= 0) {
        if (arr[i] != num)
            break;
        i--;
    }
  
    // All elements are equal
    // from arr[i + 1] to arr[pos]
    return i + 1;
}
  
// Driver code
var arr = [ 2, 1, 1, 1, 5, 2 ];
var n = arr.length;
var pos = 4;
  
// Function Call
document.write(minIndex(arr, n, pos));
  
  
// This code is contributed by rrrtnx.
</script>
Output
4

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

Efficient Approach :

Do a binary search in the sub-array [0, pos-1]. Stop condition will be if arr[mid] == arr[pos] && arr[mid-1] != arr[pos]. Go-left or Go-right will depend on if arr[mid] == arr[pos] or not respectively.

Implementation:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the minimum required index
int minIndex(int arr[], int pos)
{
    int low = 0;
    int high = pos;
    int i = pos;
  
    while (low < high) {
        int mid = (low + high) / 2;
        if (arr[mid] != arr[pos]) {
            low = mid + 1;
        }
        else {
            high = mid - 1;
            i = mid;
            if (mid > 0 && arr[mid - 1] != arr[pos]) {
  
                // Short-circuit more comparisons as found
                // the border point
                break;
            }
        }
    }
  
    // For cases were high = low + 1 and arr[high] will
    // match with
    // arr[pos] but not arr[low] or arr[mid]. In such
    // iteration the if condition will satisfy and loop will
    // break post that low will be updated. Hence i will not
    // point to the correct index.
    return arr[low] == arr[pos] ? low : i;
}
  
// Driver code
int main()
{
    int arr[] = { 2, 1, 1, 1, 5, 2 };
  
    cout << minIndex(arr, 2) << endl; // Should be 1
    cout << minIndex(arr, 3) << endl; // Should be 1
    cout << minIndex(arr, 4) << endl; // Should be 4
    return 0;
}
  
// This code is contributed by
// anshbikram

Java




// Java implementation of the approach
  
class GFG {
      
      // Function to return the minimum required index
    static int minIndex(int arr[], int pos)
    {
        int low = 0;
        int high = pos;
        int i = pos;
  
        while (low < high) {
            int mid = (low + high) / 2;
            if (arr[mid] != arr[pos]) {
                low = mid + 1;
            }
            else {
                high = mid - 1;
                i = mid;
                if (mid > 0 && arr[mid - 1] != arr[pos]) {
                      
                      // Short-circuit more comparisons as
                    // found the border point
                    break;
                }
            }
        }
  
        // For cases were high = low + 1 and arr[high] will
        // match with arr[pos] but not arr[low] or arr[mid].
        // In such iteration the if condition will satisfy
        // and loop will break post that low will be
        // updated. Hence i will not point to the correct
        // index.
        return arr[low] == arr[pos] ? low : i;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 2, 1, 1, 1, 5, 2 };
  
        System.out.println(minIndex(arr, 2)); // Should be 1
        System.out.println(minIndex(arr, 3)); // Should be 1
        System.out.println(minIndex(arr, 4)); // Should be 4
    }
}
  
// This code is contributed by
// anshbikram

Python3




# Python3 implementation of the approach
  
# Function to return the minimum
# required index
  
def minIndex(arr, pos):
    low = 0
    high = pos
    i = pos
  
    while low < high:
        mid = (low + high)//2
        if arr[mid] != arr[pos]:
            low = mid + 1
        else:
            high = mid - 1
            i = mid
            if mid > 0 and arr[mid-1] != arr[pos]:
  
                # Short-circuit more comparisons as found the border point
                break
  
    # For cases were high = low + 1 and arr[high] will match with
    # arr[pos] but not arr[low] or arr[mid]. In such iteration
    # the if condition will satisfy and loop will break post that
    # low will be updated. Hence i will not point to the correct index.
    return low if arr[low] == arr[pos] else i
  
  
# Driver code
arr = [2, 1, 1, 1, 5, 2]
  
print(minIndex(arr, 2))  # Should be 1
print(minIndex(arr, 3))  # Should be 1
print(minIndex(arr, 4))  # Should be 4
  
# This code is contributed by
# anshbikram

C#




// C# implementation of the approach
using System;
  
class GFG{
      
// Function to return the minimum 
// required index
static int minIndex(int []arr, int pos)
{
    int low = 0;
    int high = pos;
    int i = pos;
  
    while (low < high)
    {
        int mid = (low + high) / 2;
        if (arr[mid] != arr[pos]) 
        {
            low = mid + 1;
        }
        else 
        {
            high = mid - 1;
            i = mid;
            if (mid > 0 && arr[mid - 1] != arr[pos]) 
            {
                  
                // Short-circuit more comparisons as
                // found the border point
                break;
            }
        }
    }
  
    // For cases were high = low + 1 and arr[high] will
    // match with arr[pos] but not arr[low] or arr[mid].
    // In such iteration the if condition will satisfy
    // and loop will break post that low will be
    // updated. Hence i will not point to the correct
    // index.
    return arr[low] == arr[pos] ? low : i;
}
  
// Driver code
public static void Main()
{
    int []arr = { 2, 1, 1, 1, 5, 2 };
  
    Console.WriteLine(minIndex(arr, 2)); // Should be 1
    Console.WriteLine(minIndex(arr, 3)); // Should be 1
    Console.WriteLine(minIndex(arr, 4)); // Should be 4
}
}
  
// This code is contributed by chitranayal

Javascript




<script>
// javascript implementation of the approach
    // Function to return the minimum required index
    function minIndex(arr , pos) {
        var low = 0;
        var high = pos;
        var i = pos;
  
        while (low < high) {
            var mid = parseInt((low + high) / 2);
            if (arr[mid] != arr[pos]) {
                low = mid + 1;
            } else {
                high = mid - 1;
                i = mid;
                if (mid > 0 && arr[mid - 1] != arr[pos]) {
  
                    // Short-circuit more comparisons as
                    // found the border point
                    break;
                }
            }
        }
  
        // For cases were high = low + 1 and arr[high] will
        // match with arr[pos] but not arr[low] or arr[mid].
        // In such iteration the if condition will satisfy
        // and loop will break post that low will be
        // updated. Hence i will not point to the correct
        // index.
        return arr[low] == arr[pos] ? low : i;
    }
  
    // Driver code
      
        var arr = [ 2, 1, 1, 1, 5, 2 ];
  
        document.write(minIndex(arr, 2)+"<br/>"); // Should be 1
        document.write(minIndex(arr, 3)+"<br/>"); // Should be 1
        document.write(minIndex(arr, 4)+"<br/>"); // Should be 4
  
// This code is contributed by todaysgaurav 
</script>
Output
1
1
4

Time Complexity: O(log(n))
Space Complexity: O(1)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!