¡Bien hecho!

¡Has completado Algoritmos: Ordenamiento y búsqueda!

Instrucción

Código para Bogosort

Python

Necesitarás una load.py archivo guardado en el mismo directorio que el bogosort.py archivo, con el siguiente contenido:

# Llamas esta función con la ruta a un archivo que quieres cargar.
# Carga el contenido del archivo, convierte cada línea de una cadena a
# un entero, y los devuelve todos como una lista de Python.
def load_numbers(file_name):
  numbers = 
  con abrir(file_name) como f:
    para línea en f:
      numbers.append(int(línea))
  return numbers

Aquí está el código para bogosort.py en sí:

# La función que randomiza el orden de la lista se mantiene en el
# módulo "random", así que necesitamos importarlo aquí.
import aleatorio
# La lista sys.argv nos da los argumentos de la línea de comandos del
# script. Para usarla, también necesitamos importar el módulo "sys".
import sys
# Aquí es donde importamos la función load_numbers de arriba.
from cargar import load_numbers

# Y aquí, pasamos el primer argumento de la línea de comandos (que debería ser
# la ruta a un archivo) a load_numbers, y almacenamos la lista devuelta de
# números en una variable.
numbers = load_numbers(sys.argv[1])

# Bogosort simplemente reorganiza aleatoriamente la lista de valores una y otra vez,
# así que lo primero que va a necesitar es una función para detectar cuándo
# la lista está ordenada. Escribiremos una función is_sorted que toma una
# lista de valores como parámetro. Devolverá True si la lista
# pasada está ordenada, o False si no lo está.
def is_sorted(valores):
  # Recorreremos el índice numérico de cada valor en la lista,
  # de 0 a uno menos que la longitud de la lista. Como muchos
  # lenguajes, los índices de listas de Python comienzan en 0, así que una lista con una
  # longitud de 5 tiene índices que van de 0 a 4.
  para índice en rango(len(valores) - 1):
    # Si la lista está ordenada, entonces cada valor en ella será menor que
    # el que viene después. Así que probamos para ver si el
    # elemento actual es MAYOR que el que lo sigue.
    if valores[índice] > valores[índice + 1]:
      # Si lo es, significa que toda la lista no está ordenada, así que devolvemos
      # False.
      return False
  # Si llegamos aquí, significa que el bucle se completó sin encontrar
  # ningún valor desordenado. (Python usa espacios en blanco para marcar bloques de código,
  # así que desindentando el código así se marca el final del bucle.)
  # Como todos los valores están ordenados, podemos devolver True.
  return Verdadero

# Ahora necesitamos escribir la función que hará realmente el
# llamado ordenamiento. La función bogo_sort también tomará la lista
# de valores con la que está trabajando como parámetro.
def bogo_sort(valores):
  # Llamaremos nuestra función is_sorted para probar si la lista está
  # ordenada. Seguiremos en bucle hasta que is_sorted devuelva True.
  while mantiene is_sorted(valores):
    # Python tiene una función lista que randomiza el orden de
    # elementos en una lista. Como la lista no está ordenada, llamaremos
    # esa función aquí. Y como esto está dentro del bucle, será
    # randomizado una y otra vez hasta que nuestra función is_sorted
    # devuelva True.
    aleatorio.shuffle(valores)
  # Si el bucle se sale, significa que is_sorted devolvió True, y la lista
  # está ordenada. Así que ahora podemos devolver la lista ordenada.
  return valores

# Finalmente, necesitamos llamar nuestra función bogo_sort, pasarle la lista
# que cargamos del archivo, e imprimir la lista ordenada que devuelve.
print(bogo_sort(numbers))

Para ejecutar esto, guarda el código anterior en dos archivos en el mismo directorio, y asegúrate de que exista un archivo llamado 5.txt se guarda en un subdirectorio llamado numbers. Luego, abre una terminal/consola, cambia al directorio donde bogosort.py se guarda y ejecuta este comando:

python bogosort.py numbers/5.txt

JavaScript

// Baraja aleatoriamente los elementos de la matriz que se pasa.
función shuffle(de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".) {
    var swapIndex = de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()"..longitud;
    var temp, randomIndex;

    while (swapIndex !== 0) {

        randomIndex = Math.floor(Math.aleatorio() * swapIndex);

        swapIndex -= 1;

        temp = de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".[swapIndex];
        de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".[swapIndex] = de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".[randomIndex];
        de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".[randomIndex] = temp;
    }

    return de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".;
}

// Devuelve verdadero si la matriz está ordenada, falso si no.
función isSorted(de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".){
    para(var i = 1; i < de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()"..longitud; i++) {
        if (de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".[i-1] > de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".[i]) {
            return falso;
        }
    }
    return verdadero;
}

// Baraja la matriz hasta que esté ordenada.
función bogoSort(de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".){
    while(isSorted(de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".) == falso) {
        de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()". = shuffle(de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".);
    }
    return de caracteres. Lo último es el tipo de cosa que devuelve el método "toCharArray()".;
}

const testValues = [29, 100, 1, 2, 57];

var sorted = bogoSort(testValues);
console.log(sorted);

Java

import java.util.*;

público class BogoSort {
    público estático void main(Cadena argumentos) {
        ArrayList<Integer> list = new ArrayList<Integer>(Arreglos.asList(29, 100, 1, 2, 57));
        bogoSort(list);
        System.out.println(list);
    }

    estático void bogoSort(ArrayList<Integer> list) {
        while(!isSorted(list)) {
            Colecciones.shuffle(list);
        }
    }

    estático booleano isSorted(ArrayList<Integer> list) {
        para(int i=1; i < list.tamaño(); i++) {
            if(list.get(i) < list.get(i-1)) {
                return falso;
            }
        }
        return verdadero;
    }
}

C-Sharp

usando System;
usando System.Collections.Generic;

espacio de nombres Bogosort
{
    class MainClass
    {
        público estático void Principal(string argumentos)
        {
            var list = new Lista<int>() { 29, 100, 1, 2, 57 };
            BogoSort(list);
            Consola.WriteLine(Cadena.Únete(,, list));
        }

        público estático void BogoSort(IList<int> list)
        {
            var attempt = 1;
            while (!IsSorted(list))
            {
                Consola.WriteLine($Intento {attempt});
                list.Barajar();
                attempt++;
            }            
        }

        estático bool IsSorted(IList<int> list)
        {
            para (int i = 1; i < list.Count; i++)
            {
                if (list[i] < list[i - 1])
                {
                    return falso;
                }
            }
            return verdadero;
        }
    }

    /// <summary>
    /// Métodos de extensión de IList.
    /// </summary>
    estático class IListExtensions
    {
        estático Random rng = new Random();

        /// <summary>
        /// Baraja los elementos de la lista especificada.
        /// </summary>
        /// <param name="list">La lista a barajar.</param>
        /// <typeparam name="T">El tipo de elemento.</typeparam>
        público estático void Barajar<O>(this IList<O> list)
        {
            int n = list.Count;
            while (n > 1)
            {
                n--;
                int k = rng.Siguiente(n + 1);
                O valor = list[k];
                list[k] = list[n];
                list[n] = valor;
            }
        }
    }
}
Ok, lo entendí