Skip to content
Related Articles

Related Articles

Find if there is a pair with a given sum in the rotated sorted Array

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 28 Jul, 2022
View Discussion
Improve Article
Save Article

Given an array arr[] of distinct elements size N that is sorted and then around an unknown point, the task is to check if the array has a pair with a given sum X.

Examples : 

Input: arr[] = {11, 15, 6, 8, 9, 10}, X = 16
Output: true
Explanation: There is a pair (6, 10) with sum 16

Input: arr[] = {11, 15, 26, 38, 9, 10}, X = 35
Output: true
Explanation: There is a pair (26, 9) with sum 35

Input: arr[] = {11, 15, 26, 38, 9, 10}, X = 45
Output: false
Explanation: There is no pair with sum 45.

We have discussed an O(n) solution for a sorted array (See steps 2, 3, and 4 of Method 1) in this article. We can extend this solution for the rotated arrays as well. 

Approach: The idea is: 

First find the largest element in an array which is the pivot point also and the element just after the largest is the smallest element. Once we have the indices of the largest and the smallest elements, we use a similar meet-in-middle algorithm (as discussed here in method 1) to find if there is a pair. 

The only thing new here is indices are incremented and decremented in a rotational manner using modular arithmetic.

Illustration:

Let us take an example arr[]={11, 15, 6, 8, 9, 10}, sum=16.
pivot = 1,  

l = 2, r = 1:
        => arr[2] + arr[1] = 6 + 15 = 21 which is > 16 
        => So decrement r circularly. r = ( 6 + 1 – 1) % 6, r = 0

l = 2, r = 0:
        => arr[2] + arr[0] = 17 which is > 16. 
        => So decrement r circularly. r = (6 + 0 – 1) % 6, r = 5

l = 2, r = 5:
        => arr[2] + arr[5] = 16 which is equal to 16. 
        => Hence return true

Hence there exists such a pair.

Follow the steps mentioned below to implement the idea:

  • We will run a for loop from 0 to N-1, to find out the pivot point. 
  • Set the left pointer(l) to the smallest value and the right pointer(r) to the highest value.
  • To restrict the circular movement within the array we will apply the modulo operation by the size of the array.
  • While l ! = r, we shall keep checking if arr[l] + arr[r] = sum.
    • If arr[l] + arr[r] is greater than X, update r = (N+r-1) % N.
    • If arr[l] + arr[r] is less than X, update l = (l+1) % N.
    • If arr[l] + arr[r] is equal to the value X, then return true.
  • If no such pair is found after the iteration is complete, return false.

Below is the implementation of the above approach. 

C++




// C++ code to implement the approach
  
#include <bits/stdc++.h>
using namespace std;
  
// This function returns true if arr[0..n-1]
// has a pair with sum equals to x.
bool pairInSortedRotated(int arr[], int n, int x)
{
    // Find the pivot element
    int i;
    for (i = 0; i < n - 1; i++)
        if (arr[i] > arr[i + 1])
            break;
  
    // l is now index of smallest element
    int l = (i + 1) % n;
  
    // r is now index of largest element
    int r = i;
  
    // Keep moving either l or r till they meet
    while (l != r) {
  
        // If we find a pair with sum x,
        // we return true
        if (arr[l] + arr[r] == x)
            return true;
  
        // If current pair sum is less,
        // move to the higher sum
        if (arr[l] + arr[r] < x)
            l = (l + 1) % n;
  
        // Move to the lower sum side
        else
            r = (n + r - 1) % n;
    }
    return false;
}
  
// Driver code
int main()
{
    int arr[] = { 11, 15, 6, 8, 9, 10 };
    int X = 16;
    int N = sizeof(arr) / sizeof(arr[0]);
  
    // Function call
    if (pairInSortedRotated(arr, N, X))
        cout << "true";
    else
        cout << "false";
  
    return 0;
}


Java




// Java program to find a pair with a given
// sum in a sorted and rotated array
class PairInSortedRotated {
    // This function returns true if arr[0..n-1]
    // has a pair with sum equals to x.
    static boolean pairInSortedRotated(int arr[], int n,
                                       int x)
    {
        // Find the pivot element
        int i;
        for (i = 0; i < n - 1; i++)
            if (arr[i] > arr[i + 1])
                break;
  
        // l is now index of smallest element
        int l = (i + 1) % n;
  
        // r is now index of largest element
        int r = i;
  
        // Keep moving either l or r till they meet
        while (l != r) {
            // If we find a pair with sum x, we
            // return true
            if (arr[l] + arr[r] == x)
                return true;
  
            // If current pair sum is less, move
            // to the higher sum
            if (arr[l] + arr[r] < x)
                l = (l + 1) % n;
  
            // Move to the lower sum side
            else
                r = (n + r - 1) % n;
        }
        return false;
    }
  
    /* Driver program to test above function */
    public static void main(String[] args)
    {
        int arr[] = { 11, 15, 6, 8, 9, 10 };
        int X = 16;
        int N = arr.length;
  
        if (pairInSortedRotated(arr, N, X))
            System.out.print("true");
        else
            System.out.print("false");
    }
}
/*This code is contributed by Prakriti Gupta*/


Python3




