Примечание. Этот вопрос был строго отредактирован с тех пор, как я впервые разместил его здесь. Правила были перенесены сюда , прочитайте их, прежде чем публиковать любой ответ, чтобы понять цель этого. Это был первый вопрос, созданный в категории кода троллинга .

Представьте себе ленивого пользователя в Stack Overflow, который задает этот вопрос:

Мне нужна программа, в которой пользователь вводит массив значений типа double, а программа выводит отсортированный массив. Не могли бы вы дать код?

Как вы могли бы создать кусок кода, который будет троллить этого пользователя? Создайте фрагмент кода, который окажется полезным для неопытного программиста, но на практике совершенно бесполезен.

Победителем является наиболее проголосованный ответ, за исключением случаев, когда ответ каким-то образом не соответствует критериям (для определения соответствия требованиям проверьте описание вики- кода троллинга кода ). Если ранее принятый ответ с наибольшим количеством голосов был побит в будущем по количеству голосов, полученных после принятия, новый лучший ответ принимается, а предыдущий не принимается. В случае ничьей я выберу победителя по своему усмотрению или просто подожду немного больше.

Ответы без кода не принимаются. Они могут быть веселыми и получить несколько голосов, но они не будут приняты.

Правила можно найти в описании тега .

^{Примечание: это вопрос кодового троллинга . Пожалуйста, не воспринимайте вопрос и / или ответы всерьез. Больше информации здесь .}

Иногда сообщество здесь не любит помогать с домашней работой. Вот почему вы получаете столько ответов на шутки. Но я люблю помогать. Вот полное решение в «C» (так как я предполагаю, что вы хотите научиться «программированию», а не «написанию сценариев» с Java или Ruby). Я включил много советов, которые я хотел бы знать, когда я впервые учился

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

Вот это в Java. Это полный обман, неприемлемый и не поддающийся исправлению, потому что он создает базу данных MySQL, вставляет туда число, делает выбор с предложением ORDER BY и выводит числа, заданные MySQL. На самом деле сортировку выполняет MySQL, а не программа.

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 # - Там нет убийства, как перебор

Прежде всего, дорогой GiMmEtHaCoDeZ, давайте попробуем разбить вашу задачу:

1. Читать цифры
2. Сортировать их
3. Выведите отсортированные числа.

Поскольку «Разделяй и властвуй» является очень важной стратегией при работе с программными проблемами, давайте решать их по одному

1. Чтение

Еще одна важная проблема в программном обеспечении - это универсальность. Поскольку не указано, как пользователь будет вводить числа, это может произойти через консоль, через файл, через веб-сервис и т. Д. Возможно, даже какой-то метод, который мы пока не можем придумать. Поэтому важно, чтобы наше решение могло учитывать различные типы ввода. Самый простой способ добиться этого - извлечь важную часть в интерфейс, скажем,

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

  DoubleArrayReaderType Type {get;}
}

где DoubleArrayReaderTypeперечисление дано с

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

Также важно сделать программное обеспечение тестируемым с нуля, поэтому реализация интерфейса будет

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

Далее, логичный вопрос - как мы узнаем, чтобы загрузить соответствующее IDoubleArrayReaderв код. Это легко, если мы используем простую фабрику:

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

Обратите внимание, что мы используем отражение для загрузки всех активных читателей, поэтому любые будущие расширения будут автоматически доступны сейчас, в основной части нашего кода, который мы просто делаем:

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

2. Обработка (сортировка)

Теперь нам нужно обработать, то есть отсортировать полученные числа. Обратите внимание, что шаги полностью независимы друг от друга, поэтому для подсистемы сортировки не имеет значения, как были введены числа. Кроме того, поведение сортировки также может быть изменено, например, нам может потребоваться ввести более эффективный алгоритм сортировки. Итак, естественно, мы извлечем запрошенное поведение обработки в интерфейсе:

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

  DoubleArrayProcessorType Type {get;}
}

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

А поведение сортировки просто реализует интерфейс:

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

Конечно, нам понадобится фабрика для загрузки и управления экземплярами обработки.

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. Написание вывода

Здесь особо нечего сказать, так как это процесс, который отражает ввод. Фактически, мы могли бы объединить фабрики чтения и записи в одно DoubleArrayInputOutputFactory, например так:

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

}

Собираем все вместе

Наконец, наша основная программа будет просто использовать всю эту удивительность, которую мы уже создали, поэтому код будет просто:

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

где, например, мы могли бы определить reader, writerи processorиспользуя

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

Еще более буквальная интерпретация:

echo " aaehrrty"

то есть «массив» отсортирован.

Perl

Из всего, что я сделал для CodeGolf.SE, это заняло больше всего времени, по крайней мере, несколько часов.

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

