Monday, November 18, 2024
Google search engine
HomeData Modelling & AISorting array with conditional swapping

Sorting array with conditional swapping

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 : 

C++




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




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




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




// 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
// 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
?>


Javascript




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


Output

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
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments