Given an array arr containing elements from [1…to n]. Each element appears exactly once in the array arr. Given an string str of length n-1. Each character of the string is either 0 or 1. In the array, swapping of the i-th element with (i + 1)-th element can be done as many times as we want, if the i-th character of the string is 1. Our task is to find whether it is possible to sort the array or not in ascending order.
Examples:
Input : arr = {1, 2, 5, 3, 4, 6} str = "01110" Output : Yes Explanation : Here, we can swap arr[2] and arr[3], and then swap arr[3] and arr[4]. Input : arr = {1, 2, 5, 3, 4, 6} str = "01010" Output : No Explanation : Here, the 3rd element of the array i.e. 5 can not be swapped as the 3rd character of the string is 0. Therefore it is impossible to sort the array.
Approach Run a loop to length of the string str and calculate the max_element of the array from 0 to i for each i. At each iteration, if the i-th character of the string is ‘0’ and the max_element is greater than i + 1 then, it is impossible to sort the array, otherwise, possible.
Basic implementation of the above approach :
// CPP program to Check if it // is possible to sort the // array in ascending order. #include <bits/stdc++.h> using namespace std;
// Function to check if it is possible to // sort the array string possibleToSort( int * arr, int n, string str)
{ int max_element = -1;
for ( long i = 0; i < str.size(); i++) {
// Calculating max_element
// at each iteration.
max_element = max(max_element, arr[i]);
// if we can not swap the i-th element.
if (str[i] == '0' ) {
// if it is impossible to swap the
// max_element then we can not
// sort the array.
if (max_element > i + 1)
return "No" ;
}
}
// Otherwise, we can sort the array.
return "Yes" ;
} // Driver function int main()
{ int arr[] = { 1, 2, 5, 3, 4, 6 };
int n = sizeof (arr) / sizeof (arr[0]);
string str = "01110" ;
cout << possibleToSort(arr, n, str);
return 0;
} |
// Java program to Check if it is possible to // sort the array in ascending order. import java.util.*;
import java.lang.*;
// Function to check if it is possible to // sort the array class GFG
{ public static String possibleToSort( int arr[],
int n, String str)
{
int max_element = - 1 ;
for ( int i = 0 ; i < str.length(); i++)
{
// Calculating max_element at each
// iteration.
max_element = Math.max(max_element,
arr[i]);
// if we can not swap the i-th
// element.
if (str.charAt(i) == '0' ) {
// if it is impossible to swap
// the max_element then we can
// not sort the array.
if (max_element > i + 1 )
return "No" ;
}
}
// Otherwise, we can sort the array.
return "Yes" ;
}
// Driven Program
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 5 , 3 , 4 , 6 };
int n = arr.length;
String str = "01110" ;
System.out.println(
possibleToSort(arr, n, str));
}
} // This code is contributed by Prasad Kshirsagar |
# Python 3 program to Check if it # is possible to sort the # array in ascending order. # Function to check if it is # possible to sort the array def possibleToSort(arr, n, str ):
max_element = - 1
for i in range ( len ( str )) :
# Calculating max_element
# at each iteration.
max_element = max (max_element, arr[i])
# if we can not swap the i-th element.
if ( str [i] = = '0' ) :
# if it is impossible to swap the
# max_element then we can not
# sort the array.
if (max_element > i + 1 ):
return "No"
# Otherwise, we can sort the array.
return "Yes"
# Driver Code if __name__ = = "__main__" :
arr = [ 1 , 2 , 5 , 3 , 4 , 6 ]
n = len (arr)
str = "01110"
print (possibleToSort(arr, n, str ))
# This code is contributed # by ChitraNayal |
// C# program to Check if it // is possible to sort the // array in ascending order using System;
class GFG {
// Function to check if it // is possible to sort the array static string possibleToSort( int []arr,
int n,
string str)
{ int max_element = -1;
for ( int i = 0; i < str.Length; i++)
{
// Calculating max_element
// at each iteration.
max_element = Math.Max(max_element,
arr[i]);
// if we can not swap
// the i-th element.
if (str[i] == '0' )
{
// if it is impossible to swap the
// max_element then we can not
// sort the array.
if (max_element > i + 1)
return "No" ;
}
}
// Otherwise, we can
// sort the array.
return "Yes" ;
} // Driver Code
static public void Main ()
{
int []arr = {1, 2, 5, 3, 4, 6};
int n = arr.Length;
string str = "01110" ;
Console.WriteLine(possibleToSort(arr, n, str));
}
} // This code is contributed by anuj_67. |
<?php // PHP program to Check if it is possible // to sort the array in ascending order. // Function to check if it is possible // to sort the array function possibleToSort( $arr , $n , $str )
{ $max_element = -1;
for ( $i = 0; $i < sizeof( $str ); $i ++)
{
// Calculating max_element
// at each iteration.
$max_element = max( $max_element ,
$arr [ $i ]);
// if we can not swap the i-th element.
if ( $str [ $i ] == '0' )
{
// if it is impossible to swap the
// max_element then we can not
// sort the array.
if ( $max_element > $i + 1)
return "No" ;
}
}
// Otherwise, we can sort the array.
return "Yes" ;
} // Driver Code $arr = array (1, 2, 5, 3, 4, 6);
$n = sizeof( $arr );
$str = "01110" ;
echo possibleToSort( $arr , $n , $str );
// This code is contributed // by Akanksha Rai ?> |
<script> // Javascript program to Check if it
// is possible to sort the
// array in ascending order
// Function to check if it
// is possible to sort the array
function possibleToSort(arr, n, str)
{
let max_element = -1;
for (let i = 0; i < str.length; i++)
{
// Calculating max_element
// at each iteration.
max_element = Math.max(max_element, arr[i]);
// if we can not swap
// the i-th element.
if (str[i] == '0' )
{
// if it is impossible to swap the
// max_element then we can not
// sort the array.
if (max_element > i + 1)
return "No" ;
}
}
// Otherwise, we can
// sort the array.
return "Yes" ;
}
let arr = [1, 2, 5, 3, 4, 6];
let n = arr.Length;
let str = "01110" ;
document.write(possibleToSort(arr, n, str));
// This code is contributed by divyesh072019.
</script> |
Yes
Complexity Analysis:
- Time Complexity: O(n), where n is the size of the given string str
- Auxiliary Space: O(1), as no extra space is used