Вход имеет форму, [2,4,5,7,7,3]а выход имеет форму [2,3,4,5,7,7].

У меня нет времени объяснять сейчас ... вернусь позже.

В любом случае, в Perl есть нечто, называемое анонимным массивом. Это массив, но у него нет имени. Однако мы знаем, что это ссылка (ячейка памяти), которая на нее указывает. Ряд чисел в квадратных скобках создает анонимный массив и возвращает ссылку на него.

Этот ответ состоит из серии анонимных массивов, ссылки на которые хранятся в @_. Входные данные превращаются в анонимный массив. Затем мы создаем другие анонимные массивы, каждый элемент которых является ссылкой на элемент в предыдущем массиве. Вместо сортировки элементов в массиве мы сортируем указатели на элементы в этом массиве. Также мы создаем новый массив для каждого шага (и более) в операции сортировки.

питон

Предоставляет пользователю отсортированный массив, удаляя все элементы не в отсортированном порядке из входного массива.

import sys

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

Алгоритм просматривает список, добавляя каждый элемент, только если он не сделает список несортированным. Таким образом, вывод представляет собой отсортированный список, но не тот, который содержит все элементы исходного списка. Если операция просто проверяет, находится ли список в отсортированном порядке, он может не заметить, что в выводе отсутствуют значения.

Баш, 54 персонажа

Многие ответы, использующие медленные неэффективные языки, такие как C и Python ... давайте немного ускорим процесс, предложив решение на языке всех языков сценариев: Bash.

Я знаю, о чем ты думаешь - Bash даже не может обработать арифметику с плавающей запятой, так как это будет сортировать, верно? Хорошо, вот моя реализация мощного алгоритма 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."

Программа снабжена вводом в качестве аргументов командной строки. Образец прогона:

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

Это также имеет то преимущество, что, возможно, является самым коротким из всех рабочих алгоритмов, представленных здесь. Это верно - одна могущественная строка bash , использующая только встроенные функции bash и не вызывающая никаких внешних двоичных файлов (то есть, если вы не учитываете чисто необязательный подробный вывод). В отличие от bogosorts, его время выполнения является детерминированным.

Совет: Эффективная оптимизация заключается в разделении входных чисел на коэффициент перед сортировкой. Реализация оставлена ​​на усмотрение читателя.

Редактировать:

Укороченная версия для гольфа с 54 символами и менее симпатичной печатью:

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

JavaScript имеет встроенную sort()функцию, вы можете использовать ее так:

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

_{... о, совершенно забыл упомянуть, это сортирует в лексикографическом порядке, то есть 10 < 9и 9 < -100. Вероятно, это то, что вы ожидаете в любом случае.}

(jPL) язык программирования jQuery

Вы должны использовать jQuery для этого. Простое решение этой проблемы заключается в следующем:

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, с мощными программными компонентами многократного использования в GNU / Linux:

#include <stdlib.h>

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

Рубин

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

Довольно очевидный.

Или требовать, чтобы входные данные действительно были "массивом парных чисел":

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

Не использовать gets.chompдля дополнительного зла. Также использование регулярных выражений после трейлинга до, что я даже не знал, что вы могли бы сделать (спасибо Ян Дворжак), чтобы еще больше запутать ОП!

Python3.3

Конечно, вот самая простая программа на Python, которая может сортировать массив, заданный в виде литерала списка на 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)

К сожалению, он работает только в python3.3 +, поскольку использует yield fromвыражение. Код должен быть достаточно понятным, поэтому у вас не должно возникнуть проблем при передаче его вашему профессору.

Троллинг заключается в том, чтобы предоставить идеально работающее решение, которое делает именно то, для чего предназначен OP, но таким образом:

• невозможно понять (новичком)
• невозможно справиться с учителем, потому что:
  • ОП не может этого понять
  • даже если бы он мог, учитель не успел бы расшифровать, чтобы понять это
• страшно для наивного новичка, который может подумать, что программирование слишком сложно для него

Таким образом, этот ответ значительно увеличил бы разочарование студента, насмехающегося над его запросами с совершенно правильными ответами с определенной точки зрения.

^{(Не читайте, если считаете, что вы понимаете приведенный выше код)}

Я должен добавить, что троллинг также увеличивается за счет того, что реализованный алгоритм сортировки

Пузырь сортировки! ... что, безусловно, может быть реализовано таким образом, чтобы его мог понять даже ОП. Сам по себе это не неясный алгоритм, а просто хорошее запутывание кода чего-то, что ОП могло бы отлично понять.

C - медленный, сложный в использовании, неприемлемый стиль кодирования

