September 2017 Update

Task/Sorting-algorithms-Sleep-sort/C++/sorting-algorithms-sleep-sort.cpp

@@ -1,38 +1,20 @@
+#include <chrono>
 #include <iostream>
 #include <thread>
 #include <vector>
-#include <unistd.h>
 
-using namespace std;
+int main(int argc, char* argv[]) {
+  std::vector<std::thread> threads;
 
-void sortThread( int x )
-{
-    usleep( 10000 * x );
-    cout << x << " ";
-}
-
-int main()
-{
-    vector<thread*> threads;
-
-    srand( ( unsigned )time( NULL ) );
-
-    cout << "unsorted:" << endl;
-    for( int x = 0; x < 15; x++ )
-    {
-        int r = rand() % 20 + 5;
-        cout << r << " ";
-        thread* t = new thread( sortThread, r );
-        threads.push_back( t );
-    }
-    cout << endl << endl << "sorted:" << endl;
-
-    for( vector<thread*>::iterator t = threads.begin(); t != threads.end(); t++ )
-    {
-        ( *t )->join();
-        delete ( *t );
-    }
-
-    cout << endl << endl;
-    return 0;
+  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();
+  }
 }

Task/Sorting-algorithms-Sleep-sort/Factor/sorting-algorithms-sleep-sort-1.factor

@@ -0,0 +1,3 @@
+USING: threads calendar concurrency.combinators ;
+
+: sleep-sort ( seq -- ) [ dup seconds sleep . ] parallel-each ;

Task/Sorting-algorithms-Sleep-sort/Factor/sorting-algorithms-sleep-sort-2.factor

@@ -0,0 +1 @@
+{ 1 9 2 6 3 4 5 8 7 0 } sleep-sort

Task/Sorting-algorithms-Sleep-sort/Fortran/sorting-algorithms-sleep-sort.f

@@ -0,0 +1,33 @@
+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

Task/Sorting-algorithms-Sleep-sort/Haskell/sorting-algorithms-sleep-sort-1.hs

@@ -4,9 +4,9 @@ import Control.Monad
 
 sleepSort :: [Int] -> IO ()
 sleepSort values = do
-	chan <- newChan
-	forM_ values (\time -> forkIO (threadDelay (50000 * time) >> writeChan chan time))
-	forM_ values (const (readChan chan >>= print))
+        chan <- newChan
+        forM_ values (\time -> forkIO (threadDelay (50000 * time) >> writeChan chan time))
+        forM_ values (\_ -> readChan chan >>= print)
 
 main :: IO ()
 main = getArgs >>= sleepSort . map read

Task/Sorting-algorithms-Sleep-sort/Haskell/sorting-algorithms-sleep-sort-2.hs

@@ -2,8 +2,8 @@ import System.Environment
 import Control.Concurrent
 import Control.Concurrent.Async
 
-sleepSort :: [Int] -> IO [()]
-sleepSort = mapConcurrently (\x -> threadDelay (x*10^4) >> print x)
+sleepSort :: [Int] -> IO ()
+sleepSort = (() <$) . mapConcurrently (\x -> threadDelay (x*10^4) >> print x)
 
-main :: IO [()]
+main :: IO ()
 main = getArgs >>= sleepSort . map read

Task/Sorting-algorithms-Sleep-sort/Scala/sorting-algorithms-sleep-sort-1.scala

@@ -0,0 +1,17 @@
+object SleepSort {
+
+  def main(args: Array[String]): Unit = {
+    val nums = args.map(_.toInt)
+    sort(nums)
+    Thread.sleep(nums.max * 21) // Keep the JVM alive for the example
+  }
+
+  def sort(nums: Seq[Int]): Unit =
+    nums.foreach(i => new Thread {
+      override def run() {
+        Thread.sleep(i * 20) // just `i` is unpredictable with small numbers
+        print(s"$i ")
+      }
+    }.start())
+
+}

Task/Sorting-algorithms-Sleep-sort/Scala/sorting-algorithms-sleep-sort-2.scala

@@ -0,0 +1,2 @@
+$ scala SleepSort 1 3 6 0 9 7 4 2 5 8
+0 1 2 3 4 5 5 6 7 8 9

Task/Sorting-algorithms-Sleep-sort/Scala/sorting-algorithms-sleep-sort.scala

@@ -1,12 +0,0 @@
-object SleepSort {
-  def sort(nums:Seq[Int])=nums foreach {n =>
-    scala.concurrent.ops.spawn{
-      Thread.sleep(500*n)
-      print(n+" ")
-    }
-  }
-		
-  def main(args:Array[String])={
-    sort(args map (_.toInt))
-  }
-}

Task/Sorting-algorithms-Sleep-sort/Simula/sorting-algorithms-sleep-sort.simula

@@ -0,0 +1,20 @@
+SIMULATION
+BEGIN
+
+    PROCESS CLASS SORTITEM(N); INTEGER N;
+    BEGIN
+        HOLD(N);
+        OUTINT(N, 3);
+    END;
+
+    INTEGER I;
+    FOR I := 3, 2, 4, 7, 3, 6, 9, 1 DO
+    BEGIN
+        REF(SORTITEM) SI;
+        SI :- NEW SORTITEM(I);
+        ACTIVATE SI;
+    END;
+    HOLD(100000);
+    OUTIMAGE;
+
+END;

Task/Sorting-algorithms-Sleep-sort/Zkl/sorting-algorithms-sleep-sort.zkl

@@ -0,0 +1,2 @@
+vm.arglist.apply(fcn(n){ Atomic.sleep(n); print(n) }.launch);
+Atomic.waitFor(fcn{ vm.numThreads == 1 }); Atomic.sleep(2); println();