Necesito un programa donde el usuario ingrese una matriz de dobles y el programa genere la matriz ordenada

280

Nota: Esta pregunta fue editada severamente desde que la publiqué aquí por primera vez. Las reglas se movieron aquí , léalas antes de publicar cualquier respuesta para comprender el propósito de esto. Esta fue la primera pregunta creada en la categoría de .

Imagine que un usuario perezoso en Stack Overflow hace esta pregunta:

Necesito un programa donde el usuario ingrese una matriz de dobles y el programa genere la matriz ordenada. ¿Podría por favor dar el código?

¿Cómo podrías crear un código que engañe a este usuario? Cree una pieza de código que parezca útil para un programador inexperto pero que es completamente inútil en la práctica.

El ganador es la respuesta más votada, excepto si la respuesta de alguna manera no es elegible (para conocer los requisitos de elegibilidad, consulte la descripción de la etiqueta en la wiki del ). Si la respuesta más votada anteriormente es superada en el futuro en el número de votos votados después de ser aceptada, la nueva mejor respuesta se acepta y la anterior no se acepta. En caso de empate, elegiré el ganador a voluntad entre los empatados o simplemente esperaré un poco más.

Las respuestas que no tienen código no son elegibles. Pueden ser divertidos y obtener algunos votos positivos, pero no serán aceptados.

Las reglas se pueden encontrar en la descripción de la etiqueta .

Nota: Esta es una pregunta de . No tome en serio la pregunta y / o las respuestas. Más información aquí .

Victor Stafusa
fuente
48
Sobrecarga de pila
ThiefMaster
66
@bluesm Si alguien ya ha decidido pedirle a otra persona que resuelva su problema en lugar de "perder" su propio tiempo aprendiendo, publicar un enlace donde pueda aprender por sí solo no va a hacer ningún bien.
IQAndreas
3
¡Wow, esta pregunta está a punto de obtener 100 votos a favor y 10,000 vistas en menos de 24 horas!
Joe Z.
18
Dios mío, Víctor, tu cuadro Acerca de es tan triste ... todos tenemos nuestros altibajos, pero no deberías golpearte, hombre. ¡Eres un héroe para Code Golfers en todas partes ahora!
SimonT
44
Me sorprende que nadie haya ofrecido una solución basada en el tipo de sueño todavía
Frank Farmer

Respuestas:

178

A veces, a la comunidad aquí no le gusta ayudar con la tarea. Es por eso que obtienes tantas respuestas de broma. Pero me gusta ayudar. Aquí hay una solución completa en 'C' (ya que supongo que desea aprender "programación", no "secuencias de comandos" con Java o Ruby). He incluido muchos consejos que desearía haber sabido cuando estaba aprendiendo

#include <stdio.h>

//Always use meaningful names for types
typedef unsigned char boolean;
#define True 't'
#define FALSE (!True)

//this is a really neat trick for swapping values efficiently
void swap(long* a,long *b) { *a=*a^*b;*b=*b^*a;*a=*a^*b; }

//Here's a readability improvement
#define until(condition) while(!(condition))

int main(int n, char*args[]){
  double *d;
  int i;
  char input[5];  //should be long enough for most doubles.
  boolean sorted = FALSE;

  //In C, you need to specify the array size beforehand, so ask
  printf("Please enter the length of the array\n");
  gets(input);
  //scan the input string and convert to a value
  sscanf(input,"%s",&input[0]);
  n=(long)atol(input);

  //allocate space, make sure you get the order of arguments right.
  d = calloc(sizeof(double),n); 

  //Get and sort the array
  until (sorted) {

     for (i=0;i<n;i++) {
        //It's important to always ask nicely
        printf("Please enter the %d%s array item\n",i,i==1?"st":"th");
        scanf("%lf",d+i);
     }
     //do a compare and exchange sort:
     sorted = !sorted;  //not sorted
     //check all the items
     printf("%d %d\n",i,n);
     for (i=1;i<n;i++) {
        //compare
        if (d[i]<d[i-1]) {
          //exchange 
          swap(d+i,d+i-1);
          sorted = FALSE;
        }
     }
     //show results
     printf("The array is%ssorted\n",sorted?" ":" not "); }
  //use the --> "downto operator" for counting downto 0. 
  for (;n-->0;) printf("%lf\n",*d++);
  }
AShelly
fuente
32
casi todos los consejos están equivocados, y simplemente sigue pidiendo la lista de entrada hasta que la ingrese ya ordenada.
AShelly
47
+1, for 1st, 2th, 3th, 4th...and the downto operator: técnicas de programación en C muy avanzadas.
Kaya
55
Debería usar sscanf(input, "%5s", &input[0]), de lo contrario, podría haber errores de desbordamiento al analizar la entrada. Y la entrada debe declararse char input[sizeof(int)+1], para compatibilidad con versiones anteriores de sistemas de 64 bits.
sh1
12
i==1?"st":"th"jajaja ...
Guy Sirton
15
Java tiene recolección de basura. Por lo tanto, Java es para "scripting", no para programación real. Eso es básico CS101. (así lo dice el troll).
AShelly
181

Aquí está en Java. Es una trampa total, inaceptable e irreparable porque crea una base de datos MySQL, inserta el número allí, realiza una selección con una cláusula ORDER BY y genera los números dados por MySQL. De hecho, es MySQL quien está haciendo la clasificación, no el programa.

package sorter;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JOptionPane;

public class SortingAlgorithm {

    private static final String CREATE_DB = "CREATE DATABASE sorting";
    private static final String DROP_DB = "DROP DATABASE sorting";
    private static final String CREATE_TABLE = "CREATE TABLE sorting.sorting ( num double not null )";

    public static void main(String[] args) throws Exception {
        Class.forName("com.mysql.jdbc.Driver");
        List<Double> doubles = new ArrayList<>(50);
        String typed;
        do {
            typed = JOptionPane.showInputDialog(null, "Type a double:");
            if (typed != null) doubles.add(Double.parseDouble(typed));
        } while (typed != null);

        List<Double> sorted = new ArrayList<>(50);

        try (Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306", "root", "root")) {
            try (PreparedStatement ps = con.prepareStatement(CREATE_DB)) {
                ps.executeUpdate();
            }
            try (PreparedStatement ps = con.prepareStatement(CREATE_TABLE)) {
                ps.executeUpdate();
            }

            for (Double d : doubles) {
                try (PreparedStatement ps = con.prepareStatement("INSERT INTO sorting.sorting (num) VALUES (" + d + ")")) {
                    ps.executeUpdate();
                }
            }

            try (
                    PreparedStatement ps = con.prepareStatement("SELECT * FROM sorting.sorting ORDER BY num");
                    ResultSet rs = ps.executeQuery())
            {
                while (rs.next()) {
                    sorted.add(rs.getDouble("num"));
                }
            }
            try (PreparedStatement ps = con.prepareStatement(DROP_DB)) {
                ps.executeUpdate();
            }
        }

        JOptionPane.showMessageDialog(null, "The array sorted is: " + sorted);
    }
}
Victor Stafusa
fuente
103
¡De hecho, eso está demasiado cerca de casa para lo que muchos codificadores de Java considerarían una solución aceptable para las especificaciones!
Dr. Rebmu
10
Considere también el caso en el que necesita ordenar una gran cantidad de objetos. Ordenarlos "fuera del programa" en una base de datos es una solución factible.
Viktor Seifert
40
No hay suficiente abstracción aquí. Necesita al menos 10 interfaces, 20 implementaciones, enumeraciones, pruebas unitarias, pruebas de cobertura, Maven, pruebas de integración,
simulacros
66
@NaftuliTzviKay Deberíamos crear una MySQLSortEnterpriseEdition para implementar su idea. ¿Víctor aceptará la licencia GPL del código aquí para que podamos comenzar?
Joe Z.
14
@JoeZ. Sí, mi respuesta carece de comentarios sobre el modelo de licencia y debo hacer que el usuario acepte un EULA al comienzo del programa. Pero como se lo doy al OP lento, es gratuito para uso no comercial, lo que incluye ser útil para crear el esperado MySQLSortEnterpriseEdidtion premium.
Victor Stafusa
142

C # - No hay matar como exagerar

En primer lugar, querido GiMmEtHaCoDeZ, intentemos desglosar tu tarea:

  1. Lee los números
  2. Ordenarlos
  3. Salida de los números ordenados.

Como "Divide y vencerás" es una estrategia muy importante cuando trabajas con problemas de software, abordemos uno a la vez

1. lectura

Otro tema importante en el software es la versatilidad. Como no se especifica cómo el usuario ingresará los números, eso puede suceder a través de la consola, a través de un archivo, a través de un servicio web, etc. Quizás incluso algún método que no podamos pensar en este momento. Por lo tanto, es importante que nuestra solución pueda acomodar varios tipos de entrada. La forma más fácil de lograrlo será extraer la parte importante de una interfaz, digamos

public interface IDoubleArrayReader
{
  IEnumerable<double> GetDoubles();

  DoubleArrayReaderType Type {get;}
}

donde DoubleArrayReaderTypees una enumeración dada con

public enum DoubleArrayReaderType
{
  Console,
  File,
  Database,
  Internet,
  Cloud,
  MockService
}

También es importante hacer que el software sea comprobable desde cero, por lo que una implementación de la interfaz será

public class MockServiceDoubleArrayReader : IDoubleArrayReader
{
    IEnumerable<double> IDoubleArrayReader.GetDoubles()
    {
      Random r = new Random();  
      for(int i =0; i<=10; i++)
      {
        yield return r.NextDouble();
      }
    }

    DoubleArrayReaderType IDoubleArrayReader.Type 
    {
      get
      {
        return DoubleArrayReaderType.MockService;
      }
    }
}

Luego, la pregunta lógica es cómo sabremos cargar lo apropiado IDoubleArrayReaderen el código. Eso es fácil siempre que usemos una fábrica simple:

public static class DoubleArrayInputOutputFactory
{
  private static Dictionary<DoubleArrayReaderType, IDoubleArrayReader> readers;

  static DoubleArrayInputOutputFactory()
  {
      readers = new Dictionary<DoubleArrayReaderType, IDoubleArrayReader>();
      foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
      {
        try
        {
          var instance = Activator.CreateInstance(type);
          if (instance is IDoubleArrayReader)
          {
            readers.Add((instance as IDoubleArrayReader).Type, 
                        (instance as IDoubleArrayReader));
          }
        }
        catch
        {
          continue;
        }
      }
  }

  public static IDoubleArrayReader CreateDoubleArrayReader(DoubleArrayReaderType type)
  {
    return readers[type];
  }
}

Tenga en cuenta que, utilizamos la reflexión para cargar todos los lectores activos, por lo que cualquier extensión futura estará disponible automáticamente ahora, en el cuerpo principal del código que acabamos de hacer:

IDoubleArrayReader reader = DoubleArrayInputOutputFactory
                           .CreateDoubleArrayReader(DoubleArrayReaderType.MockService);
var doubles = reader.GetDoubles();

2. Procesamiento (clasificación)

Ahora tenemos que procesar, es decir, ordenar los números que hemos adquirido. Tenga en cuenta que los pasos son completamente independientes entre sí, por lo que para el subsistema de clasificación, no importa cómo se ingresaron los números. Además, el comportamiento de clasificación también es algo que está sujeto a cambios, por ejemplo, podríamos necesitar ingresar un algoritmo de clasificación más eficiente. Entonces, naturalmente, extraeremos el comportamiento de procesamiento solicitado en una interfaz:

public interface IDoubleArrayProcessor
{
  IEnumerable<double> ProcessDoubles(IEnumerable<double> input);

  DoubleArrayProcessorType Type {get;}
}

public enum DoubleArrayProcessorType
{
  Sorter,
  Doubler,
  Tripler,
  Quadrupler,
  Squarer
}

Y el comportamiento de clasificación solo implementará la interfaz:

public class SorterDoubleArrayProcessor : IDoubleArrayProcessor
{
    IEnumerable<double> IDoubleArrayProcessor.ProcessDoubles(IEnumerable<double> input)
    {
      var output = input.ToArray();
      Array.Sort(output);
      return output;
    }

    DoubleArrayProcessorType IDoubleArrayProcessor.Type 
    {
      get
      {
        return DoubleArrayProcessorType.Sorter;
      }
    }
}

Por supuesto, necesitaremos una fábrica para cargar y administrar las instancias de procesamiento.

public static class DoubleArrayProcessorFactory
{
  private static Dictionary<DoubleArrayProcessorType, IDoubleArrayProcessor> processors;

  static DoubleArrayProcessorFactory()
  {
      processors = new Dictionary<DoubleArrayProcessorType, IDoubleArrayProcessor>();
      foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
      {
        try
        {
          var instance = Activator.CreateInstance(type);
          if (instance is IDoubleArrayProcessor)
          {
            processors.Add((instance as IDoubleArrayProcessor).Type, (instance as IDoubleArrayProcessor));
          }
        }
        catch
        {
          continue;
        }
      }
  }

  public static IDoubleArrayProcessor CreateDoubleArrayProcessor(DoubleArrayProcessorType type)
  {
    return processors[type];
  }

}

3. Escribir la salida

No hay mucho que decir aquí, ya que este es un proceso que refleja la entrada. De hecho, podríamos combinar las fábricas de lectura y escritura en una sola DoubleArrayInputOutputFactory, como esta:

public interface IDoubleArrayWriter
{
  void WriteDoublesArray(IEnumerable<double> doubles);

  DoubleArrayWriterType Type {get;}
}

public enum DoubleArrayWriterType
{
  Console,
  File,
  Internet,
  Cloud,
  MockService,
  Database
}

public class ConsoleDoubleArrayWriter : IDoubleArrayWriter
{
    void IDoubleArrayWriter.WriteDoublesArray(IEnumerable<double> doubles)
    {
      foreach(double @double in doubles)
      {
        Console.WriteLine(@double);
      }
    }

    DoubleArrayWriterType IDoubleArrayWriter.Type 
    {
      get
      {
        return DoubleArrayWriterType.Console;
      }
    }
}


public static class DoubleArrayInputOutputFactory
{
  private static Dictionary<DoubleArrayReaderType, IDoubleArrayReader> readers;
  private static Dictionary<DoubleArrayWriterType, IDoubleArrayWriter> writers;

  static DoubleArrayInputOutputFactory()
  {
      readers = new Dictionary<DoubleArrayReaderType, IDoubleArrayReader>();
      writers = new Dictionary<DoubleArrayWriterType, IDoubleArrayWriter>();
      foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
      {
        try
        {
          var instance = Activator.CreateInstance(type);
          if (instance is IDoubleArrayReader)
          {
            readers.Add((instance as IDoubleArrayReader).Type, (instance as IDoubleArrayReader));
          }
        }
        catch
        {
          continue;
        }
      }

      foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
      {
        try
        {
          var instance = Activator.CreateInstance(type);
          if (instance is IDoubleArrayWriter)
          {
            writers.Add((instance as IDoubleArrayWriter).Type, (instance as IDoubleArrayWriter));
          }
        }
        catch
        {
          continue;
        }
      }

  }

  public static IDoubleArrayReader CreateDoubleArrayReader(DoubleArrayReaderType type)
  {
    return readers[type];
  }

  public static IDoubleArrayWriter CreateDoubleArrayWriter(DoubleArrayWriterType type)
  {
    return writers[type];
  }

}

Poniendolo todo junto

Finalmente, nuestro programa principal solo usará toda esta genialidad que ya hemos construido, por lo que el código será:

var doubles = reader.GetDoubles();
doubles = processor.ProcessDoubles(doubles);
writer.WriteDoublesArray(doubles);

donde, por ejemplo, podríamos definir reader, writery processorusando

IDoubleArrayReader reader = DoubleArrayInputOutputFactory.CreateDoubleArrayReader(DoubleArrayReaderType.MockService);
IDoubleArrayProcessor processor = DoubleArrayProcessorFactory.CreateDoubleArrayProcessor(DoubleArrayProcessorType.Sorter);
IDoubleArrayWriter writer = DoubleArrayInputOutputFactory.CreateDoubleArrayWriter(DoubleArrayWriterType.Console);
SWeko
fuente
49
Lol, listaOrdenar Enterprise Edition © :-P 1
Pomo
14
+1 por sobrecodificación loca. Le sugiero que divida su respuesta en 3 o más respuestas de 'módulo' para que pueda hacer +1 individualmente
greggo
15
Y lo mejor de todo es que en realidad está usando un tipo de biblioteca :) Es completamente a la especificación, y completamente inútil
SWeko
99
Eso fue hermoso.
Andrew
77
Usar DI solo confundirá al OP, ya que este es solo un ejemplo rápido.
SWeko
132

Aún más interpretación literal:

echo " aaehrrty"

es decir, "la matriz" ordenada.

RBerteig
fuente
55
Vine aquí para publicar esto.
Quuxplusone
55
guardar como archivo sort.shy llamar comosh sort.sh "an array of doubles"
Kyss Tao
Creo que te perdiste el "el usuario ingresa una matriz de dobles".
Dukeling
1
@Dukeling ese es el punto del comentario de Kyss Tao. "an array of doubles"se puede pasar al script como un argumento de línea de comandos.
AJMansfield
108

Perl

De todas las cosas que he hecho para CodeGolf.SE, esto probablemente tomó más tiempo, al menos unas horas.

$_[0]=eval<>;
for(0..$#{$_[0]}**2){
 @_[$#_+1]=[\(@{$_[$#_]}),$#{$_[$#_]}+1];
 for(1..$#{$_[$#_]}-$#_){
  if(eval('${'x$#_.'@{$_[$#_]}[$_-1]'.'}'x$#_)>eval('${'x$#_.'@{$_[$#_]}[$_]'.'}'x$#_)){
   ${$_[$#_]}[$#{$_[$#_]}]=$_;
  }
 }
 (${$_[$#_]}[${$_[$#_]}[$#{$_[$#_]}]-1],${$_[$#_]}[${$_[$#_]}[$#{$_[$#_]}]])=(${$_[$#_]}[${$_[$#_]}[$#{$_[$#_]}]],${$_[$#_]}[${$_[$#_]}[$#{$_[$#_]}]-1]);
}
for(0..~~@{$_[0]}){
 $\.=eval('${'x$#_.'${$_[$#_]}[$_-1]'.'}'x$#_).','
}
$\=~s/,*$//;$\=~s/^,*//;$\="[$\]";
print;

La entrada es de la forma [2,4,5,7,7,3]y la salida es de la forma [2,3,4,5,7,7].

No tengo tiempo para explicarte ahora ... vuelvo más tarde.

De todos modos, hay algo llamado una matriz anónima en Perl. Es una matriz, pero no tiene nombre. Lo que sí sabemos, sin embargo, es una referencia (ubicación de memoria) que apunta a ella. Una serie de números entre corchetes crea una matriz anónima y le devuelve una referencia.

Esta respuesta se basa en una serie de matrices anónimas, cuyas referencias se almacenan en @_. La entrada se convierte en una matriz anónima. Luego creamos otras matrices anónimas, cada elemento de las cuales es una referencia a un elemento en la matriz anterior. En lugar de ordenar los elementos en la matriz, clasificamos los punteros a los elementos en esa matriz. Además, creamos una nueva matriz para cada paso (y más) en la operación de clasificación.

PhiNotPi
fuente
3
¡mal! ¡mal! ¡mal!
DGM
56
casi tan descifrable como cualquier otro script de Perl para mí :)
Corey Goldberg
66
@swelljoe En realidad, $_es una cadena vacía en ese punto. Almacené mi salida deseada en $\ , que es el separador de registro de salida.
PhiNotPi
44
@Andy simple. "¿Como funciona?"
John Dvorak
1
y todas las variables creadas por el usuario tienen nombres bonitos que siguen todas las convenciones imaginables
Hagen von Eitzen
80

Pitón

Proporciona al usuario una matriz ordenada al eliminar todos los elementos que no están ordenados de la matriz de entrada.

import sys

sorted = []
for number in map(float, sys.stdin.read().split()):
    if not sorted or number >= sorted[-1]:
         sorted.append(number)
print sorted 

El algoritmo pasa por la lista solo agregando cada elemento si no hace que la lista no esté ordenada. Por lo tanto, la salida es una lista ordenada, pero no una que contenga todos los elementos de la lista original. Si la operación solo comprueba si la lista está ordenada, es posible que no note que a la salida le faltan valores.

Winston Ewert
fuente
1
Consulte otras respuestas antes de publicar la suya. Debe agregar el nombre de su idioma. Para responder a esta pregunta, también debe explicar brevemente lo que está haciendo para controlar el OP.
Wasi
55
Jeje, este realmente me hizo reír a carcajadas. De todos modos, estoy de acuerdo en que sería útil una explicación un poco mejor.
oconnor0
2
¿Es la doble llamada a sys.stdin.read()un error tipográfico o parte de la verdadera respuesta de trolling? Seguramente frustraría al OP dar la matriz como entrada y continuar esperando el resultado ...
Bakuriu
Wow, eso es malo, de acuerdo.
Sylverdrag
13
Un O(n)algoritmo de ordenación. Agradable.
ejrb
65

Bash, 54 caracteres

Muchas respuestas usando lenguajes lentos e ineficientes como C y Python ... aceleremos un poco las cosas ofreciendo una solución en la madre de todos los lenguajes de script: Bash.

Sé lo que estás pensando: Bash ni siquiera puede manejar la aritmética de coma flotante, entonces, ¿cómo va a ordenar, verdad? Bueno, he aquí, mi implementación del poderoso algoritmo SleepSort:

#!/bin/bash

for i in $@; do echo -n $(sleep $i)$i' '& done
echo "Leveraging the power of your $(grep -c ^processor /proc/cpuinfo) cores to \
sort optimally by spawning $(jobs -l | wc -l) concurrent sorting threads..."
wait
echo -e "\nThe array sorted."

El programa se proporciona con entrada como argumentos de línea de comandos. Ejecución de muestra:

> ./sleepsort.sh 7 1 4 3 2.752 6.9 0.01 0.02
Leveraging the power of your 4 cores to optimally by spawning 8 concurrent sorting threads...
0.01 0.02 1 2.752 3 4 6.9 7
The array sorted.

Esto también tiene la ventaja de ser quizás el más corto de todos los algoritmos de trabajo presentados aquí. Así es: una línea poderosa de bash , que usa solo bash builtins y no llama a ningún binario externo (es decir, si no cuenta la salida detallada puramente opcional). A diferencia de los bogosorts, su tiempo de ejecución es determinista.

Consejo: Una optimización efectiva es dividir los números de entrada por un factor antes de ordenar. La implementación se deja al lector.

Editar:

Versión de golf de 54 caracteres acortada con una impresión menos bonita:

#!/bin/sh
for i in $@;do echo $(sleep $i)$i&done;wait
Alboroto
fuente
11
Trolling 1: el algoritmo funciona, pero obviamente es extremadamente lento: genera un hilo para cada número, durmiendo durante ese número de segundos antes de emitir el número (lo que está en orden). Trolling 2: además, la mayor parte del código se gasta en escribir un buen comentario sobre cuántos subprocesos genera, y lee y analiza innecesaria y gratuitamente la información de la CPU del sistema solo por el bien de una salida detallada adicional. Trolling 3: genera "la matriz ordenada" al final, que parece ser lo que se ha hecho. Trolling 4: el usuario no puede cancelar el "ordenar" presionando ctrl-c.
Riot
44
5. Solo funciona en GNU / Linux , debido al uso de /proc/cpuinfo.
kps11346
55
Solución extremadamente creativa, por cierto :)
dmitry
8
Esto es increíble. Ni siquiera puedo expresar lo increíble que es eso. Estoy considerando usar eso activamente, porque POR QUÉ NO.
44
En realidad, realmente tengo una variante de esto en uso en la producción en alguna parte. Pero en esa situación, el tiempo de ejecución del proceso es importante, así que esa es mi excusa ...
Riot
64

JavaScript tiene una sort()función incorporada, puede usarlo así:

var numbers = [6, 2.7, 8];
numbers.sort();
// => [2.7, 6, 8]

... oh, olvidé por completo mencionarlo, se ordena en orden lexicográfico, es decir, 10 < 9y 9 < -100. Probablemente eso es lo que esperas de todos modos.

Alexey Lebedev
fuente
8
Eso es aún mejor porque es una función incorporada.
Wayne Werner
62

(jPL) Lenguaje de programación jQuery

Usted debe usar jQuery para eso. Una solución simple a este problema es la siguiente:

function jSort() {
    var a = 0.0; // position 1
    var b = 0.0; // position 2
    var c = 0.0; // position 3

    var arr = [];
    var nArr = [];

    // don't forget to validate our array!
    if (window.prompt("You must only type double values. Type 1 if you accept the terms.") != 1) {
        alert("You can't do that.");
        return;
    }

    for (var i = 0; i < 3; i++) {
        if (i == 0) {
            var a = window.prompt("Type a double value");
            arr.push(a);
        }
        if (i == 1) {
            var b = window.prompt("Type a double value");
            arr.push(b);
        }
        if (i == 2) {
            var c = window.prompt("Type a double value");
            arr.push(c);
        }
    }

    // Now the tricky part
    var b1 = false;
    var b2 = false;
    var b3 = false;
    for (var i = 0 ; i < 3; i++) {
        // check if the variable value is the same value of the same variable which now is inside the array
        if (i == 0) {
            if (a == arr[i]) {
                b1 = true;
            }
        }

        if (i == 1) {
            if (b == arr[i]) {
                b2 = true;
            }
        }

        if (i == 2) {
            if (c == arr[i]) {
                b3 = true;
            }
        }
    }

    if (b1 == true && b2 == true && b3 == true) {
        if (arr[0] > arr[1]) {
            if (arr[0] > arr[2]) {
                nArr.push(arr[0]);
            } else {
                nArr.push(arr[2]);
            }
        }

        if (arr[1] > arr[0]) {
            if (arr[1] > arr[2]) {
                nArr.push(arr[1]);
            }
            else {
                nArr.push(arr[2]);
            }
        }

        if (arr[2] > arr[0]) {
            if (arr[2] > arr[1]) {
                nArr.push(arr[2]);
            } else {
                nArr.push(arr[1]);
            }
        }

        console.log(arr.sort(function (a, b) { return a - b }));
        alert(arr.sort(function (a, b) { return a - b }));
    }
}

jSort();
Felipe Miosso
fuente
55
Particularmente me gusta cómo esto realmente no usa jQuery.
KRyan
8
-1 El nombre de su matriz debe incluir la notación húngara en él, específicamente los objetos jQuery significados usando $, las matrices usando ay los resultados de window.promptas p.
Qantas 94 Heavy
2
La "parte difícil" es elegante. OP, esforzarse por tener ese tipo de estructura de código algún día.
Chris Barker
2
Que F'n doble "validación" LOOOOOOOOOOOOL omg omg día hecho! editado por menos gorras
HC_
54

C

Esta solución combina la concisión y el acceso a nivel de sistema operativo proporcionado por C con los componentes de software potentes y reutilizables en GNU / Linux:

#include <stdlib.h>

main(int argc, char **argv)
{
    system("echo Enter numbers one per line, ending with ctrl-D; sort -g");
}
Mark Plotnick
fuente
44
O un "guión": #!/usr/bin/sort.
Caracol mecánico el
54

Rubí

print "Input an array of doubles: "
gets
puts "the array sorted."

Bastante autoexplicativo.

O requiera que la entrada sea en realidad "una matriz de dobles":

print "Input an array of doubles: "
g = gets until /an array of doubles\n/
puts "the array sorted."

No usar gets.chomppara maldad extra. ¡También uso regex después de seguir hasta que es algo que ni siquiera sabía que podías hacer (gracias Jan Dvorak) para confundir aún más a OP!

Pomo de la puerta
fuente
44
Ampliando la idea, pediría repetidamente entrada hasta que el usuario ingrese la cadena an array of doubles.
Wrzlprmft
@Wrz Ok, hecho :-)
Pomo
2
Eso es muy bueno porque el OP pobre tendrá que descubrir cómo deshacerse de una nueva línea (porque la usas en getslugar de gets.chomp).
wchargin
@WChargin Sí, tuve eso en la primera revisión (ver el historial de revisiones) pero lo eliminé para que sea aún más malvado>: D EDIT: Oh, espera, no importa, esa fue mi otra respuesta. Editaré este :-)
Pomo de la puerta
1
+1 Creé una cuenta aquí solo para decir, ¡así es exactamente como la respondería! ¡Quiéralo!
DGM
44

Python3.3

Claro, aquí está el programa Python más simple que puede ordenar una matriz dada como un literal de lista en stdin:

collections = __import__(dir(object.__subclasses__()[7])[1][4:-3] + chr(116))

URL = ('https://www.google.com/search?client=ubuntu&channel=fs&q=dante+alighieri'
      '%27s+divina+commedia&ie=utf-8&oe=utf-8#channel=fs&q=__++divina+commedia+'
      'dante+alighieri+inferno+__').translate(
          dict.fromkeys(map(ord, '+-.:,;bcdefghjklopqrstuvwxyz/&=#?%')))[30:]
SECRET_KEY = URL[2:10][::-1][3:-1]
DATA = '{}{}{}'.format(URL[:2], SECRET_KEY[:2] + SECRET_KEY[:-3:-1], URL[-2:])



if getattr(DATA, dir(list)[7])(__name__):
    pieces = 'literally - evil'.split(' - ')
    r = getattr(collections, 
                '_'.join([pieces[0][:-2],
                          pieces[1].translate({ord('j')-1: 'a'})])
                )((getattr(globals()['__{}__'.format('buildings'.translate(
                        {100:'t', 103:None}))], 'in' r"put"))
                  ())
    tuple((lambda lst:
           (yield from map(list,
                           map(lambda k: (yield from k), 
                               ((lambda i: (yield from map(lambda t:
                                             (lst.append(lst[i]) or
                                              lst.__setitem__(i, lst[t]) or
                                              lst.__setitem__(t, lst.pop())),
                                              (j for j in range(i)
                                                if (lambda: lst[i] < lst[j])())
                                              ))
                                )(è) for è in range(
                                                getattr(lst,
                                                        dir(lst)[19])()))))
          )
        )(r))
    print(r)

Desafortunadamente, solo funciona en python3.3 + ya que usa la yield fromexpresión. El código debe explicarse por sí mismo, por lo que no debería tener ningún problema al entregarlo a su profesor.


El trolling consiste en proporcionar una solución que funcione perfectamente y que haga exactamente lo que pretendía el OP, pero de una manera que es:

  • imposible de entender (por un principiante)
  • imposible de manejar con el maestro porque:
    • el OP no puede entenderlo
    • incluso si pudiera, el maestro no tendría tiempo de descifrar para entenderlo
  • da miedo a un novato ingenuo que podría pensar que la programación es demasiado difícil para él

En resumen, esta respuesta aumentaría en gran medida la frustración del estudiante burlándose de sus solicitudes con respuestas perfectamente válidas desde un cierto punto de vista.


(No lea si considera un desafío comprender el código anterior)

Debo agregar que el trolling también se incrementa por el hecho de que el algoritmo de clasificación implementado es realmente

¡ordenamiento de burbuja! ... que seguramente podría implementarse de una manera que incluso el OP podría entender. No es un algoritmo oscuro per se, solo un buen código de ofuscación de algo que el OP podría entender perfectamente.

Bakuriu
fuente
3
Creo que esto podría usar más explicaciones; ¿Qué le estás haciendo al Infierno ahora?
KRyan
1
Wow, ¿puedes hacer nombres de variables no ascii en python? no sabía ...
kratenko
1
@kratenko De python3 +. En python2, el intérprete asume ASCII como codificación y habría provocado un error. En python3, el intérprete asume UTF-8 como codificación y acepta todos los caracteres que son "letras" por propiedades unicode para identificadores.
Bakuriu
3
@KRyan: Obviamente está empleando el método de clasificación que Hell usa para atraer a las personas a los nueve círculos.
Joe Z.
10
Oh Dios mío ... +1 para è.
Sean Allred
41

C: estilo de codificación lento, difícil de usar e inaceptable

El algoritmo de clasificación en sí se conoce como slowsort y tiene una mejor complejidad de caso (simplexidad) de alrededor de n ^ (log n / 2) . El algoritmo ha sido publicado por Andrei Broder y Jorge Stolfi en su gran artículo "Algoritmos pesimistas y análisis de simplexidad", que recomiendo para las buenas risas Y para pensar.

void sort(double* arr, int n, int i, int j)
{
        if(i < j) {
                int m = (i+j)/2;
                sort(arr, n, i  , m);
                sort(arr, n, m+1, n);
                if(arr[m] > arr[j]) {
                        double t = arr[j];
                        arr[j] = arr[m];
                        arr[m] = t;
                }
                sort(arr, n, i, j-1);
        }
}

Sin embargo, la clasificación en sí misma es inútil, por lo que necesitamos una forma para que el usuario ingrese los datos que desea ordenar. Analizar los dobles es dolor, así que ¿por qué no ingresarlos byte por byte?

const unsigned MAX_ELEMS = 100;
int main()
{
        int i=0, j=0, len;
        char a[MAX_ELEMS*8];
        double* arr = (double*) a;
        short isNull=1;

        while(1) {
                a[i++] = getchar();
                if(i%8 == 0) {
                        if(isNull)
                                break;
                        isNull = 1;
                }
                else if(a[i-1] != 0)
                        isNull = 0;
        }

        len=i/8 - 1;

        sort(arr, len-1, 0, len-1);

        for(i = 0; i < len; i++)
        {
                printf("%f ", arr[i]);
        }
}

Para demostrar que funciona:

 $ gcc -g trollsort.c -o trollsort
trollsort.c: In function ‘main’:
trollsort.c:43:3: warning: incompatible implicit declaration of built-in function ‘printf’
 $ echo -en "\0\0\0\0\0\xe4\x94\x40\0\0\0\0\0\0\xf0\x3f\0\0\0\0\0\0\x45\x40\0\0\0\0\0\0\0\0" | ./trollsort
1.000000 42.000000 1337.000000

Al final tenemos:

  • El algoritmo de clasificación determinista más lento que conozco
  • Límites silenciosos codificados en la longitud de la lista
  • Entrada absolutamente horrible, también podría hacer que la salida sea similar, pero creo que es más divertido de esta manera.
    • Considere: necesitará saber qué endianess tiene su máquina para usar el programa.
    • Además, no puede ingresar 0 (-0 está bien)
  • Aritmética de punteros y prácticamente sin preocupación por los tipos, ya que los punteros se lanzan de cualquier manera
shiona
fuente
Esto tiene un comportamiento indefinido para todas las entradas mayores de 7 bytes. No es una respuesta aceptable.
Michael Spencer
1
Me encanta el papel de "Algoritmos pesimales"; Gracias.
Ryan
"El algoritmo de clasificación determinista más lento que conozco": el algoritmo de clasificación determinista probablemente más lento. Ese es el objetivo del artículo, AFAIR.
Konrad Rudolph
@MichaelSpencer ¿Cuidado para elaborar? Di un ejemplo con un tamaño de entrada de 24 bytes y la salida es lo que uno esperaría (creo que podría estar perdiendo una broma aquí).
shiona
2
@Sasho pero un tipo bogo tiene el mejor tiempo de ejecución de \ Omega (n) (n-1 comparaciones, 0 operaciones). Eso es mucho más rápido, alias. peor que \ Omega (n ^ (log n / 2)).
shiona
39

Ruby, malvado Bogosort! (Bonificación: bogosort por entrada del usuario)

print "Input array of doubles, separated by commas: "
arr = gets.split(",")
arr.shuffle! until arr.each_cons(2).all? {|x| x[0] < x[1]}
puts arr * ","

Los giros "malvados":

  • corre muy muy muy muy muy muy muy lentamente, por supuesto
  • usa la comparación de cadenas, por lo que 10 es menor que 2. Se puede arreglar fácilmente con el .map &:to_fagregado a la segunda línea, pero OP podría no saber que
  • no se usa chompasí que el último número tiene una nueva línea misteriosa al final
  • no se usa, por striplo que hay un misterioso espacio en blanco alrededor de los números si se ingresa con espacios entre comas (por ejemplo, el espacio en 1.5, 2)

O, ¿qué tal bogosorting por entrada del usuario ? >: D

print "Input array of doubles, separated by commas: "
arr = gets.split(",")
arr.shuffle! until arr.each_cons(2).all? {|x|
    print "Is #{x[0]} less than #{x[1]}? (y/n) "
    gets =~ /y/
}
puts arr * ","
Pomo de la puerta
fuente
¿Por qué no bogobogosort ? (se ejecuta en un pintoresco tiempo O (n * (n!) ^ n))
wchargin
@Wchargin Puedo considerarlo :-) ¡te puede interesar mi reciente edición! (Perdón por ser lento, en realidad estoy en mi teléfono ahora mismo ya que no puedo acceder a una computadora :-P)
Pomo de la puerta
37

COBOL

¡Seguro! "¡Incluso un mono puede hacer esto!"

Aquí hay un programa COBOL simple que clasificará la entrada por usted. Lea los comentarios para ver exactamente qué tan trivial y extensible es. Los beneficios reales de esto son que es un mecanismo probado y verdadero, no se basa en lenguajes nuevos y relativamente no probados como Java y nada basado en la web o de Microsoft. Se compila de manera realmente efectiva, y las compañías financieras más exitosas de Fortune500 y otros líderes de la industria utilizan procedimientos como este. Este código ha sido revisado por muchos expertos y es reconocido como un excelente mecanismo de clasificación.

000100 IDENTIFICATION DIVISION.
000200* Cobol sort. Consistent with COBOL 390
000300* does not use sections; does not use go to
000400* uses sort procedures
000500* does a sort with some minimal input validation
000600* since everything is done in an orderly way,
000700* you can easily add code of your own to this program
000800 PROGRAM-ID. 'SORTEX1'.
000900 ENVIRONMENT DIVISION.
001000 CONFIGURATION SECTION.
001100 INPUT-OUTPUT SECTION.
001200 FILE-CONTROL.
001300*    INPUT FILE UNSORTED
001400     SELECT UNSORTED-FILE ASSIGN UNSORTED.
001500*    The work file for the sort utility
001600*    you need the select and an sd but do not need jcl for it
001700     SELECT SORT-WORK      ASSIGN      SORTWORK.
001800*    output file normally a disk/tape file
001900*    for this program, send it to the printer
002000     SELECT SORTED-FILE ASSIGN SORTED.
002100*
002200 DATA DIVISION.
002300 FILE SECTION.
002400*
002500 FD  UNSORTED-FILE
002600     RECORDING MODE IS F
002900     RECORD CONTAINS  80 CHARACTERS.
003000
003100 01  UNSORTED-RECORD.
003200     05  WS-UR-ACCT-NO        PIC X(5).
003300     05  FILLER               PIC X(5).
003400     05  WS-UR-AMOUNT         PIC 9(5).
003500     05  WS-UR-CUST-NAME      PIC X(10).
003600     05  FILLER               PIC X(5).
003700     05  WS-UR-TRANS-CODE     PIC X(1).
003800     05  FILLER               PIC X(49).
003900
004000  SD  SORT-WORK
004400      RECORD CONTAINS  80 CHARACTERS.
004500*
004600 01  SORT-WORK-RECORD.
004700*    You need a definition and picture for
004800*    the field that is sorted on (sort key)
004900     05  SW-ACCT-NO    PIC X(05).
005000*    YOU NEED A FILLER TO COMPLETE THE DEFINITION
005100     05  FILLER        PIC X(75).
005200*
005300 FD  SORTED-FILE
005400     RECORDING MODE IS F
005700     RECORD CONTAINS  80 CHARACTERS.
005800*
005900 01  SORTED-RECORD.
006000     05  WS-SR-ACCT-NO        PIC X(05).
006100     05  FILLER               PIC X(05).
006200     05  WS-SR-AMOUNT         PIC 9(05).
006300     05  WS-SR-CUST-NAME      PIC X(10).
006400     05  FILLER               PIC X(55).
006500
006600 WORKING-STORAGE SECTION.
006700 01  SWITCHES.
006800     05  UNSORTED-FILE-AT-END      PIC X   VALUE 'N'.
006900     05  SORT-WORK-AT-END          PIC X   VALUE 'N'.
007000     05  valid-sw                  PIC X   VALUE 'N'.
007100
007200 01  COUNTERS.
007300      05 RELEASED-COUNTER PIC S9(7)
007400                PACKED-DECIMAL VALUE +0.
007500      05 REJECT-COUNTER   PIC S9(7)
007600                PACKED-DECIMAL VALUE +0.
007700
007800 PROCEDURE DIVISION.
007900     PERFORM INITIALIZATION
008000*    Compare this logic to that of the simple program
008100*    notice how the sort verb replaces the
008200*    perform main until end of file etc
008300     SORT SORT-work ASCENDING KEY SW-ACCT-NO
008400         INPUT PROCEDURE SORT-INPUT
008500         OUTPUT PROCEDURE SORT-OUTPUT
008600     PERFORM      TERMINATION
008700     GOBACK.
008800
008900 INITIALIZATION.
009000*    Do what you normally do in initialization
009100*    open the regular input file (not the sort work file)
009200*    and other files needed
009300*    (you could open them in the sort input procedure, too)
009400     OPEN INPUT UNSORTED-FILE
009500          output SORTED-FILE
009600*    READ THE FIRST RECORD ON THE REGULAR INPUT FILE
009700     PERFORM READ-IT.
009800*    Whatever else you do in initialization
009900*    headers, initialize counters, etc
010000
010100 TERMINATION.
010200*    Do what you normally do in termination
010300*    print out total lines
010400*    close the files you opened
010500*    display totals
010600     CLOSE UNSORTED-FILE
010700           SORTED-FILE.
010800
010900 READ-IT.
011000     READ UNSORTED-FILE
011100     AT END MOVE 'Y' TO UNSORTED-FILE-AT-END
011200     END-READ.
011300
011400 SORT-INPUT.
011500*    This is the 'sort input procedure'
011600*    when control passes thru the last statement in it
011700*    the input phase of the sort is finished
011800*    and actual sorting takes place
011900     PERFORM SORT-INPUT-PROCESS-ALL
012000        UNTIL UNSORTED-FILE-AT-END = 'Y'.
012100
012200  SORT-INPUT-PROCESS-ALL.
012300*  This is the point when you have each unsorted input record
012400*  in your hands
012500*  many programs do some validation or selection here
012600*  to determine which records are actually given to the sort util
012700*  we will do some simple validation here
012800     MOVE 'Y' TO VALID-SW
012900     PERFORM SORT-INPUT-VALIDATE
013000     IF VALID-SW = 'Y'
013100     THEN
013200**       Give the unsorted input record to the sort utility
013300         RELEASE SORT-work-RECord FROM unsorted-RECORD
013400         ADD 1 TO RELEASED-COUNTER
013500     ELSE
013600**       Here, you have decided not to give the unsorted input
013700**       record to the sort utility
013800         ADD 1 TO REJECT-COUNTER
013900     END-IF
014000     PERFORM READ-IT.
014100
014200 SORT-INPUT-VALIDATE.
014300*    Check the regular input record for validity.
014400*    if it is not suitable for sorting, set the valid sw
014500*    other validation criteria would apply for other files
014600     IF WS-UR-ACCT-NO IS equal to spaces
014700        THEN MOVE 'N' TO VALID-SW
014800     END-IF.
014900
015000 SORT-OUTPUT.
015100*    This is the 'sort output procedure'
015200*    when control passes thru the last statement in it
015300*    the output phase of the sort is finished
015400*    you have seen (returned) the last sorted record
015500*    and the sort utility is finished
015600     PERFORM RETURN-IT
015700     PERFORM SORT-OUTPUT-PROCESS-ALL
015800         UNTIL SORT-WORK-AT-END = 'Y'.
015900
016000 RETURN-IT.
016100*    Gets each sorted record from the sort utility
016200*    return is logically like a read
016300      RETURN SORT-work
016400         AT END MOVE 'Y' TO SORT-work-AT-END
016500      END-RETURN.
016600
016700 SORT-OUTPUT-PROCESS-ALL.
016800      PERFORM SORT-OUTPUT-PROCESSING
016900      PERFORM RETURN-IT.
017100 SORT-OUTPUT-PROCESSING.
017200* Here you do the things you do in a
017300* regular program's main processing routine
017400* add totals, compute things
017500* write detail records, print lines, etc
017600* you could put control break check here
017700* this program just and writes the record out to "sorted file"
017900     MOVE SORT-WORK-RECORD TO SORTED-RECORD
018100     WRITE SORTED-RECORD.
rolfl
fuente
66
Solo usted usaría COBOL para responder a esta pregunta. +1
syb0rg
55
Ah, el olor fresco de las tarjetas perforadas
Sklivvz
3
@EbenezerSklivvze - LOL. Una vez saqué una tarjeta perforada que estaba usando como marcador cuando mi profesor de la universidad de la Asamblea le estaba contando a la clase sobre tarjetas perforadas antiguas. Tenía el piso suficiente (fue en 1994 :). No creo que muchos de mis contemporáneos hayan visto una baraja completa ...
DVK
30

OP nunca dijo CÓMO ordenarlos ... o cuál es su definición de dobles. Asumiendo el tipo de datos doublepero interpretándolo como duplicados . Usando JavaScript aquí.

var arr = [4, 6, 7, 4, 5, 9, 11, 7],
    flag = 1,
    result = [];

while( arr.length ) {
  for( var i = 0, index = 0; i < arr.length; ++i ) {
    if( arr[i] * flag < arr[index] * flag ) {
      console.log(arr[i], arr[index]);
      index = i;
    }
  }
  arr.splice(index, 1);
  flag = -flag;
}

Resultado: orden alterna [4, 11, 4, 9, 5, 7, 6, 7]

Kiruse
fuente
44
"Asumiendo el tipo de datos doble pero interpretándolo como duplicados". Solo un verdadero genio pensaría de esa manera. ¡Sólo brillante!
Felipe Miosso
@FelipeMiosso Para ser honesto, no estoy seguro si solo estás siendo sarcástico ...
Kiruse
1
Jaja ... estaba siendo sarcástico. Sé que hay personas que realmente piensan de esa manera. De todos modos ... ¡tu respuesta fue épica! Me reí mucho.
Felipe Miosso
@FelipeMiosso Me alegra haber podido ayudar a hacer reír. ;)
Kiruse
console.log todo!
Emil Vikström
28

PHP

Aquí hay una implementación completa con manejo de errores. Es el más rápido para cualquiera array of doubles.

<?php
  function arraySorter($arr) {
      foreach ($arr as $el) {
          if ($el != 'double') {
              throw new Exception('Unexpected Error: Invalid array!');
          }
      }
      return $arr;
  }

  $arrayOfDoubles = Array('double', 'double', 'double', 'double', 'double');
  var_dump(arraySorter($arrayOfDoubles));
?>
totymedli
fuente
25
do
{
}
while(next_permutation(begin(ar), end(ar)));

La siguiente permutación en C ++ funciona devolviendo verdadero cuando la matriz está ordenada y falsa de lo contrario (después de permutar). Por lo tanto, se supone que debe ordenar la matriz y luego usarla en un do-while como se indicó anteriormente (por lo que hará un círculo completo de regreso a la matriz ordenada).

usuario974006
fuente
+1 Pensé en usar next_permutationpara mi respuesta, pero esto es mucho más limpio de lo que tenía en mente.
jliv902
25

[solución por mala dirección puntillosa]

Lea la norma pertinente, IEC 60559: 1989, Especificación para aritmética de coma flotante binaria para sistemas de microprocesador , que puede comprar aquí . En la nota al pie de página §5.10 Detalles del predicado totalOrder , se observa que:

totalOrder no impone un orden total en todas las codificaciones en un formato. En particular, no distingue entre diferentes codificaciones de la misma representación de punto flotante, como cuando una o ambas codificaciones no son canónicas.

Por lo tanto, vemos que es imposible escribir código para ordenar los dobles. Es una pregunta capciosa. ¡Ja, ja, muy listo! Dígale a su profesor que estoy disfrutando mucho su curso.

[editar: nada me obliga a no asumir que el problema exige un pedido total]

kps11346
fuente
3
Pero el problema era ordenar los dobles. Nadie requirió que los valores estuvieran en orden (total). Por ejemplo, podría ordenar la matriz en dos números, positivo y negativo. La pregunta te engañó dos veces.
shiona
23

Un malvado JavaScript:

OP, no quiero darte todo, así que te dejaré descubrir cómo obtener la entrada del usuario por tu cuenta (pista: uso prompt).

Una vez que tenga eso, aquí hay una función en la que puede pasar su matriz para ordenarla. Solo necesita proporcionar la matriz, el valor más bajo en la matriz y un incremento:

var sortDoubles = function (unsortedArray, minimumVal, increment) {
    var sortedArray = [];

    while (unsortedArray.length != sortedArray.length) {
        var index = unsortedArray.indexOf(minimumVal);
        if (index != -1) {
            sortedArray.push(unsortedArray[index]);
        }

        minimumVal += increment;
    }

    return sortedArray;
};

Aquí hay un violín para verlo en acción con el ejemplo de entrada del usuario [1.5, -3.5, 12, 10, -19.5].


Nota: además de ser de bajo rendimiento, complejo e inextensible para el problema en cuestión, esto será especialmente frustrante si el OP no sabe acerca de las matemáticas de coma flotante. Por ejemplo, si la entrada del usuario es [8.1, 5, -.8, 2.3, 5.6, 17.9]y el OP elige los valores directos (es decir, minimumVal=-.8y increment=.1), el programa se ejecutará para siempre. En una nota relacionada, actualmente soy el orgulloso propietario de 2 pestañas del navegador que no funcionan debido a este mismo problema :)

Nota II: me sentí asqueroso incluso al escribir el código anterior.

Nota III: MWA HAHAHAHA!

Briguy37
fuente
Buena idea. Debes haber sido genial cuando aún eras un novato en programación.
Pierre Arlaud
22

Aquí hay una respuesta real que me gusta para Java:

Agregue la línea antes de println y su matriz se ordenará

Arrays.sort( array );

Sin explicación, confunde el OP , pero funciona y obtendrá votos positivos de programadores más experimentados.


Otra respuesta similar :

Eche un vistazo a Arrays.sort ()

Indicar indirectamente al OP que haga su propia investigación mientras le da una respuesta vaga y correcta. Sin más investigación, el OP todavía está confundido . También me gusta que el enlace apunta a documentación anterior.

syb0rg
fuente
10
Esto es útil y, por lo tanto, merece un voto negativo.
emory
11
"Indicar indirectamente al OP que haga su propia investigación mientras le da una respuesta vaga y correcta" describe más o menos mi estilo de respuesta de StackOverflow: /
Corey Goldberg
77
"Eche un vistazo a Arrays.sort ()" ... "¿Podría obtener un ejemplo de cómo usarlo en mi programa?" ... brillante
SimonT
55
+1 especialmente porque nuestro humilde OP probablemente necesita escribir un tipo para una clase, haciendo que Array.sort () sea completamente inútil para él / ella.
Kevin
2
Ctrl + F -> "¿Podría obtener un ejemplo de cómo usarlo en mi programa?" = 3 resultados.
Qix
21

Algoritmo genético / método Monte Carlo para el problema de clasificación en JAVA

El problema de la clasificación es conocido por la ciencia de la computación desde hace mucho tiempo y se han encontrado muchas buenas soluciones. En los últimos años, ha habido grandes avances en la biocomputación y la observación de cómo la biología resuelve los problemas ha demostrado ser de gran ayuda para resolver problemas difíciles. Este algoritmo de clasificación toma la mejor de estas ideas para usarlas para resolver el problema de clasificación. La idea es bastante simple. Comienza con una matriz desordenada y descubre qué tan ordenado está esto. Le das una puntuación de su "clasificación" y luego permutas la matriz con un componente aleatorio, al igual que en biología, donde no está claro cómo se verán los niños, incluso si sabes todo sobre los padres. Esta es la parte del algoritmo genético. Creas la descendencia de esa matriz, por así decirlo. Luego verá si la descendencia está mejor clasificada que el progenitor (¡también conocida como supervivencia del más apto!). Si este es el caso, continúe con esta nueva matriz como punto de partida para construir la próxima permutación y así sucesivamente hasta que la matriz esté completamente ordenada. Lo bueno de este enfoque es que toma menos tiempo, ¡si la matriz ya está un poco ordenada desde el principio!

package testing;

import java.awt.List;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Random;

import org.joda.time.DateTime;
import org.joda.time.Interval;


public class MonteCarloSort {
    private static final Random RANDOM  = new Random();


    public static void main(String[] args) {


        List doubleList = new java.awt.List();

        //  prompt the user to enter numbers
        System.out.print("Enter a number or hit return to start sorting them!");


        //  open up standard input
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String input = null;

        //  read the numbers from the command-line; need to use try/catch !!!
        do{

            try {
                input = br.readLine();
            } catch (IOException ioe) {
                System.out.println("IO error trying to read a number!");
                System.exit(1);
            }


                try {
                    double d = Double.parseDouble(input);
                    doubleList.add(input);
                } catch (NumberFormatException e) {
                    if (!input.equals("")) System.out.println("Only numbers are allowed.");
                }

        } while (!input.equals(""));



        printCurrentListAndStuff(doubleList);

        while (isAscSorted(doubleList) < doubleList.getItemCount()){
            List newlist = createPermutation(doubleList);

            //genetic algorithm approach!
            if (isAscSorted(doubleList) <= isAscSorted(newlist)){
                //the new list is better, so we use it as starting point for the next iteration!
                doubleList = newlist;
                printCurrentListAndStuff(doubleList);

            }

        }

        System.out.println("done!");
    }

    private static void printCurrentListAndStuff(List doubleList){
        System.out.print("array sortedness is now " + isAscSorted(doubleList) + "(max = "+doubleList.getItemCount()+"): ");
        printList(doubleList);
        System.out.print("\n"); 
    }

    private static void printList(List doubleList){
        for (int i = 0; i < doubleList.getItemCount(); i++){
            String doubleVal = doubleList.getItem(i);
            System.out.print((i>0?", ":"") +doubleVal);
        }   
    }

    private static List createPermutation(List doubleList){
        int sortedness = isAscSorted(doubleList);
        if (sortedness == doubleList.getItemCount()) return doubleList;

        //we take the first non fitting item and exchange it by random
        int swapWith = RANDOM.nextInt(doubleList.getItemCount());

        //it makes no sense to swap with itself, so we exclude this
        while (swapWith == sortedness){
            swapWith = RANDOM.nextInt(doubleList.getItemCount());
        }

        List newList = new List();
        for (int i = 0; i < doubleList.getItemCount(); i++){
            if ( i == sortedness){
                newList.add(doubleList.getItem(swapWith));  
            }
            else if ( i == swapWith){
                newList.add(doubleList.getItem(sortedness));    
            }
            else{
                newList.add(doubleList.getItem(i));
            }

        }
        return newList;

    }

    /**
     * A clever method to get the "degree of sortedness" form a given array. the
     * bigger the number the more sorted it is. The given list is fully sorted if
     * the return value is the length of the list!
     * 
     * @param doubleList
     * @return a number
     */
    private static int isAscSorted(List doubleList){
        double current = Double.NEGATIVE_INFINITY;
        for (int i = 0; i < doubleList.getItemCount(); i++){
            String doubleVal = doubleList.getItem(i);
            if (Double.parseDouble(doubleVal) >= current){
                current = Double.parseDouble(doubleVal);
            }
            else{
                return i;
            }
        }
        return doubleList.getItemCount();
    }

}

Extras

  • Mal uso de java.awt.List
  • nomenclatura variable inconsistente y mala
  • completamente basura, bla, bla sobre biocomputación
  • lenguaje inventivo e inconsistente en la explicación
  • Monte Carlo es claramente la herramienta incorrecta para problemas deterministas directos
  • importaciones innecesarias
  • probablemente más golosinas ...
luksch
fuente
¿Llamar a este GA o Monte Carlo otro nivel de troll? Creo que este es un algoritmo aleatorio de escalada.
shiona
asociar este programa con nombres de palabras de moda fue intencional, pero tampoco escuché hablar del "algoritmo aleatorio de escalada" ... y en un sentido más amplio, creo que GA y Monte Carlo no están demasiado lejos para estar completamente equivocados ...
luksch
19

Pitón

a = map(float, raw_input().split())
print sorted(a, key=lambda x: int(x * 10**3) % 10 + int(x * 10**5) % 10)

Ordena la matriz (lista) por la suma de los 3 ° y 5 ° lugares decimales.

grc
fuente
55
Desafortunadamente, esto se arregla trivialmente eliminando todo después lambda x:y reemplazándolo por x. Aún así, un programador principiante nunca lo sabría, ¡así que felicitaciones!
Joe Z.
18

C ++

Esto funciona ... eventualmente.

Aquí está mi algoritmo de clasificación:

template <typename Iterator>
void sort (Iterator first, Iterator last)
{
    while (std::is_sorted (first, last) == false) {
        std::shuffle (first, last, std::random_device()) ;
    }
}

Aquí está el programa completo:

#include <algorithm>
#include <iostream>
#include <random>
#include <string>
#include <sstream>
#include <vector>

namespace professional 
{
    template <typename Iterator>
    void sort (Iterator first, Iterator last) ;

} // end of namespace professional

std::vector <double> get_doubles () ;

int main (void)
{
    std::vector <double> vecVals = get_doubles () ;
    professional::sort (std::begin (vecVals), std::end (vecVals)) ;

    for (const double d : vecVals) {
        std::cout << d << " " ;
    }

    std::cout << std::endl ;

    return 0 ;
}

template <typename Iterator>
void professional::sort (Iterator first, Iterator last)
{
    while (std::is_sorted (first, last) == false) {
        std::shuffle (first, last, std::random_device()) ;
    }
}

std::vector <double> get_doubles ()
{
    std::cout << "Please enter some space delimited doubles." << std::endl ;

    std::vector <double> vecVals ;

    std::string strLine ;
    std::getline (std::cin, strLine) ;

    std::stringstream ss (strLine) ;

    while (1) {
        double d = 0 ;
        ss >> d ;

        if (ss.bad () == false && ss.fail () == false) {
            vecVals.push_back (d) ;
        }

        else {
            break ;
        }
    }

    return vecVals ;
}
jliv902
fuente
66
Su especie de "algoritmo" me hizo llorar.
Nate
Ja, eso no es un algoritmo porque no está garantizado para terminar>: D
jmacedo
@joxnas, en realidad en sistemas donde no hay dispositivos aleatorios no deterministas disponibles, el aleatorizador en realidad puede ser periódico. Entonces, simplemente dependería de si el conjunto de permutaciones posibles permitidas por el aleatorizador subsume el conjunto de permutaciones posibles $ S_n $ para todas las posibles longitudes de matriz de entrada $ n $.
error
Aw pants, olvidé que LaTeX solo era compatible con TeX.SE y Math.SE. Solo imagine esos símbolos en cursiva snooty.
error
18

Aquí, deleita tus ojos:

<?php
if (isset($_POST["doubleArray"]) === true) {
    $doubleValues = explode(":", $_POST["doubleArray"]);
    if (is_numeric($_POST["smallestDouble"]))
    {
        $sorted = $_POST["sorted"] . ":" . $doubleValues[$_POST["smallestDouble"]];
        unset($doubleValues[$_POST["smallestDouble"]]);
        $doubleValues = array_values($doubleValues);        
    }

    if (count($doubleValues) > 0) {
        $i = 0;
        foreach ($doubleValues as $value) {
            echo $i . " : " . $value . "<br />";
            $i++;
        }
        echo "Type the index of the smallest double value in the list: ";
    } else {
        echo "Sorted values" . $sorted;
    }
}else {
       echo "Enter double values separated by a colon (:)";

}
?>

<form name="form1" method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>" >
<?php
if (!isset($doubleValues)) {
    echo '<input type="text" name="doubleArray" /><br>';
} else {
    echo '<input type="hidden" name="doubleArray" value="' .
    implode(":", $doubleValues) .
    '" ><input type="text" name="smallestDouble" /><br>'.
    '<input type="hidden" name="sorted" value="' . $sorted . '" >';
}
?>
    <input type="submit" value="Submit">
</form>

Este código muestra la matriz y le pide al usuario que ingrese el doble más pequeño de la matriz. Luego agrega el número a la lista de números ordenados, elimina el doble de la matriz y muestra los números restantes de la matriz.

* Interpretación errónea: punto débil, pero el OP no espera exactamente que el programa le pida al usuario que lo ayude a ordenar.

* Hacer trampa: el usuario es quien realiza la clasificación real.

* Rendimiento: cada número de la matriz requiere un viaje de ida y vuelta del servidor, y requiere que el usuario encuentre el número más pequeño manualmente. El rendimiento no puede empeorar mucho.

* Inaceptable: creo que tengo eso cubierto. Y buena suerte en reutilizarlo. Lo peor es lo peor, el usuario podría deshacerse del 90% del código y recorrer repetidamente para encontrar los valores más pequeños y eliminarlos cada vez, lo que le daría uno de los algoritmos de clasificación menos eficientes.

* Creativo y malvado: me cuentas.

Sylverdrag
fuente
2
Dices 'deleita tus ojos' y dame PHP Oo
Aidiakapi
3
El "mal" era parte de los requisitos, ¿no?
Sylverdrag
17

Clasificación de diseño inteligente de Javascript

function sort(array){
    console.log("Someone more intelligent than you has already sorted this optimally. Your puny brain cannot comprehend it");
    return array;//I do believe that this is the fastest sorting algorithm there is!
}
scrblnrd3
fuente
66
Crédito donde vence el
wchargin
1
¿No entiendo por qué criticas el diseño inteligente en un concurso de programación?
khebbie
12
@khebbie ¿Por qué no?
Konrad Rudolph
El problema es que si el usuario es el que ingresa los números, entonces serían más inteligentes que ellos. ;)
d -_- b
16

Python - req. # 1

Este código ordenará los dobles en orden lexicográfico en lugar de aumentar el orden numérico, creando un árbol de prefijos de dígitos y luego iterando a través de ellos de forma recursiva.

class trie_node:
    def __init__(self):    
        self.chn = {}
        self.instances = 0
        for char in "0123456789.-+e":
            self.chn[char] = None
    def insert_number(self, number):
        if(number == ""):
            self.instances += 1
        else:
            self.chn[number[0]] = trie_node()
            self.chn[number[0]].insert_number(number[1:])

def get_sorted_array(node, number):
    array_to_return = [number] * node.instances
    for char in "0123456789.-+e":
        if node.chn[char] != None:
            array_to_return += get_sorted_array(node.chn[char], number + char)
    return array_to_return

def pcg_sort(arr):
    root = trie_node()

    for element in arr:
        root.insert_number(str(element))

    sarr = get_sorted_array(root, "")
    fsarr = []
    for element in sarr:
        fsarr.append(float(element))

    return fsarr

input_array = []

while True:
    number = raw_input("Enter a double (/ to end): ")
    if(number == "/"):
        print pcg_sort(input_array)
        break
    else:
        try:
            number = float(number)
            input_array.append(number)
        except ValueError:
            pass

Funciona a n log ntiempo, y de hecho es una forma inteligente de mantener una lista ordenada de lo contrario, pero desafortunadamente para el OP, hace completamente lo incorrecto.

Joe Z.
fuente
44
También es particularmente engañoso porque si todos los números tienen el mismo número de dígitos antes del punto decimal, en realidad funcionará correctamente, por lo que el OP podría ni siquiera notar que el tipo está haciendo algo mal si solo lo prueba usando una entrada de , por ejemplo, 2, 1, 3, 8, 5.
Joe Z.
14

Ordena el conjunto de dobles. En Java:

public String sort(double[] input){
String s = "";
for(Double d:input){
    s+=Long.toBinaryString(Double.doubleToRawLongBits(d));
}
char[] chars=s.toCharArray();
Arrays.sort(chars);
s="";
for(char c:chars){
    s+=c;
}
return s;}

Por ejemplo:

[0.0, 1.5, 123]

va desde la representación binaria sin clasificar de

011111111111000000000000000000000000000000000000000000000000000100000001011110110000000000000000000000000000000000000000000000

a los elegantemente clasificados

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111

planetguy32
fuente
11

Necesito un programa donde el usuario ingrese una matriz de dobles y el programa genere la matriz ordenada. ¿Podría por favor dar el código?

Editar por @kealist, supongo que es mejor si se comenta para que la división parezca plausible. En Rebol ...

doubled-list: load ask "Input list of doubles: "

;-- The list is of doubles, so we have to undouble them before sorting
;-- Use MAP-EACH to create a new list with each element divided by two
undoubled-list: map-each num doubled-list [num / 2] 

