Clasificación de array con intercambio condicional

Dada una array arr que contiene elementos de [1…to n] . Cada elemento aparece exactamente una vez en el arreglo arr . Dada una string str de longitud n-1 . Cada carácter de la string es 0 o 1 . En la array, el intercambio del i-ésimo elemento con (i + 1)-ésimo elemento se puede realizar tantas veces como queramos, si el i-ésimo carácter de la string es 1 . Nuestra tarea es encontrar si es posible ordenar la array o no en orden ascendente. 
Ejemplos: 
 

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.

Enfoque Ejecute un ciclo hasta la longitud de la string str y calcule el max_element de la array de 0 a i para cada i . En cada iteración, si el i-ésimo carácter de la string es ‘0’ y max_element es mayor que i + 1 , entonces es imposible ordenar la array; de lo contrario, es posible.
Implementación básica del enfoque anterior: 
 

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>
Producción: 

Yes

 

Complejidad de tiempo: O(n), donde n es el tamaño de la string dada str
Espacio auxiliar: O(1), ya que no se utiliza espacio adicional

Publicación traducida automáticamente

Artículo escrito por Sagar Shukla y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *