Ngủ Sắp xếp là một thuật toán sắp xếp số nguyên tôi tìm thấy trên Internet. Nó mở một luồng đầu ra và cho mỗi số đầu vào song song, trì hoãn số giây và xuất số đó. Do sự chậm trễ, số lượng cao nhất sẽ được xuất ra cuối cùng. Tôi ước tính nó có O (n + m), trong đó n là số phần tử và m là số cao nhất.

Đây là mã gốc trong Bash

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

Đây là mã giả

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

Nhiệm vụ của bạn là thực hiện Sắp xếp giấc ngủ như một chức năng trong ngôn ngữ lập trình bạn chọn. Bạn có thể bỏ qua mọi yếu tố đồng thời như điều kiện cuộc đua và không bao giờ khóa bất kỳ tài nguyên được chia sẻ nào. Mã ngắn nhất sẽ thắng. Định nghĩa hàm tính vào chiều dài mã.

Danh sách đầu vào chỉ giới hạn ở các số nguyên không âm và độ dài của danh sách đầu vào dự kiến ​​sẽ dài một cách hợp lý (kiểm tra ít nhất 10 số) để điều kiện cuộc đua không bao giờ xảy ra. và giả sử điều kiện chủng tộc không bao giờ xảy ra.

Một loại nỗ lực khập khiễng Perl , 59 55 52 38 32 ký tự :

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

Barebones: 25 ký tự:

... nếu bạn không quan tâm đến kết quả sắp xếp là đầu ra chết:

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

Với tất cả các trang trí:

(để tuân thủ thử thách tối đa, 44 ký tự)

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

Nếu bạn để perl làm việc chờ bạn, 39 ký tự:

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

Và một lần nữa, nếu bạn không phiền die(), 32 ký tự ...

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

Lưu ý rằng trong Perl 6 hoặc khi tính năng 'say' được khai báo, có thể thay thế printchức năng bằng say, lưu một ký tự trong mỗi trường hợp. Rõ ràng vì diecả hai chấm dứt quá trình rẽ nhánh và ghi đầu ra, nó vẫn là giải pháp ngắn nhất.

C , 127 ký tự, một giải pháp khá rõ ràng:

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

(Được tổng hợp gcc -std=c99 -fopenmp sort.cvà bỏ qua tất cả các cảnh báo.)

Ruby 1.9, 32 ký tự

Là một chức năng:

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

Nếu chúng ta chỉ có thể sử dụng một biến được xác định trước, nó sẽ giảm xuống còn 25 ký tự:

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

JavaScript , 65 ký tự (tùy thuộc vào việc bạn sử dụng console.loghay cái gì khác để xuất kết quả)

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

Giả định anày là một mảng các số nguyên không âm và map()tồn tại trên nguyên mẫu mảng (JavaScript 1.6+).

APL ( 15 13)

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

Những gì nó làm:

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

Bốn lần thử trong Erlang:

Đầu ra cho bàn điều khiển, đã tự do thực hiện điều này 9ms * Numbervì nó đủ để làm cho nó hoạt động (được thử nghiệm trên bảng nhúng Atom = chậm):

Cần 60 ký tự

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

Đầu ra cho bàn điều khiển hoàn toàn không phải là Erlangish, vì vậy chúng tôi gửi tin nhắn để xử lý Pthay thế:

Cần 55 ký tự

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

Gửi sau một thời gian cũng có thể được thực hiện khác nhau (điều này thậm chí hoạt động với 1ms * Number):

Cần 41 ký tự

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

Trên thực tế điều này hơi không công bằng vì hàm dựng sẵn send_afterlà một máy tính đến muộn và cần không gian tên erlang:tiền tố, nếu chúng ta xem xét không gian tên này được nhập (được thực hiện ở cấp mô-đun):

Cần 34 ký tự

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

C # - 137 ký tự

Dưới đây là câu trả lời trong C # (được cập nhật với mức độ song song như đã nhận xét)

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

Con trăn - 81 93 148 150 153

Tinh chỉnh mã @ BiggAl, vì đó là trò chơi chúng tôi đang chơi ....

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

... hoặc 97 175 với sự chậm trễ bắt đầu

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

Đưa đầu vào qua dòng lệnh, ala

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

Cũng như nhiều sân golf python, có một điểm mà mã này đủ nhỏ gọn để các biến bí danh để rút ngắn tên thậm chí không lưu ký tự.

Điều này là thú vị mặc dù vì nó bí danh sys và luồng BÓNG như t, vì vậy sys.argv trở thành t.argv. Ngắn hơn so với nhập foo *, và tiết kiệm ký tự mạng! Tuy nhiên, tôi cho rằng Guido sẽ không hài lòng ...

Lưu ý để tự học c và ngừng chơi golf ở trăn. HOLY COW NÀY LÀ SHORTER HƠN GIẢI PHÁP C!

Để giải trí, đây là phiên bản ColdFusion (8+) ;-) Nó có 109 ký tự không kể các kết thúc dòng và thụt dòng mà tôi đã thêm cho mức độ dễ đọc ở đây.

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

Điều này giả định rằng <cfoutput>có hiệu lực. Một vài ký tự có thể được lưu bằng cách viết tất cả trên một dòng.

Java (aka không bao giờ thắng tại codegolf): 234 211 187 ký tự

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

vô dụng:

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 ký tự

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

Scala - 42 40 ký tự (trường hợp đặc biệt)

Nếu bạn có một nhóm luồng ít nhất là kích thước của số phần tử danh sách:

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

Scala - 72 ký tự (chung)

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

Haskell - 143 ký tự

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

Điều này có lẽ có thể được rút ngắn bằng cách lấy đầu vào trên stdin nếu đó là một tùy chọn, nhưng dù muộn và dù sao đi nữa, nó vẫn là 104 ký tự cho chính chức năng.

Befunge-98, 38 31 byte

Tôi biết đây là một thách thức cũ, nhưng tôi mới phát hiện ra cả hai ngôn ngữ ngủ và ngôn ngữ 2D, có ý tưởng về cách kết hợp chúng và tìm một nơi để đăng nó, vì vậy chúng tôi ở đây.

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

IP chính đọc một số ( &), sau đó nhấn vào tsố nhân bản của nó: một tiến hành trên cùng một dòng và chu kỳ, đọc số mới và tạo ra các con mới cho đến khi đạt đến EOF chấm dứt chuỗi. Tất cả các quá trình đứa trẻ gặp khó khăn trong một vòng khép kín (các vvà ^cột thứ ba) cho đến khi IP chính đọc xong đầu vào và thực hiện một chuỗi các lệnh '<21p, trong đó đặt các nhân vật <ở vị trí (1,2), ghi đè ^và giải phóng tất cả các tiến trình con, bắt đầu đồng thời chu kỳ, giảm 1 số của chúng ở mỗi lần lặp. Vì tốc độ thực thi của các IP khác nhau được đồng bộ hóa trong befunge, chúng sẽ chấm dứt (và in giá trị của chúng) theo thứ tự, sắp xếp danh sách đầu vào.

Một chút muộn để dự tiệc:

Maple - 91 83 ký tự

Năm 91:

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

Năm 83:

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

(Điều này cần Maple phiên bản 15 và hy vọng danh sách sẽ được sắp xếp theo L)

C, 70 69 ký tự

Không đợi các tiến trình con quay trở lại, nếu không thì hoạt động.

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 () chỉ có sẵn trong linux.

Bash (38):

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

Chỉnh sửa: Dấu phẩy động từ stdin, cách nhau bởi dấu cách hoặc dòng mới.

Haskell, 90

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

Tôi hy vọng điều này đáp ứng tất cả các yêu cầu.

, 11 ký tự / 22 byte

ïć⇝שĤ⇀ôa,a⸩

Try it here (Firefox only).

שĤ⇀ôa, điều này có vẻ mát mẻ.

Chỉ cần một số điều chỉnh từ phiên bản của @rmckenzie:

Python trì hoãn chủ đề bắt đầu trong 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 không chậm trễ trong 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()

Quản lý một vài tối ưu hóa hơn, sử dụng Timerthay vì Thread, có một cuộc gọi ngắn gọn hơn và loại bỏ nhu cầu nhập khẩu time. Phương thức bắt đầu luồng bị trễ có lợi từ việc hiểu danh sách vì nó loại bỏ sự cần thiết phải khởi tạo danh sách một cách riêng biệt khi bắt đầu, mặc dù nó dài hơn hai ký tự ( "["+"]"+" "-":") so với vòng lặp for nên nó vô dụng mà không bị trì hoãn và bạn phải cẩn thận khi sử dụng danh sách chứ không phải là một trình tạo, hoặc bạn không thực sự tạo ra các chuỗi thời gian cho đến khi bạn lướt qua trình tạo.

Có ai khác có bất kỳ tối ưu?

Thách thức đối với asgiúp, nhưng trong 2.7.1 bạn chỉ có thể nhập một mô-đun vào một bí danh, và sau khi một số chơi về, bạn có thể thậm chí không import mod1,mod2 as a,b, bạn phải import mod1 as a, mod2 as b. Nó vẫn cứu được một vài nhân vật, nhưng không hẳn là cách chữa trị - tất cả tôi nghĩ đó là ... Và trên thực tế, tốt hơn hết là để sys làm sys. Phân luồng bí danh vẫn giúp ...

Clojure, 54

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

Rust - 150 byte

Và đây là lý do tại sao bạn không viết mã golf trong Rust, nó dài dòng hơn Java;). Phụ thuộc vào thùng bên ngoài crossbeam, nó sẽ còn tồi tệ hơn nếu không có nó.

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

Hoàn thành chương trình kiểm tra:

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

Khá nhàm chán, cổng C #, chỉ để bắt đầu lại với ngôn ngữ:

F # - 90 ký tự

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

hoặc 71/65 ký tự không đạt tiêu chuẩn:

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

Tcl 8.6, 41 ký tự

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

Bạn phải giết nó với ^C

VB.NET 100 byte

Vì VB.Net yêu cầu lambdas dòng đơn chỉ chứa một câu lệnh, mã này phải có nhiều dòng:

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

Ung dung:

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

Tuy nhiên tôi không chắc nếu bạn đếm các câu lệnh nhập trong số byte bởi vì nếu bạn không đếm chúng thì tôi có thể viết điều này:

VB.NET 71 byte

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

Ung dung:

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

Giả sử số được đưa ra trên dòng lệnh ...

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

Toán học, 34 hoặc 36 byte

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

Chỉ cần nối thêm danh sách để được sắp xếp vào cuối mã này và đánh giá. Nếu nó cần phải là một định nghĩa hàm hợp lệ thì phải mất thêm hai byte:

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

Ungolfed và cách sử dụng:

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