Sleep Sort - алгоритм целочисленной сортировки, который я нашел в Интернете. Он открывает выходной поток, и для каждого входного числа параллельно задерживается число секунд и выводится это число. Из-за задержек наибольшее число будет выведено последним. Я оцениваю это имеет O (n + m), где n - количество элементов, а m - наибольшее число.

Вот оригинальный код на Bash

#!/bin/bash
function f() {
    sleep "$1"
    echo "$1"
}
while [ -n "$1" ]
do
    f "$1" &
    shift
done
wait

Вот псевдокод

sleepsort(xs)
 output = []
 fork
   for parallel x in xs:
     sleep for x seconds
     append x to output
 wait until length(output) == length(xs)
 return output

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

Список ввода ограничен только неотрицательными целыми числами, и ожидается, что длина списка ввода будет достаточно большой (протестируйте не менее 10 чисел), чтобы условия гонки никогда не возникали. и предполагая, что условия гонки никогда не случаются.

Этакая неудачная попытка Perl , 59 55 52 38 32 персонажа :

map{fork||exit print sleep$_}@a

Barebones: 25 символов:

... если вы не возражаете против результатов сортировки:

map{fork||die sleep$_}@a

Со всеми отделками:

(для максимального соответствия требованиям, 44 символа)

sub t{map{fork||exit print sleep$_}@_;wait}

Если вы позволите Perl ждать вас, 39 символов:

sub t{map{fork||exit print sleep$_}@_}

И снова, если не возражаете die(), 32 символа ...

sub t{map{fork||die sleep$_}@_}

Обратите внимание, что в Perl 6, или когда объявлена ​​функция 'say', можно заменить printфункцию say, сохраняя символ в каждом экземпляре. Очевидно, что, поскольку dieоба завершают разветвленный процесс и записывают вывод, это остается самым коротким решением.

C , 127 символов, довольно очевидное решение:

main(int c,char**v){
#pragma omp parallel for num_threads(c)
for(int i=1;i<c;++i){int x=atoi(v[i]);sleep(x);printf("%d ",x);}}

(Составлено gcc -std=c99 -fopenmp sort.cи игнорируется все предупреждения.)

Ruby 1.9, 32 символа

Как функция:

s=->a{a.map{|i|fork{p sleep i}}}

Если мы можем просто использовать предопределенную переменную, она сокращается до 25 символов:

a.map{|i|fork{p sleep i}}

JavaScript , 65 символов (в зависимости от того, используете ли вы console.logили что-то еще для вывода результата)

a.map(function(v){setTimeout(function(){console.log(v)},v*1000)})

Предполагается, что aэто массив неотрицательных целых чисел, который map()существует в прототипе массива (JavaScript 1.6+).

APL ( 15 13)

{⎕←⍵⊣⎕DL⍵}&¨⎕

Что оно делает:

¨⎕       : for each element of the input
&        : do on a separate thread
⎕DL⍵    : wait approx. ⍵ seconds
⎕←⍵     : output ⍵

Четыре попытки в Эрланге:

Вывод на консоль позволил себе сделать это каждый, 9ms * Numberпоскольку этого достаточно, чтобы заставить его работать (протестировано на встроенной плате Atom = медленно):

Нужно 60 символов

s(L)->[spawn(fun()->timer:sleep(9*X),io:write(X)end)||X<-L].

Вывод на консоль полный не-Erlangish, поэтому Pвместо этого мы отправляем сообщение для обработки :

Необходимо 55 символов

s(P,L)->[spawn(fun()->timer:sleep(9*X),P!X end)||X<-L].

Отправка через некоторое время также может быть выполнена по-другому (это работает даже с 1ms * Number):

Требуется 41 символ

s(P,L)->[erlang:send_after(X,P,X)||X<-L].

На самом деле это немного несправедливо, поскольку встроенная функция send_afterзапаздывает и требует erlang:префикса пространства имен , если мы считаем это пространство имен импортированным (сделано на уровне модуля):

Необходимо 34 символа

s(P,L)->[send_after(X,P,X)||X<-L].

C # - 137 символов

Вот ответ в C # (обновленный со степенями параллелизма как прокомментировано)

void ss(int[]xs){xs.AsParallel().WithDegreeOfParallelism(xs.Length).Select(x=>{Thread.Sleep(x);return x;}).ForAll(Console.WriteLine);}

Питон - 81 93 148 150 153

Настройка кода @ BiggAl, так как это игра, в которую мы играем ....

import threading as t,sys
for a in sys.argv[1:]:t.Timer(int(a),print,[a]).start()

... или 97 175 с отложенным началом резьбы

import threading as t,sys
for x in [t.Timer(int(a),print,[a]) for a in sys.argv[1:]]:x.start()

Принимает ввод через командную строку, аля

./sleep-sort\ v0.py 1 7 5 2 21 15 4 3 8

Как и во многих питон-гольфах, наступает момент, когда код достаточно компактен, чтобы псевдонимы переменных для сокращения имен даже не сохраняли символы.

Хотя это и забавно, потому что он псевдоним sys и создает потоки ОБА как t, поэтому sys.argv становится t.argv. Короче, чем от импорта foo *, и чистая экономия символов! Однако я полагаю, что Гвидо не будет доволен ...

Примечание для самостоятельного изучения c и прекращения игры в гольф на питоне. СВЯТАЯ КОРОВА, ЭТО МЕНЬШЕ, ЧЕМ РЕШЕНИЕ C!

Для забавы, вот версия ColdFusion (8+) ;-) В ней 109 символов, не считая переносы строк и отступы, которые я добавил для удобочитаемости здесь.

<cfloop array="#a#" index="v">
  <cfthread><cfthread action="sleep" duration="#v*1000#"/>#v#</cfthread>
</cfloop>

Это предполагает, что <cfoutput>это в силе. Несколько символов можно сохранить, написав все в одной строке.

Ява (иначе никогда не выигрывает в Codegolf): 234 211 187 символов

public class M{public static void main(String[]s){for(final String a:s)new Thread(){public void run(){try{sleep(Long.parseLong(a));}catch(Exception e){}System.out.println(a);}}.start();}}

ungolfed:

public class M {
    public static void main(String[] s) {
        for(final String a:s) new Thread(){
            public void run() {
                try {
                    sleep(Long.parseLong(a));
                } catch(Exception e){}
                System.out.println(a);
            }
        }.start();
    }
}

Javascript - 52 символа

for(i in a)setTimeout("console.log("+a[i]+")",a[i])

Скала - 42 40 символов (особый случай)

Если у вас есть пул потоков, по крайней мере, размер числа элементов списка:

a.par.map{i=>Thread.sleep(i);println(i)}

Скала - 72 символа (общее)

a.map(i=>new Thread{override def run{Thread.sleep(i);println(i)}}.start)

Хаскель - 143 персонажа

import Control.Concurrent
import System
d=threadDelay
f x=d(10^6*x)>>print x
g s=mapM(forkIO.f)s>>d(10^6*maximum s+1)
main=getArgs>>=g.map read

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

Befunge-98, 38 31 байт

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

&#vt6j@p12<'
v:^ >$.@
>:!#^_1-

Основной IP-адрес читает число ( &), а затем обращается к тому, tкто его клонирует: один переходит на ту же строку и циклически повторяет, считывает новые числа и генерирует новые дочерние элементы, пока не достигнет EOF, который завершает последовательность. Все дочерние процессы застревают в замкнутом цикле ( vи ^в третьем столбце) до тех пор, пока основной IP не завершит чтение ввода и не выполнит последовательность команд '<21p, которая переводит символ <в положение (1,2), перезаписывает ^и освобождает все дочерние процессы, которые начинают одновременно цикл, уменьшая на 1 их число на каждой итерации. Так как скорость выполнения различных IP-адресов синхронизируется в befunge, они будут завершаться (и печатать свои значения) по порядку, сортируя входной список.

Немного опоздал на вечеринку:

Клен - 91 83 символа

В 91:

M:=():use Threads in p:=proc(n)Sleep(n);:-M:=M,n;end:Wait(map(i->Create(p(i)),L)[])end:[M];

В 83:

M:=():use Threads in Wait(seq(Create(proc(n)Sleep(n);:-M:=M,n end(i)),i=L))end:[M];

(Для этого требуется версия Maple 15 и ожидается, что список будет отсортирован в L)

C 70 69 символов

Не ждет возврата дочерних процессов, иначе работает.

main(n) {
    while(~scanf("%d",&n)?fork()||!printf("%d\n",n,sleep(n)):0);
}

PHP 57 байт

<?for(;$i=fgets(STDIN);)pcntl_fork()?:die($i.usleep($i));

pcntl_fork () доступен только в Linux.

Баш (38):

xargs -P0 -n1 sh -c 'sleep $0;echo $0'

Изменить: Плавающая точка от стандартного ввода, разделенных пробелами или переводами строки.

Хаскелл, 90

import Control.Concurrent
s::[Int]->IO()
s=mapM_(\x->forkIO$threadDelay(x*9999)>>print x)

Я надеюсь, что это соответствует всем требованиям.

𝔼𝕊𝕄𝕚𝕟, 11 символов / 22 байта

ïć⇝שĤ⇀ôa,a⸩

Try it here (Firefox only).

שĤ⇀ôaэто выглядит круто.

Просто некоторые изменения из версии @rmckenzie:

Python отложил начало потока в 155 152 114 108 107:

