睡眠排序是我在Internet上找到的整数排序算法。它将打开一个输出流，并为每个并行输入的数字延迟数秒，然后输出该数字。由于延迟，最后输出的数字最大。我估计它具有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个数字），因此竞争条件永远不会发生。并假设种族条件永远不会发生。

一种of脚的Perl尝试，59 55 52 38 32个字符：

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

准系统：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+）上。

杀伤人员地雷（15 13）

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

它能做什么：

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

在Erlang中的四次尝试：

输出到控制台的操作很随意，9ms * Number因为这足以使它工作（在Atom嵌入式板上测试=慢）：

需要60个字符

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

到控制台的输出完全是非英语的，因此我们发送一条消息来处理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);}

的Python-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()

通过命令行输入数据，ala

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

与许多python高尔夫球一样，有一点代码的紧凑性很强，以至于别名别名缩短名称甚至都不会保存字符。

尽管这很时髦，因为它将sys别名和线程均别名为t，因此sys.argv变为t.argv。比从foo import *短，并且节省了净字符！但是我想Guido不会很高兴...

自我注意-学习c并停止在python中打高尔夫球。 天哪，这比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();}}

松散

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

Scala- 42 40个字符（特殊情况）

如果您有一个线程池，其大小至少等于列表元素的数量：

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

Scala-72个字符（常规）

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

Haskell-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个字节

我知道这是一个古老的挑战，但是我最近才发现sleepsort和2D语言，对如何将它们组合起来有了一个想法，并寻找一个发布它的地方，所以我们到了。

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

主IP读取一个数字（&），然后点击将t其克隆的一个：一个在同一行上并循环，读取新数字并生成新子代，直到到达终止该序列的EOF。所有子进程都陷入一个闭环中（第三列的v和^），直到主IP完成输入的读取并执行命令序列'<21p，这会将字符<置于位置（1,2），覆盖^并释放所有字符子进程开始同时循环，每次迭代将其数量减少1。由于不同IP的执行速度是同步的，因此它们将按顺序终止（并打印其值），并对输入列表进行排序。

晚会晚了一点：

枫木-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'

编辑：从stdin浮点数，由空格或换行符分隔。

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这使调用更加简洁，并消除了import的需要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要求单行lambda只包含一个语句，所以此代码必须具有多行：

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

取消高尔夫：

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)

取消高尔夫：

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

脱胶和用法：

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