Open In App

Find common elements in three sorted arrays

Last Updated : 28 May, 2024
Improve
Improve
Like Article
Like
Save
Share
Report

Given three sorted arrays in non-decreasing order, print all common elements in these arrays.

Examples: 

Input: 
ar1[] = {1, 5, 10, 20, 40, 80} 
ar2[] = {6, 7, 20, 80, 100} 
ar3[] = {3, 4, 15, 20, 30, 70, 80, 120} 
Output: 20, 80

Input: 
ar1[] = {1, 5, 5} 
ar2[] = {3, 4, 5, 5, 10} 
ar3[] = {5, 5, 10, 20} 
Output: 5, 5

Recommended Practice

Common elements in three sorted arrays using two pointer:

A simple solution is to first find the intersection of two arrays and store the intersection in a temporary array, then find the intersection of the third array and temporary array. 

  • Initialize both pointers i and j to 0, and an empty list common.
  • While both pointers i and j are within the bounds of the two arrays:
    • If arr1[i] is less than arr2[j], increment i by 1.
    • If arr2[j] is less than arr1[i], increment j by 1.
    • If arr1[i] is equal to arr2[j]:
    • Add arr1[i] to the common list.
    • Increment both i and j by 1.
  • Return the common list containing the common elements of the two arrays.

Below is the implementation of the above approach:

C++
#include <iostream>
using namespace std;

// Function to find the intersection of two arrays
void FindIntersection(int arr1[], int arr2[], int temp[],
                      int m, int n, int& k)
{
    int i = 0, j = 0;
    // vector to store the intersection of the arr1[] and
    // arr2[]
    while (i < m && j < n) {
        // ith element can not be common element
        if (arr1[i] < arr2[j]) {
            i++;
        }

        // jth element can not be common element
        else if (arr2[j] < arr1[i]) {
            j++;
        }

        // if arr1[i] == arr2[j]
        else {
            temp[k] = arr1[i];
            i++;
            j++;
            k++;
        }
    }
}

int main()
{

    int arr1[] = { 1, 5, 10, 20, 40, 80 };
    int arr2[] = { 6, 7, 20, 80, 100 };
    int arr3[] = { 3, 4, 15, 20, 30, 70, 80, 120 };
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
    int n2 = sizeof(arr2) / sizeof(arr2[0]);
    int n3 = sizeof(arr3) / sizeof(arr3[0]);

    // temp array to store the common elements of arr1 and
    // arr2 arrays
    int temp[200000];

    // ans array to store the common elements of temp and
    // arr3 arrays (i.e common elements of all 3 arrays)
    int ans[200000];

    int k = 0;

    // function call to find the temp array
    FindIntersection(arr1, arr2, temp, n1, n2, k);
    int tempSize = k;
    k = 0;

    // function call to find the ans array.
    FindIntersection(arr3, temp, ans, n3, tempSize, k);
    cout << "Common elements present in arrays are : \n";

    for (int i = 0; i < k; i++) {
        cout << ans[i] << " ";
    }
    cout << endl;

    return 0;
}

// This code is contributed by Hem Kishan
Java
/*package whatever //do not write package name here */

import java.io.*;

public class GFG {

    // Function to find the intersection of two arrays
    static void findIntersection(int[] arr1, int[] arr2,
                                 int[] temp, int m, int n,
                                 int[] k)
    {
        int i = 0, j = 0;
        // Loop to find the intersection of arr1[] and
        // arr2[]
        while (i < m && j < n) {
            // ith element can't be a common element
            if (arr1[i] < arr2[j]) {
                i++;
            }
            // jth element can't be a common element
            else if (arr2[j] < arr1[i]) {
                j++;
            }
            // if arr1[i] == arr2[j]
            else {
                temp[k[0]] = arr1[i];
                i++;
                j++;
                k[0]++;
            }
        }
    }

    public static void main(String[] args)
    {

        int[] arr1 = { 1, 5, 10, 20, 40, 80 };
        int[] arr2 = { 6, 7, 20, 80, 100 };
        int[] arr3 = { 3, 4, 15, 20, 30, 70, 80, 120 };
        int n1 = arr1.length;
        int n2 = arr2.length;
        int n3 = arr3.length;

        // temp array to store the common elements of arr1
        // and arr2 arrays
        int[] temp = new int[200000];

        // ans array to store the common elements of temp
        // and arr3 arrays
        int[] ans = new int[200000];

        int[] k = {
            0
        }; // Mutable integer to simulate pass-by-reference

        // function call to find the temp array
        findIntersection(arr1, arr2, temp, n1, n2, k);
        int tempSize = k[0];
        k[0] = 0;

        // function call to find the ans array
        findIntersection(arr3, temp, ans, n3, tempSize, k);

        System.out.println(
            "Common elements present in arrays are :");

        // Printing the common elements
        for (int i = 0; i < k[0]; i++) {
            System.out.print(ans[i] + " ");
        }
        System.out.println();
    }
}
Python
# Function to find the intersection of two arrays
def find_intersection(arr1, arr2, temp, m, n, k):
    i = 0
    j = 0
    while i < m and j < n:
        if arr1[i] < arr2[j]:
            i += 1
        elif arr2[j] < arr1[i]:
            j += 1
        else:
            temp[k[0]] = arr1[i]
            i += 1
            j += 1
            k[0] += 1

# Main function


def main():
    arr1 = [1, 5, 10, 20, 40, 80]
    arr2 = [6, 7, 20, 80, 100]
    arr3 = [3, 4, 15, 20, 30, 70, 80, 120]
    n1 = len(arr1)
    n2 = len(arr2)
    n3 = len(arr3)

    temp = [0] * 200000
    ans = [0] * 200000

    k = [0]  # Mutable list to simulate pass-by-reference

    # Function call to find the temp array
    find_intersection(arr1, arr2, temp, n1, n2, k)
    temp_size = k[0]
    k[0] = 0

    # Function call to find the ans array
    find_intersection(arr3, temp, ans, n3, temp_size, k)

    print("Common elements present in arrays are:")

    # Printing the common elements
    for i in range(k[0]):
        print(ans[i], end=" ")
    print()


if __name__ == "__main__":
    main()
C#
using System;

public class GFG {
    // Function to find the intersection of two arrays
    static void FindIntersection(int[] arr1, int[] arr2,
                                 int[] temp, int m, int n,
                                 int[] k)
    {
        int i = 0, j = 0;
        // Loop to find the intersection of arr1[] and
        // arr2[]
        while (i < m && j < n) {
            // ith element can't be a common element
            if (arr1[i] < arr2[j]) {
                i++;
            }
            // jth element can't be a common element
            else if (arr2[j] < arr1[i]) {
                j++;
            }
            // if arr1[i] == arr2[j]
            else {
                temp[k[0]] = arr1[i];
                i++;
                j++;
                k[0]++;
            }
        }
    }

    public static void Main(string[] args)
    {
        int[] arr1 = { 1, 5, 10, 20, 40, 80 };
        int[] arr2 = { 6, 7, 20, 80, 100 };
        int[] arr3 = { 3, 4, 15, 20, 30, 70, 80, 120 };
        int n1 = arr1.Length;
        int n2 = arr2.Length;
        int n3 = arr3.Length;

        // temp array to store the common elements of arr1
        // and arr2 arrays
        int[] temp = new int[200000];

        // ans array to store the common elements of temp
        // and arr3 arrays
        int[] ans = new int[200000];

        int[] k = {
            0
        }; // Mutable integer to simulate pass-by-reference

        // Function call to find the temp array
        FindIntersection(arr1, arr2, temp, n1, n2, k);
        int tempSize = k[0];
        k[0] = 0;

        // Function call to find the ans array
        FindIntersection(arr3, temp, ans, n3, tempSize, k);

        Console.WriteLine(
            "Common elements present in arrays are :");

        // Printing the common elements
        for (int i = 0; i < k[0]; i++) {
            Console.Write(ans[i] + " ");
        }
        Console.WriteLine();
    }
}
Javascript
// Function to find the intersection of two arrays
function findIntersection(arr1, arr2) {
    let i = 0;
    let j = 0;
    const temp = [];

    while (i < arr1.length && j < arr2.length) {
        if (arr1[i] < arr2[j]) {
            i++;
        } else if (arr2[j] < arr1[i]) {
            j++;
        } else {
            temp.push(arr1[i]);
            i++;
            j++;
        }
    }

    return temp;
}

function main() {
    const arr1 = [1, 5, 10, 20, 40, 80];
    const arr2 = [6, 7, 20, 80, 100];
    const arr3 = [3, 4, 15, 20, 30, 70, 80, 120];

    // Find the intersection of arr1 and arr2
    const temp = findIntersection(arr1, arr2);

    // Find the intersection of temp and arr3 to get common elements
    const ans = findIntersection(temp, arr3);

    console.log("Common elements present in arrays are:");
    for (const element of ans) {
        console.log(element);
    }
}

// Call the main function to start the program
main();

Output
Common elements present in arrays are : 
20 80 

Time complexity: O(n1 + n2 + n3), where n1, n2 and n3 are sizes of ar1[], ar2[] and ar3[] respectively.
Auxiliary Space: O(max(n1,n2,n3))

Common elements in three sorted arrays using three pointer:

It is known that the arrays are sorted in a non-decreasing order. When a common integer has been found, we want to move forward in each array in search of another common integer. Otherwise, the smaller integer among the three must not be common.

The reason for this is that at least one of the other integers is a larger integer, and as we move forward in the array, we only encounter larger integers. In this case, we want to proceed with only the array that contains the smaller integer.

  • Create and initialize three variables i, j, and k with 0, it will point to the indices of the arrays.
  • Repeat the following steps until we reach the end of any one of the arrays:
    • Check whether the integers appointed by i, j, and k are equal or not.
    • If they are equal, print any of the integers and increase i, j, and k by 1.
    • Otherwise, increase the index that points to the smaller integer by 1.

Illustration:

common elements in three sorted arrays

Below is the implementation of the above approach:

C++
// C++ program to print common elements in three arrays
#include <bits/stdc++.h>
using namespace std;

// This function prints common elements in ar1
void findCommon(int ar1[], int ar2[], int ar3[], int n1,
                int n2, int n3)
{
    // Initialize starting indexes for ar1[], ar2[] and
    // ar3[]
    int i = 0, j = 0, k = 0;

    // Iterate through three arrays while all arrays have
    // elements
    while (i < n1 && j < n2 && k < n3) {

        // If x = y and y = z, print any of them and move
        // ahead in all arrays
        if (ar1[i] == ar2[j] && ar2[j] == ar3[k]) {
            cout << ar1[i] << " ";
            i++;
            j++;
            k++;
        }

        // x < y
        else if (ar1[i] < ar2[j])
            i++;

        // y < z
        else if (ar2[j] < ar3[k])
            j++;

        // We reach here when x > y and z < y, i.e., z is
        // smallest
        else
            k++;
    }
}

// Driver code
int main()
{
    int ar1[] = { 1, 5, 10, 20, 40, 80 };
    int ar2[] = { 6, 7, 20, 80, 100 };
    int ar3[] = { 3, 4, 15, 20, 30, 70, 80, 120 };
    int n1 = sizeof(ar1) / sizeof(ar1[0]);
    int n2 = sizeof(ar2) / sizeof(ar2[0]);
    int n3 = sizeof(ar3) / sizeof(ar3[0]);

    cout << "Common Elements are ";
    findCommon(ar1, ar2, ar3, n1, n2, n3);
    return 0;
}

// This code is contributed by Sania Kumari Gupta
// (kriSania804)
C
// C program to print common elements in three arrays
#include <stdio.h>

// This function prints common elements in ar1
void findCommon(int ar1[], int ar2[], int ar3[], int n1,
                int n2, int n3)
{
    // Initialize starting indexes for ar1[], ar2[] and
    // ar3[]
    int i = 0, j = 0, k = 0;

    // Iterate through three arrays while all arrays have
    // elements
    while (i < n1 && j < n2 && k < n3) {
        // If x = y and y = z, print any of them and move
        // ahead in all arrays
        if (ar1[i] == ar2[j] && ar2[j] == ar3[k]) {
            printf("%d ", ar1[i]);
            i++;
            j++;
            k++;
        }

        // x < y
        else if (ar1[i] < ar2[j])
            i++;

        // y < z
        else if (ar2[j] < ar3[k])
            j++;

        // We reach here when x > y and z < y, i.e., z is
        // smallest
        else
            k++;
    }
}

// Driver code
int main()
{
    int ar1[] = { 1, 5, 10, 20, 40, 80 };
    int ar2[] = { 6, 7, 20, 80, 100 };
    int ar3[] = { 3, 4, 15, 20, 30, 70, 80, 120 };
    int n1 = sizeof(ar1) / sizeof(ar1[0]);
    int n2 = sizeof(ar2) / sizeof(ar2[0]);
    int n3 = sizeof(ar3) / sizeof(ar3[0]);

    printf("Common Elements are ");
    findCommon(ar1, ar2, ar3, n1, n2, n3);
    return 0;
}

// This code is contributed by Sania Kumari Gupta
// (kriSania804)
Java
// Java program to find common elements in three arrays
import java.io.*;
class FindCommon {
    // This function prints common elements in ar1
    void findCommon(int ar1[], int ar2[], int ar3[])
    {
        // Initialize starting indexes for ar1[], ar2[] and
        // ar3[]
        int i = 0, j = 0, k = 0;

        // Iterate through three arrays while all arrays
        // have elements
        while (i < ar1.length && j < ar2.length
               && k < ar3.length) {
            // If x = y and y = z, print any of them and
            // move ahead in all arrays
            if (ar1[i] == ar2[j] && ar2[j] == ar3[k]) {
                System.out.print(ar1[i] + " ");
                i++;
                j++;
                k++;
            }

            // x < y
            else if (ar1[i] < ar2[j])
                i++;

            // y < z
            else if (ar2[j] < ar3[k])
                j++;

            // We reach here when x > y and z < y, i.e., z
            // is smallest
            else
                k++;
        }
    }

    // Driver code to test above
    public static void main(String args[])
    {
        FindCommon ob = new FindCommon();

        int ar1[] = { 1, 5, 10, 20, 40, 80 };
        int ar2[] = { 6, 7, 20, 80, 100 };
        int ar3[] = { 3, 4, 15, 20, 30, 70, 80, 120 };

        System.out.print("Common elements are ");
        ob.findCommon(ar1, ar2, ar3);
    }
}

/*This code is contributed by Rajat Mishra */
Python
# Python function to print common elements in three sorted arrays
def findCommon(ar1, ar2, ar3, n1, n2, n3):

    # Initialize starting indexes for ar1[], ar2[] and ar3[]
    i, j, k = 0, 0, 0

    # Iterate through three arrays while all arrays have elements
    while (i < n1 and j < n2 and k < n3):

        # If x = y and y = z, print any of them and move ahead
        # in all arrays
        if (ar1[i] == ar2[j] and ar2[j] == ar3[k]):
            print ar1[i],
            i += 1
            j += 1
            k += 1

        # x < y
        elif ar1[i] < ar2[j]:
            i += 1

        # y < z
        elif ar2[j] < ar3[k]:
            j += 1

        # We reach here when x > y and z < y, i.e., z is smallest
        else:
            k += 1


# Driver program to check above function
ar1 = [1, 5, 10, 20, 40, 80]
ar2 = [6, 7, 20, 80, 100]
ar3 = [3, 4, 15, 20, 30, 70, 80, 120]
n1 = len(ar1)
n2 = len(ar2)
n3 = len(ar3)
print "Common elements are",
findCommon(ar1, ar2, ar3, n1, n2, n3)

# This code is contributed by __Devesh Agrawal__
C#
// C# program to find common elements in
// three arrays
using System;

class GFG {

    // This function prints common element
    // s in ar1
    static void findCommon(int[] ar1, int[] ar2, int[] ar3)
    {

        // Initialize starting indexes for
        // ar1[], ar2[] and ar3[]
        int i = 0, j = 0, k = 0;

        // Iterate through three arrays while
        // all arrays have elements
        while (i < ar1.Length && j < ar2.Length
               && k < ar3.Length) {

            // If x = y and y = z, print any of
            // them and move ahead in all arrays
            if (ar1[i] == ar2[j] && ar2[j] == ar3[k]) {
                Console.Write(ar1[i] + " ");
                i++;
                j++;
                k++;
            }

            // x < y
            else if (ar1[i] < ar2[j])
                i++;

            // y < z
            else if (ar2[j] < ar3[k])
                j++;

            // We reach here when x > y and
            // z < y, i.e., z is smallest
            else
                k++;
        }
    }

    // Driver code to test above
    public static void Main()
    {

        int[] ar1 = { 1, 5, 10, 20, 40, 80 };
        int[] ar2 = { 6, 7, 20, 80, 100 };
        int[] ar3 = { 3, 4, 15, 20, 30, 70, 80, 120 };

        Console.Write("Common elements are ");

        findCommon(ar1, ar2, ar3);
    }
}