# Python3 program to find a
# pair with a given sum in
# a sorted and rotated array
  
  
# This function returns True
# if arr[0..n-1] has a pair
# with sum equals to x.
def pairInSortedRotated(arr, n, x):
  
    # Find the pivot element
    for i in range(0, n - 1):
        if (arr[i] > arr[i + 1]):
            break
  
    # l is now index of smallest element
    l = (i + 1) % n
    # r is now index of largest element
    r = i
  
    # Keep moving either l
    # or r till they meet
    while (l != r):
  
        # If we find a pair with
        # sum x, we return True
        if (arr[l] + arr[r] == x):
            return True
  
        # If current pair sum is less,
        # move to the higher sum
        if (arr[l] + arr[r] < x):
            l = (l + 1) % n
        else:
  
            # Move to the lower sum side
            r = (n + r - 1) % n
  
    return False
  
  
# Driver program to test above function
arr = [11, 15, 6, 8, 9, 10]
X = 16
N = len(arr)
  
if (pairInSortedRotated(arr, N, X)):
    print("true")
else:
    print("false")
  
  
# This article contributed by saloni1297


C#




// C# program to find a pair with a given
// sum in a sorted and rotated array
using System;
  
class PairInSortedRotated {
    // This function returns true if arr[0..n-1]
    // has a pair with sum equals to x.
    static bool pairInSortedRotated(int[] arr, int n, int x)
    {
        // Find the pivot element
        int i;
        for (i = 0; i < n - 1; i++)
            if (arr[i] > arr[i + 1])
                break;
  
        // l is now index of smallest element
        int l = (i + 1) % n;
  
        // r is now index of largest element
        int r = i;
  
        // Keep moving either l or r till they meet
        while (l != r) {
            // If we find a pair with sum x, we
            // return true
            if (arr[l] + arr[r] == x)
                return true;
  
            // If current pair sum is less,
            // move to the higher sum
            if (arr[l] + arr[r] < x)
                l = (l + 1) % n;
  
            // Move to the lower sum side
            else
                r = (n + r - 1) % n;
        }
        return false;
    }
  
    // Driver Code
    public static void Main()
    {
        int[] arr = { 11, 15, 6, 8, 9, 10 };
        int X = 16;
        int N = arr.Length;
  
        if (pairInSortedRotated(arr, N, X))
            Console.WriteLine("true");
        else
            Console.WriteLine("false");
    }
}
  
// This code is contributed by vt_m.


PHP




<?php
// PHP program to find a pair
// with a given sum in a
// sorted and rotated array
  
// This function returns true
// if arr[0..n-1] has a pair 
// with sum equals to x.
  
function pairInSortedRotated($arr, $n, $x)
{
    // Find the pivot element
    $i;
    for ($i = 0; $i < $n - 1; $i++)
        if ($arr[$i] > $arr[$i + 1])
            break;
          
    // l is now index of 
    // smallest element
    $l = ($i + 1) % $n
      
    // r is now index of
    // largest element
    $r = $i;
  
    // Keep moving either l 
    // or r till they meet
    while ($l != $r)
    {
        // If we find a pair with
        // sum x, we return true
        if ($arr[$l] + $arr[$r] == $x)
            return true;
  
        // If current pair sum is 
        // less, move to the higher sum
        if ($arr[$l] + $arr[$r] < $x)
            $l = ($l + 1) % $n;
              
        // Move to the lower sum side
        else 
            $r = ($n + $r - 1) % $n;
    }
    return false;
}
  
// Driver Code
$arr = array(11, 15, 6, 8, 9, 10);
$X = 16;
$N = sizeof($arr);
  
if (pairInSortedRotated($arr, $N, $X))
    echo "true";
else
    echo "false";
  
// This code is contributed by aj_36
?>


Javascript




<script>
  
// Javascript program to find a 
// pair with a given sum in a 
// sorted and rotated array
      
// This function returns true if arr[0..n-1] 
// has a pair with sum equals to x.
function pairInSortedRotated(arr, n, x)
{
      
    // Find the pivot element
    let i;
    for(i = 0; i < n - 1; i++)
        if (arr[i] > arr[i + 1])
            break;
              
    // l is now index of                                          
    // smallest element          
    let l = (i + 1) % n; 
      
    // r is now index of largest 
    // element                   
    let r = i;       
     
    // Keep moving either l or 
    // r till they meet
    while (l != r)
    {
          
         // If we find a pair with sum x, we
         // return true
         if (arr[l] + arr[r] == x)
              return true;
     
         // If current pair sum is less, move 
         // to the higher sum
         if (arr[l] + arr[r] < x)
              l = (l + 1) % n;
                
         // Move to the lower sum side       
         else  
              r = (n + r - 1) % n;
    }
    return false;
}
  
// Driver code
let arr = [ 11, 15, 6, 8, 9, 10 ];
let X = 16;
let N = arr.length;
  
if (pairInSortedRotated(arr, N, X))
    document.write("true");
else
    document.write("false");
  
// This code is contributed by avanitrachhadiya2155
      
</script>


Output

true

Time Complexity: O(N). The step to find the pivot can be optimized to O(Logn) using the Binary Search approach discussed here.
Auxiliary Space: O(1).

Exercise: 
1) Extend the above solution to work for arrays with duplicates allowed.
This article is contributed by Himanshu Gupta. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!