Técnica de dos punteros

Dos punteros es realmente una técnica fácil y efectiva que normalmente se usa para buscar pares en una array ordenada.
Dada una array ordenada A (ordenada en orden ascendente), que tiene N enteros, encuentre si existe algún par de elementos (A[i], A[j]) tal que su suma sea igual a X.

Ilustración : 

// C++ Program Illustrating Naive Approach to
// Find if There is a Pair in A[0..N-1] with Given Sum
  
// Importing all libraries
#include <bits/stdc++.h>
  
using namespace std;
  
bool isPairSum(int A[], int N, int X)
{
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            // as equal i and j means same element
            if (i == j)
                continue;
  
            // pair exists
            if (A[i] + A[j] == X)
                return true;
  
            // as the array is sorted
            if (A[i] + A[j] > X)
                break;
        }
    }
  
    // No pair found with given sum.
    return false;
}
  
// Driver code
int main()
{
    int arr[] = { 2, 3, 5, 8, 9, 10, 11 };
    int val = 17;
    int arrSize = *(&arr + 1) - arr;
    sort(arr, arr + arrSize); // Sort the array
    // Function call
    cout << isPairSum(arr, arrSize, val);
  
    return 0;
}

// C Program Illustrating Naive Approach to
// Find if There is a Pair in A[0..N-1] with Given Sum
  
// Importing all libraries
#include <stdio.h>
  
int isPairSum(int A[], int N, int X)
{
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            // as equal i and j means same element
            if (i == j)
                continue;
  
            // pair exists
            if (A[i] + A[j] == X)
                return true;
  
            // as the array is sorted
            if (A[i] + A[j] > X)
                break;
        }
    }
  
    // No pair found with given sum.
    return 0;
}
  
// Driver Code
int main()
{
    int arr[] = { 2, 3, 5, 8, 9, 10, 11 };
    int val = 17;
    int arrSize = sizeof(arr) / sizeof(arr[0]);
  
    // Function call
    printf("%d", isPairSum(arr, arrSize, val));
  
    return 0;
}

// Java Program Illustrating Naive Approach to
// Find if There is a Pair in A[0..N-1] with Given Sum
  
// Importing all input output classes
import java.io.*;
  
// Main class
class GFG {
  
    // Method 1
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring and initializing array
        int arr[] = { 2, 3, 5, 8, 9, 10, 11 };
  
        int val = 17;
  
        System.out.println(isPairSum(arr, arr.length, val));
    }
  
    // Method 2
    //  To find Pairs in A[0..N-1] with given sum
    private static int isPairSum(int A[], int N, int X)
    {
        // Nested for loops for iterations
        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
                // As equal i and j means same element
                if (i == j)
  
                    // continue keyword skips the execution
                    // for following condition
                    continue;
  
                // Condition check if pair exists
                if (A[i] + A[j] == X)
                    return 1;
  
                // By now the array is sorted
                if (A[i] + A[j] > X)
  
                    // Break keyword to hault the execution
                    break;
            }
        }
  
        // No pair found with given sum.
        return 0;
    }
}

# Python Program Illustrating Naive Approach to
# Find if There is a Pair in A[0..N-1] with Given Sum
  
# Method
  
  
def isPairSum(A, N, X):
  
    for i in range(N):
        for j in range(N):
  
            # as equal i and j means same element
            if(i == j):
                continue
  
            # pair exists
            if (A[i] + A[j] == X):
                return True
  
            # as the array is sorted
            if (A[i] + A[j] > X):
                break
  
    # No pair found with given sum
    return 0
  
  
# Driver code
arr = [2, 3, 5, 8, 9, 10, 11]
val = 17
  
print(isPairSum(arr, len(arr), val))
  
# This code is contributed by maheshwaripiyush9

// C# Program Illustrating Naive Approach to
// Find if There is a Pair in A[0..N-1] with Given Sum
using System;
  
// Main class
class GFG {
  
    // Method 1
    // Main driver method
    public static void Main(String[] args)
    {
  
        // Declaring and initializing array
        int[] arr = { 2, 3, 5, 8, 9, 10, 11 };
  
        int val = 17;
  
        Console.Write(isPairSum(arr, arr.Length, val));
    }
  
