수면 정렬은 인터넷에서 찾은 정수 정렬 알고리즘입니다. 출력 스트림을 열고 각 입력 숫자에 대해 병렬로 숫자 초 동안 지연시키고 해당 숫자를 출력합니다. 지연으로 인해 가장 높은 숫자가 마지막에 출력됩니다. 나는 그것이 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 개의 숫자 테스트) 레이스 조건이 발생하지 않습니다. 경쟁 조건이 발생하지 않는다고 가정합니다.

일종의 절름발이 펄 시도, 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}

펄이 당신을 기다리게하면 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모든 경고를 편집 하고 무시합니다.)

루비 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

많은 파이썬 골프와 마찬가지로 이름을 짧게하는 앨리어싱 변수가 문자를 저장하지 않을 정도로 코드가 컴팩트 한 지점이 있습니다.

이것은 sys의 별칭을 지정하고 BOTH를 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>효과가 있다고 가정합니다 . 한 줄에 모두 써서 몇 개의 문자를 저장할 수 있습니다.

자바 (일명 결코 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();
    }
}

자바 스크립트-52 자

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

스칼라 -42 40 자 (특별한 경우)

스레드 풀이 적어도 목록 요소 수의 크기 인 경우 :

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

스칼라-72 자 (일반)

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

하스켈-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 자입니다.

베 펀지 -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];

(이것은 메이플 버전 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 ()는 리눅스에서만 사용할 수 있습니다.

배쉬 (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의 버전에서 약간의 조정 :

파이썬 지연 스레드 시작 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()

지연없이 파이썬 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 루프보다 두 문자가 길기 때문에 ( ) 지연된 시작 없이는 쓸모가 없으므로 목록을 신중하게 사용해야합니다. 생성기가 아닌 생성기를 통과 할 때까지 실제로 타이머 스레드를 생성하지 않습니다.

다른 사람이 최적화를 했습니까?

와 트릭은 as도움이되지만 2.7.1에서 당신은 단지 별칭에 하나 개의 모듈을 가져올 수 있습니다, 그리고 당신에 대한 몇 가지 재생 후에도 수 없습니다 import mod1,mod2 as a,b, 당신은에 있습니다 import mod1 as a, mod2 as b. 그것은 여전히 ​​몇 문자를 절약하지만 내가 생각한 치료법은 아닙니다 ... 실제로 sys를 sys로 두는 것이 좋습니다. 앨리어싱 스레딩은 여전히 ​​도움이됩니다 ...

클로저, 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)

자바 스크립트, 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에는 단일 행 람다가 하나의 명령문 만 포함해야하므로이 코드에는 여러 행이 있어야합니다.

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

그러나 바이트 수로 imports 문을 계산하는지 확실하지 않은 경우 계산하지 않으면 다음과 같이 작성할 수 있습니다.

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

그루비, 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;
}