Rosetta Code

Sorting algorithms/Cocktail sort with shifting bounds: Difference between revisions

Page Discussion

Sorting algorithms/Cocktail sort with shifting bounds (view source)

Revision as of 11:33, 8 February 2024

16,021 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
(Added Arturo implementation)
m (→‎{{header|Wren}}: Minor tidy)
 
(10 intermediate revisions by 7 users not shown)
Line 45:
Pseudocode for the &nbsp; <big> 2<sup>nd</sup> </big> &nbsp; algorithm &nbsp; (from
[[wp:Cocktail sort|Wikipedia]]) &nbsp; with an added comment and changed indentations:
<langsyntaxhighlight lang="matlab">function A = cocktailShakerSort(A)
% `beginIdx` and `endIdx` marks the first and last index to check.
beginIdx = 1;
Line 75:
beginIdx = newBeginIdx + 1;
end
end</langsyntaxhighlight>
<big>'''%'''</big> &nbsp; indicates a comment, &nbsp; and &nbsp; '''deal''' &nbsp; indicates a &nbsp; ''swap''.
 
Line 92:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F cocktailshiftingbounds(&A)
V beginIdx = 0
V endIdx = A.len - 1
Line 113:
V test1 = [7, 6, 5, 9, 8, 4, 3, 1, 2, 0]
cocktailshiftingbounds(&test1)
print(test1)</langsyntaxhighlight>
 
{{out}}
Line 123:
For maximum compatibility, this program uses only the basic instruction set.
The program uses also HLASM structured macros (DO,ENDDO,IF,ELSE,ENDIF) for readability and two ASSIST/360 macros (XDECO,XPRNT) to keep the code as short as possible.
<langsyntaxhighlight lang="360asm">* Cocktail sort with shifting bounds 10/05/2020
COCKSHIS CSECT
USING COCKSHIS,R13 base register
Line 206:
REGEQU
RI EQU 6 i
END COCKSHIS </langsyntaxhighlight>
{{out}}
<pre>
Line 214:
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
<lang AArch64 Assembly>
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program cocktailSortbound64.s */
Line 401:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
</lang>
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC PrintArray(INT ARRAY a INT size)
INT i
 
Put('[)
FOR i=0 TO size-1
DO
IF i>0 THEN Put(' ) FI
PrintI(a(i))
OD
Put(']) PutE()
RETURN
 
PROC CoctailShakerSort(INT ARRAY a INT size)
INT begIdx,endIdx,newBegIdx,newEndIdx,i,tmp
 
begIdx=0 endIdx=size-2
WHILE begIdx<=endIdx
DO
newBegIdx=endIdx
newEndIdx=begIdx
i=begIdx
WHILE i<=endIdx
DO
IF a(i)>a(i+1) THEN
tmp=a(i) a(i)=a(i+1) a(i+1)=tmp
newEndIdx=i
FI
i==+1
OD
endIdx=newEndIdx-1
 
i=endIdx
WHILE i>=begIdx
DO
IF a(i)>a(i+1) THEN
tmp=a(i) a(i)=a(i+1) a(i+1)=tmp
newBegIdx=i
FI
i==-1
OD
begIdx=newBegIdx+1
OD
RETURN
 
PROC Test(INT ARRAY a INT size)
PrintE("Array before sort:")
PrintArray(a,size)
CoctailShakerSort(a,size)
PrintE("Array after sort:")
PrintArray(a,size)
PutE()
RETURN
 
PROC Main()
INT ARRAY
a(10)=[1 4 65535 0 3 7 4 8 20 65530],
b(21)=[10 9 8 7 6 5 4 3 2 1 0
65535 65534 65533 65532 65531
65530 65529 65528 65527 65526],
c(8)=[101 102 103 104 105 106 107 108],
d(12)=[1 65535 1 65535 1 65535 1
65535 1 65535 1 65535]
Test(a,10)
Test(b,21)
Test(c,8)
Test(d,12)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Cocktail_sort_with_shifting_bounds.png Screenshot from Atari 8-bit computer]
<pre>
Array before sort:
[1 4 -1 0 3 7 4 8 20 -6]
Array after sort:
[-6 -1 0 1 3 4 4 7 8 20]
 
Array before sort:
[10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10]
Array after sort:
[-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10]
 
Array before sort:
[101 102 103 104 105 106 107 108]
Array after sort:
[101 102 103 104 105 106 107 108]
 
Array before sort:
[1 -1 1 -1 1 -1 1 -1 1 -1 1 -1]
Array after sort:
[-1 -1 -1 -1 -1 -1 1 1 1 1 1 1]
</pre>
 
=={{header|ALGOL 60}}==
{{works with|A60}}
<langsyntaxhighlight lang="algol60">begin
comment Sorting algorithms/Cocktail sort with shifting bounds - Algol 60;
integer nA;
Line 460 ⟶ 553:
writetable(1,nA)
end
end </langsyntaxhighlight>
{{out}}
<pre>
Line 466 ⟶ 559:
3 6 14 16 19 23 28 33 33 47 61 62 64 67 73 77 78 81 83 92
</pre>
 
=={{header|ALGOL 68}}==
Based on the pseudo-code with test cases from the Action! sample.
<syntaxhighlight lang="algol68">
BEGIN # cocktail sort with shifting bounds #
 
# sorts data, using a cocktail sort with shifting bounds #
# a reference to the sorted data is returned #
# - defined as an operator as Algol 68 has operator overloading but not #
# procedure overloading #
# (similar operators with the same name could be defined for other types #
# of array) #
OP COCKTAILSORTSB = ( []INT data )REF[]INT:
BEGIN
# make a copy of the data #
REF[]INT a := HEAP[ LWB data : UPB data ]INT := data;
# `beginIdx` and `endIdx` marks the first and last index to check. #
INT begin idx := LWB a;
INT end idx := UPB a - 1;
 
WHILE begin idx <= end idx DO
INT new begin idx := end idx;
INT new end idx := begin idx;
FOR ii FROM begin idx TO end idx DO
IF a[ ii ] > a[ ii + 1 ] THEN
INT aii = a[ ii ];
a[ ii ] := a[ ii + 1 ];
a[ ii + 1 ] := aii;
new end idx := ii
FI
OD;
 
# decreases `endIdx` because the elements after `newEndIdx` are in correct order #
end idx := new end idx - 1;
 
FOR ii FROM end idx BY -1 TO begin idx DO
IF a[ ii ] > a[ ii + 1 ] THEN
INT aii = a[ ii ];
a[ ii ] := a[ ii + 1 ];
a[ ii + 1 ] := aii;
new begin idx := ii
FI
OD;
 
# increases `beginIdx` because the elements before `newBeginIdx` are in correct order. #
begin idx := new begin idx + 1
OD;
a
END # COCKTAILSORTSB # ;
 
# test the COCKTAILSORTSB operator #
PROC test cocktail sort with shifting bounds = ( []INT data )VOID:
BEGIN
REF[]INT sorted := COCKTAILSORTSB data;
print( ( "[" ) );
FOR i FROM LWB data TO UPB data DO print( ( " ", whole( data[ i ], 0 ) ) ) OD;
print( ( " ]", newline, " -> [" ) );
FOR i FROM LWB sorted TO UPB sorted DO print( ( " ", whole( sorted[ i ], 0 ) ) ) OD;
print( ( " ]", newline ) )
END # test cocktail sort with shifting bounds # ;
 
# test cases from the Action! sample #
test cocktail sort with shifting bounds( ( 1, 4, -1, 0, 3, 7, 4, 8, 20, -6 ) );
test cocktail sort with shifting bounds( ( 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10
)
);
test cocktail sort with shifting bounds( ( 101, 102, 103, 104, 105, 106, 107, 108 ) );
test cocktail sort with shifting bounds( ( 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1 ) );
# additional test cases #
test cocktail sort with shifting bounds( ( 1, 1, 1, 1, 1, 1 ) );
test cocktail sort with shifting bounds( ( 0 ) );
test cocktail sort with shifting bounds( () )
END
</syntaxhighlight>
{{out}}
<pre>
[ 1 4 -1 0 3 7 4 8 20 -6 ]
-> [ -6 -1 0 1 3 4 4 7 8 20 ]
[ 10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 ]
-> [ -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 ]
[ 101 102 103 104 105 106 107 108 ]
-> [ 101 102 103 104 105 106 107 108 ]
[ 1 -1 1 -1 1 -1 1 -1 1 -1 1 -1 ]
-> [ -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 ]
[ 1 1 1 1 1 1 ]
-> [ 1 1 1 1 1 1 ]
[ 0 ]
-> [ 0 ]
[ ]
-> [ ]
</pre>
 
=={{header|ALGOL W}}==
Based on the pseudo-code - test code based on the Algol 68 test code.
<syntaxhighlight lang="algolw">
begin % cocktail sort with shifting bounds %
 
% sorts in-place a using a cocktail sort with shifting bounds %
% the bounds of a must be specified in lb and ub %
procedure cocktailSortWithShiftingBounds ( integer array a ( * )
; integer value lb, ub
);
begin
% `beginIdx` and `endIdx` marks the first and last index to check. %
integer beginIdx, endIdx;
beginIdx := lb;
endIdx := ub - 1;
 
while beginIdx <= endIdx do begin
integer newBeginIdx, newEndIdx;
newBeginIdx := endIdx;
newEndIdx := beginIdx;
for ii := beginIdx until endIdx do begin
integer aii;
if a( ii ) > a( ii + 1 ) then begin
integer aii;
aii := a( ii );
a( ii ) := a( ii + 1 );
a( ii + 1 ) := aii;
newEndIdx := ii
end
end for_ii ;
 
% decreases `endIdx` because the elements after `newEndIdx` are in correct order %
endIdx := newEndIdx - 1;
 
for ii := endIdx step -1 until beginIdx do begin
if a( ii ) > a( ii + 1 ) then begin
integer aii;
aii := a( ii );
a( ii ) := a( ii + 1 );
a( ii + 1 ) := aii;
newBeginIdx := ii
end
end for_ii ;
 
% increases `beginIdx` because the elements before `newBeginIdx` are in correct order. %
beginIdx := newBeginIdx + 1
 
end while_beginIdx_le_endIdx
 
end coctailSortWithShiftingBounds ;
 
% test the cocktailSortWithShiftingBounds procedure %
begin
 
integer procedure inc ( integer value result i ) ;
begin
i := i + 1;
i
end inc ;
 
procedure testCocktailSortWithShiftingBounds( integer array data ( * )
; integer value lb, ub
);
begin
i_w := 1; s_w := 0; % set formatting %
write( "[" );
for i := lb until ub do writeon( " ", data( i ) );
writeon( " ]" );
cocktailSortWithShiftingBounds( data, lb, ub );
write( " -> [" );
for i := lb until ub do writeon( " ", data( i ) );
writeon( " ]" )
end testCocktailSortWithShiftingBounds ;
 
integer array t ( 1 :: 32 );
integer tPos;
 
% test cases from the Action! sample %
tPos := 0;
for d := 1, 4, -1, 0, 3, 7, 4, 8, 20, -6 do t( inc( tPos ) ) := d;
testCocktailSortWithShiftingBounds( t, 1, tPos );
tPos := 0;
for d := 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10
do t( inc( tPos ) ) := d;
testCocktailSortWithShiftingBounds( t, 1, tPos );
tPos := 0;
for d := 101, 102, 103, 104, 105, 106, 107, 108 do t( inc( tPos ) ) := d;
testCocktailSortWithShiftingBounds( t, 1, tPos );
tPos := 0;
for d := 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1 do t( inc( tPos ) ) := d;
testCocktailSortWithShiftingBounds( t, 1, tPos );
% additional test cases %
tPos := 0;
for d := 1, 1, 1, 1, 1, 1 do t( inc( tPos ) ) := d;
testCocktailSortWithShiftingBounds( t, 1, tPos );
tPos := 0;
for d := 0 do t( inc( tPos ) ) := d;
testCocktailSortWithShiftingBounds( t, 1, tPos );
tPos := 0;
testCocktailSortWithShiftingBounds( t, 1, tPos );
end
end.
</syntaxhighlight>
{{out}}
<pre>
[ 1 4 -1 0 3 7 4 8 20 -6 ]
-> [ -6 -1 0 1 3 4 4 7 8 20 ]
[ 10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 ]
-> [ -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 ]
[ 101 102 103 104 105 106 107 108 ]
-> [ 101 102 103 104 105 106 107 108 ]
[ 1 -1 1 -1 1 -1 1 -1 1 -1 1 -1 ]
-> [ -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 ]
[ 1 1 1 1 1 1 ]
-> [ 1 1 1 1 1 1 ]
[ 0 ]
-> [ 0 ]
[ ]
-> [ ]
</pre>
 
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
<lang ARM Assembly>
/* ARM assembly Raspberry PI */
/* program cocktailSortBound.s */
Line 642 ⟶ 950:
.include "../affichage.inc"
 
</syntaxhighlight>
</lang>
 
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">cocktailShiftSort: function [items][
a: new items
beginIdx: 0
Line 680 ⟶ 988:
]
 
print cocktailShiftSort [3 1 2 8 5 7 9 4 6]</langsyntaxhighlight>
 
{{out}}
Line 687 ⟶ 995:
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">cocktailShakerSort(A){
beginIdx := 1
endIdx := A.Count() - 1
Line 712 ⟶ 1,020:
beginIdx := newBeginIdx + 1
}
}</langsyntaxhighlight>
Examples:<langsyntaxhighlight AutoHotkeylang="autohotkey">A := [8,6,4,3,5,2,7,1]
cocktailShakerSort(A)
for k, v in A
output .= v ", "
MsgBox % "[" Trim(output, ", ") "]" ; show output</langsyntaxhighlight>
{{out}}
<pre>[1, 2, 3, 4, 5, 6, 7, 8]</pre>
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <string.h>
 
