スリープソートは、インターネットで見つけた整数ソートアルゴリズムです。出力ストリームを開き、各入力番号に対して並列に、number秒遅延してその番号を出力します。遅延のため、最も大きい番号が最後に出力されます。私はそれが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

タスクは、選択したプログラミング言語の関数としてスリープソートを実装することです。競合状態などの同時実行要因を無視して、共有リソースをロックすることはできません。最短のコードが優先されます。関数定義はコード長にカウントされます。

入力リストは負でない整数のみに制限されており、入力リストの長さはかなり長い（少なくとも10個の数字をテストする）と予想されるため、競合状態は発生しません。競合状態が発生しないと仮定します。

ある種の不完全な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+）に存在することを前提としています。

APL（15 13）

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

それが何をする：

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

Erlangでの4つの試行：

コンソールへの出力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);}

パイソン-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 *よりも短く、ネットキャラクターを節約できます！しかし、グイドは満足していないだろうと思う...

自己への注意-Cを学び、Pythonでゴルフをやめます。 聖なる牛これはCソリューションよりも短い！

楽しみのために、ColdFusion（8+）バージョンがあります;-)ここには読みやすくするために追加した行の折り返しとインデントをカウントしない109文字が含まれています。

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

これは、それ<cfoutput>が有効であることを前提としています。すべてを1行に書き込むことで、いくつかの文字を保存できます。

Java（別名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が入力を読み込み、一連のコマンド実行が終了するまで、3列目の）'<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ループよりも2文字長い（）ジェネレーターではなく、ジェネレーターをチャンクするまで実際にタイマースレッドを作成していません。

他に最適化はありますか？

トリックは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では、1行のラムダに1つのステートメントのみを含める必要があるため、このコードには複数の行が必要です。

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}]&/@

ソートするリストをこのコードの最後に追加して、評価してください。有効な関数定義である必要がある場合、さらに2バイト必要です。

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