// This code is contributed by Sam007.
Javascript
// JavaScript program to print 
// common elements in three arrays

// This function prints common elements in ar1
function findCommon(ar1, ar2, ar3, n1, n2, n3) {
    // Initialize starting indexes 
    // for ar1[], ar2[] and ar3[]
    var i = 0,
        j = 0,
        k = 0;

    // Iterate through three arrays 
    // while all arrays have elements
    while (i < n1 && j < n2 && k < n3) {

        // If x = y and y = z, print any of them and move ahead
        // in all arrays
        if (ar1[i] == ar2[j] && ar2[j] == ar3[k]) {
            console.log(ar1[i] + " ");
            i++;
            j++;
            k++;
        }

        // x < y
        else if (ar1[i] < ar2[j]) i++;

        // y < z
        else if (ar2[j] < ar3[k]) j++;

        // We reach here when x > y and z < y, i.e., z is smallest
        else k++;
    }
}

// Driver code
var ar1 = [1, 5, 10, 20, 40, 80];
var ar2 = [6, 7, 20, 80, 100];
var ar3 = [3, 4, 15, 20, 30, 70, 80, 120];
var n1 = ar1.length;
var n2 = ar2.length;
var n3 = ar3.length;

console.log("Common Elements are:");
findCommon(ar1, ar2, ar3, n1, n2, n3);
PHP
<?php
// PHP program to print common elements
// in three arrays

// This function prints common elements
// in ar1
function findCommon( $ar1, $ar2, $ar3,
                         $n1, $n2, $n3)
{
    
    // Initialize starting indexes for
    // ar1[], ar2[] and ar3[]
    $i = 0; $j = 0; $k = 0;

    // Iterate through three arrays while
    // all arrays have elements
    while ($i < $n1 && $j < $n2 && $k < $n3)
    {
        
        // If x = y and y = z, print any
        // of them and move ahead in all 
        // arrays
        if ($ar1[$i] == $ar2[$j] &&
                      $ar2[$j] == $ar3[$k])
        {
            echo $ar1[$i] , " ";
            $i++;
            $j++;
            $k++; 
        }

        // x < y
        else if ($ar1[$i] < $ar2[$j])
            $i++;

        // y < z
        else if ($ar2[$j] < $ar3[$k])
            $j++;

        // We reach here when x > y and
        // z < y, i.e., z is smallest
        else
            $k++;
    }
}

// Driver program to test above function
    $ar1 = array(1, 5, 10, 20, 40, 80);
    $ar2 = array(6, 7, 20, 80, 100);
    $ar3 = array(3, 4, 15, 20, 30, 70, 
                                80, 120);
    $n1 = count($ar1);
    $n2 = count($ar2);
    $n3 = count($ar3);

    echo "Common Elements are ";
    
    findCommon($ar1, $ar2, $ar3,$n1, $n2, $n3);
    
// This code is contributed by anuj_67.
?>

Output
Common Elements are 20 80 

Time complexity: O(n1 + n2 + n3), In the worst case, the largest-sized array may have all small elements and the middle-sized array has all middle elements.
Auxiliary Space:  O(1)

Common elements in three sorted arrays using two pointer:

In this approach, we compare first array and second array and appends the common elements into the reference list. Then, compare the reference list and the third array and appends common elements into the final list, which contains the common elements among all three arrays.

Steps:

Follow the given steps to solve the problem:

  1. Initialize an empty reference list (ref) and a final list (final) to store common elements.
  2. Iterate through each element in the first array (ar1).
  3. Check if the current element exists in the second array (ar2). If found, append it to the reference list (ref).
  4. Iterate through each element in the reference list (ref).
  5. Check if the current element exists in the third array (ar3). If found, append it to the final list (final).
  6. Print the final list containing the common elements among all three arrays.

Below is the implementation of the above approach:

C++
#include <iostream>
#include <vector>
#include <algorithm> // Include the <algorithm> header for std::find

std::vector<int> findCommonElements(const std::vector<int>& ar1,
                                    const std::vector<int>& ar2,
                                    const std::vector<int>& ar3)
{
    std::vector<int> ref;
    std::vector<int> finalList;

    // Step 1: Iterate through ar1
    for (int num : ar1) {
        // Step 2: Check if num exists in ar2
        if (std::find(ar2.begin(), ar2.end(), num) != ar2.end()) {
            // If found, append it to the reference list
            ref.push_back(num);
        }
    }

    // Step 3: Iterate through the reference list
    for (int num : ref) {
        // Step 4: Check if num exists in ar3
        if (std::find(ar3.begin(), ar3.end(), num) != ar3.end()) {
            // If found, append it to the final list
            finalList.push_back(num);
        }
    }

    return finalList;
}

int main()
{
    std::vector<int> ar1 = { 1, 5, 10, 20, 40, 80 };
    std::vector<int> ar2 = { 6, 7, 20, 80, 100 };
    std::vector<int> ar3 = { 3, 4, 15, 20, 30, 70, 80, 120 };

    std::vector<int> finalList = findCommonElements(ar1, ar2, ar3);

    for (int num : finalList) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}
Java
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static List<Integer> findCommonElements(List<Integer> ar1,
                                                   List<Integer> ar2,
                                                   List<Integer> ar3) {
        List<Integer> ref = new ArrayList<>();
        List<Integer> finalList = new ArrayList<>();

        // Step 1: Iterate through ar1
        for (int num : ar1) {
            // Step 2: Check if num exists in ar2
            if (ar2.contains(num)) {
                // If found, append it to the reference list
                ref.add(num);
            }
        }

        // Step 3: Iterate through the reference list
        for (int num : ref) {
            // Step 4: Check if num exists in ar3
            if (ar3.contains(num)) {
                // If found, append it to the final list
                finalList.add(num);
            }
        }

        return finalList;
    }

    public static void main(String[] args) {
        List<Integer> ar1 = List.of(1, 5, 10, 20, 40, 80);
        List<Integer> ar2 = List.of(6, 7, 20, 80, 100);
        List<Integer> ar3 = List.of(3, 4, 15, 20, 30, 70, 80, 120);

        List<Integer> finalList = findCommonElements(ar1, ar2, ar3);

        for (int num : finalList) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}
Python
def find_common_elements(ar1, ar2, ar3):
    ref = []
    final_list = []

    # Step 1: Iterate through ar1
    for num in ar1:
        # Step 2: Check if num exists in ar2
        if num in ar2:
            # If found, append it to the reference list
            ref.append(num)

    # Step 3: Iterate through the reference list
    for num in ref:
        # Step 4: Check if num exists in ar3
        if num in ar3:
            # If found, append it to the final list
            final_list.append(num)

    return final_list

# Test data
ar1 = [1, 5, 10, 20, 40, 80]
ar2 = [6, 7, 20, 80, 100]
ar3 = [3, 4, 15, 20, 30, 70, 80, 120]

final_list = find_common_elements(ar1, ar2, ar3)
print(final_list)
JavaScript
function findCommonElements(ar1, ar2, ar3) {
    let ref = [];
    let finalList = [];

    // Step 1: Iterate through ar1
    for (let num of ar1) {
        // Step 2: Check if num exists in ar2
        if (ar2.includes(num)) {
            // If found, append it to the reference list
            ref.push(num);
        }
    }

    // Step 3: Iterate through the reference list
    for (let num of ref) {
        // Step 4: Check if num exists in ar3
        if (ar3.includes(num)) {
            // If found, append it to the final list
            finalList.push(num);
        }
    }

    return finalList;
}

// Test data
let ar1 = [1, 5, 10, 20, 40, 80];
let ar2 = [6, 7, 20, 80, 100];
let ar3 = [3, 4, 15, 20, 30, 70, 80, 120];

let finalList = findCommonElements(ar1, ar2, ar3);
console.log(finalList);

Output
20 80 

Time complexity: O(N)+O(N) = O(N), where N is size of the largest-sized array.
Auxiliary Space: O(N)

This article is compiled by Rahul Gupta



Previous Article
Next Article

Similar Reads

Find three closest elements from given three sorted arrays
Given three sorted arrays A[], B[] and C[], find 3 elements i, j and k from A, B and C respectively such that max(abs(A[i] - B[j]), abs(B[j] - C[k]), abs(C[k] - A[i])) is minimized. Here abs() indicates absolute value. Example : Input : A[] = {1, 4, 10} B[] = {2, 15, 20} C[] = {10, 12} Output: 10 15 10Explanation: 10 from A, 15 from B and 10 from C
15+ min read
Generate all possible sorted arrays from alternate elements of two given sorted arrays
Given two sorted arrays A and B, generate all possible arrays such that the first element is taken from A then from B then from A, and so on in increasing order till the arrays are exhausted. The generated arrays should end with an element from B. Example: A = {10, 15, 25} B = {1, 5, 20, 30} The resulting arrays are: 10 20 10 20 25 30 10 30 15 20 1
12 min read
Find three element from given three arrays such that their sum is X | Set 2
Given three sorted integer arrays A[], B[] and C[], the task is to find three integers, one from each array such that they sum up to a given target value X. Print Yes or No depending on whether such triplet exists or not.Examples: Input: A[] = {2}, B[] = {1, 6, 7}, C[] = {4, 5}, X = 12 Output: Yes A[0] + B[1] + C[0] = 2 + 6 + 4 = 12Input: A[] = {2}
9 min read
Find three element from different three arrays such that a + b + c = sum
Given three integer arrays and a "sum", the task is to check if there are three elements a, b, c such that a + b + c = sum and a, b and c belong to three different arrays. Examples : Input : a1[] = { 1 , 2 , 3 , 4 , 5 }; a2[] = { 2 , 3 , 6 , 1 , 2 }; a3[] = { 3 , 2 , 4 , 5 , 6 }; sum = 9 Output : Yes 1 + 2 + 6 = 9 here 1 from a1[] and 2 from a2[] a
15+ min read
Count number of common elements between a sorted array and a reverse sorted array
Given two arrays consisting of N distinct integers such that the array A[] and B[] are sorted in ascending and descending order respectively, the task is to find the number of values common in both arrays. Examples: Input: A[] = {1, 10, 100}, B[] = {200, 20, 2}Output: 0 Input: A[] = {2, 4, 5, 8, 12, 13, 17, 18, 20, 22, 309, 999}, B[] = {109, 99, 68
15+ min read
Find common elements in three linked lists
Given three linked lists, find all common elements among the three linked lists. Examples: Input : 10 15 20 25 12 10 12 13 15 10 12 15 24 25 26 Output : 10 12 15 Input : 1 2 3 4 5 1 2 3 4 6 9 8 1 2 4 5 10 Output : 1 2 4 Method 1 : (Simple) Use three-pointers to iterate the given three linked lists and if any element common print that element. Time
11 min read
Minimize (max(A[i], B[j], C[k]) - min(A[i], B[j], C[k])) of three different sorted arrays
Given three sorted arrays A, B, and C of not necessarily same sizes. Calculate the minimum absolute difference between the maximum and minimum number of any triplet A[i], B[j], C[k] such that they belong to arrays A, B and C respectively, i.e., minimize (max(A[i], B[j], C[k]) - min(A[i], B[j], C[k])) Examples: Input : A : [ 1, 4, 5, 8, 10 ] B : [ 6
8 min read
Check if two sorted arrays can be merged to form a sorted array with no adjacent pair from the same array
Given two sorted arrays A[] and B[] of size N, the task is to check if it is possible to merge two given sorted arrays into a new sorted array such that no two consecutive elements are from the same array. Examples: Input: A[] = {3, 5, 8}, B[] = {2, 4, 6}Output: Yes Explanation: Merged array = {B[0], A[0], B[1], A[1], B[2], A[2]} Since the resultan
15+ min read
Program to find the common ratio of three numbers
Given a:b and b:c. The task is to write a program to find ratio a:b:cExamples: Input: a:b = 2:3, b:c = 3:4 Output: 2:3:4 Input: a:b = 3:4, b:c = 8:9 Output: 6:8:9 Approach: The trick is to make the common term ‘b’ equal in both ratios. Therefore, multiply the first ratio by b2 (b term of second ratio) and the second ratio by b1. Given: a:b1 and b2:
5 min read
intersection_update() in Python to find common elements in n arrays
We are given list of n number of arrays, find all common elements in given arrays ? Examples: Input : arr = [[1,2,3,4], [8,7,3,2], [9,2,6,3], [5,1,2,3]] Output : Common Elements = [2,3] We can solve this problem quickly in python using intersection_update() method of Set() data structure. How intersection_update() works ? Suppose we have two sets A
1 min read