Сам алгоритм сортировки известен как медленная сортировка и имеет наилучшую сложность (симплексность) около n ^ (log n / 2) . Алгоритм был опубликован Андреем Бродером и Хорхе Столфи в их замечательной статье «Алгоритмы Пессимал и анализ симплексности», которую я очень рекомендую для хорошего смеха и пищи для размышлений.

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

Однако сама сортировка бесполезна, поэтому нам нужен способ ввода данных, которые он хочет отсортировать. Разбор двойных чисел - это боль, так почему бы не вводить их побайтно.

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

Чтобы доказать, что это работает:

 $ 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

В итоге имеем:

• Самый медленный детерминированный алгоритм сортировки, который я знаю
• Тихие жестко заданные ограничения на длину списка
• Абсолютно ужасный вклад, я мог бы сделать вывод похожим, но я думаю, что так смешнее.
  • Подумайте: вам нужно будет знать, на каком компьютере ваша программа использует программу.
  • Также вы не можете ввести 0 (-0 в порядке)
• Арифметика указателей и в значительной степени не заботится о типах, так как указатели приводятся любым способом

Рубин, злой Богосорт! (Бонус: bogosort по вводу пользователя)

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

«Злые» повороты:

• работает очень-очень-очень-очень медленно, конечно
• использует сравнение строк, поэтому 10 меньше 2. Может быть легко исправлено .map &:to_fдобавлением ко второй строке, но OP может не знать, что
• не использовать, chompтак что последний номер имеет таинственный перевод строки в конце
• не использовать, stripтак что есть загадочный пробел вокруг чисел, если ввод с пробелом через запятую (например, пробел в 1.5, 2)

Или как насчет сортировки по пользовательскому вводу ?! >: 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 , которая отсортирует входные данные для вас. Прочитайте комментарии, чтобы увидеть, насколько это тривиально и расширяемо. Реальные преимущества этого в том, что это проверенный и настоящий механизм, он не опирается на новые и относительно непроверенные языки, такие как Java и все, что связано с Интернетом или от Microsoft. Он очень эффективно компилируется, и подобные процедуры используются самыми успешными финансовыми компаниями в списке Fortune500 и другими лидерами отрасли. Этот код был рассмотрен многими экспертами и признан отличным механизмом сортировки.

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.

ОП никогда не говорил, КАК сортировать их ... или каково его определение двойников. Предполагая тип данных, doubleно интерпретируя его как дубликаты . Используя JavaScript здесь.

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

Результат: чередующийся порядок [4, 11, 4, 9, 5, 7, 6, 7]

PHP

Вот полная реализация с обработкой ошибок. Это самый быстрый для любого 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)));

Следующая перестановка в C ++ работает, возвращая true, когда массив отсортирован, и false в противном случае (после того, как он переставляет). Таким образом, вы должны отсортировать массив, а затем использовать его в течение заданного времени, как указано выше (поэтому он сделает полный круг обратно в отсортированный массив).

[решение с помощью точного неверного направления]

Пожалуйста, прочитайте соответствующий стандарт, IEC 60559: 1989 Спецификация для двоичной арифметики с плавающей запятой для микропроцессорных систем , которую вы можете приобрести здесь . В сноске к §5.10 Подробности предиката totalOrder отмечается, что:

totalOrder не навязывает итоговый порядок для всех кодировок в формате. В частности, он не различает разные кодировки одного и того же представления с плавающей запятой, как, например, когда один или оба кодирования являются неканоническими.

Таким образом, мы видим, что невозможно написать код для сортировки двойников. Это вопрос с подвохом. Ха-ха, очень умный! Пожалуйста, скажите своему профессору, что я наслаждаюсь его курсом.

[править: ничто не требует от меня, чтобы я не предполагал, что проблема требует полного порядка]

Злой JavaScript:

ОП, я не хочу давать вам все, поэтому я позволю вам выяснить, как получить информацию от пользователя самостоятельно (подсказка: используйте prompt).

Если у вас есть это, вот функция, в которую вы можете передать свой массив для сортировки. Вам просто нужно предоставить массив, самое низкое значение в массиве и приращение:

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

Вот скрипка, чтобы увидеть это в действии с примером пользовательского ввода [1.5, -3.5, 12, 10, -19.5].

Примечание. Помимо неэффективного, сложного и нерасширяемого решения рассматриваемой проблемы, это будет особенно неприятно, если ОП не знает о математике с плавающей запятой. Например, если пользовательский ввод [8.1, 5, -.8, 2.3, 5.6, 17.9]и ОП выбирает простые значения (то есть minimumVal=-.8и increment=.1), программа будет работать вечно. В связи с этим я в настоящее время являюсь счастливым владельцем двух неработающих вкладок браузера из-за этой самой проблемы :)

Примечание II: я чувствовал себя отвратительно даже при написании кода выше.

