Nota: questa domanda è stata gravemente modificata da quando l'ho pubblicata qui. Le regole sono state spostate qui , leggerle prima di pubblicare qualsiasi risposta per capire lo scopo di questo. Questa è stata la prima domanda creata nella categoria di troll del codice .

Immagina che un utente pigro su Stack Overflow faccia questa domanda:

Ho bisogno di un programma in cui l'utente inserisce una matrice di doppi e il programma produce l'array ordinato. Potresti per favore dare il codice?

Come hai potuto creare un pezzo di codice che troll questo utente? Crea un pezzo di codice che sembrerà utile a un programmatore inesperto ma nella pratica è assolutamente inutile.

Il vincitore è la risposta più votata, tranne nel caso in cui la risposta non sia in qualche modo ammissibile (per i requisiti di idoneità, controlla la descrizione della tag wiki del code-trolling ). Se la risposta precedentemente più votata viene battuta in futuro nel numero di voti dopo essere stata accettata, la nuova risposta migliore viene accettata e la precedente non viene accettata. In caso di pareggio, sceglierò il vincitore a piacimento tra quelli in parità o aspetterò ancora un po '.

Le risposte senza codice non sono idonee. Potrebbero essere divertenti e ottenere alcuni voti, ma non saranno accettati.

Le regole sono disponibili nella descrizione del tag .

^{Nota: questa è una domanda di traina del codice . Si prega di non prendere sul serio la domanda e / o le risposte. Maggiori informazioni qui .}

A volte alla comunità qui non piace aiutare con i compiti. Ecco perché stai ricevendo così tante risposte scherzose. Ma mi piace aiutare. Ecco una soluzione completa in 'C' (poiché presumo che tu voglia imparare la "programmazione", non "lo scripting" con Java o Ruby). Ho incluso molti suggerimenti che avrei voluto sapere quando stavo imparando per la prima volta

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

Eccolo a java. È assolutamente imbroglione, inaccettabile e non risolvibile perché crea un database MySQL, inserisce il numero lì, effettua una selezione con una clausola ORDER BY e genera i numeri forniti da MySQL. In effetti, è MySQL che sta eseguendo l'ordinamento, non il programma.

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 # - Non c'è uccisione come eccessiva

Prima di tutto, caro GiMmEtHaCoDeZ, proviamo a scomporre il tuo compito:

1. Leggi i numeri
2. Ordinali
3. Stampa i numeri ordinati.

Poiché "Dividi e conquista" è una strategia molto importante quando si lavora con problemi di software, è possibile affrontarli uno alla volta

1. Lettura

Un altro problema importante nel software è la versatilità. Dal momento che non è specificato come l'utente inserirà i numeri, ciò può accadere tramite la console, tramite un file, tramite un servizio web, ecc. Forse anche qualche metodo che non possiamo pensare al momento. Pertanto, è importante che la nostra soluzione sia in grado di supportare vari tipi di input. Il modo più semplice per raggiungere questo obiettivo è quello di estrarre la parte importante in un'interfaccia, diciamo

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

  DoubleArrayReaderType Type {get;}
}

dove DoubleArrayReaderTypeviene data un'enumerazione

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

È anche importante rendere il software testabile da zero, quindi sarà un'implementazione dell'interfaccia

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

Successivamente, la domanda logica è come sapremo caricare l'appropriato IDoubleArrayReadernel codice. È facile finché usiamo una semplice fabbrica:

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

Si noti che, utilizziamo la riflessione per caricare tutti i lettori attivi, quindi eventuali estensioni future saranno automaticamente disponibili Ora, nel corpo principale del nostro codice di uscita, facciamo semplicemente:

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

2. Elaborazione (ordinamento)

Ora dobbiamo elaborare, cioè ordinare i numeri che abbiamo acquisito. Si noti che i passaggi sono completamente indipendenti l'uno dall'altro, quindi per il sottosistema di ordinamento, non importa come sono stati immessi i numeri. Inoltre, anche il comportamento dell'ordinamento è soggetto a modifiche, ad esempio potrebbe essere necessario introdurre un algoritmo di ordinamento più efficiente in atto. Quindi, naturalmente, estrarremo il comportamento di elaborazione richiesto in un'interfaccia:

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

  DoubleArrayProcessorType Type {get;}
}

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

E il comportamento dell'ordinamento implementerà semplicemente l'interfaccia:

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

Naturalmente, avremo bisogno di una fabbrica per caricare e gestire le istanze di elaborazione.

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. Scrivere l'output

Non c'è molto da dire qui, poiché si tratta di un processo che rispecchia l'input. In effetti, potremmo combinare le fabbriche di lettura e scrittura in un singolo DoubleArrayInputOutputFactory, in questo modo:

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

}

Mettere tutto insieme

Infine, il nostro programma principale utilizzerà solo tutta questa meraviglia che abbiamo già creato, quindi il codice sarà:

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

dove, ad esempio, potremmo definire reader, writere processorusando

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

Un'interpretazione ancora più letterale:

echo " aaehrrty"

cioè "l'array" ordinato.

Perl

Di tutte le cose che ho fatto per CodeGolf.SE, questo probabilmente ha richiesto più tempo, almeno alcune ore.

$_[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;

L'input è nella forma [2,4,5,7,7,3]e l'output è nella forma [2,3,4,5,7,7].

Non ho tempo di spiegare ora ... torno più tardi.

Comunque, c'è qualcosa chiamato un array anonimo in Perl. È un array, ma non ha un nome. Ciò che sappiamo, tuttavia, è un riferimento (posizione della memoria) che lo indica. Una serie di numeri tra parentesi quadre crea un array anonimo e restituisce un riferimento ad esso.

Questa risposta è costruita da una serie di array anonimi, i cui riferimenti sono memorizzati @_. L'input viene trasformato in un array anonimo. Creiamo quindi altri array anonimi, ognuno dei quali è un riferimento a un elemento nell'array precedente. Invece di ordinare gli elementi nell'array, ordiniamo i puntatori agli elementi in quell'array. Inoltre, creiamo un nuovo array per ogni passaggio (e altro) nell'operazione di ordinamento.

Pitone

Fornisce all'utente un array ordinato rimuovendo tutti gli elementi non in ordine dall'array di input.

import sys

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

L'algoritmo passa attraverso l'elenco aggiungendo ogni elemento solo se non renderà l'elenco non ordinato. Pertanto, l'output è un elenco ordinato, ma non uno che contiene tutti gli elementi dell'elenco originale. Se l'operazione controlla solo se l'elenco è in ordine, potrebbe non notare che nell'output mancano i valori.

Bash, 54 caratteri

Molte risposte usando linguaggi lenti e inefficienti come C e Python ... acceleriamo un po 'le cose offrendo una soluzione nella madre di tutti i linguaggi di scripting: Bash.

So cosa stai pensando: Bash non riesce nemmeno a gestire l'aritmetica in virgola mobile, quindi come si sistemerà, giusto? Bene, ecco, la mia implementazione del potente 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."

Il programma viene fornito con input come argomenti della riga di comando. Esecuzione di esempio:

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

Questo ha anche il vantaggio di essere forse il più breve di tutti gli algoritmi di lavoro presentati qui. Esatto: una potente linea di bash , che utilizza solo i builtin bash e non chiama alcun binario esterno (vale a dire, se non si conteggia l'output dettagliato puramente facoltativo). A differenza dei bogosorts, il suo runtime è deterministico.

Suggerimento: un'ottimizzazione efficace consiste nel dividere i numeri di input per un fattore prima dell'ordinamento. L'implementazione è lasciata al lettore.

Modificare:

Versione da golf ridotta a 54 caratteri con stampa meno carina:

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

JavaScript ha una sort()funzione integrata, puoi usarlo in questo modo:

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

_{... oh, completamente dimenticato di menzionare, ordina in ordine lessicografico, cioè 10 < 9e 9 < -100. Probabilmente è quello che ti aspetti comunque.}

(jPL) Linguaggio di programmazione jQuery

È necessario utilizzare jQuery per questo. Una semplice soluzione a questo problema è la seguente:

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

Questa soluzione combina la concisione e l'accesso a livello di sistema operativo forniti da C con i componenti software potenti e riutilizzabili in GNU / Linux:

#include <stdlib.h>

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

Rubino

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

Abbastanza autoesplicativo.

O richiede che l'input sia effettivamente "un array di doppi":

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

Non usare gets.chompper malvagità extra. Anche usando regex dopo il trailing fino a, cosa che non sapevo nemmeno che potevi fare (grazie Jan Dvorak) per confondere ancora di più OP!

Python3.3

Certo, ecco il programma Python più semplice che può ordinare un array dato come un elenco letterale su 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)

Sfortunatamente funziona solo in python3.3 + poiché usa l' yield fromespressione. Il codice dovrebbe essere abbastanza autoesplicativo, quindi non dovresti avere problemi quando lo consegni al tuo professore.

Il trolling consiste nel fornire una soluzione perfettamente funzionante che fa esattamente ciò che l'OP intendeva, ma in un modo che sia:

• impossibile da capire (da un principiante)
• impossibile gestire l'insegnante perché:
  • l'OP non può capirlo
  • anche se avesse potuto, l'insegnante non avrebbe avuto il tempo di decifrare per capirlo
• spaventoso per un principiante ingenuo che potrebbe pensare che la programmazione sia troppo difficile per lui

In sintesi, questa risposta aumenterebbe notevolmente la frustrazione dello studente che deride le sue richieste con risposte perfettamente valide da un certo punto di vista.

^{(Non leggere se si considera una sfida comprendere il codice sopra)}

Devo aggiungere che il trolling è aumentato anche dal fatto che l'algoritmo di ordinamento implementato è effettivamente

bubble-sort! ... che potrebbe sicuramente essere implementato in un modo che anche l'OP potrebbe capire. Non è un oscuro algoritmo in sé, ma solo un buon offuscamento del codice di qualcosa che l'OP potrebbe altrimenti comprendere perfettamente.

C - Stile di codifica lento, difficile da usare e inaccettabile

L'algoritmo di ordinamento stesso è noto come slowsort e presenta una complessità del caso migliore (simplexity) di circa n ^ (log n / 2) . L'algoritmo è stato pubblicato da Andrei Broder e Jorge Stolfi nel loro grande articolo "Algoritmi pessimali e analisi di simplexità" che consiglio vivamente per buone risate E spunti di riflessione.

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

Tuttavia l'ordinamento stesso è inutile, quindi abbiamo bisogno di un modo per l'utente di inserire i dati che vogliono ordinare. L'analisi dei doppi è un problema, quindi perché non inserirli byte per 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]);
        }
}

Per dimostrare che funziona:

 $ 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

Alla fine abbiamo:

• L'algoritmo di ordinamento deterministico più lento di cui sono a conoscenza
• Limiti silenziosi codificati per la lunghezza dell'elenco
• Input assolutamente orribile, potrei anche rendere l'output simile ma penso che sia più divertente in questo modo.
  • Considerare: sarà necessario sapere quale endianess deve utilizzare il programma.
  • Inoltre non puoi inserire 0 (-0 è ok)
• L'aritmetica del puntatore e praticamente nessuna preoccupazione per i tipi in quanto i puntatori vengono espressi in qualsiasi modo

Ruby, il malvagio Bogosort! (Bonus: bogosort per input dell'utente)

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

I colpi di scena "cattivi":

• corre molto, molto, molto, molto lentamente, ovviamente
• usa il confronto delle stringhe, quindi 10 è inferiore a 2. Può essere risolto facilmente con l' .map &:to_faggiunta alla seconda riga, ma OP potrebbe non saperlo
• non usando chompquindi l'ultimo numero ha una misteriosa newline alla fine
• non usando, stripquindi c'è uno spazio bianco misterioso attorno ai numeri se inserito con spaziatura tra virgole (es. Lo spazio in 1.5, 2)

Oppure, che ne dici di bogosorting per input dell'utente ?! >: 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

Sicuro! "Anche una scimmia può farlo!"

Ecco un semplice programma COBOL che ordinerà l'input per te. Leggi i commenti per vedere esattamente quanto sia banale ed estensibile. I veri vantaggi di questo sono che è un meccanismo provato e vero, non si basa su linguaggi nuovi e relativamente non testati come Java e qualsiasi cosa basata sul web o da Microsoft. Si compila in modo molto efficace e procedure come questa sono utilizzate dalle società finanziarie di maggior successo di Fortune500 e da altri leader del settore. Questo codice è stato rivisto da molti esperti ed è riconosciuto come un eccellente meccanismo per l'ordinamento.

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 non ha mai detto come ordinarli ... o quale sia la sua definizione di doppio. Supponendo che il tipo di dati doublesia interpretato come duplicato . Utilizzando JavaScript qui.

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

Risultato: ordine alternato [4, 11, 4, 9, 5, 7, 6, 7]

PHP

Ecco un'implementazione completa con gestione degli errori. È il più veloce per tutti 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 permutazione successiva in C ++ funziona restituendo true quando l'array viene ordinato e false in caso contrario (dopo che lo consente). Quindi dovresti ordinare l'array e poi usarlo in un do-while come sopra (quindi farà un cerchio completo di nuovo all'array ordinato).

[soluzione per puntuale malinteso]

Leggere la norma pertinente, IEC 60559: 1989 Specifiche per l'aritmetica binaria in virgola mobile per sistemi a microprocessore , che è possibile acquistare qui . Nella nota in calce al §5.10 Dettagli del predicato dell'Ordine totale , si nota che:

totalOrder non impone un ordinamento totale su tutte le codifiche in un formato. In particolare, non distingue tra codifiche diverse della stessa rappresentazione in virgola mobile, come quando una o entrambe le codifiche sono non canoniche.

Quindi vediamo che è impossibile scrivere codice per ordinare i doppi. È una domanda trabocchetto. Ah ah ah, molto intelligente! Per favore, dì al tuo professore che mi sto divertendo molto.

[modifica: nulla mi richiede di non presumere che il problema richieda un ordine totale]

Un JavaScript malvagio:

OP, non voglio darti tutto, quindi ti farò capire come ottenere input dall'utente da solo (suggerimento: uso prompt).

Una volta ottenuto questo, ecco una funzione in cui è possibile passare l'array per ordinarlo. Devi solo fornire l'array, il valore più basso nell'array e 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;
};

Ecco un violino per vederlo in azione con l'input dell'utente di esempio [1.5, -3.5, 12, 10, -19.5].

Nota: Oltre ad essere poco performante, complesso e non estensibile per il problema in questione, ciò sarà particolarmente frustrante se l'OP non è a conoscenza della matematica in virgola mobile. Ad esempio, se l'ingresso dell'utente è [8.1, 5, -.8, 2.3, 5.6, 17.9]e l'OP sceglie i valori semplici (ie minimumVal=-.8e increment=.1), il programma funzionerà per sempre. Su una nota correlata, sono attualmente l'orgoglioso proprietario di 2 schede del browser non funzionanti a causa di questo problema :)

Nota II: mi sono sentito disgustoso anche scrivendo il codice sopra.

Nota III: MWA HAHAHAHA!

Ecco una risposta effettiva che mi piace per Java:

Aggiungi la riga prima di println e l'array viene ordinato

Arrays.sort( array );

Nessuna spiegazione, confonde l'OP , ma funziona e otterrà voti da programmatori più esperti.

Un'altra risposta simile :

Dai un'occhiata a Arrays.sort ()

Dire indirettamente all'OP di fare le proprie ricerche dandogli una vaga risposta corretta. Senza ulteriori ricerche, l' OP è ancora confuso . Mi piace anche che il link rimandi a documentazione precedente.

Algoritmo genetico / metodo Monte Carlo per il problema di ordinamento in JAVA

Il problema dell'ordinamento è noto alla scienza informatica da molto tempo e sono state trovate molte buone soluzioni. Negli ultimi anni ci sono stati grandi progressi nel biocomputer e guardare come la biologia risolve i problemi ha dimostrato di essere di grande aiuto nella risoluzione di problemi difficili. Questo algoritmo di ordinamento prende il meglio da queste idee per usarle per risolvere il problema di ordinamento. L'idea è piuttosto semplice. Inizi con un array non ordinato e scopri quanto è già ordinato. Gli dai un punteggio del suo "ordinamento" e poi permetti l'array con un componente casuale - proprio come in biologia dove non è chiaro come saranno i bambini anche se sai tutto sui genitori! Questa è la parte dell'algoritmo genetico. Si crea la prole di quell'array, per così dire. Quindi vedi se la prole è meglio ordinata rispetto al genitore (ovvero la sopravvivenza del più adatto!). In questo caso, si continua con questo nuovo array come punto di partenza per costruire la permutazione successiva e così via fino a quando l'array non è completamente ordinato. La cosa interessante di questo approccio è che richiede meno tempo, se l'array è già un po 'ordinato dall'inizio!

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

}

extra

• Uso improprio di java.awt.List
• denominazione variabile incoerente e errata
• completamente cazzate blah blah sul biocomputer
• linguaggio inventivo e incoerente nella spiegazione
• monte carlo è chiaramente lo strumento sbagliato per problemi deterministici diretti
• importazioni non necessarie
• probabilmente più chicche ...

Pitone

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

Ordina la matrice (elenco) per la somma delle posizioni 3 ^° e 5 ^° decimale.

C ++

Questo funziona ... alla fine.

Ecco il mio algoritmo di ordinamento:

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

Ecco il programma 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 ;
}

Ecco, festa i tuoi occhi:

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

Questo pezzo di codice visualizza l'array e chiede all'utente di inserire il doppio più piccolo dell'array. Quindi aggiunge il numero all'elenco dei numeri ordinati, rimuove il doppio dall'array e visualizza i numeri dell'array rimanenti.

* Interpretazione errata: punto debole, ma l'OP non si aspetta esattamente che il programma chieda all'utente di aiutare l'ordinamento.

* Cheating: l'utente è quello che sta facendo l'ordinamento effettivo.

* Prestazioni: ogni numero dell'array richiede un roundtrip del server e richiede all'utente di trovare manualmente il numero più piccolo. Le prestazioni non possono andare molto peggio.

* Inaccettabile: penso di averlo coperto. E buona fortuna per riutilizzarlo. Il peggio è il peggio, l'utente potrebbe sbarazzarsi del 90% del codice e scorrere ripetutamente per trovare i valori più piccoli e rimuoverli ogni volta, il che gli darebbe uno degli algoritmi di ordinamento meno efficienti.

* Creativo e cattivo: dimmelo tu.

Ordinamento intelligente di 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

Questo codice ordinerà i doppi in ordine lessicografico piuttosto che aumentando l'ordine numerico, creando un albero di prefisso di cifre e quindi ripetendo in modo ricorsivo.

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

Funziona in n log ntempo, ed è in realtà un modo intelligente per mantenere un elenco ordinato altrimenti, ma sfortunatamente per l'OP, fa completamente la cosa sbagliata.

Ordina la matrice dei doppi. In 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;}

Per esempio:

[0.0, 1.5, 123]

va dalla rappresentazione binaria non ordinata di

011111111111000000000000000000000000000000000000000000000000000100000001011110110000000000000000000000000000000000000000000000

a quelli elegantemente ordinati

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111

Ho bisogno di un programma in cui l'utente inserisce una matrice di doppi e il programma produce l'array ordinato. Potresti per favore dare il codice?

Modifica per @kealist, suppongo sia meglio se commentato per rendere plausibile la divisione. In 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

Giocando fuori dall'idea che in realtà non sanno cosa sia un doppio, e potrebbe credere che un elenco di doppi sia solo un mucchio di numeri moltiplicato per due.

Malinteso deliberatamente la domanda:

Utilizzando un approccio ricorsivo:

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

L'array ordinato è garantito per essere emesso ad un certo punto, per qualsiasi tipo di dati nell'array, anche qualsiasi tipo di ordinamento e persino qualsiasi tipo di separatore per l'input, il che rende questo approccio estremamente flessibile. Il suo principale svantaggio è che è un po 'lento per array di grandi dimensioni, ma puoi risolverlo facilmente con il multithreading.