    // Method 2
    //  To find Pairs in A[0..N-1] with given sum
    private static int isPairSum(int[] A, int N, int X)
    {
  
        // Nested for loops for iterations
        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
  
                // As equal i and j means same element
                if (i == j)
  
                    // continue keyword skips the execution
                    // for following condition
                    continue;
  
                // Condition check if pair exists
                if (A[i] + A[j] == X)
                    return 1;
  
                // By now the array is sorted
                if (A[i] + A[j] > X)
  
                    // Break keyword to hault the execution
                    break;
            }
        }
  
        // No pair found with given sum.
        return 0;
    }
}
  
// This code is contributed by shivanisinghss2110

// JavaScript Program Illustrating Naive Approach to
// Find if There is a Pair in A[0..N-1] with Given Sum
  
<script>
  
 // Naive solution to find if there is a
// pair in A[0..N-1] with given sum.
  
function isPairSum(A, N, X)
{
        for (var i = 0; i < N-1; i++)
        {
            for (var j = i+1; j < N; j++)
            {
                // as equal i and j means same element
                if (i == j)
                    continue;
  
                // pair exists
                if (A[i] + A[j] == X)
                    return 1;
  
                // as the array is sorted
                if (A[i] + A[j] > X)
                    break;
            }
        }
  
        // No pair found with given sum.
        return 0;
}
  
  
      
        var arr=[ 2, 3, 5, 8, 9, 10, 11 ];
          
        // value to search
        var val = 17;
      
        // size of the array
        var arrSize = 7;
      
        // Function call
        document.write(isPairSum(arr, arrSize, val));
  
</script>

// C++ Program Illustrating Naive Approach to
// Find if There is a Pair in A[0..N-1] with Given Sum
// Using Two-pointers Technique
  
// Importing required libraries 
#include <iostream>
#include <algorithm>
  
using namespace std;
  
// Two pointer technique based solution to find
// if there is a pair in A[0..N-1] with a given sum.
int isPairSum(int A[], int N, int X)
{
    // represents first pointer
    int i = 0;
  
    // represents second pointer
    int j = N - 1;
  
    while (i < j) {
  
        // If we find a pair
        if (A[i] + A[j] == X)
            return 1;
  
        // If sum of elements at current
        // pointers is less, we move towards
        // higher values by doing i++
        else if (A[i] + A[j] < X)
            i++;
  
        // If sum of elements at current
        // pointers is more, we move towards
        // lower values by doing j--
        else
            j--;
    }
    return 0;
}
  
// Driver code
int main()
{
    // array declaration
    int arr[] = { 2, 3, 5, 8, 9, 10, 11 };
      
    // value to search
    int val = 17;
      
    // size of the array
    int arrSize = *(&arr + 1) - arr;
      
      // array should be sorted before using two-pointer technique
      sort(arr, arr+7);
    
    // Function call
    cout << (bool)isPairSum(arr, arrSize, val);
  
    return 0;
}

// C Program Illustrating Naive Approach to
// Find if There is a Pair in A[0..N-1] with Given Sum
// Using Two-pointers Technique
  
// Importing I/O libraries 
#include <stdio.h>
  
// Two pointer technique based solution to find
// if there is a pair in A[0..N-1] with a given sum.
int isPairSum(int A[], int N, int X)
{
    // Represents first pointer
    int i = 0;
  
    // Represents second pointer
    int j = N - 1;
  
    while (i < j)
    {
        // If we find a pair
        if (A[i] + A[j] == X)
            return 1;
  
        // If sum of elements at current
        // pointers is less, we move towards
        // higher values by doing i++
        else if (A[i] + A[j] < X)
            i++;
  
        // If sum of elements at current
        // pointers is more, we move towards
        // lower values by doing j--
        else
            j--;
    }
    return 0;
}
  
// Main method 
int main()
{
    // Array declaration
    int arr[] = { 2, 3, 5, 8, 9, 10, 11 };
      
    // Custom value to be searched
    int val = 17;
      
    // size of the array
    int arrSize = sizeof(arr) / sizeof(arr[0]);
    
    // Function call
    printf("%d", isPairSum(arr, arrSize, val));
  
    return 0;
}

// Java Program Illustrating Naive Approach to
// Find if There is a Pair in A[0..N-1] with Given Sum
// Using Two-pointers Technique
  
// Importing all utility classes
import java.io.*;
  
// Main class
class GFG 
{
     // Two pointer technique based solution to find
    // if there is a pair in A[0..N-1] with a given sum.
    public static int isPairSum(int A[], int N, int X)
    {
        // represents first pointer
        int i = 0;
  
        // represents second pointer
        int j = N - 1;
  
        while (i < j) {
  
            // If we find a pair
            if (A[i] + A[j] == X)
                return 1;
  
            // If sum of elements at current
            // pointers is less, we move towards
            // higher values by doing i++
            else if (A[i] + A[j] < X)
                i++;
  
            // If sum of elements at current
            // pointers is more, we move towards
            // lower values by doing j--
            else
                j--;
        }
        return 0;
    }
    
    // Driver code
    public static void main(String[] args)
    {
        // array declaration
        int arr[] = { 2, 3, 5, 8, 9, 10, 11 };
          
        // value to search
        int val = 17;
        
        // size of the array
        int arrSize = arr.length;
        
        // Function call
        System.out.println(isPairSum(arr, arrSize, val));
    }
}

# Python Program Illustrating Naive Approach to
# Find if There is a Pair in A[0..N-1] with Given Sum
# Using Two-pointers Technique
  
# Method 
def isPairSum(A, N, X):
  
    # represents first pointer
    i = 0
  
    # represents second pointer
    j = N - 1
  
    while(i < j):
        
        # If we find a pair
        if (A[i] + A[j] == X):
            return True
  
        # If sum of elements at current
        # pointers is less, we move towards
        # higher values by doing i += 1
        elif(A[i] + A[j] < X):
            i += 1
  
        # If sum of elements at current
        # pointers is more, we move towards
        # lower values by doing j -= 1
        else:
            j -= 1
    return 0
  
# array declaration
arr = [2, 3, 5, 8, 9, 10, 11]
  
# value to search
val = 17
  
print(isPairSum(arr, len(arr), val))
  
# This code is contributed by maheshwaripiyush9.

// C# Program Illustrating Naive Approach to
// Find if There is a Pair in A[0..N-1] with Given Sum
// Using Two-pointers Technique
  
// Importing all utility classes
using System;
  
// Main class
class GFG 
{
     // Two pointer technique based solution to find
    // if there is a pair in A[0..N-1] with a given sum.
    public static int isPairSum(int []A, int N, int X)
    {
        // represents first pointer
        int i = 0;
  
        // represents second pointer
        int j = N - 1;
  
        while (i < j) {
  
            // If we find a pair
            if (A[i] + A[j] == X)
                return 1;
  
            // If sum of elements at current
            // pointers is less, we move towards
            // higher values by doing i++
            else if (A[i] + A[j] < X)
                i++;
  
            // If sum of elements at current
            // pointers is more, we move towards
            // lower values by doing j--
            else
                j--;
        }
        return 0;
    }
    
    // Driver code
    public static void Main(String[] args)
    {
        // array declaration
        int []arr = { 2, 3, 5, 8, 9, 10, 11 };
          
        // value to search
        int val = 17;
        
        // size of the array
        int arrSize = arr.Length;
        
        // Function call
        Console.Write(isPairSum(arr, arrSize, val));
    }
}
  
// This code is contributed by shivanisinghss2110

// JavaScript Program Illustrating Naive Approach to
// Find if There is a Pair in A[0..N-1] with Given Sum
// Using Two-pointers Technique
  
<script>
// Two pointer technique based solution to find
// if there is a pair in A[0..N-1] with a given sum.
function isPairSum(A, N, X)
{
  
    // represents first pointer
    var i = 0;
  
    // represents second pointer
    var j = N - 1;
  
    while (i < j) {
  
        // If we find a pair
        if (A[i] + A[j] == X)
            return true;
  
        // If sum of elements at current
        // pointers is less, we move towards
        // higher values by doing i++
        else if (A[i] + A[j] < X)
            i++;
  
        // If sum of elements at current
        // pointers is more, we move towards
        // lower values by doing j--
        else
            j--;
    }
    return false;
}
  
// Driver code
  
    // array declaration
    var arr = [ 2, 3, 5, 8, 9, 10, 11 ];
      
    // value to search
    var val = 17;
      
    // size of the array
    var arrSize =7;
      
    // Function call
    document.write(isPairSum(arr, arrSize, val));
      
    // This Code is Contributed by Harshit Srivastava
  
   </script>