Примечание III: МВА ХАХАХАХА!

Вот фактический ответ, который мне нравится для Java:

Добавьте строку перед println, и ваш массив будет отсортирован

Arrays.sort( array );

Никаких объяснений, смущает ОП , но работает и получит положительные отзывы от более опытных программистов.

Еще один похожий ответ :

Посмотрите на Arrays.sort ()

Косвенно приказывая ОП провести свое собственное исследование, давая ему неопределенный правильный ответ. Без дальнейших исследований ФП все еще запутался . Мне также нравится, что ссылка указывает на более старую документацию.

Генетический алгоритм / метод Монте-Карло для задачи сортировки в JAVA

Проблема сортировки давно известна вычислительной технике, и было найдено много хороших решений. В последние годы были достигнуты большие успехи в области биокомпьютинга, и изучение того, как биология решает проблемы, показало большую помощь в решении сложных задач. Этот алгоритм сортировки использует лучшие из этих идей, чтобы использовать их для решения проблемы сортировки. Идея довольно проста. Вы начинаете с неупорядоченного массива и узнаете, как это уже отсортировано. Вы даете ему оценку его «сортировки», а затем переставляете массив случайным компонентом - как в биологии, где неясно, как будут выглядеть дети, даже если вы знаете все о родителях! Это часть генетического алгоритма. Вы создаете потомство этого массива, так сказать. Затем вы видите, отсортировано ли потомство лучше, чем родитель (иначе говоря, выживание наиболее приспособленных!). Если это так, вы продолжаете использовать этот новый массив в качестве отправной точки для построения следующей перестановки и так далее, пока массив не будет полностью отсортирован. Крутая вещь в этом подходе состоит в том, что он занимает меньше времени, если массив уже немного отсортирован с самого начала!

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

}

Дополнительно

• Злоупотребление списком java.awt.List
• непоследовательное и неправильное именование переменных
• бред бла бла про биокомпьютер
• изобретательный и противоречивый язык в объяснении
• Монте-Карло явно неправильный инструмент для прямых детерминированных проблем
• ненужный импорт
• наверное больше вкусностей ...

питон

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

Сортирует массив (список) по сумме 3- ^го и 5- ^го десятичных знаков.

C ++

Это работает ... в конце концов.

Вот мой алгоритм сортировки:

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

Вот полная программа:

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

Здесь полюбуйтесь:

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

Этот фрагмент кода отображает массив и просит пользователя ввести наименьший двойной массив. Затем он добавляет число в список отсортированных чисел, удаляет двойное число из массива и отображает оставшиеся номера массива.

* Неверное истолкование: слабое место, но ОП точно не ожидает, что программа попросит пользователя помочь в сортировке.

Обман: пользователь выполняет сортировку.

* Производительность: для каждого числа массива требуется обход сервера, и пользователю необходимо найти наименьшее число вручную. Производительность не может быть намного хуже.

* Неприемлемо: я думаю, что получил это. И удачи в повторном использовании. Хуже всего то, что пользователь может избавиться от 90% кода и периодически повторять циклы, чтобы найти наименьшие значения и каждый раз удалять их, что даст ему один из наименее эффективных алгоритмов сортировки.

* Творческий и зла: ты мне.

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 - требуется # 1

Этот код будет сортировать двойные числа в лексикографическом порядке, а не увеличивать числовой порядок, создавая префиксное дерево цифр и затем рекурсивно повторяя их.

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

Это работает n log nвовремя, и на самом деле это умный способ сохранить отсортированный список в противном случае, но, к сожалению, для OP, он делает совершенно не то, что нужно.

Сортирует массив двойников. В 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;}

Например:

[0.0, 1.5, 123]

выходит из несортированного двоичного представления

011111111111000000000000000000000000000000000000000000000000000100000001011110110000000000000000000000000000000000000000000000

в элегантно отсортированном

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111

Мне нужна программа, в которой пользователь вводит массив значений типа double, а программа выводит отсортированный массив. Не могли бы вы дать код?

Отредактируйте за @kealist, я думаю, что было бы лучше, если бы прокомментировать, чтобы разделение казалось правдоподобным. В Реболе ...

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

Подчеркивая, что они на самом деле не знают, что такое двойное число, и могут поверить, что список двойных чисел - это просто набор чисел, умноженных на два.

Умышленное недопонимание вопроса:

Используя рекурсивный подход:

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

Сортированный массив гарантированно будет выведен в какой-то момент для любого типа данных в массиве, даже для любого вида порядка сортировки и даже любого вида разделителя для ввода, что делает этот подход чрезвычайно гибким. Его главный недостаток в том, что он работает довольно медленно для больших массивов, но вы можете легко решить эту проблему с помощью многопоточности.