Сонний сортування - це цілий алгоритм сортування, який я знайшов в Інтернеті. Він відкриває вихідний потік і паралельно для кожного вхідного числа затримується на число секунд і виводить це число. Через затримки найвища кількість буде виведена останньою. Я вважаю, що він має 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

Баребони: 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і ігнорує всі попередження.)

Рубін 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 ⍵

Чотири спроби в Ерланге:

Вийдіть на консоль, ви можете зробити це кожен, 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

Tweaking @ 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()

Вводиться через командний рядок, аля

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

Як і у багатьох гольфів-пітонів, настає момент, коли код є досить компактним, що зведення змінних для скорочення імен навіть не зберігає символи.

Цей фанк, хоча тому, що він псевдонімує sys і нанизує BOTH як t, тому sys.argv стає t.argv. Коротше, ніж від імпорту foo *, і економія чистого символу! Однак, гадаю, Гвідо не сподобається ...

Зауважте, щоб самостійно вивчити c та зупинити гольф у пітон. СВЯТА КОРОЦЬ ЦЕ БУДЬШЕ, ніж С РІШЕННЯ!

Для задоволення, ось версія ColdFusion (8+) ;-) У ній є 109 символів, не враховуючи обгортання рядків та відступи, які я додав для розбірливості.

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

Це передбачає, що <cfoutput>діє. Кілька символів можна зберегти, записавши все це в один рядок.

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 байт

Я знаю, що це давнє завдання, але я нещодавно виявив і сон, і 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];

(Для цього потрібна 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'

Редагувати: плаваюча точка від 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:

Початок запуску потоку 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()

Пітон без затримки в 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. Знизування різьби все ще допомагає ...

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

Ткл 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

Однак я не впевнений, якщо ви зараховуєте імпортні дані до байтових підрахунків, тому що якщо ви їх не порахуєте, я можу написати це:

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

Просто додайте список для сортування до кінця цього коду та оцініть. Якщо це має бути правильним визначенням функції, то він займає два зайвих байти:

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