Line 783 ⟶ 1,091:
print(a, len);
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 792 ⟶ 1,100:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <algorithm>
#include <cassert>
#include <iostream>
Line 844 ⟶ 1,152:
print(v.begin(), v.end());
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 851 ⟶ 1,159:
after: -6 0 1 2 3 4 5 12 13 15
</pre>
 
 
=={{header|FreeBASIC}}==
{{trans|VBA}}
<syntaxhighlight lang="freebasic">
Sub cocktailShakerSort(bs() As Long)
Dim As Long i, lb = Lbound(bs), ub = Ubound(bs) -1
Dim As Long newlb, newub, tmp
Do While lb <= ub
newlb = ub
newub = lb
For i = lb To ub
If bs(i) > bs(i + 1) Then
tmp = bs(i): bs(i) = bs(i + 1): bs(i + 1) = tmp
newub = i
End If
Next i
ub = newub - 1
For i = ub To lb Step -1
If bs(i) > bs(i + 1) Then
tmp = bs(i): bs(i) = bs(i + 1): bs(i + 1) = tmp
newlb = i
End If
Next i
lb = newlb + 1
Loop
End Sub
 
'--- Programa Principal ---
Dim As Long i, array(-7 To 7)
Dim As Long a = Lbound(array), b = Ubound(array)
 
Randomize Timer
For i = a To b : array(i) = i : Next i
For i = a To b
Swap array(i), array(Int(Rnd * (b - a + 1)) + a)
Next i
 
Print "unsort ";
For i = a To b : Print Using "####"; array(i); : Next i
 
cocktailShakerSort(array()) ' ordenar el array
 
Print !"\n sort ";
For i = a To b : Print Using "####"; array(i); : Next i
 
Print !"\n--- terminado, pulsa RETURN---"
Sleep
</syntaxhighlight>
{{out}}
<pre>
unsort -4 0 5 -7 -2 4 3 -5 -1 7 2 1 6 -3 -6
sort -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7
</pre>
 
 
=={{header|Go}}==
If you run this a few times, the figures for 8K random numbers upwards are quite stable at around the levels shown.
<langsyntaxhighlight lang="go">package main
 
import (
Line 957 ⟶ 1,321:
fmt.Printf(" %2dk %0.3f\n", n/1000, sum/runs)
}
}</langsyntaxhighlight>
 
{{out}}
Line 979 ⟶ 1,343:
=={{header|Groovy}}==
{{trans|Java}}
<langsyntaxhighlight lang="groovy">class CocktailSort {
static void main(String[] args) {
Integer[] array = [ 5, 1, -6, 12, 3, 13, 2, 4, 0, 15 ]
Line 1,023 ⟶ 1,387:
array[j] = tmp
}
}</langsyntaxhighlight>
{{out}}
<pre>before: [5, 1, -6, 12, 3, 13, 2, 4, 0, 15]
Line 1,029 ⟶ 1,393:
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.util.*;
 
public class CocktailSort {
Line 1,074 ⟶ 1,438:
array[j] = tmp;
}
}</langsyntaxhighlight>
 
{{out}}
Line 1,085 ⟶ 1,449:
The implementation chosen is to extend the native Julia base sort! function, which by default in base Julia supports insertion sort,
quick sort, partial quick sort, and merge sort.
<langsyntaxhighlight lang="julia">module CocktailShakerSorts
 
using Base.Order, Base.Sort
Line 1,138 ⟶ 1,502:
println("\nUsing CocktailShakerSort:")
@btime cocktailshakersort!([5, 8, 2, 0, 6, 1, 9, 3, 4])
</langsyntaxhighlight>{{out}}
<pre>
[5, 8, 2, 0, 6, 1, 9, 3, 4] => [0, 1, 2, 3, 4, 5, 6, 8, 9] => [9, 8, 6, 5, 4, 3, 2, 1, 0]
Line 1,151 ⟶ 1,515:
=={{header|Kotlin}}==
{{trans|Java}}
<langsyntaxhighlight lang="scala">fun <T> swap(array: Array<T>, i: Int, j: Int) {
val temp = array[i]
array[i] = array[j]
Line 1,194 ⟶ 1,558:
cocktailSort(array)
println("after: ${array.contentToString()}")
}</langsyntaxhighlight>
{{out}}
<pre>before: [5, 1, -6, 12, 3, 13, 2, 4, 0, 15]
after: [-6, 0, 1, 2, 3, 4, 5, 12, 13, 15]</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[CocktailShakerSort]
CocktailShakerSort[in_List] :=
Module[{x = in, swapped, begin = 1, end = Length[in] - 1},
swapped = True;
While[swapped,
swapped = False;
Do[
If[x[[i]] > x[[i + 1]],
x[[{i, i + 1}]] //= Reverse;
swapped = True;
]
,
{i, begin, end}
];
end--;
Do[
If[x[[i]] > x[[i + 1]],
x[[{i, i + 1}]] //= Reverse;
swapped = True;
]
,
{i, end, begin, -1}
];
begin++;
];
x
]
CocktailShakerSort[{44, 21, 5, 88, 52, 44, 36, 93, 66, 18, 88, 61, 45, 47, 47, 68, 19, 60}]</syntaxhighlight>
{{out}}
<pre>{5, 18, 19, 21, 36, 44, 44, 45, 47, 47, 52, 60, 61, 66, 68, 88, 88, 93}</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">proc cocktailShakerSort[T](a: var openarray[T]) =
 
var beginIdx = 0
Line 1,224 ⟶ 1,621:
var a = @[4, 65, 2, -31, 0, 99, 2, 83, 782]
cocktailShakerSort a
echo a</langsyntaxhighlight>
 
{{out}}
Line 1,230 ⟶ 1,627:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
Line 1,261 ⟶ 1,658:
}
 
