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 trolling de código .

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 código de trolling ). 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 arrastre de código . No tome en serio la pregunta y / o las respuestas. Más información aquí .}

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++);
  }

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);
    }
}

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

Aún más interpretación literal:

echo " aaehrrty"

es decir, "la matriz" ordenada.

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.

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.

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

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

(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();

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");
}

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!

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.

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

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 * ","

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.

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]

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));
?>

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

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

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!

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.

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

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.

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

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.

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

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.

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

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.

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.