Sleep Sort adalah algoritma pengurutan bilangan bulat yang saya temukan di Internet. Ini membuka aliran output, dan untuk setiap nomor input secara paralel, tunda untuk nomor detik dan output nomor itu. Karena penundaan, angka tertinggi akan dikeluarkan terakhir. Saya memperkirakan ia memiliki O (n + m), di mana n adalah jumlah elemen dan m adalah angka tertinggi.

Ini kode asli di Bash

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

Ini kodesemu

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

Tugas Anda adalah mengimplementasikan Sleep Sort sebagai fungsi dalam bahasa pemrograman pilihan Anda. Anda dapat mengabaikan faktor konkurensi seperti kondisi balapan dan tidak pernah mengunci sumber daya bersama. Kode terpendek menang. Definisi fungsi diperhitungkan terhadap panjang kode.

Daftar input dibatasi hanya untuk bilangan bulat non-negatif, dan panjang daftar input diharapkan cukup panjang (uji setidaknya 10 angka) sehingga kondisi balapan tidak pernah terjadi. dan dengan asumsi kondisi balapan tidak pernah terjadi.

Semacam upaya Perl lumpuh , 59 55 52 38 32 karakter :

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

Barebones: 25 Karakter:

... jika Anda tidak keberatan dengan hasil sortir sebagai output mati:

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

Dengan semua fasilitasnya:

(untuk kepatuhan tantangan maksimum, 44 karakter)

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

Jika Anda membiarkan perl menunggu Anda, 39 karakter:

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

Dan lagi, jika Anda tidak keberatan die(), 32 karakter ...

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

Perhatikan bahwa di Perl 6, atau ketika fitur 'say' dideklarasikan, dimungkinkan untuk mengganti printfungsinya dengan say, menyimpan karakter di setiap instance. Jelas karena diekeduanya mengakhiri proses bercabang dan menulis output, itu tetap solusi terpendek.

C , 127 karakter, solusi yang agak jelas:

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

(Dikompilasi dengan gcc -std=c99 -fopenmp sort.cdan mengabaikan semua peringatan.)

Ruby 1.9, 32 karakter

Sebagai fungsi:

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

Jika kita bisa menggunakan variabel yang sudah ditentukan sebelumnya, itu berkurang menjadi 25 karakter:

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

JavaScript , 65 karakter (tergantung pada apakah Anda menggunakan console.logatau sesuatu yang lain untuk menghasilkan hasilnya)

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

Ini mengasumsikan bahwa itu aadalah array bilangan bulat non-negatif dan yang map()ada pada prototipe array (JavaScript 1.6+).

APL ( 15 13)

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

Apa fungsinya:

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

Empat percobaan di Erlang:

Output ke konsol, telah mengambil kebebasan untuk melakukan ini masing-masing 9ms * Numberkarena ini cukup banyak untuk membuatnya bekerja (diuji pada papan tertanam Atom = lambat):

Membutuhkan 60 karakter

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

Output ke konsol adalah total un-Erlangish, jadi kami mengirim pesan untuk diproses Psebagai gantinya:

Membutuhkan 55 karakter

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

Mengirim setelah beberapa waktu juga dapat dilakukan secara berbeda (ini bahkan bekerja dengan 1ms * Number):

Membutuhkan 41 karakter

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

Sebenarnya ini agak tidak adil karena fungsi send_afterbawaan adalah pendatang yang terlambat dan membutuhkan namespace erlang:diawali, jika kita menganggap namespace ini diimpor (dilakukan pada level modul):

Membutuhkan 34 karakter

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

C # - 137 karakter

Berikut adalah jawaban dalam C # (diperbarui dengan derajat paralelisme seperti yang dikomentari)

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

Tweaking @ BiggAl's code, karena itulah game yang kami mainkan ....

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

... atau 97 175 dengan thread tertunda mulai

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

Mengambil input melalui baris perintah, ala

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

Seperti halnya banyak golf python, ada satu titik di mana kodenya cukup ringkas sehingga aliasing variabel untuk mempersingkat nama bahkan tidak menyimpan karakter.

Yang satu ini funky karena alias alias dan threading KEDUA seperti t, jadi sys.argv menjadi t.argv. Lebih pendek daripada dari impor foo *, dan penghematan karakter bersih! Namun saya kira Guido tidak akan senang ...

Catatan untuk belajar sendiri c dan berhenti bermain golf dengan python. SAPI KUDUS INI LEBIH MUDAH DARI SOLUSI C!

Untuk bersenang-senang, inilah versi ColdFusion (8+) ;-) Ia memiliki 109 karakter tanpa menghitung garis pembungkus dan lekukan yang saya tambahkan untuk keterbacaan di sini.

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

Ini mengasumsikan bahwa <cfoutput>berlaku. Beberapa karakter dapat disimpan dengan menulis semuanya dalam satu baris.

Java (alias tidak pernah menang di codegolf): 234 211 187 karakter

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 karakter

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

Scala - 42 40 karakter (case khusus)

Jika Anda memiliki kumpulan utas setidaknya ukuran jumlah elemen daftar:

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

Scala - 72 karakter (umum)

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

Haskell - 143 karakter

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

Ini mungkin bisa dibuat lebih pendek dengan mengambil input pada stdin jika itu pilihan, tapi sudah terlambat dan bagaimanapun, masih 104 karakter untuk fungsi itu sendiri.

Befunge-98, 38 31 byte

Saya tahu ini adalah tantangan lama, tetapi saya baru-baru ini menemukan bahasa sleepsort dan 2D, memiliki ide tentang cara menggabungkannya, dan mencari tempat untuk mempostingnya, jadi inilah kami.

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

IP utama membaca angka ( &), lalu klik tyang mengkloningnya: satu menghasilkan pada baris dan siklus yang sama, membaca nomor baru dan menghasilkan anak baru hingga mencapai EOF yang mengakhiri urutan. Semua proses anak terjebak dalam lingkaran tertutup (yang vdan ^dari kolom ketiga) sampai IP utama selesai membaca input dan mengeksekusi urutan perintah '<21p, yang menempatkan karakter <pada posisi (1,2), Timpa ^dan membebaskan semua proses anak, yang mulai siklus secara bersamaan, mengurangi dengan 1 jumlah mereka di setiap iterasi. Karena kecepatan eksekusi IP yang berbeda disinkronkan di befunge, mereka akan mengakhiri (dan mencetak nilainya) secara berurutan, mengurutkan daftar input.

Sedikit terlambat ke pesta:

Maple - 91 83 karakter

Dalam 91:

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

Dalam 83:

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

(Ini membutuhkan Maple versi 15, dan mengharapkan daftar untuk diurutkan dalam L)

C, 70 69 karakter

Tidak menunggu proses anak kembali, jika tidak berfungsi.

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

PHP 57 byte

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

pcntl_fork () hanya tersedia di linux.

Bash (38):

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

Sunting: Floating-point dari stdin, dipisahkan oleh spasi atau baris baru.

Haskell, 90

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

Saya harap ini memenuhi semua persyaratan.

𝔼𝕊𝕄𝕚𝕟, 11 karakter / 22 byte

ïć⇝שĤ⇀ôa,a⸩

Try it here (Firefox only).

שĤ⇀ôa, ini terlihat keren.

Hanya beberapa penyesuaian dari versi @rmckenzie:

Ular Python tertunda mulai di 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 tanpa penundaan 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()

Mengelola beberapa optimisasi lebih banyak, menggunakan Timeralih-alih Thread, yang memiliki panggilan yang lebih ringkas dan menghilangkan kebutuhan untuk mengimpor time. Metode thread start yang tertunda mendapat manfaat dari pemahaman daftar karena menghilangkan kebutuhan untuk menginisialisasi daftar secara terpisah di awal, meskipun dua karakter lebih panjang ( "["+"]"+" "-":") daripada untuk loop sehingga tidak berguna tanpa awal yang tertunda, dan Anda harus berhati-hati menggunakan daftar daripada generator, atau Anda tidak benar-benar membuat utas pengatur waktu sampai Anda memotong-motong generator.

Apakah ada orang lain yang punya optimisasi?

Trik dengan asbantuan, tetapi dalam 2.7.1 Anda hanya dapat mengimpor satu modul ke alias, dan setelah beberapa bermain tentang Anda bahkan tidak bisa import mod1,mod2 as a,b, Anda harus import mod1 as a, mod2 as b. Itu masih menyimpan beberapa karakter, tetapi tidak cukup menyembuhkan-semua yang saya pikir itu ... Dan sebenarnya lebih baik meninggalkan sys sebagai sys. Mengurangi threading masih membantu ...

Clojure, 54

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

Karat - 150 byte

Dan inilah mengapa Anda tidak membuat kode golf di Rust, ini lebih bertele-tele daripada Jawa;). Tergantung pada peti eksternal crossbeam, akan lebih buruk tanpa itu.

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

Program tes lengkap:

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

Agak membosankan, port C #, hanya untuk memulai dengan bahasa lagi:

F # - 90 karakter

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

atau 71/65 karakter dengan tidak standar:

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

Tcl 8.6, 41 karakter

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

Anda harus membunuhnya dengan ^C

VB.NET 100 byte

Karena VB.Net membutuhkan lambdas baris tunggal untuk hanya berisi satu pernyataan, kode ini harus memiliki beberapa baris:

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

Tidak Disatukan:

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

Namun saya tidak yakin jika Anda menghitung laporan impor dalam jumlah byte karena jika Anda tidak menghitungnya maka saya bisa menulis ini:

VB.NET 71 byte

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

Tidak Disatukan:

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 byte

Mengasumsikan angka diberikan pada baris perintah ...

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

Mathematica, 34 atau 36 byte

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

Cukup tambahkan daftar untuk disortir hingga akhir kode ini dan evaluasi. Jika perlu definisi fungsi yang valid maka dibutuhkan dua byte tambahan:

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

C ++ 11, 229 byte

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

Tidak digabungkan dan digunakan:

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