;-- Note: We could also have sorted before we undoubled the numbers
print sort undoubled-list

Jugando con la idea de que en realidad no saben qué es un doble, y podrían creer que una lista de dobles era solo un grupo de números multiplicados por dos.

Dr. Rebmu
fuente
66
¡Quizás necesiten reducirse a la mitad ya que la entrada ya está duplicada!
kealist
@kealist Lo consideré, sin embargo, esto juega con la idea de que se está "duplicando". Creo que es un poco mejor tener el [2 * num].
Dr. Rebmu
10

Deliberadamente malinterpreta la pregunta:

Usando un enfoque recursivo:

def recsort(array):
    "Recursive sort"
    if array:
        for j, i in enumerate(array):
            for l1 in recsort(array[:j]):
                for l2 in recsort(array[j+1:]):
                    yield i + l1 + l2
                    yield i + l2 + l1
    else:
        yield ''

for p in recsort(raw_input("Array:")):
    print p

Se garantiza que la matriz ordenada se superará en algún momento, para cualquier tipo de datos en la matriz, incluso cualquier tipo de orden de clasificación, e incluso cualquier tipo de separador para la entrada, lo que hace que este enfoque sea extremadamente flexible. Su principal inconveniente es que es un poco lento para matrices grandes, pero puede resolverlo fácilmente con subprocesos múltiples.

Valentin CLEMENT
fuente