Nota: Esta pergunta foi editada severamente desde que a publiquei aqui pela primeira vez. As regras foram movidas para aqui , leia-as antes de postar qualquer resposta para entender o objetivo disso. Esta foi a primeira pergunta criada na categoria de trollagem de código .

Imagine que um usuário preguiçoso no Stack Overflow faz esta pergunta:

Eu preciso de um programa em que o usuário insira uma matriz de duplas e o programa emita a matriz classificada. Poderia, por favor, fornecer o código?

Como você pode criar um código que trollará esse usuário? Crie um pedaço de código que parecerá útil para um programador inexperiente, mas é totalmente inútil na prática.

O vencedor é a resposta mais votada, exceto se a resposta não for de alguma forma qualificada (para requisitos de elegibilidade, verifique a descrição da tag wiki de trollagem de código ). Se a resposta mais votada anteriormente for derrotada no futuro no número de votações após a aceitação, a nova melhor resposta será aceita e a anterior será inaceitável. No caso de empate, escolherei o vencedor à vontade entre os empatados ou esperarei um pouco mais.

Respostas que não têm código não são elegíveis. Eles podem ser divertidos e receber votos positivos, mas não serão aceitos.

As regras podem ser encontradas na descrição da tag .

^{Nota: Esta é uma pergunta de controle de código . Por favor, não leve a sério a pergunta e / ou respostas. Mais informações aqui .}

Às vezes, a comunidade aqui não gosta de ajudar com a lição de casa. É por isso que você está recebendo tantas respostas de piadas. Mas eu gosto de ajudar. Aqui está uma solução completa em 'C' (desde que eu assumo que você queira aprender "programação", não "scripts" com Java ou Ruby). Incluí muitas dicas que eu gostaria de saber quando aprendi pela primeira vez

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

Aqui está em java. É uma trapaça total, inaceitável e impossível de corrigir, porque cria um banco de dados MySQL, insere o número lá, faz uma seleção com uma cláusula ORDER BY e gera os números fornecidos pelo MySQL. De fato, é o MySQL quem está fazendo a classificação, não o 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);
    }
}

Não há matança como exagero

Primeiro de tudo, querido GiMmEtHaCoDeZ, vamos tentar dividir sua tarefa:

1. Leia os números
2. Classificá-los
3. Saída os números classificados.

Como "Dividir e conquistar" é uma estratégia muito importante ao trabalhar com problemas de software, vamos enfrentá-los um por vez

1. Leitura

Outra questão importante no software é a versatilidade. Como não está especificado como o usuário digitará os números, isso pode acontecer por meio do console, por um arquivo, por um serviço da web etc. etc. Talvez até algum método que não possamos pensar no momento. Portanto, é importante que nossa solução possa acomodar vários tipos de entrada. A maneira mais fácil de conseguir isso é extrair a parte importante de uma interface, digamos

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

  DoubleArrayReaderType Type {get;}
}

onde DoubleArrayReaderTypeé uma enumeração fornecida com

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

Também é importante tornar o software testável desde o início, para que uma implementação da interface seja

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

A seguir, a questão lógica é como saberemos carregar o apropriado IDoubleArrayReaderno código. Isso é fácil, desde que usemos uma fábrica simples:

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

Observe que usamos a reflexão para carregar todos os leitores ativos, para que futuras extensões sejam disponibilizadas automaticamente Agora, no corpo principal do código, apenas fazemos:

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

2. Processamento (classificação)

Agora precisamos processar, ou seja, classificar os números que adquirimos. Observe que as etapas são completamente independentes uma da outra; portanto, para o subsistema de classificação, não importa como os números foram inseridos. Além disso, o comportamento de classificação também está sujeito a alterações, por exemplo, talvez seja necessário inserir um algoritmo de classificação mais eficiente. Portanto, naturalmente, extrairemos o comportamento de processamento solicitado em uma interface:

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

  DoubleArrayProcessorType Type {get;}
}

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

E o comportamento de classificação apenas implementará a interface:

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

Obviamente, precisaremos de uma fábrica para carregar e gerenciar as instâncias de processamento.

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. Escrevendo a saída

Não há muito o que dizer aqui, pois esse é um processo que reflete a entrada. De fato, poderíamos combinar as fábricas de leitura e escrita em uma única DoubleArrayInputOutputFactory, assim:

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

}

Juntando tudo

Por fim, nosso programa principal usará toda essa grandiosidade que já construímos, portanto o código será apenas:

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

onde, por exemplo, podemos definir reader, writere processorusando

IDoubleArrayReader reader = DoubleArrayInputOutputFactory.CreateDoubleArrayReader(DoubleArrayReaderType.MockService);
IDoubleArrayProcessor processor = DoubleArrayProcessorFactory.CreateDoubleArrayProcessor(DoubleArrayProcessorType.Sorter);
IDoubleArrayWriter writer = DoubleArrayInputOutputFactory.CreateDoubleArrayWriter(DoubleArrayWriterType.Console);

Interpretação ainda mais literal:

echo " aaehrrty"

isto é, "a matriz" classificada.

Perl

De todas as coisas que eu fiz para o CodeGolf.SE, isso provavelmente levou mais tempo, pelo menos algumas 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;

A entrada é do formato [2,4,5,7,7,3]e a saída é do formato [2,3,4,5,7,7].

Não tenho tempo para explicar agora ... volto mais tarde.

De qualquer forma, existe algo chamado matriz anônima no Perl. É uma matriz, mas não tem nome. O que sabemos, no entanto, é uma referência (localização da memória) que aponta para ela. Uma série de números entre colchetes cria uma matriz anônima e retorna uma referência a ela.

Essa resposta é criada a partir de uma série de matrizes anônimas, cujas referências são armazenadas @_. A entrada é transformada em uma matriz anônima. Em seguida, criamos outras matrizes anônimas, cada elemento da qual é uma referência a um elemento na matriz anterior. Em vez de classificar os elementos na matriz, classificamos os ponteiros para os elementos nessa matriz. Além disso, criamos uma nova matriz para cada etapa (e mais) na operação de classificação.

Pitão

Dá ao usuário uma matriz classificada, removendo todos os elementos que não estão em ordem classificada da 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 

O algoritmo passa pela lista apenas adicionando cada elemento se não tornar a lista não classificada. Portanto, a saída é uma lista classificada, mas não uma que contém todos os elementos da lista original. Se o op apenas verificar se a lista está na ordem de classificação, ele pode não perceber que a saída está com valores ausentes.

Bash, 54 caracteres

Muitas respostas usando linguagens lentas e ineficientes como C e Python ... vamos acelerar um pouco as coisas, oferecendo uma solução na mãe de todas as linguagens de script: Bash.

Eu sei o que você está pensando - o Bash não consegue nem lidar com a aritmética de ponto flutuante; então, como isso vai resolver, certo? Bem, eis que minha implementação do 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."

O programa é fornecido com entrada como argumentos da linha de comando. Exemplo de execução:

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

Isso também tem a vantagem de ser o menor de todos os algoritmos de trabalho apresentados aqui. Isso mesmo - uma poderosa linha de bash , usando apenas bash basins e não chamando binários externos (ou seja, se você não contar a saída detalhada puramente opcional). Ao contrário dos bogosorts, seu tempo de execução é determinístico.

Dica: Uma otimização eficaz é dividir os números de entrada por um fator antes de classificar. A implementação é deixada para o leitor.

Editar:

Versão de golfe de 54 caracteres reduzida com impressão menos bonita:

#!/bin/sh
for i in $@;do echo $(sleep $i)$i&done;wait

O JavaScript tem uma sort()função interna, você pode usá-lo assim:

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

_{... oh, esqueci totalmente de mencionar, classifica em ordem lexicográfica, ie 10 < 9e 9 < -100. Provavelmente é o que você espera de qualquer maneira.}

