Rosetta Code

Sorting algorithms/Sleep sort: Difference between revisions

Page Discussion

Sorting algorithms/Sleep sort (view source)

Revision as of 14:17, 8 March 2024

22,166 bytes added ,  2 months ago
m
→‎{{header|Elena}}
(→‎{{header|Python}}: Formatting changes)
 
(45 intermediate revisions by 31 users not shown)
Line 1:
{{task|Sorting Algorithms}}{{Sorting Algorithm}}
{{Sorting Algorithm}}
[[Category:Sorting]]
 
In general, sleep sort works by starting a separate task for each item to be sorted, where each task sleeps for an interval corresponding to the item's sort key, then emits the item. Items are then collected sequentially in time.
 
Task: Write a program that implements sleep sort. Have it accept non-negative integers on the command line and print the integers in sorted order. If this is not idomatic in your language or environment, input and output may be done differently. Enhancements for optimization, generalization, practicality, robustness, and so on are not required.
 
Sleep sort was [httphttps://disarchive.4chan.org/read/progfo/1295544154xhGo presented] anonymously on 4chan and has been [http://news.ycombinator.com/item?id=2657277 discussed] on Hacker News.
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;
with Ada.Command_Line; use Ada.Command_Line;
procedure SleepSort is
Line 21 ⟶ 24:
TaskList(i) := new PrintTask(Integer'Value(Argument(i)));
end loop;
end SleepSort;</langsyntaxhighlight>
{{out}}
<pre>./sleepsort 35 21 11 1 2 27 32 7 42 20 50 42 25 41 43 14 46 20 30 8
Line 27 ⟶ 30:
 
=={{header|APL}}==
<syntaxhighlight lang="apl">
<lang APL>
sleepsort←{{r}⎕TSYNC{r,←⊃⍵,⎕DL ⍵}&¨⍵,r←⍬}
</syntaxhighlight>
</lang>
 
=={{header|Assembly}}==
{{works with|flat assembler for Linux x64}}
<syntaxhighlight lang="asm">
format ELF64 executable 3
entry start
 
; parameters: argc, argv[] on stack
start:
mov r12, [rsp] ; get argc
mov r13, 1 ; skip argv[0]
 
.getargv:
cmp r13, r12 ; check completion of args
je .wait
mov rdi, [rsp+8+8*r13] ; get argv[n]
inc r13
 
mov rax, 57 ; sys_fork
syscall
 
cmp rax, 0 ; continue loop in main process
jnz .getargv
 
push rdi ; save pointer to sort item text
 
call atoi_simple ; convert text to integer
test rax, rax ; throw out bad input
js .done
 
sub rsp, 16 ; stack space for timespec
mov [rsp], rax ; seconds
mov qword [rsp+8], 0 ; nanoseconds
 
lea rdi, [rsp]
xor rsi, rsi
mov rax, 35 ; sys_nanosleep
syscall
 
add rsp, 16
 
pop rdi ; retrieve item text
call strlen_simple
 
mov rsi, rdi
mov byte [rsi+rax], ' '
mov rdi, 1
mov rdx, rax
inc rdx
mov rax, 1 ; sys_write
syscall
 
jmp .done
 
.wait:
dec r12 ; wait for each child process
jz .done
mov rdi, 0 ; any pid
mov rsi, 0
mov rdx, 0
mov r10, 4 ; that has terminated
mov rax, 247 ; sys_waitid
syscall
 
jmp .wait
 
.done:
xor rdi, rdi
mov rax, 60 ; sys_exit
syscall
 
; parameter: rdi = string pointer
; return: rax = integer conversion
atoi_simple:
push rdi
push rsi
 
xor rax, rax
 
.convert:
movzx rsi, byte [rdi]
test rsi, rsi ; check for null
jz .done
 
cmp rsi, '0'
jl .baddigit
cmp rsi, '9'
jg .baddigit
sub rsi, 48 ; get ascii code for digit
 
imul rax, 10 ; radix 10
add rax, rsi ; add current digit to total
 
inc rdi
jmp .convert
 
.baddigit:
mov rax, -1 ; return error code on failed conversion
 
.done:
pop rsi
pop rdi
ret ; return integer value
 
; parameter: rdi = string pointer
; return: rax = length
strlen_simple:
xor rax, rax
 
.compare:
cmp byte [rdi+rax], 0
je .done
inc rax
jmp .compare
 
.done:
ret
</syntaxhighlight>
{{out}}
<pre>
./sleepsort 35 21 11 1 2 27 32 7 42 20 50 42 25 41 43 14 46 20 30 8
1 2 7 8 11 14 20 20 21 25 27 30 32 35 41 42 42 43 46 50
</pre>
 
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">items := [1,5,4,9,3,4]
for i, v in SleepSort(items)
result .= v ", "
MsgBox, 262144, , % result := "[" Trim(result, ", ") "]"
return
 
SleepSort(items){
global Sorted := []
slp := 50
for i, v in items{
fn := Func("PushFn").Bind(v)
SetTimer, %fn%, % v * -slp
}
Sleep % Max(items*) * slp
return Sorted
}
 
PushFn(v){
global Sorted
Sorted.Push(v)
}</syntaxhighlight>
{{out}}
<pre>[1, 3, 4, 4, 5, 9]</pre>
 
=={{header|Bash}}==
<syntaxhighlight lang="bash">
function sleep_and_echo {
sleep "$1"
echo "$1"
}
 
for val in "$@"; do
sleep_and_echo "$val" &
done
 
wait
</syntaxhighlight>
 
{{out}}
 
<pre>
$ ./sleep_sort.sh 35 21 11 1 2 27 32 7 42 20 50 42 25 41 43 14 46 20 30 8
1
2
7
8
11
14
20
20
21
25
27
30
32
35
41
42
42
43
46
50
</pre>
 
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
This does not explicitly 'sleep', but uses timers to implement the different delays.
<langsyntaxhighlight lang="bbcbasic"> INSTALL @lib$+"TIMERLIB"
DIM test%(9)
Line 57 ⟶ 248:
DEF PROCtask7 : PRINT test%(7) : ENDPROC
DEF PROCtask8 : PRINT test%(8) : ENDPROC
DEF PROCtask9 : PRINT test%(9) : ENDPROC</langsyntaxhighlight>
'''Output:'''
<pre>
Line 73 ⟶ 264:
 
=={{header|Brainf***}}==
<syntaxhighlight lang="c">
<lang C>
>>>>>,----------[++++++++
++[->+>+<<]>+>[-<<+>>]+++
Line 82 ⟶ 273:
->>>>>[>>>>>]<-<<<<[<<<<<
]+<]<<<<]>>>>>[>>>>>]<]
</syntaxhighlight>
</lang>
Not exactly 'sleep' sort but it is similar,: it inputs an array of digits and in each iteration reduces elements by 1. andWhen printsan theelement numberbecomes if0 result– isit 0prints the original digit.
 
Input: 1539\n
Line 90 ⟶ 281:
 
=={{header|C}}==
<langsyntaxhighlight Clang="c">#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
Line 102 ⟶ 293:
wait(0);
return 0;
}</langsyntaxhighlight>
Running it:<syntaxhighlight lang="text">% ./a.out 5 1 3 2 11 6 4
1
2
Line 110 ⟶ 301:
5
6
11</langsyntaxhighlight>
If you worry about time efficiency of this sorting algorithm (ha!), you can make it a 100 times faster by replacing the <code>sleep(...</code> with <code>usleep(10000 * (c = atoi(v[c])))</code>. The smaller the coefficient, the faster it is, but make sure it's not comparable to your kernel clock ticks or the wake up sequence will be wrong.
 
=={{header|C++}}==
<lang cpp>
#include <chrono>
#include <iostream>
#include <thread>
#include <vector>
 
int main(int argc, char* argv[]) {
std::vector<std::thread> threads;
 
for (int i = 1; i < argc; ++i) {
threads.emplace_back([i, &argv]() {
int arg = std::stoi(argv[i]);
std::this_thread::sleep_for(std::chrono::seconds(arg));
std::cout << argv[i] << std::endl;
});
}
 
for (auto& thread : threads) {
thread.join();
}
}
</lang>
{{out}}
<pre>
./a.out 8 15 14 9 17 20 16 24 6 24 21 23 19 23 19
6
8
9
14
15
16
17
19
19
20
21
23
23
24
24
</pre>
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
Line 182 ⟶ 330:
SleepSort(arguments.Select(int.Parse));
}
}</langsyntaxhighlight>
 
===Using Tasks===
 
<langsyntaxhighlight lang="csharp">var input = new[] { 1, 9, 2, 1, 3 };
 
foreach (var n in input)
Line 194 ⟶ 342:
Console.WriteLine(n);
});
</syntaxhighlight>
</lang>
 
Output, i.e. in LINQPad:
Line 203 ⟶ 351:
3
9</pre>
 
=={{header|C++}}==
<syntaxhighlight lang="cpp">
#include <chrono>
#include <iostream>
#include <thread>
#include <vector>
 
int main(int argc, char* argv[]) {
std::vector<std::thread> threads;
 
for (int i = 1; i < argc; ++i) {
threads.emplace_back([i, &argv]() {
int arg = std::stoi(argv[i]);
std::this_thread::sleep_for(std::chrono::seconds(arg));
std::cout << argv[i] << std::endl;
});
}
 
for (auto& thread : threads) {
thread.join();
}
}
</syntaxhighlight>
{{out}}
<pre>
./a.out 8 15 14 9 17 20 16 24 6 24 21 23 19 23 19
6
8
9
14
15
16
17
19
19
20
21
23
23
24
24
</pre>
 
=={{header|Clojure}}==
Using core.async
<langsyntaxhighlight lang="clojure">(ns sleepsort.core
(require [clojure.core.async :as async :refer [chan go <! <!! >! timeout]]))
 
Line 214 ⟶ 405:
(go (<! (timeout (* 1000 i)))
(>! c i)))
(<!! (async/into [] (async/take (count l) c)))))</langsyntaxhighlight>
<langsyntaxhighlight lang="clojure">(sleep-sort [4 5 3 1 2 7 6])
;=> [1 2 3 4 5 6 7]</langsyntaxhighlight>
 
=={{header|CoffeeScript}}==
{{works_with|node.js}}
<langsyntaxhighlight lang="coffeescript">
after = (s, f) -> setTimeout f, s*1000
 
Line 232 ⟶ 423:
input = (parseInt(arg) for arg in process.argv[2...])
sleep_sort input
</syntaxhighlight>
</lang>
output
<syntaxhighlight lang="text">
> time coffee sleep_sort.coffee 5, 1, 3, 4, 2
1
Line 245 ⟶ 436:
user 0m0.147s
sys 0m0.024s
</syntaxhighlight>
</lang>
 
=={{header|Common Lisp}}==
{{works_with|SBCL}}
<langsyntaxhighlight lang="lisp">(defun sleeprint(n)
(sleep (/ n 10))
(format t "~a~%" n))
Line 256 ⟶ 447:
(sb-thread:make-thread (lambda() (sleeprint (parse-integer arg)))))
 
(loop while (not (null (cdr (sb-thread:list-all-threads)))))</langsyntaxhighlight>
{{Out}}
<pre>$ sbcl --script ss.cl 3 1 4 1 5
Line 267 ⟶ 458:
 
=={{header|D}}==
<syntaxhighlight lang="d">void main(string[] args)
<lang d>
import core.thread, std.concurrency, std.datetime,
std.stdio, std.algorithm, std.conv;
 
void main(string[] args)
{
import core.thread, std;
if (!args.length)
args.drop(1).map!(a => a.to!uint).parallel.each!((a)
return;
{
 
Thread.sleep(dur!"msecs"(a));
foreach (number; args[1 .. $].map!(to!uint))
spawnwrite((uinta, num" ") {;
});
Thread.sleep(dur!"msecs"(10 * num));
}</syntaxhighlight>
writef("%d ", num);
}, number);
 
thread_joinAll();
}
 
</lang>
{{out}}
<pre>$ ./sorting_algorithms_sleep_sort 200 20 50 10 80
<pre>sorting_algorithms_sleep_sort 1 6 2 5 3 4
110 220 350 480 5 6200</pre>
 
=={{header|Dart}}==
<syntaxhighlight lang ="dart">import 'dart:async';
void main() async {
Future<void> sleepsort(Iterable<int> input) => Future.wait(input
.map((i) => Future.delayed(Duration(milliseconds: i), () => print(i))));
 
await sleepsort([3, 10, 2, 120, 122, 121, 54]);
Future<List<int>> sleepsort(List<int> input) {
List<Future<int>> tasks = [];
List<int> result = [];
for (int i in input) {
tasks.add(new Future.delayed(new Duration(seconds: i), () {
result.add(i);
}));
}
return Future.wait(tasks).then((_) {
return result;
});
}
</syntaxhighlight>
 
sleepsort.sleepsort([3, 1, 2]).then((List<int> sorted) {
print(sorted);
});
</lang>
{{out}}
<pre>1 2 3</pre>
2
3
10
54
120
121
122
</pre>
 
=={{header|Delphi}}==
<langsyntaxhighlight Delphilang="delphi">program SleepSortDemo;
 
{$APPTYPE CONSOLE}
Line 372 ⟶ 550:
Writeln;
ReadLn;
end.</langsyntaxhighlight>
Output:
<pre>
Line 378 ⟶ 556:
0 0 0 1 1 2 3 4 4 4 5 6 7 10 12 12
</pre>
 
=={{header|Elena}}==
ELENA 36.40 :
<langsyntaxhighlight lang="elena">import extensions.;
import system'routines.;
import extensions'threading.;
import system'threading;
static sync = new object();
extension op
{
sleepSort()
[{
self .forEach(::(n)
[{
threadControl .start:(
[{
var a := threadControl.sleep(1000 * n.);
threadControl sleeplock(1000 * nsync).
console printLine(n).{
] console.printLine(n)
] }
] })
}
}
}
 
public program()
{
[
program_arguments .skipping:(1; ).selectBy(%"convertorOp.mssgconst toInt"<intConvertOp>[1]); .toArray; sleepSort().sleepSort();
 
console .readChar()
}</syntaxhighlight>
]</lang>
 
=={{header|Elixir}}==
{{trans|Erlang}}
<langsyntaxhighlight lang="elixir">defmodule Sort do
def sleep_sort(args) do
Enum.each(args, fn(arg) -> Process.send_after(self, arg, 5 * arg) end)
Line 425 ⟶ 609:
end
 
Sort.sleep_sort [2, 4, 8, 12, 35, 2, 12, 1]</langsyntaxhighlight>
 
{{out}}
Line 437 ⟶ 621:
12
35
</pre>
 
=={{header|Emacs Lisp}}==
GNU Emacs supports threads, but it's more straightforward to do this by just using timers.
Evaluate in the *scratch* buffer by typing <code>C-M-x</code> on the expression:
<syntaxhighlight lang="lisp">(dolist (i '(3 1 4 1 5 92 65 3 5 89 79 3))
(run-with-timer (* i 0.001) nil 'message "%d" i))</syntaxhighlight>
 
The output printed in the *Messages* buffer is:
<pre>
1 [2 times]
3 [3 times]
4
5 [2 times]
65
79
89
92
</pre>
 
=={{header|Erlang}}==
<langsyntaxhighlight lang="erlang">#!/usr/bin/env escript
%% -*- erlang -*-
%%! -smp enable -sname sleepsort
Line 457 ⟶ 659:
io:format("~s~n", [Num]),
loop(N - 1)
end.</langsyntaxhighlight>
{{out}}
<pre>./sleepsort 2 4 8 12 35 2 12 1
Line 470 ⟶ 672:
 
=={{header|Euphoria}}==
<langsyntaxhighlight lang="euphoria">include get.e
 
integer count
Line 500 ⟶ 702:
task_yield()
end while
end if</langsyntaxhighlight>
 
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
let sleepSort (values: seq<int>) =
values
|> Seq.map (fun x -> async {
do! Async.Sleep x
Console.WriteLine x
})
|> Async.Parallel
|> Async.Ignore
|> Async.RunSynchronously
</syntaxhighlight>
 
Usage:
<syntaxhighlight lang="fsharp">
sleepSort [10; 33; 80; 32]
10
32
33
80
</syntaxhighlight>
 
=={{header|Factor}}==
 
<syntaxhighlight lang="factor">
<lang Factor>
USING: threads calendar concurrency.combinators ;
 
: sleep-sort ( seq -- ) [ dup seconds sleep . ] parallel-each ;
</syntaxhighlight>
</lang>
 
Usage:
 
<syntaxhighlight lang="factor">
<lang Factor>
{ 1 9 2 6 3 4 5 8 7 0 } sleep-sort
</syntaxhighlight>
</lang>
 
=={{header|Fortran}}==
<syntaxhighlight lang="fortran">
program sleepSort
use omp_lib
implicit none
integer::nArgs,myid,i,stat
integer,allocatable::intArg(:)
character(len=5)::arg
 
!$omp master
nArgs=command_argument_count()
if(nArgs==0)stop ' : No argument is given !'
allocate(intArg(nArgs))
do i=1,nArgs
call get_command_argument(i, arg)
read(arg,'(I5)',iostat=stat)intArg(i)
if(intArg(i)<0 .or. stat/=0) stop&
&' :Only 0 or positive integer allowed !'
end do
call omp_set_num_threads(nArgs)
!$omp end master
 
!$omp parallel private(myid)
myid =omp_get_thread_num()
call sleepNprint(intArg(myid+1))
!$omp end parallel
 
contains
subroutine sleepNprint(nSeconds)
integer::nSeconds
call sleep(nSeconds)
print*,nSeconds
end subroutine sleepNprint
end program sleepSort
</syntaxhighlight>
Compile and Output:
<pre>
gfortran -fopenmp sleepSort.f90 -o sleepSort
./sleepSort 0 3 1 4 1 5 9
0
1
1
3
4
5
9
</pre>
 
=={{header|FreeBASIC}}==
Can't use FreeBASIC '''sleep''' since it halts the program.
Instead it uses a second array filled with times based on the value of number, this array is check against the timer. If the timer is past the stored time the value is printed.
<langsyntaxhighlight lang="freebasic">' version 21-10-2016
' compile with: fbc -s console
' compile with: fbc -s console -exx (for bondry check on the array's)
Line 576 ⟶ 849:
Print : Print "hit any key to end program"
Sleep
End</langsyntaxhighlight>
{{out}}
<pre>unsorted 5 2 5 6 4 6 9 5 1 2 0
 
sorted 0 1 2 2 4 5 5 5 6 6 9</pre>
 
=={{header|Fortran}}==
<lang Fortran>
program sleepSort
use omp_lib
implicit none
integer::nArgs,myid,i,stat
integer,allocatable::intArg(:)
character(len=5)::arg
 
!$omp master
nArgs=command_argument_count()
if(nArgs==0)stop ' : No argument is given !'
allocate(intArg(nArgs))
do i=1,nArgs
call get_command_argument(i, arg)
read(arg,'(I5)',iostat=stat)intArg(i)
if(intArg(i)<0 .or. stat/=0) stop&
&' :Only 0 or positive integer allowed !'
end do
call omp_set_num_threads(nArgs)
!$omp end master
 
!$omp parallel private(myid)
myid =omp_get_thread_num()
call sleepNprint(intArg(myid+1))
!$omp end parallel
 
contains
subroutine sleepNprint(nSeconds)
integer::nSeconds
call sleep(nSeconds)
print*,nSeconds
end subroutine sleepNprint
end program sleepSort
</lang>
Compile and Output:
<pre>
gfortran -fopenmp sleepSort.f90 -o sleepSort
./sleepSort 0 3 1 4 1 5 9
0
1
1
3
4
5
9
</pre>
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 657 ⟶ 881:
fmt.Println(<-out)
}
}</langsyntaxhighlight>
Usage and output:
<pre>./sleepsort 3 1 4 1 5 9
Line 667 ⟶ 891:
9
</pre>
 
=== Using sync.WaitGroup ===
<syntaxhighlight lang="go">package main
 
import (
"fmt"
"log"
"os"
"strconv"
"sync"
"time"
)
 
func main() {
var wg sync.WaitGroup
wg.Add(len(os.Args[1:]))
for _,i := range os.Args[1:] {
x, err := strconv.ParseUint(i, 10, 64)
if err != nil {
log.Println(err)
}
wg.Add(1)
go func(i uint64, wg *sync.WaitGroup) {
defer wg.Done()
time.Sleep(time.Duration(i) * time.Second)
fmt.Println(i)
}(x, &wg)
}
wg.Wait()
}</syntaxhighlight>
 
Usage and output are the same as the version using channels. Note that the original version would sleep for increments of 1 full second, so I made my code do the same.
 
=={{header|Groovy}}==
<langsyntaxhighlight lang="groovy">
@Grab(group = 'org.codehaus.gpars', module = 'gpars', version = '1.2.1')
import groovyx.gpars.GParsPool
Line 679 ⟶ 935:
}
}
</syntaxhighlight>
</lang>
 
Sample Run:
Line 692 ⟶ 948:
=={{header|Haskell}}==
 
<langsyntaxhighlight lang="haskell">import System.Environment
import Control.Concurrent
import Control.Monad
Line 703 ⟶ 959:
 
main :: IO ()
main = getArgs >>= sleepSort . map read</langsyntaxhighlight>
 
===Using mapConcurrentlymapConcurrently_===
<langsyntaxhighlight lang="haskell">import System.Environment
import Control.Concurrent
import Control.Concurrent.Async
 
sleepSort :: [Int] -> IO ()
sleepSort = (() <$) . mapConcurrentlymapConcurrently_ (\x -> threadDelay (x*10^4) >> print x)
 
main :: IO ()
main = getArgs >>= sleepSort . map read</langsyntaxhighlight>
 
This is problematic for inputs with multiple duplicates like <code>[1,2,3,1,4,1,5,1]</code> because simultaneous <code>print</code>s are done concurrently and the 1s and newlines get output in jumbled up order. The channels-based version above doesn't have this problem.
Line 722 ⟶ 978:
The following solution only works in Unicon.
 
<langsyntaxhighlight lang="unicon">procedure main(A)
every insert(t:=set(),mkThread(t,!A))
every spawn(!t) # start threads as closely grouped as possible
Line 730 ⟶ 986:
procedure mkThread(t,n) # 10ms delay scale factor
return create (delay(n*10),delete(t,&current),n@>&main)
end</langsyntaxhighlight>
 
Sample run:
Line 746 ⟶ 1,002:
->
</pre>
 
=={{header|J}}==
 
{{works with|J|903+}}
<syntaxhighlight lang="j">scheduledumb=: {{
id=:'dumb',":x:6!:9''
wd 'pc ',id
(t)=: u {{u y[erase n}} t=. id,'_timer'
wd 'ptimer ',":n p.y
}}
 
 
ssort=: {{
R=: ''
poly=. 1,>./ y
poly{{ y{{R=:R,m[y}}scheduledumb m y}}"0 y
{{echo R}} scheduledumb poly"0 >:>./ y
EMPTY
}}</syntaxhighlight>
 
Task example:
 
<syntaxhighlight lang="j"> t=: ?~30
t
11 7 22 16 17 2 1 19 23 29 9 21 15 10 12 27 3 4 24 20 14 5 26 18 8 6 0 13 25 28
ssort t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29</syntaxhighlight>
 
Note that since t is the result of an RNG, the order of values in t would be different in subsequent attempts. For example:
 
<syntaxhighlight lang="j"> t=: ?~30
t
23 26 24 25 10 12 4 5 7 27 16 17 14 8 3 15 18 13 19 21 2 28 22 9 6 20 11 1 29 0
ssort t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29</syntaxhighlight>
 
=={{header|Java}}==
{{works with|Java|1.5+}}
<langsyntaxhighlight lang="java5">import java.util.concurrent.CountDownLatch;
 
public class SleepSort {
Line 779 ⟶ 1,070:
sleepSortAndPrint(nums);
}
}</langsyntaxhighlight>
Output (using "3 1 4 5 2 3 1 6 1 3 2 5 4 6" as arguments):
<pre>1
Line 797 ⟶ 1,088:
 
=={{header|JavaScript}}==
<langsyntaxhighlight lang="javascript">Array.prototype.timeoutSort = function (f) {
this.forEach(function (n) {
setTimeout(function () { f(n) }, 5 * n)
});
}
</syntaxhighlight>
</lang>
Usage and output:
<langsyntaxhighlight lang="javascript">[1, 9, 8, 7, 6, 5, 3, 4, 5, 2, 0].timeoutSort(function(n) { document.write(n + '<br>'); })</langsyntaxhighlight>
<pre>
0
Line 818 ⟶ 1,109:
</pre>
 
<langsyntaxhighlight lang="javascript">Array.prototype.sleepSort = function(callback) {
const res = [];
for (let n of this)
Line 831 ⟶ 1,122:
[1, 9, 8, 7, 6, 5, 3, 4, 5, 2, 0].sleepSort(console.log);
// [ 1, 0, 2, 3, 4, 5, 5, 6, 7, 8, 9 ]
</syntaxhighlight>
</lang>
 
=={{header|jq}}==
Line 838 ⟶ 1,129:
Doesn't actually sleep. Instead, iterates reducing the values by one until each is zero.
 
<langsyntaxhighlight lang="jq">echo '[5, 1, 3, 2, 11, 6, 4]' | jq '
def f:
if .unsorted == [] then
Line 848 ⟶ 1,139:
end;
{unsorted: [.[] | {v: ., t: .}], sorted: []} | f | .[]
'</langsyntaxhighlight>
{{out}}
<pre>1
Line 859 ⟶ 1,150:
 
=={{header|Julia}}==
{{works with|Julia|01.6}}
 
<langsyntaxhighlight lang="julia">function sleepsort(arrV::Vector{T}) where {T <: Real})
outU = Vector{eltype(arr)T}(0)
sizehint!(outU, length(arrV))
@sync for xv in arrV
@async begin
sleep(xabs(v))
(v < 0 ? pushfirst! : push!)(outU, xv)
end
end
return outU
end
 
 
 
v = rand(-10:10, 10)
println("# unordered: $v\n -> ordered: ", sleepsort(v))</langsyntaxhighlight>
 
{{out}}
<pre># unordered: [910, 5-1, 3, 8-9, 81, 2-5, 5-8, 2-7, 5-3, 53]
-> ordered: [2-9, 2-8, 3-7, -5, 5-3, 5-1, 51, 83, 83, 910]</pre>
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.1.51
 
import kotlin.concurrent.thread
Line 903 ⟶ 1,196:
println("Unsorted: ${list.joinToString(" ")}")
sleepSort(list, 50)
}</langsyntaxhighlight>
 
Sample output:
<pre>
$ java -jar sleepsort.jar 5 7 -1 2 4 1 8 0 3 9 6
Unsorted: 5 7 2 4 1 8 0 3 9 6
Sorted : 0 1 2 3 4 5 6 7 8 9
</pre>
 
=== Using coroutines ===
<syntaxhighlight lang="kotlin">
import kotlinx.coroutines.*
 
fun sleepSort(list: List<Int>, delta: Long) {
runBlocking {
list.onEach {
launch {
delay(it * delta)
print("$it ")
}
}
}
}
 
fun main() {
val list = listOf(5, 7, 2, 4, 1, 8, 0, 3, 9, 6)
println("Unsorted: ${list.joinToString(" ")}")
print("Sorted : ")
sleepSort(list, 10)
}
 
</syntaxhighlight>
 
Output:
<pre>
Unsorted: 5 7 2 4 1 8 0 3 9 6
Sorted : 0 1 2 3 4 5 6 7 8 9
Line 915 ⟶ 1,238:
Here's a slow implementation using only stock C Lua:
 
<langsyntaxhighlight lang="lua">function sleeprint(n)
local t0 = os.time()
while os.time() - t0 <= n do
Line 941 ⟶ 1,264:
end
end
end</langsyntaxhighlight>
 
By installing LuaSocket, you can get better than 1-second precision on the clock, and therefore faster output:
 
<langsyntaxhighlight lang="lua">socket = require 'socket'
 
function sleeprint(n)
Line 973 ⟶ 1,296:
end
end
end</langsyntaxhighlight>
 
Either way, the output is the same:
Line 993 ⟶ 1,316:
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight lang="mathematica">SleepSort = RunScheduledTask[Print@#, {#, 1}] & /@ # &;
SleepSort@{1, 9, 8, 7, 6, 5, 3, 4, 5, 2, 0};</langsyntaxhighlight>
{{Out}}
<pre>
Line 1,013 ⟶ 1,336:
As implemented this sample goes beyond the scope of the task as defined; it will handle negative numbers.
 
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols nobinary
import java.util.concurrent.CountDownLatch
Line 1,072 ⟶ 1,395:
parent.getDoneLatch().countDown() -- this one's done; decrement the latch
return
</syntaxhighlight>
</lang>
'''Output:'''
<pre>
Line 1,081 ⟶ 1,404:
=={{header|Nim}}==
Compile with <code>nim --threads:on c sleepsort</code>:
<langsyntaxhighlight lang="nim">import os, strutils
 
proc single(n: int) =
Line 1,093 ⟶ 1,416:
thr.joinThreads
 
main()</langsyntaxhighlight>
Usage:
<pre>$ ./sleepsort 5 1 3 2 11 6 4
Line 1,105 ⟶ 1,428:
 
=={{header|Objeck}}==
<langsyntaxhighlight lang="objeck">
use System.Concurrency;
use Collection;
Line 1,137 ⟶ 1,460:
}
}
</syntaxhighlight>
</lang>
 
=={{header|Objective-C}}==
<langsyntaxhighlight lang="objc">#import <Foundation/Foundation.h>
 
int main(int argc, char **argv)
Line 1,153 ⟶ 1,476:
}
[queue waitUntilAllOperationsAreFinished];
}</langsyntaxhighlight>
Rather than having multiple operations that sleep, we could also dispatch the tasks after a delay:
<langsyntaxhighlight lang="objc">#import <Foundation/Foundation.h>
 
int main(int argc, char **argv)
Line 1,165 ⟶ 1,488:
^{ NSLog(@"%d\n", i); });
}
}</langsyntaxhighlight>
 
=={{header|Oforth}}==
Line 1,173 ⟶ 1,496:
20 milliseconds is used to (try to) handle scheduler tick on Windows systems (around 15 ms). On Linux systems (after kernel 2.6.8), this value can be smaller.
 
<langsyntaxhighlight Oforthlang="oforth">import: parallel
 
: sleepSort(l)
Line 1,179 ⟶ 1,502:
Channel new ->ch
l forEach: n [ #[ n dup 20 * sleep ch send drop ] & ]
ListBuffer newSize(l size) #[ ch receive over add ] times(l size) ;</langsyntaxhighlight>
 
{{out}}
Line 1,194 ⟶ 1,517:
3, 93, 94, 94, 95, 95, 96, 96, 97, 97, 98, 98, 99, 99, 100, 100]
</pre>
 
=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(define (sleep-sort lst)
(for-each (lambda (timeout)
(async (lambda ()
(sleep timeout)
(print timeout))))
lst))
 
(sleep-sort '(5 8 2 7 9 10 5))
</syntaxhighlight>
{{Out}}
<pre>
2
5
5
7
8
9
10
</pre>
 
=={{header|Pascal}}==
{{works with|Free Pascal}}
my limit under linux was 4000 threads nearly 2 GB.
<syntaxhighlight lang="pascal">
program sleepsort;
{$IFDEF FPC}
{$MODE DELPHI} {$Optimization ON,ALL}
{$ElSE}
{$APPTYPE CONSOLE}
{$ENDIF}
uses
{$IFDEF UNIX}
cthreads,
{$ENDIF}
SysUtils;
 
const
HiLimit = 40;
type
tCombineForOneThread = record
cft_count : Uint64;
cft_ThreadID: NativeUint;
cft_ThreadHandle: NativeUint;
end;
pThreadBlock = ^tCombineForOneThread;
var
SortIdx : array of INteger;
ThreadBlocks : array of tCombineForOneThread;
gblThreadCount,
Finished: Uint32;
 
procedure PrepareThreads(thdCount:NativeInt);
var
i : NativeInt;
Begin
For i := 0 to thdCount-1 do
ThreadBlocks[i].cft_count:= random(2*HiLimit);
end;
 
procedure TestRunThd(parameter: pointer);
var
pThdBlk: pThreadBlock;
fi: NativeInt;
begin
pThdBlk := @ThreadBlocks[NativeUint(parameter)];
with pThdBlk^ do
begin
sleep(40*cft_count+1);
fi := Finished-1;
//write(fi:5,cft_count:8,#13);
InterLockedDecrement(Finished);
SortIdx[fi]:= NativeUint(parameter);
end;
EndThread(0);
end;
 
procedure Test;
var
j,UsedThreads: NativeInt;
begin
randomize;
UsedThreads:= GblThreadCount;
Finished :=UsedThreads;
PrepareThreads(UsedThreads);
j := 0;
while (j < UsedThreads) do
begin
with ThreadBlocks[j] do
begin
cft_ThreadHandle :=
BeginThread(@TestRunThd, Pointer(j), cft_ThreadID,16384 {stacksize} );
If cft_ThreadHandle = 0 then break;
end;
Inc(j);
end;
writeln(j);
UsedThreads := j;
Finished :=UsedThreads;
repeat
sleep(1);
until finished = 0;
For j := 0 to UsedThreads-1 do
CloseThread(ThreadBlocks[j].cft_ThreadID);
 
//output of sleep-sorted data
For j := UsedThreads-1 downto 1 do
write(ThreadBlocks[SortIdx[j]].cft_count,',');
writeln(ThreadBlocks[SortIdx[0]].cft_count);
end;
 
 
begin
randomize;
gblThreadCount := Hilimit;
Writeln('Testthreads : ',gblThreadCount);
setlength(ThreadBlocks,gblThreadCount);
setlength(SortIdx,gblThreadCount);
Test;
 
setlength(ThreadBlocks, 0);
{$IFDEF WINDOWS}
readln;
{$ENDIF}
end.</syntaxhighlight>
{{out}}
<pre>time ./sleepsort
Testthreads : 40
40
1,8,9,10,11,12,12,13,14,18,24,24,24,26,28,35,35,37,42,49,50,52,54,54,56,57,59,60,61,62,64,69,69,71,72,73,76,77,78,79
 
real 0m3,164s</pre>
 
=={{header|Perl}}==
Basically the C code.
<langsyntaxhighlight Perllang="perl">1 while ($_ = shift and @ARGV and !fork);
sleep $_;
print "$_\n";
wait;</langsyntaxhighlight>
 
 
A more optimal solution makes use of Coro, a cooperative threading library. It has the added effect of being much faster, fully deterministic (sleep is not exact), and it allows you to easily collect the return value:
<langsyntaxhighlight Perllang="perl">use Coro;
$ret = Coro::Channel->new;
@nums = qw(1 32 2 59 2 39 43 15 8 9 12 9 11);
Line 1,215 ⟶ 1,672:
}
 
print $ret->get,"\n" for 1..@nums;</langsyntaxhighlight>
 
=={{header|Perl 6Phix}}==
Based on [[Sorting_algorithms/Sleep_sort#Euphoria|Euphoria]]
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (multitasking)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">count</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">sleeper</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">key</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span> <span style="color: #000000;">key</span> <span style="color: #000080;font-style:italic;">-- (or maybe res &= key)</span>
<span style="color: #000000;">count</span> <span style="color: #0000FF;">-=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000080;font-style:italic;">--sequence s = command_line()[3..$]</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"3 1 4 1 5 9 2 6 5"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Nothing to sort.\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">else</span>
<span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">object</span> <span style="color: #000000;">si</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">to_number</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>
<span style="color: #008080;">if</span> <span style="color: #004080;">integer</span><span style="color: #0000FF;">(</span><span style="color: #000000;">si</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">task</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">task_create</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sleeper</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">si</span><span style="color: #0000FF;">})</span>
<span style="color: #7060A8;">task_schedule</span><span style="color: #0000FF;">(</span><span style="color: #000000;">task</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">si</span><span style="color: #0000FF;">/</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">si</span><span style="color: #0000FF;">/</span><span style="color: #000000;">10</span><span style="color: #0000FF;">})</span>
<span style="color: #000000;">count</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">count</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">task_yield</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<!--</syntaxhighlight>-->
 
=={{header|PHP}}==
<lang perl6>await map -> $delay { start { sleep $delay ; say $delay } },
A PHP implementation of sleep sort using process forking.
<6 8 1 12 2 14 5 2 1 0>;</lang>
<syntaxhighlight lang="php">
<?php
 
$buffer = 1;
{{out}}
$pids = [];
<pre>0
 
1
for ($i = 1; $i < $argc; $i++) {
$pid = pcntl_fork();
if ($pid < 0) {
die("failed to start child process");
}
 
if ($pid === 0) {
sleep($argv[$i] + $buffer);
echo $argv[$i] . "\n";
exit();
}
$pids[] = $pid;
}
 
foreach ($pids as $pid) {
pcntl_waitpid($pid, $status);
}
</syntaxhighlight>
<pre>
php ./sleepsort.php 35 21 11 1 2 27 32 7 42 20 50 42 25 41 43 14 46 20 30 8
1
2
7
2
5
6
8
11
12
14</pre>
20
20
21
25
27
30
32
35
41
42
42
43
46
50
</pre>
 
=={{header|Phix}}==
Copy of [[Sorting_algorithms/Sleep_sort#Euphoria|Euphoria]]
<lang Phix>integer count
procedure sleeper(integer key)
? key
count -= 1
end procedure
sequence s, val
atom task
s = command_line()
s = s[3..$]
if length(s)=0 then
puts(1,"Nothing to sort.\n")
else
count = 0
for i = 1 to length(s) do
val = value(s[i])
if val[1] = GET_SUCCESS then
task = task_create(routine_id("sleeper"),{val[2]})
task_schedule(task,{val[2],val[2]}/10)
count += 1
end if
end for
while count do
task_yield()
end while
end if</lang>
 
=={{header|PicoLisp}}==
===Sleeping in main process===
<langsyntaxhighlight PicoLisplang="picolisp">(de sleepSort (Lst)
(make
(for (I . N) Lst
Line 1,275 ⟶ 1,767:
(pop 'Lst)
(task (- I)) ) )
(wait NIL (not Lst)) ) )</langsyntaxhighlight>
===Sleeping in child processes===
<langsyntaxhighlight PicoLisplang="picolisp">(de sleepSort (Lst)
(make
(for N Lst
Line 1,284 ⟶ 1,776:
(pop 'Lst)
(task (close @)) ) )
(wait NIL (not Lst)) ) )</langsyntaxhighlight>
Output in both cases:
<pre>: (sleepSort (3 1 4 1 5 9 2 6 5))
Line 1,290 ⟶ 1,782:
===Just printing (no sorted result list)===
Basically the C code.
<langsyntaxhighlight PicoLisplang="picolisp">(for N (3 1 4 1 5 9 2 6 5)
(unless (fork)
(call 'sleep N)
(msg N)
(bye) ) )</langsyntaxhighlight>
Output:
<pre>1
Line 1,305 ⟶ 1,797:
6
9</pre>
 
=={{header|Pike}}==
 
<syntaxhighlight lang="pike">
#!/usr/bin/env pike
int main(int argc, array(string) argv)
{
foreach(argv[1..], string value)
{
int v = (int)value;
if(v<0)
continue;
call_out(print, v, value);
}
return -1;
}
 
void print(string value)
{
write("%s\n", value);
if(find_call_out(print)==-1)
exit(0);
return;
}
</syntaxhighlight>
Output :
<pre>
$ ./sleep-sort.pike 4 5 -3 1 2 7 6
1
2
4
5
6
7
</pre>
 
=={{header|Prolog}}==
Works with SWI-Prolog.
<langsyntaxhighlight Prologlang="prolog">sleep_sort(L) :-
thread_pool_create(rosetta, 1024, []) ,
maplist(initsort, L, LID),
Line 1,317 ⟶ 1,845:
thread_create_in_pool(rosetta, (sleep(V), writeln(V)), Id, []).
 
</syntaxhighlight>
</lang>
Output :
<pre> sleep_sort([5, 1, 3, 2, 11, 6, 3, 4]).
Line 1,333 ⟶ 1,861:
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">NewMap threads()
 
Procedure Foo(n)
Line 1,349 ⟶ 1,877:
Next
Print("Press ENTER to exit"): Input()
EndIf</langsyntaxhighlight>
<pre>Sleep_sort.exe 3 1 4 1 5 9
1
Line 1,360 ⟶ 1,888:
 
=={{header|Python}}==
===Python: Using threading.Timer===
 
<langsyntaxhighlight lang="python">from time import sleep
from threading import Timer
 
Line 1,381 ⟶ 1,909:
print('sleep sort worked for:',x)
else:
print('sleep sort FAILED for:',x)</langsyntaxhighlight>
 
;Sample output:
Line 1,391 ⟶ 1,919:
could be a sole translation from the original version in Bash:
{{Works with|Python 3.5+}}
<langsyntaxhighlight lang="python">#!/usr/bin/env python3
from asyncio import run, sleep, wait
from sys import argv
Line 1,400 ⟶ 1,928:
 
if __name__ == '__main__':
run(wait(list(map(f, map(int, argv[1:])))))</langsyntaxhighlight>
Example usage:
<pre>
Line 1,417 ⟶ 1,945:
=={{header|Racket}}==
 
<langsyntaxhighlight lang="racket">
#lang racket
 
Line 1,433 ⟶ 1,961:
;; outputs '(2 5 5 7 8 9 10)
(sleep-sort '(5 8 2 7 9 10 5))
</syntaxhighlight>
</lang>
 
=={{header|REXXRaku}}==
(formerly Perl 6)
This sort will accept any manner of numbers, or for that matter, any character string as well.
<br>REXX isn't particular what is being sorted.
 
<syntaxhighlight lang="raku" line>await map -> $delay { start { sleep $delay ; say $delay } },
This REXX version '''only''' works with Regina REXX &nbsp; (as the program uses the &nbsp; '''fork''' &nbsp;
<6 8 1 12 2 14 5 2 1 0>;</syntaxhighlight>
function.
<lang rexx>/*REXX program implements a sleep sort (with numbers entered from C.L.).*/
numeric digits 300 /*over the top, but what the hey!*/
/* (above) ··· from vaudeville.*/
#.= /*placeholder for the array of #s*/
stuff= 1e9 50 5 40 4 1 100 30 3 12 2 8 9 7 6 6 10 20 0 /*alphabetically*/
parse arg numbers /*let the user specify on the CL.*/
if numbers='' then numbers=stuff /*Not specified? Then use default*/
N=words(numbers) /*N is the number of numbers. */
w=length(N) /*width of N (for nice output).*/
say N 'numbers to be sorted:' numbers /*informative informational info.*/
 
{{out}}
do j=1 for N /*let's start to boogie-woogie. */
<pre>0
#.j=word(numbers,j) /*plug in one number at a time. */
1
if datatype(#.j,'N') then #.j=#.j/1 /*normalize it if a number.*/
1
call fork /*only REGINA REXX supports FORK.*/
2
call sortItem j /*start a sort for array number. */
2
5
6
8
12
14</pre>
 
This can also be written using reactive programming:
 
<syntaxhighlight lang="raku" line>#!/usr/bin/env raku
use v6;
react whenever Supply.from-list(@*ARGS).start({ .&sleep // +$_ }).flat { .say }</syntaxhighlight>
 
{{out}}
<pre>$ ./sleep-sort 1 3 5 6 2 4
1
2
3
4
5
6</pre>
 
=={{header|REXX}}==
This sort will accept any manner of numbers, &nbsp; or for that matter, &nbsp; any character string as well.
<br>REXX isn't particular what is being sorted.
<syntaxhighlight lang="rexx">/*REXX program implements a sleep sort (with numbers entered from the command line (CL).*/
numeric digits 300 /*over the top, but what the hey! */
/* (above) ··· from vaudeville. */
@.= /*placeholder for the array of numbers.*/
stuff= 1e9 50 5 40 4 1 100 30 3 12 2 8 9 7 6 6 10 20 0 /*alphabetically ··· so far.*/
parse arg numbers /*obtain optional arguments from the CL*/
if numbers='' then numbers= stuff /*Not specified? Then use the default.*/
N= words(numbers) /*N is the number of numbers in list. */
w= length(N) /*width of N (used for nice output). */
parse upper version !ver . /*obtain which REXX we're running under*/
!regina= ('REXX-REGINA'==left(!ver, 11) ) /*indicate (or not) if this is Regina. */
say N 'numbers to be sorted:' numbers /*informative informational information*/
/*from department of redundancy depart.*/
do j=1 for N /*let's start to boogie─woogie da sort.*/
@.j= word(numbers, j) /*plug in a single number at a time. */
if datatype(@.j, 'N') then @.j= @.j / 1 /*normalize it if it's a numeric number*/
if !regina then call fork /*only REGINA REXX supports FORK BIF.*/
call sortItem j /*start a sort for an array number. */
end /*j*/
 
do forever while \inOrder(N) /*wait for the sorts to complete. */
call sleepdelay 1 /*1one secsecond is minimum effective time.*/
end /*forever while*/ /*well heck, other than zero seconds. */
 
m= max(length(#@.1), length(#@.N) ) /*width of smallest |or largest numnumber. */
say; say 'after sort:' say 'after sort:' /*display a blank line and a title. */
 
do k=1 for N /*list the (sorted) array's elements.*/
say left('', 20) 'array element' right(k, w) '───►' right(#@.k, m)
end /*k*/
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
/*───────────────────────────────────SortItem subroutine────────────────*/
sortItem: procedure expose #@.; parse arg ? /*sorts a single (numeric) item. */
do Asort=1 until \switched /*cooksort unsorted array until cooked.it's sorted*/
switched= 0 /*it's all hunky─dorey, happy─dappy /*hunky-dorey so far···*/
do i=1 while #@.i\=='' & \switched
if #@.? >= #@.i then iterate /*thisitem oneis in order. ok*/
parse value #@.? #@.i with #@.i #@.?
switched= 1 /* [↑] swapped one.*/
end /*i*/
if Asort//?==0 then call sleepdelay switched /*sleep if last item*/
end /*Asort*/
return /*Sleeping Beauty awakes. Not to worry: (c) = circa 1697.*/
/*──────────────────────────────────────────────────────────────────────────────────────*/
/*───────────────────────────────────InOrder subroutine─────────────────*/
inOrder: procedure expose #@.; parse arg howMany /*is the array in numerical order? */
do m=1 for howMany-1; next= m+1; if #@.m>#@.next then return 0 /*¬ in order*/
end /*m*/ /*keep looking for fountain of yutyouth. */
return 1 /*yes, indicate with an indicator. */</syntaxhighlight>
Programming note: &nbsp; this REXX program makes use of &nbsp; '''DELAY''' &nbsp; BIF which delays (sleeps) for a specified amount of seconds.
</lang>
<br>Some REXXes don't have a &nbsp; '''DELAY''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[DELAY.REX]].
'''output''' when using the default input
 
 
{{out|output|text=&nbsp; when using the internal default input:}}
<pre>
19 numbers to be sorted: 1e91E9 50 5 40 4 1 100 30 3 12 2 8 9 7 6 6 10 20 0
 
after sort:
array element 1 ───>───► 0
array element 2 ───>───► 1
array element 3 ───>───► 2
array element 4 ───>───► 3
array element 5 ───>───► 4
array element 6 ───>───► 5
array element 7 ───>───► 6
array element 8 ───>───► 6
array element 9 ───>───► 7
array element 10 ───>───► 8
array element 11 ───>───► 9
array element 12 ───>───► 10
array element 13 ───>───► 12
array element 14 ───>───► 20
array element 15 ───>───► 30
array element 16 ───>───► 40
array element 17 ───>───► 50
array element 18 ───>───► 100
array element 19 ───>───► 1000000000
</pre>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">require 'thread'
 
nums = ARGV.collect(&:to_i)
Line 1,529 ⟶ 2,092:
threads.each {|t| t.join}
 
p sorted</langsyntaxhighlight>
 
Example
Line 1,536 ⟶ 2,099:
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">use std::thread;
 
fn sleepsort<I: Iterator<Item=u32>>(nums: I) {
Line 1,548 ⟶ 2,111:
fn main() {
sleepsort(std::env::args().skip(1).map(|s| s.parse().unwrap()));
}</langsyntaxhighlight>
Output:
<pre>$ ./sleepsort 50 34 43 3 2
Line 1,559 ⟶ 2,122:
 
=={{header|Scala}}==
<langsyntaxhighlight lang="scala">object SleepSort {
 
def main(args: Array[String]): Unit = {
Line 1,575 ⟶ 2,138:
}.start())
 
}</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="bash">$ scala SleepSort 1 3 6 0 9 7 4 2 5 8
0 1 2 3 4 5 5 6 7 8 9 </langsyntaxhighlight>
 
=={{header|Swift}}==
<lang Swift>import Foundation
 
for i in [5, 2, 4, 6, 1, 7, 20, 14] {
let time = dispatch_time(DISPATCH_TIME_NOW,
Int64(i * Int(NSEC_PER_SEC)))
dispatch_after(time, dispatch_get_main_queue()) {
print(i)
}
}
 
CFRunLoopRun()</lang>
{{out}}
<pre>
1
2
4
5
6
7
14
20
</pre>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">ARGV.map{.to_i}.map{ |i|
{Sys.sleep(i); say i}.fork;
}.each{.wait};</langsyntaxhighlight>
{{out}}
<pre>% sidef test.sf 5 1 3 2 11 6 4
Line 1,618 ⟶ 2,156:
6
11</pre>
 
=={{header|Simula}}==
<langsyntaxhighlight lang="simula">SIMULATION
BEGIN
 
Line 1,638 ⟶ 2,177:
OUTIMAGE;
 
END;</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 3 4 6 7 9
Line 1,645 ⟶ 2,184:
=={{header|SNUSP}}==
Bloated SNUSP is ideally suited to this task, since this the variant adds multithreading and an additional dimension of data space. Sleep time is simulated by the loop delay required to copy each cell value, thereby ensuring that smaller values are printed earlier than larger values. This program requires a Bloated SNUSP interpreter which returns zero on input end-of-file.
<syntaxhighlight lang="snusp">
<lang SNUSP>
/$>\ input until eof
#/?<\?,/ foreach: fork
Line 1,651 ⟶ 2,190:
/:\?-; delay /
\.# print and exit thread
</syntaxhighlight>
</lang>
 
Legend:
Line 1,657 ⟶ 2,196:
* ''': ;''' - UP and DOWN are equivalent to '''< >''' LEFT and RIGHT, but moves the data pointer in the second dimension.
* '''#''' - in Bloated SNUSP, LEAVE only terminates the current thread. The overall program only exits when all threads have quit.
 
=={{header|Swift}}==
<syntaxhighlight lang="swift">import Foundation
 
for i in [5, 2, 4, 6, 1, 7, 20, 14] {
let time = dispatch_time(DISPATCH_TIME_NOW,
Int64(i * Int(NSEC_PER_SEC)))
dispatch_after(time, dispatch_get_main_queue()) {
print(i)
}
}
 
CFRunLoopRun()</syntaxhighlight>
{{out}}
<pre>
1
2
4
5
6
7
14
20
</pre>
 
=={{header|Tcl}}==
===Tcl 8.5===
<lang tcl>#!/bin/env tclsh
<syntaxhighlight lang="tcl">#!/bin/env tclsh
set count 0
proc process val {
Line 1,672 ⟶ 2,237:
while {$count < $argc} {
vwait count
}</langsyntaxhighlight>
'''Demo:'''
Demonstrating:
<pre>
bash$ sleepsort.tcl 3 1 4 5 2 3 1 6 1 3 2 5 4 6
Line 1,690 ⟶ 2,255:
6
6
</pre>
===Tcl 8.6===
<syntaxhighlight lang="tcl">set sorted {}
lmap x $argv {after $x [list lappend sorted $x]}
while {[llength $sorted] != $argc} {
vwait sorted
}
puts $sorted</syntaxhighlight>
{{out}}
<pre>$ echo 'puts [lmap _ [lrepeat 30 {}] {expr {int(rand() * 100)}}]' | tclsh | tee /dev/tty | xargs tclsh sleepsort.tcl
5 8 70 27 15 80 49 2 69 93 29 1 14 84 43 2 81 44 60 62 8 75 23 61 42 68 79 46 72 65
1 2 2 5 8 8 14 15 23 27 29 42 43 44 46 49 60 61 62 65 68 69 70 72 75 79 80 81 84 93</pre>
 
===Tcl 8.6: coroutine===
<syntaxhighlight lang="tcl">#! /usr/bin/env tclsh
package require Tcl 8.6
# By aspect (https://wiki.tcl-lang.org/page/aspect). Modified slightly.
# 1. Schedule N delayed calls to our own coroutine.
# 2. Yield N times to grab the scheduled values. Print each.
# 3. Store the sorted list in $varName.
proc sleep-sort {ls varName} {
foreach x $ls {
after $x [info coroutine] $x
}
set $varName [lmap x $ls {
set newX [yield]
puts $newX
lindex $newX
}]
}
 
# Ensure the list is suitable for use with [sleep-sort].
proc validate ls {
if {[llength $ls] == 0} {
error {list is empty}
}
foreach x $ls {
if {![string is integer -strict $x] || $x < 0} {
error [list invalid value: $x]
}
}
return $ls
}
coroutine c sleep-sort [validate $argv] ::sorted
vwait sorted</syntaxhighlight>
'''Demo:'''
<pre>
$ ./sleepsort.tcl 1 2 100 40 76 0 0 0 200 199
0
0
0
1
2
40
76
100
199
200
</pre>
 
=={{header|UNIX Shell}}==
{{works with|Bourne Shell}}
<langsyntaxhighlight lang="bash">f() {
sleep "$1"
echo "$1"
Line 1,703 ⟶ 2,332:
shift
done
wait</langsyntaxhighlight>
Usage and output:
<pre>
Line 1,713 ⟶ 2,342:
5
9
</pre>
 
=={{header|Visual Basic .NET}}==
<syntaxhighlight lang="vbnet">Imports System.Threading
 
Module Module1
 
Sub SleepSort(items As IEnumerable(Of Integer))
For Each item In items
Task.Factory.StartNew(Sub()
Thread.Sleep(1000 * item)
Console.WriteLine(item)
End Sub)
Next
End Sub
 
Sub Main()
SleepSort({1, 5, 2, 1, 8, 10, 3})
Console.ReadKey()
End Sub
 
End Module</syntaxhighlight>
 
{{out}}
<pre>
1
1
2
3
5
8
10
</pre>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="vlang">
import time
import sync
 
fn main() {
mut wg := sync.new_waitgroup()
test_arr := [3, 2, 1, 4, 1, 7]
wg.add(test_arr.len)
for i, value in test_arr {
go sort(i, value, mut wg)
}
wg.wait()
println('Printed sorted array')
}
 
fn sort(id int, value int, mut wg sync.WaitGroup) {
time.sleep(value * time.millisecond) // can change duration to second or others
println(value)
wg.done()
}
</syntaxhighlight>
 
{{out}}
<pre>
1
1
2
3
4
7
Printed sorted array
</pre>
 
=={{header|Wren}}==
More of a simulation than a 'true' sleep sort.
<syntaxhighlight lang="wren">import "timer" for Timer
import "io" for Stdout
import "os" for Process
 
var args = Process.arguments
var n = args.count
if (n < 2) Fiber.abort("There must be at least two arguments passed.")
var list = args.map{ |a| Num.fromString(a) }.toList
if (list.any { |i| i == null || !i.isInteger || i < 0 } ) {
Fiber.abort("All arguments must be non-negative integers.")
}
var max = list.reduce { |acc, i| acc = (i > acc) ? i : acc }
var fibers = List.filled(max+1, null)
System.print("Before: %(list.join(" "))")
for (i in list) {
var sleepSort = Fiber.new { |i|
Timer.sleep(1000)
Fiber.yield(i)
}
fibers[i] = sleepSort
}
System.write("After : ")
for (i in 0..max) {
var fib = fibers[i]
if (fib) {
System.write("%(fib.call(i)) ")
Stdout.flush()
}
}
System.print()</syntaxhighlight>
 
{{out}}
Sample run:
<pre>
$ wren Sorting_algorithms_Sleep_sort.wren 1 8 3 7 4 6
Before: 1 8 3 7 4 6
After : 1 3 4 6 7 8
</pre>
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">vm.arglist.apply(fcn(n){ Atomic.sleep(n); print(n) }.launch);
Atomic.waitFor(fcn{ vm.numThreads == 1 }); Atomic.sleep(2); println();</langsyntaxhighlight>
{{out}}
<pre>
Arakov
1

edit

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/189161...361378"