Sorting algorithms/Strand sort: Difference between revisions

{{trans|Python}}

[Int] out

L !a.empty & !b.empty

R out

{{out}}

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

(

-2 0 -2 5 5 3 -1 -3 5 5 0 2 -4 4 2

string := list, list = "", index := 0

}

unsorted:-2 0 -2 5 5 3 -1 -3 5 5 0 2 -4 4 2

=={{header|C}}==

Strand sort using singly linked list. C99, compiled with <code>gcc -std=c99</code>

typedef struct node_t *node, node_t;

return 0;

=={{header|C++}}==

template <typename T>

}

return result;

=={{header|Clojure}}==

(defn merge-join

(strand-sort [1, 6, 3, 2, 1, 7, 5, 3])

;;=> (1 1 2 3 3 5 6 7)

=={{header|CMake}}==

Only for lists of integers.

function(strand_sort var)

# Strand sort moves elements from _ARGN_ to _answer_.

set("${var}" ${answer} PARENT_SCOPE)

=={{header|Common Lisp}}==

(if l

(let* ((l (reverse l))

(let ((r (loop repeat 15 collect (random 10))))

(print r)

=={{header|D}}==

=== Using doubly linked lists ===

DList!T strandSort(T)(DList!T list) {

foreach (e; strandSort(lst))

write(e, " ");

{{out}}

<pre>-4 -3 -2 -2 -1 0 0 2 2 3 4 5 5 5 5 </pre>

=== Faster version using slices ===

T[] strandSort(T)(const(T)[] list) pure nothrow {

const arr = [-2, 0, -2, 5, 5, 3, -1, -3, 5, 5, 0, 2, -4, 4, 2];

arr.strandSort.writeln;

{{out}}

<pre>[-4, -3, -2, -2, -1, 0, 0, 2, 2, 3, 4, 5, 5, 5, 5]</pre>

=={{header|Elixir}}==

{{trans|Ruby}}

def strand_sort(args), do: strand_sort(args, [])

end

{{out}}

=={{header|Euphoria}}==

sequence result

result = {}

? s

puts(1,"After: ")

Output:

=={{header|Go}}==

import "fmt"

}

return

Output:

<pre>

=={{header|Haskell}}==

merge :: (Ord a) => [a] -> [a] -> [a]

merge [] ys = ys

extractStrand x (x1 : xs)

| x <= x1 = let (strand, rest) = extractStrand x1 xs in (x : strand, rest)

=={{header|J}}==

Using <code>merge</code> defined at [[Sorting algorithms/Merge sort#J]]:

Example use:

Note: the order in which this J implementation processes the strands differs from the pseudocode currently at the wikipedia page on strand sort and matches the haskell implementation currently at the wikipedia page.

Also note that the individual strands can be seen by using <code>;</code> instead of <code>merge</code>.

┌───┬───┬─┬┐

│3 5│1 4│2││

┌─────────┬─────┬┐

│3 3 4 5 6│1 2 3││

=={{header|Java}}==

{{works with|Java|1.6+}}

import java.util.LinkedList;

System.out.println(strandSort(new LinkedList<Integer>(Arrays.asList(3,3,1,2,4,3,5,6))));

}

Output:

<pre>[1, 2, 3, 4, 5]

=={{header|jq}}==

# in turn; # if both arrays are sorted, the result will be sorted:

def merge(x):

| ($s[0] | merge( $s[1] | strand_sort))

end ;

Example:

[1,3,5,2,4,6] | strand_sort

=={{header|Julia}}==

{{trans|Python}}

out = Vector{Int}()

while !isempty(a) && !isempty(b)

println(strandsort([1, 6, 3, 2, 1, 7, 5, 3]))

[1, 1, 2, 3, 3, 5, 6, 7]

</pre>

=={{header|Kotlin}}==

{{trans|D}}

fun <T : Comparable<T>> strandSort(l: List<T>): List<T> {

val l = listOf(-2, 0, -2, 5, 5, 3, -1, -3, 5, 5, 0, 2, -4, 4, 2)

println(strandSort(l))

{{out}}

=={{header|Mathematica}}/{{header|Wolfram Language}}==

While[Length@A > 0,

sublist = {A[[1]]}; A = A[[2;;All]];

results = #[[Ordering@#]]&@Join[sublist, results];];

results ]

{{out}}

<pre>{1, 2, 3, 4, 5, 7, 7}</pre>

=={{header|MAXScript}}==

(

arr = deepcopy arr

return results

Output:

a = for i in 1 to 20 collect random 1 40

#(19, 26, 14, 31, 11, 33, 2, 14, 32, 28, 12, 38, 2, 37, 27, 18, 31, 24, 39, 28)

strandSort a

#(2, 2, 11, 12, 14, 14, 18, 19, 24, 26, 27, 28, 28, 31, 31, 32, 33, 37, 38, 39)

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols binary

return result

;Output

<pre>

=={{header|Nim}}==

result = @[]

while a.len > 0 and b.len > 0:

var a = @[1, 6, 3, 2, 1, 7, 5, 3]

Output:

<pre>@[1, 1, 2, 3, 3, 5, 6, 7]</pre>

=={{header|OCaml}}==

{{trans|Haskell}}

[] -> []

| x::xs ->

in

let strand, rest = extract_strand x xs in

usage

<pre>

=={{header|PARI/GP}}==

my(sorted=[],unsorted=v,remaining,working);

while(#unsorted,

);

ret

=={{header|Pascal}}==

type

end;

writeln;

=={{header|Perl}}==

use warnings;

use feature 'say';

say "Before @a";

@a = strand_sort(@a);

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">strand_sort</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shuffle</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)))</span>

{{out}}

<pre>

{{trans|D}}

{{works with|PHP 5.3.0+}}

foreach (array(1,20,64,72,48,75,96,55,42,74) as $v)

$lst->push($v);

foreach ($right as $v) $res->push($v);

return $res;

<pre>1 20 42 48 55 64 72 74 75 96</pre>

=={{header|PicoLisp}}==

(let Res NIL # Result list

(while Lst

(pop 'Res)

(fifo 'Sub) ) ) ) ) ) ) )

Test:

<pre>: (strandSort (3 1 5 4 2))

=={{header|PL/I}}==

declare A(100) fixed, used(100) bit (1), sorted fixed controlled;

declare (temp, work) fixed controlled;

end move;

Generated data:

<pre>

=={{header|PureBasic}}==

Protected NewList subList()

Protected NewList results()

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre>List 1:

=={{header|Python}}==

out = []

while len(a) and len(b):

return out

=={{header|Racket}}==

#lang racket

(require mzlib/list)

(strand-sort (build-list 10 (λ(_) (random 15))))

=={{header|Raku}}==

(formerly Perl 6)

{{Works with|Rakudo|2018.04.01}}

my @x = | @x-in;

my @y = | @y-in;

say "Before {@a}";

@a = strand_sort(@a);

{{out}}

<pre>Before 1 20 64 72 48 75 96 55 42 74

It can handle integers, floating point numbers, exponentiated numbers, and/or character strings.

parse arg size minv maxv old /*obtain optional arguments from the CL*/

if size=='' | size=="," then size=20 /*Not specified? Then use the default.*/

#=1+(word(a.1,1) >= word(a.2,1)); p=p word(a.#,1); a.#=subword(a.#,2)

end /*forever*/

'''output''' &nbsp; when using the input of: &nbsp; <tt> 25 -9 30 1000 2000 3000 </tt>

<pre>

=={{header|Ring}}==

# Project : Sorting algorithms/Strand sort

svect = left(svect, len(svect) - 1)

see svect + nl

Output:

<pre>

=={{header|Ruby}}==

def strandsort

a = dup

end

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

var out = [];

while (x && y) {

var a = 10.of { 100.irand };

say "Before: #{a}";

{{out}}

=={{header|Tcl}}==

upvar 1 $listVar v

set i [set j 0]

}

=={{header|Ursala}}==

@NiX -+

:-0 ~&B^?a\~&Y@a "r"?abh/~&alh2faltPrXPRC ~&arh2falrtPXPRC,

=={{header|Wren}}==

{{trans|Kotlin}}

var res = []

while (!left.isEmpty && !right.isEmpty) {

System.print("Unsorted: %(a)")

a = strandSort.call(a)

{{out}}

=={{header|zkl}}==

sublist:=List.createLong(A.len()); results:=List.createLong(A.len());

while(A){

}

results

The createLong list method creates a new list with pre-allocated space

{{out}}

<pre>