Open In App

Check if an array of pairs can be sorted by swapping pairs with different first elements

Improve
Improve
Like Article
Like
Save
Share
Report

Given an array arr[] consisting of N pairs, where each pair represents the value and ID respectively, the task is to check if it is possible to sort the array by the first element by swapping only pairs having different IDs. If it is possible to sort, then print “Yes”. Otherwise, print “No”.

Examples:

Input: arr[] = {{340000, 2}, {45000, 1}, {30000, 2}, {50000, 4}}
Output: Yes
Explanation:
One of the possible way to sort the array is to swap the array elements in the following order:

  1. Swap, arr[0] and arr[3], which modifies the array to arr[] = {{50000, 4}, {45000, 1}, {30000, 2}, {340000, 2}}.
  2. Swap, arr[0] and arr[2], which modifies the array to arr[] = {{30000, 2}, {45000, 1}, {50000, 4}, {340000, 2}}.

Therefore, after the above steps the given array is sorted by the first element..

Input: arr[] = {{15000, 2}, {34000, 2}, {10000, 2}}
Output: No

Approach: The given problem can be solved based on the observation that the array can be sorted if there exist any two array elements with different IDs. Follow the steps below to solve the problem:

  • Initialize a variable, say X that stores the ID of the pair at index 0.
  • Traverse the array arr[] and if there exists any pair whose ID is different from X, then print “Yes” and break out of the loop.
  • After completing the above steps, if all the elements have the same IDs and if the array is already sorted then print “Yes”. Otherwise, Print “No”.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if an
// array is sorted or not
bool isSorted(pair<int, int>* arr,
              int N)
{
    // Traverse the array arr[]
    for (int i = 1; i < N; i++) {
 
        if (arr[i].first
            > arr[i - 1].first) {
            return false;
        }
    }
 
    // Return true
    return true;
}
 
// Function to check if it is possible
// to sort the array w.r.t. first element
string isPossibleToSort(
    pair<int, int>* arr, int N)
{
    // Stores the ID of the first element
    int group = arr[0].second;
 
    // Traverse the array arr[]
    for (int i = 1; i < N; i++) {
 
        // If arr[i].second is not
        // equal to that of the group
        if (arr[i].second != group) {
            return "Yes";
        }
    }
 
    // If array is sorted
    if (isSorted(arr, N)) {
        return "Yes";
    }
    else {
        return "No";
    }
}
 
// Driver Code
int main()
{
    pair<int, int> arr[]
        = { { 340000, 2 }, { 45000, 1 },
            { 30000, 2 }, { 50000, 4 } };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    cout << isPossibleToSort(arr, N);
 
    return 0;
}


Java




// java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
public class GFG {
 
    // Function to check if an
    // array is sorted or not
    static boolean isSorted(int[][] arr, int N)
    {
        // Traverse the array arr[]
        for (int i = 1; i < N; i++) {
 
            if (arr[i][0] > arr[i - 1][0]) {
                return false;
            }
        }
 
        // Return true
        return true;
    }
 
    // Function to check if it is possible
    // to sort the array w.r.t. first element
    static String isPossibleToSort(int[][] arr, int N)
    {
        // Stores the ID of the first element
        int group = arr[0][1];
 
        // Traverse the array arr[]
        for (int i = 1; i < N; i++) {
 
            // If arr[i].second is not
            // equal to that of the group
            if (arr[i][1] != group) {
                return "Yes";
            }
        }
 
        // If array is sorted
        if (isSorted(arr, N)) {
            return "Yes";
        }
        else {
            return "No";
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        int arr[][] = { { 340000, 2 },
                        { 45000, 1 },
                        { 30000, 2 },
                        { 50000, 4 } };
 
        int N = arr.length;
        System.out.print(isPossibleToSort(arr, N));
    }
}
 
// This code is contributed by Kingash.


Python3




# Python3 program for the above approach
 
# Function to check if an
# array is sorted or not
def isSorted(arr, N):
   
    # Traverse the array arr[]
    for i in range(1, N):
        if (arr[i][0] > arr[i - 1][0]):
            return False
 
    # Return true
    return True
 
# Function to check if it is possible
# to sort the array w.r.t. first element
def isPossibleToSort(arr, N):
   
    # Stores the ID of the first element
    group = arr[0][1]
 
    # Traverse the array arr[]
    for i in range(1, N):
       
        # If arr[i][1] is not
        # equal to that of the group
        if (arr[i][1] != group):
            return "Yes"
 
