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

• Last Updated : 20 Jul, 2022

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 ` `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

 ``

Output:

`Yes`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :