# Check if the array can be sorted only if the elements on given positions can be swapped

Given an array arr[] of length N and another array P[] containing {a1, a2, … ak} which represents the positions of the given array arr[], the task is to check if the array can be sorted by only swapping the elements’ arr[ai], arr[ai+1] where ‘i’ is some element in the array P[].
Examples:

Input: arr[] = {3, 2, 1}, P[] = {1, 2}
Output: Yes
Explanation:
Initially, i = 1 (i.e.) first element and second element are swapped. Therefore, arr[0] <=> arr[1]. arr[] = {2, 3, 1}.
Similarly, i = 2 (i.e.) second element and third element are swapped. arr[] = {2, 1, 3}.
Finally, i = 1 (i.e.) first element and second element are swapped. arr[] = {1, 2, 3}.
Since this array is sorted, therefore, the given array can be sorted.
Input: arr[] = {5, 3, -4, 1, 12}, P[] = {2, 4, 3}
Output: No

Approach: The idea is to use two pointer approach to check if the array can be sorted or not.

• Initially, we create a position array pos[] of size N. This array will be used to mark the given positions in the array P[]. That is:
```if j = ai (1 ? i ? K)
then the element pos[ai-1] will be 1
else 0```
• Now, iterate through the array and check if pos[i] = 1 or not.
• If we encounter the pos[i]=1, we store the iterator in a temporary variable, and then we increment the iterator with value 1, till we have pos[i]=1 continuously, i.e.,
```j = i
while (j < N and pos[j])
j=j+1```
• After this increment, we sort this segment that we obtained from i to j+1 and finally, check after the position j, in the vector that we have to check, because we have sorted till this segment.
```Sort(arr[i] to arr[j+1])
i=j```
• Finally, after this loop completion, we have to check if the array has been sorted or not.

Below is the implementation of the above approach:

## C++

 `// C++ program to check if the array ``// can be sorted only if the elements ``// on the given positions can be swapped ` `#include ``using` `namespace` `std; ` `// Function to check if the array can ``// be sorted only if the elements on ``// the given positions can be swapped ``void` `check_vector(vector<``int``> A, ``int` `n, ``                ``vector<``int``> p) ``{ ` `    ``// Creating an array for marking ``    ``// the positions ``    ``vector<``int``> pos(A.size()); ` `    ``// Iterating through the array and ``    ``// mark the positions ``    ``for` `(``int` `i = 0; i < p.size(); i++) { ``        ``pos[p[i] - 1] = 1; ``    ``} ` `    ``int` `flag = 1; ` `    ``// Iterating through the given array ``    ``for` `(``int` `i = 0; i < n; i++) { ``        ``if` `(pos[i] == 0) ``            ``continue``; ``        ``int` `j = i; ` `        ``// If pos[i] is 1, then incrementing ``        ``// till 1 is continuously present in pos ``        ``while` `(j < n && pos[j]) ``            ``++j; ` `        ``// Sorting the required segment ``        ``sort(A.begin() + i, A.begin() + j + 1); ``        ``i = j; ``    ``} ` `    ``// Checking if the vector is sorted or not ``    ``for` `(``int` `i = 0; i < n - 1; i++) { ``        ``if` `(A[i] > A[i + 1]) { ``            ``flag = 0; ``            ``break``; ``        ``} ``    ``} ` `    ``// Print yes if it is sorted ``    ``if` `(flag == 1) ``        ``cout << ``"Yes"``; ``    ``else``        ``cout << ``"No"``; ``} ` `// Driver code ``int` `main() ``{ ``    ``vector<``int``> A{ 3, 2, 1 }; ``    ``vector<``int``> p{ 1, 2 }; ` `    ``check_vector(A, A.size(), p); ``    ``return` `0; ``} `

## Java

 `// Java program to check if the array ``// can be sorted only if the elements ``// on the given positions can be swapped ``import` `java.util.Arrays; ` `class` `GFG{``    ` `// Function to check if the array can ``// be sorted only if the elements on ``// the given positions can be swapped ``public` `static` `void` `check_vector(``int``[] A, ``                                ``int` `n,``                                ``int``[] p) ``{ ` `    ``// Creating an array for marking ``    ``// the positions ``    ``int``[] pos = ``new` `int``[A.length]; ` `    ``// Iterating through the array and ``    ``// mark the positions ``    ``for``(``int` `i = ``0``; i < p.length; i++) ``    ``{ ``        ``pos[p[i] - ``1``] = ``1``; ``    ``} ` `    ``int` `flag = ``1``; ` `    ``// Iterating through the given array ``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{ ``        ``if` `(pos[i] == ``0``) ``            ``continue``; ``            ` `        ``int` `j = i; ` `        ``// If pos[i] is 1, then incrementing ``        ``// till 1 is continuously present in pos ``        ``while` `(j < n && pos[j] != ``0``) ``            ``++j; ` `        ``// Sorting the required segment ``        ``Arrays.sort(A, i, j + ``1``);``        ``i = j; ``    ``} ` `    ``// Checking if the vector is sorted or not ``    ``for``(``int` `i = ``0``; i < n - ``1``; i++) ``    ``{ ``        ``if` `(A[i] > A[i + ``1``])``        ``{ ``            ``flag = ``0``; ``            ``break``; ``        ``} ``    ``} ` `    ``// Print yes if it is sorted ``    ``if` `(flag == ``1``) ``        ``System.out.print(``"Yes"``); ``    ``else``        ``System.out.print(``"No"``); ``} ` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `A[] = { ``3``, ``2``, ``1` `};``    ``int` `p[] = { ``1``, ``2` `};``    ` `    ``check_vector(A, A.length, p);``}``}` `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 program to check if the array ``# can be sorted only if the elements ``# on the given positions can be swapped ` `# Function to check if the array can ``# be sorted only if the elements on ``# the given positions can be swapped ``def` `check_vector(A, n, p): ``    ` `    ``# Creating an array for marking ``    ``# the positions ``    ``pos ``=` `[``0` `for` `i ``in` `range``(``len``(A))] ` `    ``# Iterating through the array and ``    ``# mark the positions ``    ``for` `i ``in` `range``(``len``(p)): ``        ``pos[p[i] ``-` `1``] ``=` `1` `    ``flag ``=` `1` `    ``# Iterating through the given array ``    ``for` `i ``in` `range``(n): ``        ``if` `(pos[i] ``=``=` `0``): ``            ``continue``        ``j ``=` `i ` `        ``# If pos[i] is 1, then incrementing ``        ``# till 1 is continuously present in pos ``        ``while` `(j < n ``and` `pos[j]): ``            ``j ``+``=` `1` `        ``# Sorting the required segment ``        ``p ``=` `A[: i] ``        ``q ``=` `A[i : i ``+` `j ``+` `1``] ``        ``r ``=` `A[i ``+` `j ``+` `1` `: ``len``(A)] ``        ` `        ``q.sort(reverse ``=` `False``) ``        ``A ``=` `p ``+` `q ``+` `r ``        ``i ``=` `j ` `    ``# Checking if the vector is sorted or not ``    ``for` `i ``in` `range``(n ``-` `1``): ``        ``if` `(A[i] > A[i ``+` `1``]): ``            ``flag ``=` `0``            ``break` `    ``# Print yes if it is sorted ``    ``if` `(flag ``=``=` `1``): ``        ``print``(``"Yes"``) ``    ``else``: ``        ``print``(``"No"``); ` `# Driver code ``if` `__name__ ``=``=` `'__main__'``: ``    ` `    ``A ``=` `[ ``3``, ``2``, ``1` `] ``    ``p ``=` `[ ``1``, ``2` `] ` `    ``check_vector(A,``len``(A), p) ` `# This code is contributed by Samarth `

## C#

 `// C# program to check ``// if the array can be ``// sorted only if the ``// elements on the given ``// positions can be swapped ``using` `System;``class` `GFG{``    ` `// Function to check if the array can ``// be sorted only if the elements on ``// the given positions can be swapped ``public` `static` `void` `check_vector(``int``[] A, ``                                ``int` `n,``                                ``int``[] p) ``{ ``  ``// Creating an array for marking ``  ``// the positions ``  ``int``[] pos = ``new` `int``[A.Length]; ` `  ``// Iterating through the array and ``  ``// mark the positions ``  ``for``(``int` `i = 0; i < p.Length; i++) ``  ``{ ``    ``pos[p[i] - 1] = 1; ``  ``} ` `  ``int` `flag = 1; ` `  ``// Iterating through the given array ``  ``for``(``int` `i = 0; i < n; i++)``  ``{ ``    ``if` `(pos[i] == 0) ``      ``continue``; ` `    ``int` `j = i; ` `    ``// If pos[i] is 1, then ``    ``// incrementing till 1 ``    ``// is continuously present in pos ``    ``while` `(j < n && pos[j] != 0) ``      ``++j; ` `    ``// Sorting the required segment ``    ``Array.Sort(A, i, j + 1);``    ``i = j; ``  ``} ` `  ``// Checking if the vector ``  ``// is sorted or not ``  ``for``(``int` `i = 0; i < n - 1; i++) ``  ``{ ``    ``if` `(A[i] > A[i + 1])``    ``{ ``      ``flag = 0; ``      ``break``; ``    ``} ``  ``} ` `  ``// Print yes if it is sorted ``  ``if` `(flag == 1) ``    ``Console.Write(``"Yes"``); ``  ``else``    ``Console.Write(``"No"``); ``} ` `// Driver code``public` `static` `void` `Main()``{``  ``int``[] A = {3, 2, 1};``  ``int``[] p = {1, 2};``  ``check_vector(A, A.Length, p);``}``}` `// This code is contributed by Chitranayal`

## Javascript

 ``

Output:
`Yes`

Time Complexity: O(N * log(N)), where N is the size of the array.

Space Complexity: O(N) as pos vector has been created. Here, N is the size of the array.

Previous
Next