    # If array is sorted
    if (isSorted(arr, N)):
        return "Yes"
    else:
        return "No"
 
# Driver Code
if __name__ == '__main__':
    arr = [ [ 340000, 2 ], [ 45000, 1 ],[ 30000, 2 ], [ 50000, 4 ] ]
 
    N = len(arr)
 
    print (isPossibleToSort(arr, N))
 
# This code is contributed by mohit kumar 29.


C#




// C# program for the above approach
using System;
class GFG {
    // Function to check if an
    // array is sorted or not
    static bool isSorted(int[, ] arr, int N)
    {
        // Traverse the array arr[]
        for (int i = 1; i < N; i++) {
 
            if (arr[i, 0] > arr[i - 1, 0]) {
                return false;
            }
        }
 
        // Return true
        return true;
    }
 
    // Function to check if it is possible
    // to sort the array w.r.t. first element
    static string isPossibleToSort(int[, ] arr, int N)
    {
        // Stores the ID of the first element
        int group = arr[0, 1];
 
        // Traverse the array arr[]
        for (int i = 1; i < N; i++) {
 
            // If arr[i].second is not
            // equal to that of the group
            if (arr[i, 1] != group) {
                return "Yes";
            }
        }
 
        // If array is sorted
        if (isSorted(arr, N)) {
            return "Yes";
        }
        else {
            return "No";
        }
    }
 
    // Driver Code
    public static void Main()
    {
        int[, ] arr = { { 340000, 2 },
                        { 45000, 1 },
                        { 30000, 2 },
                        { 50000, 4 } };
 
        int N = arr.GetLength(0);
 
        Console.WriteLine(isPossibleToSort(arr, N));
    }
}
 
// This code is contributed by ukasp.


Javascript




<script>
        // Javascript program for the above approach
 
        // Function to check if an
        // array is sorted or not
        function isSorted(arr, N) {
            // Traverse the array arr[]
            for (let i = 1; i < N; i++) {
 
                if (arr[i][0] > arr[i - 1][0]) {
                    return false;
                }
            }
 
            // Return true
            return true;
        }
 
        // Function to check if it is possible
        // to sort the array w.r.t. first element
        function isPossibleToSort(arr, N) {
            // Stores the ID of the first element
            let group = arr[0][1];
 
            // Traverse the array arr[]
            for (let i = 1; i < N; i++) {
 
                // If arr[i].second is not
                // equal to that of the group
                if (arr[i][1] != group) {
                    return "Yes";
                }
            }
 
            // If array is sorted
            if (isSorted(arr, N)) {
                return "Yes";
            }
            else {
                return "No";
            }
        }
 
        // Driver Code
 
        let arr = [[340000, 2],
        [15000, 2],
        [34000, 2],
        [10000, 2]];
 
        let N = arr.length;
        document.write(isPossibleToSort(arr, N));
 
        // This code is contributed by Hritik
    </script>


Output

Yes





Time Complexity: O(N)
Auxiliary Space: O(1),  since no extra space has been taken.

Approach 2: Sorting Technique:

Here’s another approach to solve the problem:

  • Sort the given array of pairs in descending order of the first element.
  • Traverse the sorted array of pairs and check if the i-th element and (i+1)-th element belong to the same group. If not, return “Yes” as they need to be swapped to make the array sorted.
  • If all pairs belong to the same group and the array is still not sorted, return “No”.
  • Time Complexity: O(n*log(n)) where n is the number of elements in the array.
  • Space Complexity: O(1)

Here’s the implementation of this approach in C++:

C++




#include <bits/stdc++.h>
using namespace std;
 
bool comparePairs(pair<int, int> a, pair<int, int> b) {
    return a.first > b.first;
}
 
string isPossibleToSort(pair<int, int>* arr, int N) {
    // Sort the given array in descending order of first element
    sort(arr, arr + N, comparePairs);
 
    // Check if array is already sorted
    bool isSorted = true;
    for (int i = 1; i < N; i++) {
        if (arr[i].first > arr[i-1].first) {
            isSorted = false;
            break;
        }
    }
    if (isSorted) {
        return "Yes";
    }
 
    // Check if it is possible to sort the array by swapping
    int group = arr[0].second;
    for (int i = 1; i < N; i++) {
        if (arr[i].second != group) {
            return "Yes";
        }
    }
 
    // If all pairs belong to the same group and array is not sorted
    return "No";
}
 
int main() {
    pair<int, int> arr[] = { { 340000, 2 }, { 45000, 1 }, { 30000, 2 }, { 50000, 4 } };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << isPossibleToSort(arr, N);
    return 0;
}


Java




import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Pair[] arr = { new Pair(340000, 2), new Pair(45000, 1), new Pair(30000, 2), new Pair(50000, 4) };
        int N = arr.length;
        System.out.println(isPossibleToSort(arr, N));
    }
 
    static class Pair {
        int first, second;
        public Pair(int first, int second) {
            this.first = first;
            this.second = second;
        }
    }
 
    static boolean comparePairs(Pair a, Pair b) {
        return a.first > b.first;
    }
 
    static String isPossibleToSort(Pair[] arr, int N) {
        // Sort the given array in descending order of first element
        Arrays.sort(arr, new Comparator<Pair>() {
            public int compare(Pair a, Pair b) {
                return comparePairs(a, b) ? -1 : 1;
            }
        });
 
        // Check if array is already sorted
        boolean isSorted = true;
        for (int i = 1; i < N; i++) {
            if (arr[i].first > arr[i-1].first) {
                isSorted = false;
                break;
            }
        }
        if (isSorted) {
            return "Yes";
        }
 
        // Check if it is possible to sort the array by swapping
        int group = arr[0].second;
        for (int i = 1; i < N; i++) {
            if (arr[i].second != group) {
                return "Yes";
            }
        }
 
        // If all pairs belong to the same group and array is not sorted
        return "No";
    }
}


Python3




def compare_pairs(a, b):
    return a[0] > b[0]
 
def is_possible_to_sort(arr):
    # Sort the given list of pairs in descending order of the first element
    arr.sort(key=lambda x: x[0], reverse=True)
 
    # Check if the list is already sorted
    is_sorted = all(arr[i][0] >= arr[i + 1][0] for i in range(len(arr) - 1))
    if is_sorted:
        return "Yes"
 
    # Check if it is possible to sort the list by swapping
    group = arr[0][1]
    if all(arr[i][1] == group for i in range(1, len(arr))):
        return "Yes"
 
    # If all pairs belong to the same group and the list is not sorted
    return "No"
 
arr = [(340000, 2), (45000, 1), (30000, 2), (50000, 4)]
print(is_possible_to_sort(arr))
 
# This code is contributed by akshitaguprzj3


C#




using System;
using System.Linq;
 
public class Program
{
    // Custom comparison function to sort pairs in descending order of the first element
    static int ComparePairs((int, int) a, (int, int) b)
    {
        return b.Item1.CompareTo(a.Item1);
    }
 
    // Function to check if it's possible to sort the array
    static string IsPossibleToSort((int, int)[] arr)
    {
        // Sort the given array in descending order of the first element
        Array.Sort(arr, ComparePairs);
 
        // Check if the array is already sorted
        bool isSorted = true;
        for (int i = 1; i < arr.Length; i++)
        {
            if (arr[i].Item1 > arr[i - 1].Item1)
            {
                isSorted = false;
                break;
            }
        }
        if (isSorted)
        {
            return "Yes";
        }
 
        // Check if it is possible to sort the array by swapping
        int group = arr[0].Item2;
        for (int i = 1; i < arr.Length; i++)
        {
            if (arr[i].Item2 != group)
            {
                return "Yes";
            }
        }
 
        // If all pairs belong to the same group and the array is not sorted
        return "No";
    }
 
    public static void Main()
    {
        // Input array of pairs
        var arr = new[] { (340000, 2), (45000, 1), (30000, 2), (50000, 4) };
        Console.WriteLine(IsPossibleToSort(arr));
    }
}


Javascript




// Nikunj Sonigara
 
function comparePairs(a, b) {
    return a.first > b.first;
}
 
function isPossibleToSort(arr) {
    // Sort the given array in descending order of first element
    arr.sort(comparePairs);
 
    // Check if array is already sorted
    let isSorted = true;
    for (let i = 1; i < arr.length; i++) {
        if (arr[i].first > arr[i - 1].first) {
            isSorted = false;
            break;
        }
    }
    if (isSorted) {
        return "Yes";
    }
 
    // Check if it is possible to sort the array by swapping
    const group = arr[0].second;
    for (let i = 1; i < arr.length; i++) {
        if (arr[i].second !== group) {
            return "Yes";
        }
    }
 
    // If all pairs belong to the same group and array is not sorted
    return "No";
}
 
const arr = [
    { first: 340000, second: 2 },
    { first: 45000, second: 1 },
    { first: 30000, second: 2 },
    { first: 50000, second: 4 }
];
 
console.log(isPossibleToSort(arr));


Output: 

Yes

Time Complexity: O(n*log(n)) where n is the number of elements in the array.

Auxiliary Space: O(1)



Last Updated : 07 Nov, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads