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 หรือเมื่อมีการประกาศคุณสมบัติ 'พูด' คุณสามารถแทนที่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:

เอาท์พุทไปยังคอนโซลได้ใช้เสรีภาพในการทำสิ่งนี้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

Tweaking @ BiggAl's code เนื่องจากเป็นเกมที่เรากำลังเล่นอยู่ ....

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 golfs หลายจุดมีจุดที่รหัสมีขนาดเล็กพอที่ตัวแปรนามแฝงเพื่อย่อชื่อไม่ได้บันทึกตัวละคร

อันนี้ขี้ขลาดแม้ว่าเพราะมันเป็นนามแฝง sys และเกลียวทั้งเป็น t ดังนั้น sys.argv กลายเป็น t.argv สั้นกว่าจาก foo import * และการประหยัดอักขระสุทธิ! อย่างไรก็ตามฉันคิดว่ากุยโดจะไม่พอใจ ...

หมายเหตุถึงตนเองเรียนรู้ c และหยุดเล่นกอล์ฟในหลาม ศักดิ์สิทธิ์วัวนี่มันสั้นกว่าทางออก C!

เพื่อความสนุกนี่คือเวอร์ชัน ColdFusion (8+) ;-) มีอักขระ 109 ตัวที่ไม่นับการตัดบรรทัดและการเยื้องบรรทัดที่ฉันเพิ่มเพื่อความชัดเจน

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

สิ่งนี้จะถือว่า<cfoutput>มีผล สามารถบันทึกอักขระได้สองสามตัวโดยเขียนทุกบรรทัดในบรรทัดเดียว

Java (aka ไม่เคยชนะที่ 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])

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 bytes

ฉันรู้ว่านี่เป็นความท้าทายที่เก่าแก่ แต่เมื่อเร็ว ๆ นี้ฉันเพิ่งค้นพบทั้งภาษา sleepsort และ 2D มีความคิดเกี่ยวกับวิธีการรวมพวกเขาและมองหาสถานที่ที่จะโพสต์ดังนั้นที่นี่เราอยู่

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

IP หลักจะอ่านตัวเลข ( &) จากนั้นจะชนกับtโคลนอันใดอันหนึ่งคือดำเนินการในบรรทัดและรอบเดียวกันอ่านตัวเลขใหม่และสร้าง childs ใหม่จนกว่าจะถึง EOF ซึ่งจะยุติลำดับ กระบวนการลูกทั้งหมดติดค้างในวงปิด ( vและ^คอลัมน์ที่สาม) จนกระทั่ง IP หลักเสร็จสิ้นการอ่านอินพุตและดำเนินการตามลำดับของคำสั่ง'<21pซึ่งทำให้อักขระ<อยู่ที่ตำแหน่ง (1,2) เขียนทับ^และปล่อยทั้งหมด กระบวนการลูกซึ่งเริ่มวงจรพร้อมกันลด 1 หมายเลขของพวกเขาในแต่ละรอบ เนื่องจากความเร็วในการดำเนินการของ IP ที่แตกต่างกันจะถูกซิงโครไนซ์กันก่อนจึงจะยุติ (และพิมพ์ค่า) ตามลำดับเรียงลำดับรายการอินพุต

สายไปงานเลี้ยงเล็กน้อย:

Maple - 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 เท่านั้น

Bash (38):

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

แก้ไข: ทศนิยมจาก stdin คั่นด้วยช่องว่างหรือขึ้นบรรทัดใหม่

Haskell, 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()

จัดการ optimisations อีกไม่กี่ใช้Timerแทนซึ่งมีการเรียกร้องที่รัดกุมมากขึ้นและลบออกจำเป็นที่จะต้องนำเข้าThread timeวิธีการเธรดเริ่มต้นที่ล่าช้าจะได้ประโยชน์จากรายการความเข้าใจเนื่องจากไม่จำเป็นต้องกำหนดค่าเริ่มต้นรายการแยกกันตั้งแต่เริ่มต้นถึงแม้ว่าจะมีอักขระสองตัวที่ยาวกว่า ( "["+"]"+" "-":") มากกว่า for for loop ดังนั้นจึงไม่มีประโยชน์โดยไม่ต้องเริ่มล่าช้า แทนที่จะเป็นตัวสร้างหรือคุณไม่ได้สร้างเธรดตัวจับเวลาจนกว่าคุณจะผ่านตัวกำเนิด

ใครบ้างที่มีการเพิ่มประสิทธิภาพ

เคล็ดลับกับasช่วย แต่ใน 2.7.1 คุณสามารถนำเข้าโมดูลหนึ่งเป็นนามแฝงและหลังจากการเล่นเกี่ยวกับคุณไม่ได้คุณต้องimport mod1,mod2 as a,b import mod1 as a, mod2 as bมันยังช่วยรักษาตัวละครได้ไม่กี่ตัว แต่ก็ไม่ได้แก้อะไรทั้งหมดที่ฉันคิดว่ามันเป็น ... และในความเป็นจริงมันจะดีกว่าถ้าปล่อยให้ระบบเป็น 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 ต้องการ lambdas บรรทัดเดียวเพื่อให้มีคำสั่งเดียวเท่านั้นโค้ดนี้จึงต้องมีหลายบรรทัด:

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