import sys, threading as t
for x in [t.Timer(int(a),sys.stdout.write,[a]) for a in sys.argv[1:]]:x.start()

Python без задержки в 130 128 96 95 93:

import sys,threading as t
for a in sys.argv[1:]:t.Timer(int(a),sys.stdout.write,[a]).start()

Управлял еще несколькими оптимизациями, используя Timerвместо Threadнего более лаконичный вызов и устранял необходимость в импорте time. Метод запуска с отложенным потоком выигрывает от понимания списка, так как устраняет необходимость отдельно инициализировать список в начале, хотя он на два символа длиннее ( "["+"]"+" "-":"), чем цикл for, поэтому он бесполезен без отложенного запуска, и вы должны быть осторожны при использовании списка а не генератор, или вы фактически не создаете потоки таймера, пока не разберетесь с генератором.

У кого-нибудь еще есть оптимизация?

Трюк с asподсказками, но в 2.7.1 вы можете импортировать только один модуль в псевдоним, и после некоторой игры с ним вы даже не сможете import mod1,mod2 as a,b, вы должны это сделать import mod1 as a, mod2 as b. Он по-прежнему сохраняет несколько символов, но это не совсем лекарство - все, о чем я думал ... И на самом деле лучше оставить sys в качестве sys. Псевдоним потоков все еще помогает, хотя ...

Clojure, 54

(defn s[n](doseq[i n](future(Thread/sleep i)(prn i))))

Ржавчина - 150 байт

И именно поэтому вы не пишете гольф в Rust, он более многословен, чем Java;). Зависит от внешнего ящика crossbeam, было бы еще хуже без него.

|x|{extern crate crossbeam;crossbeam::scope(|s|for&v in x{s.spawn(move||{std::thread::sleep(std::time::Duration::from_secs(v));println!("{}",v)});})}

Полная тестовая программа:

fn main() {
    let z =
    |x|{extern crate crossbeam;crossbeam::scope(|s|for&v in x{s.spawn(move||{std::thread::sleep(std::time::Duration::from_secs(v));println!("{}",v)});})}
    ;
    z(&[4, 2, 3, 5, 7, 8, 9, 1, 6, 10])
}

Скучно, порт C #, просто чтобы снова начать работать с языком:

F # - 90 символов

PSeq.withDegreeOfParallelism a.Length a|>PSeq.iter(fun x->Thread.Sleep(x);printfn "%A" x)

JavaScript, 74

function(a){for(i=0;i<a.length;i++)setTimeout('alert('+a[i]+')',a[i]*1e3)}

или 71/65 символов с нестандартностью:

function(a){a.map(function(v){setTimeout('console.log('+v+')',v*1e3)})}

Tcl 8,6, 41 символ

lmap c $argv {after $c "puts $c"};vwait f

Вы должны убить это с ^C

VB.NET 100 байт

Поскольку VB.Net требует, чтобы однострочные лямбды содержали только одну инструкцию, этот код должен иметь несколько строк:

Array.ForEach(i, Async Sub(x)
Await Threading.Tasks.Task.Delay(x*1000)
Console.WriteLine(x)
End Sub)

Ungolfed:

Option Strict Off

Sub Main(i() as String)
    Array.ForEach(i, Async Sub(x)
                         Await Threading.Tasks.Task.Delay(x * 1000)
                         Console.WriteLine(x)
                     End Sub)
End Sub

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

VB.NET 71 байт

a.ForEach(i, Async Sub(x)
Await t.Delay(x*1000)
c.WriteLine(x)
End Sub)

Ungolfed:

Option Strict Off
Imports t = System.Threading.Tasks.Task
Imports c = System.Console
Imports a = System.Array

Sub Main(i() as String)
    a.ForEach(i, Async Sub(x)
                     Await t.Delay(x * 1000)
                     c.WriteLine(x)
                 End Sub)
End Sub

Groovy, 47 байтов

Предполагается, что номера приведены в командной строке ...

args.each{i->Thread.start{sleep(i*22)print i}}

Mathematica, 34 или 36 байт

RunScheduledTask[Print@#,{#,1}]&/@

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

RunScheduledTask[Print@#,{#,1}]&/@#&

C ++ 11, 229 байт

#import<future>
#import<iostream>
using namespace std;int main(int a,char**v){auto G=new future<void>[a];while(--a){G[a]=move(async([=](){this_thread::sleep_for(chrono::seconds(atoi(v[a])));cout<<v[a]<<" "<<flush;}));}delete[]G;}

Ungolfed и использование:

#import<future>
#import<iostream>
using namespace std;
int main(int a,char**v){
 auto G=new future<void>[a];
 while(--a){
  G[a]=move(async(
   [=](){
    this_thread::sleep_for(chrono::seconds(atoi(v[a])));
    cout<<v[a]<<" "<<flush;
   }
  ));
 }
 delete[]G;
}