Open In App

Pair Sum in a Sorted and Rotated Array

Last Updated : 25 Feb, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given an array arr[] of size n, which is sorted and then rotated around an unknown pivot, the task is to check whether there exists a pair of elements in the array whose sum is equal to a given target value.

Examples : 

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

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

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

Table of Content

[Naive Approach] Using Hashing - O(n) Time and O(n) Space

We have discussed different solutions for finding a pair with given sum in an array (not sorted). The best complexities we can achieve is O(n) Time and O(n) auxiliary space in the hashing based solution.

C++ 
// C++ code to check whether any pair exists
// whose sum is equal to the given target value

#include <iostream>
#include <vector>
#include <unordered_set>
using namespace std;

bool pairInSortedRotated(vector<int> &arr, int target){
    unordered_set<int> s;
    for (int i = 0; i < arr.size(); i++){

        // Calculate the complement that added to
        // arr[i], equals the target
        int complement = target - arr[i];

        // Check if the complement exists in the set
        if (s.find(complement) != s.end())
            return true;

        // Add the current element to the set
        s.insert(arr[i]);
    }
  
    // If no pair is found
    return false;
}

int main(){
    vector<int> arr = {11, 15, 6, 8, 9, 10};
    int target = 16;
    if (pairInSortedRotated(arr, target))
        cout << "true";
    else
        cout << "false";

    return 0;
}
Java 
// Java code to check whether any pair exists
// whose sum is equal to the given target value

import java.util.HashSet;
class GfG {
    static boolean pairInSortedRotated(int[] arr, int target){
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < arr.length; i++) {

            // Calculate the complement that added to
            // arr[i], equals the target
            int complement = target - arr[i];

            // Check if the complement exists in the set
            if (set.contains(complement)) {
                return true;
            }

            // Add the current element to the set
            set.add(arr[i]);
        }
        
        // If no pair is found
        return false;
    }

    public static void main(String[] args) {
        int[] arr = {11, 15, 6, 8, 9, 10};
        int target = 16;

        if (pairInSortedRotated(arr, target))
            System.out.println("true");
        else
            System.out.println("false");
    }
}
Python 
# Python3 code to check whether any pair exists
# whose sum is equal to the given target value

def pairInSortedRotated(arr, target):  
    s = set()
    for num in arr:
      
        # Calculate the complement that added to
        # num, equals the target
        complement = target - num

        # Check if the complement exists in the set
        if complement in s:
            return True

        # Add the current element to the set
        s.add(num)

    # If no pair is found
    return False
  
if __name__ == "__main__":
    arr = [11, 15, 6, 8, 9, 10]
    target = 16

    if pairInSortedRotated(arr, target):
        print("true")
    else:
        print("false")
C# 
// C# code to check whether any pair exists
// whose sum is equal to the given target value
using System;
using System.Collections.Generic;

class GfG {
    static bool pairInSortedRotated(int[] arr, int target){
        HashSet<int> set = new HashSet<int>();
        for (int i = 0; i < arr.Length; i++) {

            // Calculate the complement that added to
            // arr[i], equals the target
            int complement = target - arr[i];

            // Check if the complement exists in the set
            if (set.Contains(complement))
                return true;

            // Add the current element to the set
            set.Add(arr[i]);
        }
        // If no pair is found
        return false;
    }

    static void Main(){
        int[] arr = {11, 15, 6, 8, 9, 10};
        int target = 16;

        if (pairInSortedRotated(arr, target))
            Console.WriteLine("true");
        else 
            Console.WriteLine("false"); 
    }
}
JavaScript 
// Javascript code to check whether any pair exists
// whose sum is equal to the given target value
function pairInSortedRotated(arr, target) {
    let set = new Set();
    for (let num of arr) {
    
        // Calculate the complement that added to
        // num, equals the target
        let complement = target - num;

        // Check if the complement exists in the set
        if (set.has(complement)) {
            return true;
        }

        // Add the current element to the set
        set.add(num);
    }
    // If no pair is found
    return false;
}

// Driver Code
let arr = [11, 15, 6, 8, 9, 10];
let target = 16;

if (pairInSortedRotated(arr, target))
    console.log("true");
else 
    console.log("false");

Output
true

[Expected Approach] Two Pointer Technique - O(n) Time and O(1) Space

First find the largest element in an array which is the pivot point. The element just after the largest element is the smallest element. Once we have the indices of the largest and the smallest elements, we use two pointer technique to find the pair.

  • Set the left pointer(l) to the smallest value and the right pointer(r) to the highest value.
  • To handle the circular nature of the rotated array, we will use the modulo operation with the array size.
  • While l ! = r, we shall keep checking if arr[l] + arr[r] = target.
    • If arr[l] + arr[r] > target, update r = (r - 1 + n) % n.
    • If arr[l] + arr[r] < target, update l = (l + 1) % n.
    • If arr[l] + arr[r] = target, then return true.
  • If no such pair is found after the iteration is complete, return false.
C++ 
// Cpp program to find a Pair Sum in a Sorted 
// and Rotated Array using Two Pointer Technique

#include <iostream>
#include <vector>
using namespace std;

bool pairInSortedRotated(vector<int>& arr, int target) {
    int n = arr.size();

    // 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 target, return true
        if (arr[l] + arr[r] == target)
            return true;

        // If current pair sum is less, move to higher sum
        if (arr[l] + arr[r] < target)
            l = (l + 1) % n;

        // Move to lower sum
        else
            r = (r - 1 + n) % n;
    }
    return false;
}

int main() {
    vector<int> arr = {11, 15, 6, 8, 9, 10};
    int target = 16;
    if (pairInSortedRotated(arr, target))
        cout << "true";
    else
        cout << "false";

    return 0;
}
Java 
// Java program to find a Pair Sum in a Sorted 
// and Rotated Array using Two Pointer Technique

class GfG {
    static boolean pairInSortedRotated(int[] arr, int target) {
        int n = arr.length;

        // 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 target, return true
            if (arr[l] + arr[r] == target)
                return true;

            // If current pair sum is less, move to higher sum
            if (arr[l] + arr[r] < target)
                l = (l + 1) % n;

            // Move to lower sum side
            else
                r = (r - 1 + n) % n;
        }
        return false;
    }

    public static void main(String[] args) {
        int[] arr = {11, 15, 6, 8, 9, 10};
        int target = 16;
        if (pairInSortedRotated(arr, target))
            System.out.println("true");
        else
            System.out.println("false");
    }
}
Python 
# Python program to find a Pair Sum in a Sorted 
# and Rotated Array using Two Pointer Technique

def pairInSortedRotated(arr, target):
    n = len(arr)

    # Find the pivot element
    i = 0
    for i in range(n - 1):
        if arr[i] > arr[i + 1]:
            break
	
    # if whole array is sorted max
    # element will be at last index
    if arr[i] <= arr[i + 1]:
        i += 1
        
    # 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 target, return true
        if arr[l] + arr[r] == target:
            return True

        # If current pair sum is less, move to higher sum
        if arr[l] + arr[r] < target:
            l = (l + 1) % n

        # Move to lower sum side
        else:
            r = (r - 1 + n) % n
    return False
  
if __name__ == "__main__":
    arr = [11, 15, 6, 8, 9, 10]
    target = 16
    if pairInSortedRotated(arr, target):
        print("true")
    else:
        print("false")
C# 
// C# program to find a Pair Sum in a Sorted 
// and Rotated Array using Two Pointer Technique

using System;
using System.Collections.Generic;

class GfG {
    static bool pairInSortedRotated(int[] arr, int target) {
        int n = arr.Length;

        // 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 target, return true
            if (arr[l] + arr[r] == target)
                return true;

            // If current pair sum is less, move to higher sum
            if (arr[l] + arr[r] < target)
                l = (l + 1) % n;

            // Move to lower sum side
            else
                r = (r - 1 + n) % n;
        }
        return false;
    }

    static void Main() {
        int[] arr = { 11, 15, 6, 8, 9, 10 };
        int target = 16;
        if (pairInSortedRotated(arr, target))
            Console.WriteLine("true");
        else
            Console.WriteLine("false");
    }
}
JavaScript 
// JavaScript program to find a Pair Sum in a Sorted 
// and Rotated Array using Two Pointer Technique

function pairInSortedRotated(arr, target) {
    let n = arr.length;

    // 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 target, return true
        if (arr[l] + arr[r] === target)
            return true;

        // If current pair sum is less, move to higher sum
        if (arr[l] + arr[r] < target)
            l = (l + 1) % n;

        // Move to lower sum side
        else
            r = (r - 1 + n) % n;
    }
    return false;
}

// Driver Code
let arr = [11, 15, 6, 8, 9, 10];
let target = 16;
if (pairInSortedRotated(arr, target))
    console.log("true");
else
    console.log("false");

Output
true

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

Further Optimization : The above implementation find the pivot point using a linear search in O(n) Time. We can find the pivot point using Binary Search in O(Log n). Please refer Search in a sorted and rotated array for details. Please note that the overall time complexity remains same as we run a linear time two pointer algorithms after finding the pivot point.


Next Article
K’th Smallest/Largest Element in Unsorted Array | Worst case Linear Time

H

Himanshu Gupta
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox