Rosetta Code

Sorting algorithms/Stooge sort: Difference between revisions

Page Discussion

Sorting algorithms/Stooge sort (view source)

Revision as of 23:00, 13 February 2024

5,960 bytes added ,  3 months ago
m
→‎{{header|EasyLang}}
(Added Quackery.)
(12 intermediate revisions by 10 users not shown)
Line 25:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F stoogesort(&l, i, j) -> N
I l[j] < l[i]
swap(&l[i], &l[j])
Line 39:
V data = [1, 4, 5, 3, -6, 3, 7, 10, -2, -5, 7, 5, 9, -3, 7]
stooge(&data)
print(data)</langsyntaxhighlight>
 
{{out}}
Line 48:
=={{header|Action!}}==
Action! language does not support recursion. Therefore an iterative approach with a stack has been proposed.
<langsyntaxhighlight Actionlang="action!">DEFINE MAX_COUNT="100"
INT ARRAY stack(MAX_COUNT)
INT stackSize
Line 127:
Test(c,8)
Test(d,12)
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Stooge_sort.png Screenshot from Atari 8-bit computer]
Line 156:
Using slices and 'First / 'Last removes the need for I / J parameters.
 
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;
procedure Stooge is
type Integer_Array is array (Positive range <>) of Integer;
Line 187:
end loop;
Ada.Text_IO.New_Line;
end Stooge;</langsyntaxhighlight>
 
{{out}}
Line 194:
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}
<langsyntaxhighlight lang="algol68"># swaps the values of the two REF INTs #
PRIO =:= = 1;
OP =:= = ( REF INT a, b )VOID: ( INT t := a; a := b; b := t );
Line 220:
# test the stooge sort #
[]INT data = ( 67, -201, 0, 9, 9, 231, 4 );
print( ( "before: ", data, newline, "after: ", stooge sort( data ), newline ) )</langsyntaxhighlight>
{{out}}
<pre>
Line 226:
after: -201 +0 +4 +9 +9 +67 +231
</pre>
 
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">innerStoogeSort: function [a, i, j][
if a\[j] < a\[i] [
t: a\[i]
a\[i]: a\[j]
a\[j]: t
]
if 1 < j - i [
t: (1 + j - i) / 3
innerStoogeSort a i j-t
innerStoogeSort a i+t j
innerStoogeSort a i j-t
]
]
 
stoogeSort: function [arr][
result: new arr
innerStoogeSort result 0 dec size result
return result
]
 
print stoogeSort [3 1 2 8 5 7 9 4 6]</syntaxhighlight>
 
{{out}}
 
<pre>1 2 3 4 5 6 7 8 9</pre>
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">StoogeSort(L, i:=1, j:=""){
if !j
j := L.MaxIndex()
Line 243 ⟶ 270:
}
return L
}</langsyntaxhighlight>
Examples:<langsyntaxhighlight AutoHotkeylang="autohotkey">MsgBox % map(StoogeSort([123,51,6,73,3,-12,0]))
return
 
Line 251 ⟶ 278:
res .= v ","
return trim(res, ",")
}</langsyntaxhighlight>
Outputs:<pre>-12,0,3,6,51,73,123</pre>
 
=={{header|BASIC}}==
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic"> DIM test%(9)
test%() = 4, 65, 2, -31, 0, 99, 2, 83, 782, 1
PROCstoogesort(test%(), 0, DIM(test%(),1))
FOR i% = 0 TO 9
PRINT test%(i%) ;
NEXT
PRINT
END
DEF PROCstoogesort(l%(), i%, j%)
LOCAL t%
IF l%(j%) < l%(i%) SWAP l%(i%), l%(j%)
IF j% - i% > 1 THEN
t% = (j% - i% + 1)/3
PROCstoogesort(l%(), i%, j%-t%)
PROCstoogesort(l%(), i%+t%, j%)
PROCstoogesort(l%(), i%, j%-t%)
ENDIF
ENDPROC</syntaxhighlight>
{{out}}
<pre>
-31 0 1 2 2 4 65 83 99 782
</pre>
 
==={{header|QuickBASIC}}===
{{works with|QuickBASIC|7.1}}
 
Line 260 ⟶ 313:
It ''definitely'' does '''not''' work with QBasic.
 
<langsyntaxhighlight lang="qbasic">DECLARE SUB stoogesort (L() AS LONG, i AS LONG, j AS LONG)
 
RANDOMIZE TIMER
Line 283 ⟶ 336:
NEXT
PRINT
 
 
SUB stoogesort (L() AS LONG, i AS LONG, j AS LONG)
Line 293 ⟶ 347:
stoogesort L(), i, j - t
END IF
END SUB</langsyntaxhighlight>
 
{{out}}
<pre>
Before: 15 42 21 50 33 65 40 43 20 25 19
After: 15 19 20 21 33 25 40 42 43 50 65
</pre>
<pre>
Before: 99 21 84 55 32 26 86 27 8 45 11
After: 8 11 21 26 27 32 45 55 84 86 99
</pre>
<pre>
Before: 11 50 11 37 97 94 92 70 92 57 88
After: 11 11 37 50 57 70 88 92 92 94 97
 
=={{header|BBC BASIC}}==
<lang bbcbasic> DIM test%(9)
test%() = 4, 65, 2, -31, 0, 99, 2, 83, 782, 1
PROCstoogesort(test%(), 0, DIM(test%(),1))
FOR i% = 0 TO 9
PRINT test%(i%) ;
NEXT
PRINT
END
DEF PROCstoogesort(l%(), i%, j%)
LOCAL t%
IF l%(j%) < l%(i%) SWAP l%(i%), l%(j%)
IF j% - i% > 1 THEN
t% = (j% - i% + 1)/3
PROCstoogesort(l%(), i%, j%-t%)
PROCstoogesort(l%(), i%+t%, j%)
PROCstoogesort(l%(), i%, j%-t%)
ENDIF
ENDPROC</lang>
{{out}}
<pre>
-31 0 1 2 2 4 65 83 99 782
</pre>
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
 
let stoogesort(L, i, j) be
Line 357 ⟶ 391:
stoogesort(array, 0, length-1)
write("After: ", array, length)
$)</langsyntaxhighlight>
{{out}}
<pre>Before: 4 65 2 -31 0 99 2 83 782 1
Line 363 ⟶ 397:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
 
#define SWAP(r,s) do{ t=r; r=s; s=t; } while(0)
Line 393 ⟶ 427:
return 0;
}</langsyntaxhighlight>
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight Clang="c sharp|Cc#"> public static void Sort<T>(List<T> list) where T : IComparable {
if (list.Count > 1) {
StoogeSort(list, 0, list.Count - 1);
Line 413 ⟶ 447:
StoogeSort(L, i, j - t);
}
}</langsyntaxhighlight>
 
=={{header|C++}}==
<syntaxhighlight lang="cpp">
<lang Cpp>
#include <iostream>
#include <time.h>
Line 447 ⟶ 481:
return system( "pause" );
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 464 ⟶ 498:
 
=={{header|Clojure}}==
<langsyntaxhighlight lang="clojure">(defn swap [v x y]
(assoc! v y (v x) x (v y)))
 
Line 476 ⟶ 510:
(stooge-sort v (+ i t) j)
(stooge-sort v i (- j t))))
v))</langsyntaxhighlight>
 
=={{header|COBOL}}==
{{works with|GNU Cobol}}
<langsyntaxhighlight lang="cobol"> >>SOURCE FREE
IDENTIFICATION DIVISION.
PROGRAM-ID. stooge-sort-test.
Line 559 ⟶ 593:
END-IF
.
END PROGRAM stooge-sort.</langsyntaxhighlight>
 
{{out}}
Line 568 ⟶ 602:
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">(defun stooge-sort (vector &optional (i 0) (j (1- (length vector))))
(when (> (aref vector i) (aref vector j))
(rotatef (aref vector i) (aref vector j)))
Line 576 ⟶ 610:
(stooge-sort vector (+ i third) j)
(stooge-sort vector i (- j third))))
vector)</langsyntaxhighlight>
 
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.stdio, std.algorithm, std.array;
 
void stoogeSort(T)(T[] seq) pure nothrow {
Line 597 ⟶ 631:
data.stoogeSort();
writeln(data);
}</langsyntaxhighlight>
{{out}}
[-6, -5, -2, 1, 3, 3, 4, 5, 7, 10]
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
 
procedure StoogeSort(var L: array of integer; I,J: integer);
var T,M: integer;
begin
if L[j] < L[i] then
begin
M:=L[I];
L[I]:=L[J];
L[J]:=M;
end;
if (J - I) > 1 then
begin
T:=(J - I + 1) div 3;
StoogeSort(L, I, J-T);
StoogeSort(L, I+T, J);
StoogeSort(L, I, J-T);
end;
end;
 
 
procedure DoStoogeSort(var L: array of integer);
begin
StoogeSort(L,0,High(L));
end;
 
 
var TestData: array [0..9] of integer = (17, 23, 21, 56, 14, 10, 5, 2, 30, 25);
 
 
function GetArrayStr(IA: array of integer): string;
var I: integer;
begin
Result:='[';
for I:=0 to High(IA) do
begin
if I>0 then Result:=Result+' ';
Result:=Result+Format('%3d',[IA[I]]);
end;
Result:=Result+']';
end;
 
procedure ShowStoogeSort(Memo: TMemo);
begin
Memo.Lines.Add('Raw Data: '+GetArrayStr(TestData));
DoStoogeSort(TestData);
Memo.Lines.Add('Sorted Data: '+GetArrayStr(TestData));
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
Raw Data: [ 17 23 21 56 14 10 5 2 30 25]
Sorted Data: [ 2 5 10 14 17 21 23 25 30 56]
Elapsed Time: 1.158 ms.
 
</pre>
 
 
=={{header|EasyLang}}==
<syntaxhighlight>
proc stsort left right . d[] .
if d[left] > d[right]
swap d[left] d[right]
.
if right - left + 1 > 2
t = (right - left + 1) div 3
stsort left right - t d[]
stsort left + t right d[]
stsort left right - t d[]
.
.
for i = 1 to 100
d[] &= randint 1000
.
stsort 1 len d[] d[]
print d[]
</syntaxhighlight>
 
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
<lang Eiffel>
class
STOOGE_SORT
Line 632 ⟶ 752:
end
end
</syntaxhighlight>
</lang>
Test:
<syntaxhighlight lang="eiffel">
<lang Eiffel>
class
APPLICATION
Line 667 ⟶ 787:
 
end
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 677 ⟶ 797:
 
=={{header|Elena}}==
ELENA 46.x :
<langsyntaxhighlight lang="elena">import extensions;
import system'routines;
Line 704 ⟶ 824:
public program()
{
var list := new Range(0, 15).selectBy::(n => randomGenerator.evalnextInt(20)).toArray();
console.printLine("before:", list.asEnumerable());
console.printLine("after:", list.stoogeSort().asEnumerable())
}</langsyntaxhighlight>
{{out}}
<pre>
Line 716 ⟶ 836:
 
=={{header|Elixir}}==
<langsyntaxhighlight lang="elixir">defmodule Sort do
def stooge_sort(list) do
stooge_sort(List.to_tuple(list), 0, length(list)-1) |> Tuple.to_list
Line 738 ⟶ 858:
 
(for _ <- 1..20, do: :rand.uniform(20)) |> IO.inspect
|> Sort.stooge_sort |> IO.inspect</langsyntaxhighlight>
 
{{out}}
Line 747 ⟶ 867:
 
=={{header|Euphoria}}==
<langsyntaxhighlight lang="euphoria">function stooge(sequence s, integer i, integer j)
object temp
integer t
Line 771 ⟶ 891:
 
? s
? stoogesort(s)</langsyntaxhighlight>
 
{{out}}
Line 779 ⟶ 899:
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: kernel locals math prettyprint sequences ;
IN: rosetta-code.stooge-sort
 
Line 803 ⟶ 923:
{ 1 4 5 3 -6 3 7 10 -2 -5 } stooge-sort . ;
 
MAIN: stooge-sort-demo</langsyntaxhighlight>
{{out}}
<pre>
Line 811 ⟶ 931:
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<langsyntaxhighlight lang="fortran">program Stooge
implicit none
 
Line 841 ⟶ 961:
 
end subroutine
end program</langsyntaxhighlight>
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">' version 23-10-2016
' compile with: fbc -s console
 
Line 884 ⟶ 1,004:
Print : Print "hit any key to end program"
Sleep
End</langsyntaxhighlight>
{{out}}
<pre>Unsorted
Line 893 ⟶ 1,013:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 917 ⟶ 1,037:
stoogesort(a[:len(a)-t])
}
}</langsyntaxhighlight>
 
=={{header|Haskell}}==
 
<langsyntaxhighlight lang="haskell">import Data.List
import Control.Arrow
import Control.Monad
Line 940 ⟶ 1,060:
xs'
| xs!!j < xs!!i = swapElems xs i j
| otherwise = xs</langsyntaxhighlight>
Example:
<langsyntaxhighlight lang="haskell">*Main> stoogeSort [1, 4, 5, 3, -6, 3, 7, 10, -2, -5, 7, 5, 9, -3, 7]
[-6,-5,-3,-2,1,3,3,4,5,5,7,7,7,9,10]</langsyntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
<langsyntaxhighlight Iconlang="icon">procedure main() #: demonstrate various ways to sort a list and string
demosort(stoogesort,[3, 14, 1, 5, 9, 2, 6, 3],"qwerty")
end
Line 967 ⟶ 1,087:
}
return X # X must be returned and assigned to sort a string
end</langsyntaxhighlight>
 
Note: This example relies on [[Sorting_algorithms/Bubble_sort#Icon| the supporting procedures 'sortop', and 'demosort' in Bubble Sort]].
Line 982 ⟶ 1,102:
 
=={{header|IS-BASIC}}==
<langsyntaxhighlight ISlang="is-BASICbasic">100 PROGRAM "StoogSrt.bas"
110 RANDOMIZE
120 NUMERIC ARRAY(5 TO 16)
Line 1,009 ⟶ 1,129:
350 CALL STOOGESORT(A,I,J-T)
360 END IF
370 END DEF</langsyntaxhighlight>
 
=={{header|J}}==
<langsyntaxhighlight lang="j">swapElems=: |.@:{`[`]}
 
stoogeSort=: 3 : 0
Line 1,022 ⟶ 1,142:
(x-0,t) stoogeSort (x+t,0) stoogeSort (x-0,t) stoogeSort y
else. y end.
)</langsyntaxhighlight>
Example:
<langsyntaxhighlight lang="j"> (,: stoogeSort) ?~13
3 10 8 4 7 12 1 2 11 6 5 9 0
0 1 2 3 4 5 6 7 8 9 10 11 12
</syntaxhighlight>
</lang>
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.util.Arrays;
 
public class Stooge {
Line 1,056 ⟶ 1,176:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>[-6, -5, -2, 1, 3, 3, 4, 5, 7, 10]</pre>
 
=={{header|JavaScript}}==
<langsyntaxhighlight lang="javascript">function stoogeSort (array, i, j) {
if (j === undefined) {
j = array.length - 1;
Line 1,082 ⟶ 1,202:
stoogeSort(array, i, j-t);
}
};</langsyntaxhighlight>
Example:
<langsyntaxhighlight lang="javascript">arr = [9,1,3,10,13,4,2];
stoogeSort(arr);
console.log(arr);</langsyntaxhighlight>
{{out}}
<pre>[1, 2, 3, 4, 9, 10, 13]</pre>
Line 1,092 ⟶ 1,212:
=={{header|jq}}==
{{works with|jq|1.4}}
<langsyntaxhighlight lang="jq">def stoogesort:
def swap(i;j): .[i] as $t | .[i] = .[j] | .[j] = $t;
Line 1,108 ⟶ 1,228:
end;
 
[., 0, length-1] | ss;</langsyntaxhighlight>
'''Example'''
<langsyntaxhighlight lang="jq">([],
[1],
[1,2],
[1,3,2,4],
[1,4,5,3,-6,3,7,10,-2,-5]
) | stoogesort</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="sh">$ jq -c -n -f stooge_sort.jq
[]
[1]
[1,2]
[1,2,3,4]
[-6,-5,-2,1,3,3,4,5,7,10]</langsyntaxhighlight>
 
=={{header|Julia}}==
{{works with|Julia|0.6}}
{{trans|Matlab}}
<langsyntaxhighlight lang="julia">function stoogesort!(a::Array, i::Int=1, j::Int=length(a))
if a[j] < a[i]
a[[i, j]] = a[[j, i]];
Line 1,143 ⟶ 1,263:
 
x = randn(10)
@show x stoogesort!(x)</langsyntaxhighlight>
 
{{out}}
Line 1,150 ⟶ 1,270:
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.1.0
 
fun stoogeSort(a: IntArray, i: Int, j: Int) {
Line 1,171 ⟶ 1,291:
stoogeSort(a, 0, a.size - 1)
println("Sorted : ${a.asList()}")
}</langsyntaxhighlight>
 
{{out}}
Line 1,178 ⟶ 1,298:
Sorted : [-199, -52, 2, 3, 33, 56, 99, 100, 177, 200]
</pre>
 
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def stoogesort
{def stoogesort.r
{lambda {:a :i :j}
{let { {:a {if {< {A.get :j :a} {A.get :i :a}}
then {A.swap! :i :j :a}
else :a}}
{:i :i} {:j :j}
{:t {floor {/ {+ :j {- :i} 1} 3}}}
} {if {> {- :j :i} 1}
then {stoogesort.r :a :i {- :j :t}}
{stoogesort.r :a {+ :i :t} :j}
{stoogesort.r :a :i {- :j :t}}
else }} }}
{lambda {:a}
{stoogesort.r :a 0 {- {A.length :a} 1}} :a}}
-> stoogesort
 
{def A {A.new 9 1 3 10 13 4 2}}
-> A
 
{stoogesort {A}}
-> [1,2,3,4,9,10,13]
</syntaxhighlight>
 
=={{header|Lua}}==
Line 1,184 ⟶ 1,330:
and made generic with an optional predicate parameter.
 
<langsyntaxhighlight lang="lua">
local Y = function (f)
return (function(x) return x(x) end)(function(x) return f(function(...) return x(x)(...) end) end)
Line 1,212 ⟶ 1,358:
print(unpack(stoogesort{9,7,8,5,6,3,4,2,1,0}))
 
</syntaxhighlight>
</lang>
 
=={{header|Maple}}==
<langsyntaxhighlight Maplelang="maple">swap := proc(arr, a, b)
local temp := arr[a];
arr[a] := arr[b];
Line 1,239 ⟶ 1,385:
 
arr := Array([4, 2, 6, 1, 3, 7, 9, 5, 8]):
stoogesort(arr, 1, numelems(arr));</langsyntaxhighlight>
{{out}}
<pre>
Line 1,247 ⟶ 1,393:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">stoogeSort[lst_, I_, J_] := Module[{i = I, j = J, list = lst},
If[list[[j]] < list[[i]], list[[{i,j}]] = list[[{j,i}]];]
If[(j-i) > 1, t = Round[(j-i+1)/3];
Line 1,254 ⟶ 1,400:
list=stoogeSort[list,i,j-t];];
list
]</langsyntaxhighlight>
{{out}}
<pre>stoogeSort[{3,2,9,6,8},1,5]
Line 1,260 ⟶ 1,406:
 
=={{header|MATLAB}} / {{header|Octave}}==
<langsyntaxhighlight MATLABlang="matlab">%Required inputs:
%i = 1
%j = length(list)
Line 1,277 ⟶ 1,423:
end
 
end</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight MATLABlang="matlab">>> stoogeSort([1 -6 4 -9],1,4)
 
ans =
 
-9 -6 1 4</langsyntaxhighlight>
 
=={{header|MAXScript}}==
<langsyntaxhighlight MAXScriptlang="maxscript">fn stoogeSort arr i: j: =
(
if i == unsupplied do i = 1
Line 1,303 ⟶ 1,449:
)
return arr
)</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight MAXScriptlang="maxscript">a = for i in 1 to 15 collect random 1 20
#(10, 2, 1, 19, 18, 20, 18, 5, 13, 2, 13, 9, 7, 10, 6)
stoogeSort a
#(1, 2, 2, 5, 6, 7, 9, 10, 10, 13, 13, 18, 18, 19, 20)
</syntaxhighlight>
</lang>
 
=={{header|NetRexx}}==
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref savelog symbols binary
 
Line 1,347 ⟶ 1,493:
 
return L_
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,355 ⟶ 1,501:
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">proc stoogeSort[T](a: var openarray[T], i, j: int) =
if a[j] < a[i]: swap a[i], a[j]
if j - i > 1:
Line 1,365 ⟶ 1,511:
var a = @[4, 65, 2, -31, 0, 99, 2, 83, 782]
stoogeSort a, 0, a.high
echo a</langsyntaxhighlight>
{{out}}
<pre>@[-31, 0, 2, 2, 4, 65, 83, 99, 782]</pre>
 
=={{header|Objeck}}==
<langsyntaxhighlight lang="objeck">
bundle Default {
class Stooge {
Line 1,402 ⟶ 1,548:
}
}
</syntaxhighlight>
</lang>
 
=={{header|OCaml}}==
 
<langsyntaxhighlight lang="ocaml">let swap ar i j =
let tmp = ar.(i) in
ar.(i) <- ar.(j);
Line 1,422 ⟶ 1,568:
end
in
aux 0 (Array.length ar - 1)</langsyntaxhighlight>
 
testing:
<langsyntaxhighlight lang="ocaml">let () =
let ar = [| 3; 1; 7; 2; 6; 5; 4; 9; 8 |] in
stoogesort ar;
Array.iter (Printf.printf " %d") ar;
print_newline()</langsyntaxhighlight>
 
=={{header|ooRexx}}==
{{Trans|NetRexx}}
<langsyntaxhighlight ooRexxlang="oorexx">/* Rexx */
 
call demo
Line 1,513 ⟶ 1,659:
self~put(item, ix)
return
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,539 ⟶ 1,685:
 
=={{header|Oz}}==
<langsyntaxhighlight lang="oz">declare
proc {StoogeSort Arr}
proc {Swap I J}
Line 1,578 ⟶ 1,724:
for I in {Array.low Arr}..{Array.high Arr} do
{System.printInfo Arr.I#", "}
end</langsyntaxhighlight>
 
{{out}}
Line 1,585 ⟶ 1,731:
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang="parigp">stoogeSort(v)={
local(v=v); \\ Give children access to v
ss(1,#v); \\ Sort
Line 1,604 ⟶ 1,750:
ss(i,j-t)
)
};</langsyntaxhighlight>
 
=={{header|Pascal}}==
<langsyntaxhighlight lang="pascal">program StoogeSortDemo;
type
Line 1,652 ⟶ 1,798:
end;
writeln;
end.</langsyntaxhighlight>
{{out}}
<pre>./StoogeSort
Line 1,662 ⟶ 1,808:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">sub stooge {
use integer;
my ($x, $i, $j) = @_;
Line 1,685 ⟶ 1,831:
stooge(\@a);
print "After @a\n";
</syntaxhighlight>
</lang>
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
Line 1,705 ⟶ 1,851:
<span style="color: #0000FF;">?</span><span style="color: #000000;">stoogesort</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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,712 ⟶ 1,858:
 
=={{header|PHP}}==
<langsyntaxhighlight lang="php">
function stoogeSort(&$arr, $i, $j)
{
Line 1,727 ⟶ 1,873:
}
}
</syntaxhighlight>
</lang>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de stoogeSort (L N)
(default N (length L))
(let P (nth L N)
Line 1,740 ⟶ 1,886:
(stoogeSort (nth L (inc D)) (- N D))
(stoogeSort L (- N D)) ) )
L )</langsyntaxhighlight>
Test:
<pre>: (apply < (stoogeSort (make (do 100 (link (rand))))))
Line 1,746 ⟶ 1,892:
 
=={{header|PL/I}}==
<langsyntaxhighlight lang="pli">stoogesort: procedure (L) recursive; /* 16 August 2010 */
declare L(*) fixed binary;
declare (i, j, t, temp) fixed binary;
Line 1,762 ⟶ 1,908:
end;
end;
end stoogesort;</langsyntaxhighlight>
 
=={{header|PowerBASIC}}==
Line 1,776 ⟶ 1,922:
This version is closely based on the BASIC code above.
 
<langsyntaxhighlight lang="powerbasic">%arraysize = 10
 
SUB stoogesort (L() AS LONG, i AS LONG, j AS LONG)
Line 1,816 ⟶ 1,962:
 
? s
END FUNCTION</langsyntaxhighlight>
 
{{out}}
Line 1,827 ⟶ 1,973:
 
=={{header|PowerShell}}==
<langsyntaxhighlight PowerShelllang="powershell">Function StoogeSort( [Int32[]] $L )
{
$i = 0
Line 1,848 ⟶ 1,994:
}
 
StoogeSort 9, 7, 5, 3, 1, 2, 4, 6, 8</langsyntaxhighlight>
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">Procedure Stooge_Sort(Array L.i(1), i=0 , j=0)
If j=0
j=ArraySize(L())
Line 1,864 ⟶ 2,010:
Stooge_Sort(L(), i, j-t)
EndIf
EndProcedure</langsyntaxhighlight>
Implementation may be as<langsyntaxhighlight PureBasiclang="purebasic">Define AmountOfPosts=(?Stop_Data-?Start_data)/SizeOf(Integer)
Dim Xyz.i(AmountOfPosts)
CopyMemory(?Start_data, @Xyz(), ?Stop_Data-?Start_data)
Line 1,879 ⟶ 2,025:
Data.i 1, 4, 5, 3, -6, 3, 7, 10, -2, -5, 7, 5, 9, -3, 7
Stop_Data:
EndDataSection</langsyntaxhighlight>
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">>>> data = [1, 4, 5, 3, -6, 3, 7, 10, -2, -5, 7, 5, 9, -3, 7]
>>> def stoogesort(L, i=0, j=None):
if j is None:
Line 1,896 ⟶ 2,042:
 
>>> stoogesort(data)
[-6, -5, -3, -2, 1, 3, 3, 4, 5, 5, 7, 7, 7, 9, 10]</langsyntaxhighlight>
 
This alternate solution uses a wrapper function
to compute the initial value of ''j''
rather than detecting the sentinel value ''None''.
<langsyntaxhighlight lang="python">>>> def stoogesort(L, i, j):
if L[j] < L[i]:
L[i], L[j] = L[j], L[i]
Line 1,915 ⟶ 2,061:
>>> data = [1, 4, 5, 3, -6, 3, 7, 10, -2, -5, 7, 5, 9, -3, 7]
>>> stooge(data)
[-6, -5, -3, -2, 1, 3, 3, 4, 5, 5, 7, 7, 7, 9, 10]</langsyntaxhighlight>
 
=={{header|Quackery}}==
 
<langsyntaxhighlight Quackerylang="quackery"> [ 2 * 3 /mod 0 > + ] is onethird twothirds ( n --> n )
 
[ 2 * onethird ] is twothirds ( n --> n )
 
[ dup 0 peek over -1 peek
Line 1,932 ⟶ 2,076:
dup size twothirds split
swap recurse swap join
dup size onethird3 / split
recurse join
dup size twothirds split
Line 1,939 ⟶ 2,083:
[] 33 times [ 90 random 10 + join ]
dup echo cr
stoogesort echo</syntaxhighlight>
</lang>
 
{{out}}
Line 1,949 ⟶ 2,092:
 
=={{header|R}}==
<langsyntaxhighlight Rlang="r">stoogesort = function(vect) {
i = 1
j = length(vect)
Line 1,965 ⟶ 2,108:
k = stoogesort(v)
v
k</langsyntaxhighlight>
{{out}}
<pre>
Line 1,973 ⟶ 2,116:
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">
#lang racket
(define (stooge-sort xs [i 0] [j (- (vector-length xs) 1)])
Line 1,986 ⟶ 2,129:
(stooge-sort xs i (- j t)))
xs)
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" perl6line>sub stoogesort( @L, $i = 0, $j = @L.end ) {
@L[$j,$i] = @L[$i,$j] if @L[$i] > @L[$j];
 
Line 2,007 ⟶ 2,150:
 
stoogesort(@L).Str.say;
</syntaxhighlight>
</lang>
 
=={{header|REXX}}==
This REXX example starts an array at element zero &nbsp; (but any integer could be used); &nbsp; a zero-
<br>based index was used because the algorithm shown in the Rosetta Code task used zero.
<langsyntaxhighlight REXXlang="rexx">/*REXX program sorts an integer array @. [the first element starts at index zero].*/
parse arg N . /*obtain an optional argument from C.L.*/
if N=='' | N=="," then N=19 /*Not specified? Then use the default.*/
Line 2,034 ⟶ 2,177:
call stoogeSort i , j-t /* " " */
end
return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default (internal generated) inputs:}}
 
Line 2,084 ⟶ 2,227:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
test = [4, 65, 2, -31, 0, 99, 2, 83, 782, 1]
stoogeSort(test, 1, len(test))
Line 2,103 ⟶ 2,246:
stoogeSort(list, i, j-t) ok
return list
</langsyntaxhighlight>
Output:
<pre>
Line 2,110 ⟶ 2,253:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">class Array
def stoogesort
self.dup.stoogesort!
Line 2,129 ⟶ 2,272:
end
 
p [1,4,5,3,-6,3,7,10,-2,-5].stoogesort </langsyntaxhighlight>
 
{{out}}
Line 2,135 ⟶ 2,278:
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">fn stoogesort<E>(a: &mut [E])
where E: PartialOrd
{
Line 2,156 ⟶ 2,299:
stoogesort(&mut numbers);
println!("After: {:?}", &numbers);
}</langsyntaxhighlight>
 
=={{header|Scala}}==
<langsyntaxhighlight Scalalang="scala">object StoogeSort extends App {
def stoogeSort(a: Array[Int], i: Int, j: Int) {
if (a(j) < a(i)) {
Line 2,178 ⟶ 2,321:
stoogeSort(a, 0, a.length - 1)
println(s"Sorted : ${a.mkString(", ")}")
}</langsyntaxhighlight>
 
See it running in your browser by [https://scastie.scala-lang.org/QTCrb5SNTVqDNC6oRQRmZw Scastie (JVM)].
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func stooge(x, i, j) {
if (x[j] < x[i]) {
x.swap(i, j)
Line 2,200 ⟶ 2,343:
say "Before #{a}"
stooge(a, 0, a.end)
say "After #{a}"</langsyntaxhighlight>
 
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<langsyntaxhighlight lang="smalltalk">OrderedCollection extend [
stoogeSortFrom: i to: j [
(self at: j) < (self at: i)
Line 2,227 ⟶ 2,370:
test := #( 1 4 5 3 -6 3 7 10 -2 -5) asOrderedCollection.
test stoogeSort.
test printNl.</langsyntaxhighlight>
 
Here is a "functional" variation (a 1:1 adaption of the original algorithm):
<langsyntaxhighlight lang="smalltalk">stoogesort := [:L :i :j |
(L at:i) > (L at:j) ifTrue:[
L swap:i with:j
Line 2,244 ⟶ 2,387:
a := #(1 4 5 3 -6 3 7 10 -2 -5 7 5 9 -3 7) copy.
stoogesort value:a value:1 value:a size.
Transcript showCR:a</langsyntaxhighlight>
 
Output:
Line 2,250 ⟶ 2,393:
 
=={{header|Swift}}==
<langsyntaxhighlight Swiftlang="swift">func stoogeSort(inout arr:[Int], _ i:Int = 0, var _ j:Int = -1) {
if j == -1 {
j = arr.count - 1
Line 2,271 ⟶ 2,414:
stoogeSort(&a)
 
println(a)</langsyntaxhighlight>
{{out}}
<pre>
Line 2,279 ⟶ 2,422:
=={{header|Tcl}}==
{{works with|Tcl|8.5}}
<langsyntaxhighlight lang="tcl">package require Tcl 8.5
 
proc stoogesort {L {i 0} {j -42}} {
Line 2,300 ⟶ 2,443:
}
 
stoogesort {1 4 5 3 -6 3 7 10 -2 -5}</langsyntaxhighlight>
{{out}}
<pre>-6 -5 -2 1 3 3 4 5 7 10</pre>
 
=={{header|True BASIC}}==
<syntaxhighlight lang="qbasic">SUB swap (vb1,vb2)
LET temp = vb1
LET vb1 = vb2
LET vb2 = temp
END SUB
 
SUB stoogesort (l(),i,j)
IF l(j) < l(i) THEN CALL swap (L(i), L(j))
IF (j-i) > 1 THEN
LET t = (j-i+1)/3
CALL stoogesort (l(), i, j-t)
CALL stoogesort (L(), i + t, j)
CALL stoogesort (L(), i, j - t)
END IF
END SUB
 
RANDOMIZE
LET arraysize = 10
DIM x(0)
MAT REDIM x(arraysize)
 
PRINT "unsort: ";
FOR i = 1 TO arraysize
LET x(i) = INT(RND*100)
PRINT x(i); " ";
NEXT i
PRINT
 
CALL stoogesort (x(), 1, arraysize)
 
PRINT " sort: ";
FOR i = 1 TO arraysize
PRINT x(i); " ";
NEXT i
PRINT
END</syntaxhighlight>
 
=={{header|uBasic/4tH}}==
{{trans|BBC BASIC}}
<syntaxhighlight lang="text">PRINT "Stooge sort:"
n = FUNC (_InitArray)
PROC _ShowArray (n)
Line 2,357 ⟶ 2,538:
PRINT
RETURN</langsyntaxhighlight>
 
=={{header|Wren}}==
<langsyntaxhighlight ecmascriptlang="wren">var stoogeSort // recursive
stoogeSort = Fn.new { |a, i, j|
if (a[j] < a[i]) {
Line 2,375 ⟶ 2,556:
}
 
var asarray = [ [4, 65, 2, -31, 0, 99, 2, 83, 782, 1], [7, 5, 2, 6, 1, 4, 2, 6, 3] ]
for (a in asarray) {
System.print("Before: %(a)")
stoogeSort.call(a, 0, a.count-1)
System.print("After : %(a)")
System.print()
}</langsyntaxhighlight>
 
{{out}}
Line 2,393 ⟶ 2,574:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">code ChOut=8, IntOut=11; \intrinsic routines
 
proc StoogeSort(L, I, J); \Sort array L
Line 2,412 ⟶ 2,593:
StoogeSort(A, 0, 10-1);
for I:= 0 to 10-1 do [IntOut(0, A(I)); ChOut(0, ^ )];
]</langsyntaxhighlight>
 
{{out}}
Line 2,422 ⟶ 2,603:
Based on pseudocode, except using Yorick's 1-based arrays.
Sorts in place.
<langsyntaxhighlight lang="yorick">func stoogesort(&L, i, j) {
if(is_void(i)) i = 1;
if(is_void(j)) j = numberof(L);
Line 2,433 ⟶ 2,614:
stoogesort, L, i, j-t;
}
}</langsyntaxhighlight>
 
Example interactive use:
Line 2,442 ⟶ 2,623:
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">fcn stoogeSort(list,i=0,j=Void){ if(Void==j) j=list.len() - 1; // default parameters set before call
if(list[j]<list[i]) list.swap(i,j);
if(j - i >1){
Line 2,451 ⟶ 2,632:
}
list
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">stoogeSort(List(67,-201,0,9,9,231,4)).println();</langsyntaxhighlight>
{{out}}
<pre>
Chkas
2,058

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/153459...350248"