say join ' ', cocktail_sort( <t h e q u i c k b r o w n f o x j u m p s o v e r t h e l a z y d o g> );</langsyntaxhighlight>
{{out}}
<pre>a b c d e e e f g h h i j k l m n o o o o p q r r s t t u u v w x y z</pre>
Line 1,267 ⟶ 1,664:
=={{header|Phix}}==
Averages 7 or 8% better than [[Sorting_algorithms/Cocktail_sort#Phix]] which already shifted the bounds, however this shifts >1 (sometimes).
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
Line 1,304 ⟶ 1,701:
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</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;">12</span><span style="color: #0000FF;">))</span> <span style="color: #0000FF;">?{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cocktailShakerSort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)}</span>
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"one"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"two"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"three"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"four"</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">?{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cocktailShakerSort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)}</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,312 ⟶ 1,709:
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">
"""
 
Line 1,353 ⟶ 1,750:
cocktailshiftingbounds(test2)
print(''.join(test2))
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,360 ⟶ 1,757:
abcdefghiijklmnopqrstuvwxyz
</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="Quackery">
[ stack ] is limit ( --> s )
[ stack ] is offset ( --> s )
 
[ offset share +
2dup 1+ peek dip peek > ] is compare ( [ n --> b )
 
[ offset share +
dup 1+ unrot
2dup peek
dip
[ 2dup 1+ peek
unrot poke
swap ]
unrot poke ] is exchange ( [ n --> [ )
 
[ dup size 1 - limit put
0 offset put
[ 0 swap
limit share times
[ dup i^ compare if
[ i^ exchange
dip 1+ ] ]
over while
limit share times
[ dup i compare if
[ i exchange
dip 1+ ] ]
over while
-2 limit tally
1 offset tally
nip again ]
nip
limit release
offset release ] is cocktail ( [ --> [ )
 
randomise
[] 20 times [ 89 random 10 + join ]
dup echo cr
cocktail echo</syntaxhighlight>
 
{{out}}
 
<pre>[ 88 46 64 82 35 34 92 15 48 78 94 19 50 79 62 19 42 79 43 50 ]
[ 15 19 19 34 35 42 43 46 48 50 50 62 64 78 79 79 82 88 92 94 ]</pre>
 
=={{header|Raku}}==
{{works with|Rakudo|2020.05}}
 
<syntaxhighlight lang="raku" perl6line>sub cocktail_sort ( @a ) {
my ($min, $max) = 0, +@a - 2;
loop {
Line 1,397 ⟶ 1,842:
 
my @weights = (flat 0..9, 'A'..'F').roll(2 + ^4 .roll).join xx 100;
say @weights.sort.Str eq @weights.&cocktail_sort.Str ?? 'ok' !! 'not ok';</langsyntaxhighlight>
 
=={{header|REXX}}==
This REXX version can handle array elements that may contain blanks or spaces.
<langsyntaxhighlight lang="rexx">/*REXX program sorts an array using the cocktail─sort method with shifting bounds. */
call gen /*generate some array elements. */
call show 'before sort' /*show unsorted array elements. */
Line 1,456 ⟶ 1,901:
say 'element' right(j, w) arg(1)":" @.j
end /*j*/ /* ↑ */
return /* └─────max width of any line.*/</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the internal default inputs:}}
 
Line 1,502 ⟶ 1,947:
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">fn cocktail_shaker_sort<T: PartialOrd>(a: &mut [T]) {
let mut begin = 0;
let mut end = a.len();
Line 1,536 ⟶ 1,981:
cocktail_shaker_sort(&mut v);
println!("after: {:?}", v);
}</langsyntaxhighlight>
 
{{out}}
Line 1,546 ⟶ 1,991:
=={{header|Swift}}==
{{trans|Rust}}
<langsyntaxhighlight lang="swift">func cocktailShakerSort<T: Comparable>(_ a: inout [T]) {
var begin = 0
var end = a.count
Line 1,585 ⟶ 2,030:
print("before: \(array2)")
cocktailShakerSort(&array2)
print(" after: \(array2)")</langsyntaxhighlight>
 
{{out}}
Line 1,596 ⟶ 2,041:
 
=={{header|VBA}}==
<langsyntaxhighlight lang="vb">' Sorting algorithms/Cocktail sort with shifting bounds - VBA
 
Function cocktailShakerSort(ByVal A As Variant) As Variant
Line 1,629 ⟶ 2,074:
Debug.Print Join(B, ", ")
Debug.Print Join(cocktailShakerSort(B), ", ")
End Sub</langsyntaxhighlight>
{{out}}
<pre>
Line 1,638 ⟶ 2,083:
 
=={{header|VBScript}}==
<langsyntaxhighlight lang="vb">' Sorting algorithms/Cocktail sort with shifting bounds - VBScript
 
Function cocktailShakerSort(ByVal A)
Line 1,669 ⟶ 2,114:
Next
Wscript.Echo Join(cocktailShakerSort(B)," ")
</langsyntaxhighlight>
{{out}}
<pre>
Line 1,677 ⟶ 2,122:
=={{header|Visual Basic .NET}}==
{{works with|Visual Basic .NET|9.0}}
<langsyntaxhighlight lang="vbnet">' Sorting algorithms/Cocktail sort with shifting bounds - VB.Net
Private Sub Cocktail_Shaker_Sort()
Dim A(20), tmp As Long 'or Integer Long Single Double String
Line 1,708 ⟶ 2,153:
'Display the sorted list
Debug.Print(String.Join(", ", A))
End Sub 'Cocktail_Shaker_Sort </langsyntaxhighlight>
{{out}}
<pre>
Line 1,720 ⟶ 2,165:
 
Ratios are noticeably less than the Go example (more in keeping with the REXX results in the talk page) and vary more if the script is run a few times. Frankly, I don't know why this is.
<langsyntaxhighlight ecmascriptlang="wren">import "./fmt" for Fmt
import "random" for Random
 
Line 1,820 ⟶ 2,265:
}
System.print(" %(Fmt.d(2, (n/1000).floor))k %(Fmt.f(0, sum/runs, 3))")
}</langsyntaxhighlight>
 
{{out}}
Line 1,839 ⟶ 2,284:
20k 1.228
</pre>
 
=={{header|XPL0}}==
Translation of the pseudo code from Wikipedia.
<syntaxhighlight lang "XPL0">procedure CocktailShakerSort(A, Length);
integer A, Length;
integer BeginIdx, EndIdx; \mark the first and last index to check
integer NewBeginIdx, NewEndIdx, II, T;
begin
BeginIdx:= 0;
EndIdx:= Length - 1;
 
while BeginIdx <= EndIdx do
begin
NewBeginIdx:= EndIdx;
NewEndIdx:= BeginIdx;
for II:= BeginIdx to EndIdx - 1 do
begin
if A(II) > A(II + 1) then
begin
T:= A(II+1); A(II+1):= A(II); A(II):= T;
NewEndIdx:= II;
end;
end;
 
\Decreases EndIdx because the elements after NewEndIdx are in correct order
EndIdx:= NewEndIdx;
 
for II:= EndIdx downto BeginIdx - 1 do
begin
if A(II) > A(II + 1) then
begin
T:= A(II+1); A(II+1):= A(II); A(II):= T;
NewBeginIdx:= II;
end;
end;
 
\Increases BeginIdx because elements before NewBeginIdx are in correct order
BeginIdx:= NewBeginIdx + 1;
end;
end;
 
int Test, Len, I;
begin
Test:= [7, 6, 5, 9, 8, 4, 3, 1, 2, 0];
Len:= 10;
CocktailShakerSort(Test, Len);
for I:= 0 to Len-1 do
begin
IntOut(0, Test(I));
ChOut(0, ^ );
end;
end</syntaxhighlight>
{{out}}
<pre>
0 1 2 3 4 5 6 7 8 9 </pre>
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/300128...354173"