(jPL) Linguagem de programação jQuery

Você deve usar o jQuery para isso. Uma solução simples para esse problema é a seguinte:

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 solução combina a concisão e o acesso no nível do SO fornecido pela C com os poderosos e reutilizáveis ​​componentes de software no GNU / Linux:

#include <stdlib.h>

main(int argc, char **argv)
{
    system("echo Enter numbers one per line, ending with ctrl-D; sort -g");
}

Rubi

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

Bastante auto-explicativo.

Ou exija que a entrada seja "uma matriz de duplas":

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

Não usando gets.chomppara maldade extra. Também usando regex depois de seguir até, o que é algo que eu nem sabia que você poderia fazer (obrigado Jan Dvorak) para confundir ainda mais o OP!

Python3.3

Claro, aqui está o programa Python mais simples que pode classificar uma matriz fornecida como uma lista literal no 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)

Infelizmente, ele funciona apenas em python3.3 +, pois usa a yield fromexpressão O código deve ser bastante auto-explicativo; portanto, você não deve ter nenhum problema ao entregá-lo ao seu professor.

O trolling consiste em fornecer uma solução perfeitamente funcional que faça exatamente o que o OP pretendia, mas de uma maneira que seja:

• impossível de entender (por um iniciante)
• impossível lidar com o professor porque:
  • o OP não consegue entender
  • mesmo que ele pudesse, o professor não teria tempo de decifrar para entender
• assustador para um novato ingênuo que pode pensar que a programação é muito difícil para ele

Em resumo, essa resposta aumentaria bastante a frustração de o aluno zombar de seus pedidos com respostas perfeitamente válidas de um certo ponto de vista.

^{(Não leia se considerar um desafio entender o código acima)}

Devo acrescentar que o trolling também é aumentado pelo fato de o algoritmo de classificação implementado ser realmente

Tipo de bolha! ... que certamente poderia ser implementado de uma maneira que até o OP pudesse entender. Não é um algoritmo obscuro em si, apenas uma boa ofuscação de código de algo que o OP poderia entender perfeitamente.

C - Estilo de codificação lento, difícil de usar e inaceitável

O algoritmo de classificação propriamente dito é conhecido como slowsort e possui uma complexidade (melhor simplicidade) de aproximadamente n ^ (log n / 2) . O algoritmo foi publicado por Andrei Broder e Jorge Stolfi em seu excelente artigo "Algoritmos pessimais e análise de simplicidade", que eu recomendo para boas risadas e alimento para reflexão.

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

No entanto, a classificação em si é inútil, por isso precisamos de uma maneira de o usuário inserir os dados que deseja classificar. Analisar duplas é complicado, então por que não introduzi-las byte a 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 provar 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

No final, temos:

• O algoritmo de classificação determinística mais lento que eu conheço
• Limites silenciosos codificados no comprimento da lista
• Entrada absolutamente horrível, eu também poderia tornar a saída semelhante, mas acho que é mais engraçado dessa maneira.
  • Considere: Você precisará saber qual endianess sua máquina deve usar o programa.
  • Além disso, você não pode inserir 0 (-0 está ok)
• Aritmética de ponteiro e praticamente nenhuma preocupação com os tipos, pois os ponteiros são lançados da maneira que for

Ruby, malvado Bogosort! (Bônus: bogosort por entrada do usuário)

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

As torções "más":

• corre muito, muito, muito, muito, muito, muito devagar, é claro
• usa comparação de cadeias, então 10 é menor que 2. Pode ser corrigido facilmente com .map &:to_fanexado à segunda linha, mas o OP pode não saber que
• não usar, chompentão o último número tem uma nova linha misteriosa no final
• não usar, strippara que haja um espaço em branco misterioso ao redor dos números se for inserido com espaçamento entre vírgulas (ex. O espaço em 1.5, 2)

Ou então, e quanto a bogosorting por entrada do usuário ?! >: 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

Certo! "Até um macaco pode fazer isso!"

Aqui está um programa COBOL simples que classificará a entrada para você. Leia os comentários para ver exatamente como é trivial e extensível. Os benefícios reais disso são que ele é um mecanismo experimentado e verdadeiro, não depende de linguagens novas e relativamente não testadas, como Java e qualquer coisa baseada na Web ou da Microsoft. Ele é compilado com muita eficácia e procedimentos como esse são usados ​​pelas empresas financeiras de maior sucesso na Fortune500 e por outros líderes do setor. Esse código foi revisado por muitos especialistas e é reconhecido como um excelente mecanismo de classificação.

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 disse COMO classificá-los ... ou qual é a sua definição de duplas. Assumindo o tipo de dados, doublemas interpretando-o como duplicado . Usando JavaScript aqui.

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: ordem alternada [4, 11, 4, 9, 5, 7, 6, 7]

PHP

Aqui está uma implementação completa com tratamento de erros. É o mais rápido para qualquer um 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)));

A próxima permutação em C ++ funciona retornando true quando a matriz é classificada e falsa (caso contrário). Portanto, você deve classificar a matriz e, em seguida, usá-la durante o processo, conforme descrito acima (para fazer um círculo completo de volta à matriz classificada).

[solução por direcionamento pontual]

Leia a norma relevante, IEC 60559: 1989, para aritmética binária de ponto flutuante para sistemas de microprocessadores , que você pode adquirir aqui . Na nota de rodapé de §5.10 Detalhes do predicado totalOrder , observe -se que:

totalOrder não impõe uma ordem total a todas as codificações em um formato. Em particular, ele não distingue entre diferentes codificações da mesma representação de ponto flutuante, como quando uma ou ambas as codificações são não canônicas.

Assim, vemos que é impossível escrever código para classificar duplas. É uma pergunta complicada. Ha, ha, muito esperto! Por favor, diga ao seu professor que estou gostando muito do curso dele.

[editar: nada exige que eu não assuma que o problema exige uma ordem total]

Um JavaScript maligno:

OP, não quero dar tudo a você, por isso vou deixar você descobrir como obter informações do usuário por conta própria (dica: use prompt).

Depois de ter isso, aqui está uma função na qual você pode passar seu array para classificá-lo. Você só precisa fornecer a matriz, o menor valor na matriz e um 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;
};

Aqui está um violino para vê-lo em ação com a entrada do usuário de exemplo [1.5, -3.5, 12, 10, -19.5].

Nota: Além de apresentar um desempenho insatisfatório, complexo e inextensível para o problema em questão, isso será especialmente frustrante se o OP não souber sobre matemática de ponto flutuante. Por exemplo, se a entrada do usuário for [8.1, 5, -.8, 2.3, 5.6, 17.9]e o OP escolher os valores diretos (ie minimumVal=-.8e increment=.1), o programa será executado para sempre. Em uma nota relacionada, atualmente sou o orgulhoso proprietário de duas guias do navegador que não funcionam devido a esse problema :)

Nota II: Eu me senti nojento mesmo escrevendo o código acima.

Nota III: MWA HAHAHAHA!

Aqui está uma resposta real que eu gosto para Java:

Adicione a linha antes de println e sua matriz será classificada

Arrays.sort( array );

Nenhuma explicação confunde o OP , mas funciona e receberá votos de programadores mais experientes.

Outra resposta semelhante :

Dê uma olhada em Arrays.sort ()

Indiretamente ao OP para fazer sua própria pesquisa, dando-lhe uma vaga resposta correta. Sem mais pesquisas, o OP ainda está confuso . Também gosto que o link aponte para documentação mais antiga.

Algoritmo genético / método de Monte Carlo para o problema de classificação em JAVA

O problema da classificação é conhecido pela ciência da computação há muito tempo e muitas boas soluções foram encontradas. Nos últimos anos, houve grandes avanços na biocomputação e ver como a biologia resolve problemas se mostrou de grande ajuda na solução de problemas difíceis. Esse algoritmo de classificação utiliza o melhor dessas idéias para usá-las na solução do problema de classificação. A ideia é muito simples. Você começa com uma matriz não ordenada e descobre como isso já está classificado. Você dá uma pontuação de sua "ordenação" e depois permuta a matriz com um componente aleatório - assim como na biologia, onde não está claro como as crianças serão, mesmo que você saiba tudo sobre os pais! Esta é a parte do algoritmo genético. Você cria a prole dessa matriz, por assim dizer. Então você vê se a prole é melhor classificada do que o pai (também conhecido como sobrevivência do mais apto!). Se for esse o caso, você continua com essa nova matriz como ponto de partida para criar a próxima permutação e assim por diante até que a matriz esteja totalmente classificada. O legal dessa abordagem é que ela demora mais, se a matriz já estiver um pouco classificada desde o início!

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

• Uso indevido de java.awt.List
• nomeação de variável inconsistente e incorreta
• completamente besteira blá blá sobre biocomputação
• linguagem inventiva e inconsistente na explicação
• Monte Carlo é claramente a ferramenta errada para problemas determinísticos diretos
• importações desnecessárias
• provavelmente mais guloseimas ...

Pitão

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

Classifica o array (lista), pela soma dos 3 ^rd e 5 ^th casas decimais.

C ++

Isso funciona ... eventualmente.

Aqui está o meu algoritmo de classificação:

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

Aqui está o 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 ;
}

Aqui, deleite seus olhos:

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

Esse trecho de código exibe a matriz e solicita que o usuário insira o menor dobro da matriz. Em seguida, adiciona o número à lista de números classificados, remove o dobro da matriz e exibe os números restantes da matriz.

* Interpretação incorreta: ponto fraco, mas o OP não está exatamente esperando que o programa peça ao usuário para ajudar na classificação.

* Trapaça: o usuário é o responsável pela classificação.

* Desempenho: todo número da matriz requer uma ida e volta do servidor e exige que o usuário encontre o menor número manualmente. O desempenho não pode ficar muito pior.

* Inaceitável: acho que cobri isso. E boa sorte em reutilizá-lo. Na pior das hipóteses, o usuário pode se livrar de 90% do código e percorrer repetidamente para encontrar os menores valores e removê-los a cada vez, o que daria a ele um dos algoritmos de classificação menos eficientes.

* Criativo e mau: você me diz.

Javascript Design Inteligente Classificar

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

Esse código classificará as dobras em ordem lexicográfica, em vez de aumentar a ordem numérica, criando uma árvore de prefixos de dígitos e, em seguida, repetindo-os recursivamente.

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 ntempo e, de fato, é uma maneira inteligente de manter uma lista classificada, mas infelizmente para o OP, ele faz completamente a coisa errada.

Classifica a matriz de duplas. Em 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 exemplo:

[0.0, 1.5, 123]

vai da representação binária não classificada de

011111111111000000000000000000000000000000000000000000000000000100000001011110110000000000000000000000000000000000000000000000

para o elegantemente classificado

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111

Eu preciso de um programa em que o usuário insira uma matriz de duplas e o programa emita a matriz classificada. Poderia, por favor, fornecer o código?

Editar por @ kealist, eu acho que é melhor se comentado para fazer a divisão parecer plausível. Em 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

Brincando com a idéia de que eles realmente não sabem o que é um dobro, e podem acreditar que uma lista de duplos era apenas um monte de números multiplicados por dois.

Deliberadamente entendendo mal a pergunta:

Usando uma abordagem recursiva:

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

É garantido que a matriz classificada seja produzida em algum momento, para qualquer tipo de dado na matriz, mesmo qualquer tipo de ordem de classificação e até mesmo qualquer tipo de separador para a entrada, o que torna essa abordagem extremamente flexível. Sua principal desvantagem é que é um pouco lento para matrizes grandes, mas você pode resolver isso facilmente com multithreading.