Implement Sleep Sort

Question

Sleep Sort is an integer sorting algorithm I found on the Internet. It opens an output stream, and for each input numbers in parallel, delay for the number seconds and output that number. Because of the delays, the highest number will be outputted last. I estimate it has O(n + m), where n is the number of elements and m is the highest number.

Here is the original code in Bash

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

Here is the pseudocode

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

Your task is to implement Sleep Sort as a function in the programming language of your choice. You can neglect any concurrency factors such as race conditions and never lock any shared resources. The shortest code wins. The function definition counts toward the code length.

The input list is limited to non-negative integers only, and the length of the input list is expected to reasonably long (test at least 10 numbers) so race conditions never happen. and assuming race conditions never happen.

Answer 1

JavaScript, 74

function(a){for(i=0;i<a.length;i++)setTimeout('alert('+a[i]+')',a[i]*1e3)}

or 71/65 characters with nonstandardness:

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

Answer 2

Tcl 8.6, 41 chars

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

You have to kill it with ^C

Answer 3

VB.NET 100 bytes

Because VB.Net requires single line lambdas to contain only one statement, this code has to have the multiple lines:

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

---

However I'm not sure if you count imports statements in the byte counts because if you don't count them then I could write this:

VB.NET 71 bytes

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

Answer 4

Groovy, 47 bytes

Assumes numbers are given on the command line...

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

Answer 5

Mathematica, 34 or 36 bytes

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

Just append the list to be sorted to the end of this code and evaluate. If it needs to be a valid function definition then it takes two extra bytes:

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

Answer 6

Java 9, 82 bytes

i->{i.parallelStream().map(j->{Thread.sleep(j);System.out.println(j);return 0;});}
i->{                                                                             }  //lambda: arguments: List<int> i
    i.parallelStream().map(                                                    );   //iterate over each item in a parallel thread
                           j->{                                               }     //lambda: arguments: int j
                               Thread.sleep(j);                                     //sleep j milliseconds
                                               System.out.println(j);               //print that int
                                                                     return 0;      //just some return value to fullfil the requirements of map()

Answer 7

Java - 106 bytes

l->l.forEach(x->new Thread(()->{try{Thread.sleep(x);System.out.println(x);}catch(Exception e){}}).start())

Complete test program:

import java.util.List;
import java.util.function.Consumer;

public class CG {
    public static void main(String[] args) {
        Consumer<List<Integer>> sleepSort = l->l.forEach(x->new Thread(()->{try{Thread.sleep(x);System.out.println(x);}catch(Exception e){}}).start());
        sleepSort.accept(List.of(3423, 143, 4545, 2545, 764, 5121, 2333, 944, 6555, 1066));
    }
}

Answer 8

Japt, 11 bytes

Ëe3 t{OpD
P

Try it online!

Unpacked & How it works

UmD{De3 t{OpD
P

UmD{  Map input array with the function...
De3 t{  Run the following function after D * 1000 milliseconds...
OpD       Print D with newline

P     Set "" as the thing to implicitly print

JS's setTimeout is obviously the winner. Unlike setInterval which is low-capped at 10ms, setTimeout doesn't have such an arbitrary limit.

If the delay need not be in seconds, the following works (and gives the result much faster):

8 bytes

Ët{OpD
P

Try it online!

Answer 9

PowerShell 6, 34 bytes

$args|%{$(sleep $_;$_)&}|rcjb -wai

Try it online!

See Background operator &

---

PowerShell, 48 bytes

$args|%{sajb{sleep $args;$args}-ar $_}|rcjb -wai

Try it online!

where:

• sajb is the predefined alias for start-job and
• rcjb is the predefined alias for receive-job

The default ThrottleLimit is 32.