Sorting algorithms/Comb sort

(Redirected from Comb sort)
This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.
Sorting algorithms/Comb sort
You are encouraged to solve this task according to the task description, using any language you may know.

Sorting Algorithm
This is a sorting algorithm.   It may be applied to a set of data in order to sort it.     For comparing various sorts, see compare sorts.   For other sorting algorithms,   see sorting algorithms,   or:

O(n logn) sorts

O(n log2n) sorts
Shell Sort

Task

Implement a   comb sort.

The Comb Sort is a variant of the Bubble Sort.

Like the Shell sort, the Comb Sort increases the gap used in comparisons and exchanges.

Dividing the gap by   ${\displaystyle (1-e^{-\varphi})^{-1} \approx 1.247330950103979}$   works best, but   1.3   may be more practical.

Some implementations use the insertion sort once the gap is less than a certain amount.

Also see

Variants:

• Combsort11 makes sure the gap ends in (11, 8, 6, 4, 3, 2, 1), which is significantly faster than the other two possible endings.
• Combsort with different endings changes to a more efficient sort when the data is almost sorted (when the gap is small).   Comb sort with a low gap isn't much better than the Bubble Sort.

Pseudocode:

function combsort(array input)
gap := input.size //initialize gap size
loop until gap = 1 and swaps = 0
//update the gap value for a next comb. Below is an example
gap := int(gap / 1.25)
if gap < 1
//minimum gap is 1
gap := 1
end if
i := 0
swaps := 0 //see Bubble Sort for an explanation
//a single "comb" over the input list
loop until i + gap >= input.size //see Shell sort for similar idea
if input[i] > input[i+gap]
swap(input[i], input[i+gap])
swaps := 1 // Flag a swap has occurred, so the
// list is not guaranteed sorted
end if
i := i + 1
end loop
end loop
end function


11l

Translation of: Python
F combsort(&input)
V gap = input.len
V swaps = 1B
L gap > 1 | swaps
gap = max(1, Int(gap / 1.25))
swaps = 0B
L(i) 0 .< input.len - gap
V j = i + gap
I input[i] > input[j]
swap(&input[i], &input[j])
swaps = 1B

V y = [88, 18, 31, 44, 4, 0, 8, 81, 14, 78, 20, 76, 84, 33, 73, 75, 82, 5, 62, 70]
combsort(&y)
assert(y == sorted(y))
print(y)
Output:
[0, 4, 5, 8, 14, 18, 20, 31, 33, 44, 62, 70, 73, 75, 76, 78, 81, 82, 84, 88]


360 Assembly

Translation from prototype.
The program uses ASM structured macros and two ASSIST macros to keep the code as short as possible.

*        Comb sort                 23/06/2016
COMBSORT CSECT
USING  COMBSORT,R13       base register
B      72(R15)            skip savearea
DC     17F'0'             savearea
STM    R14,R12,12(R13)    prolog
ST     R13,4(R15)         "
ST     R15,8(R13)         "
LR     R13,R15            "
L      R2,N               n
BCTR   R2,0               n-1
ST     R2,GAP             gap=n-1
DO     UNTIL=(CLC,GAP,EQ,=F'1',AND,CLI,SWAPS,EQ,X'00') repeat
L      R4,GAP               gap                             |
MH     R4,=H'100'           gap*100                         |
SRDA   R4,32                .                               |
D      R4,=F'125'           /125                            |
ST     R5,GAP               gap=int(gap/1.25)               |
IF     CLC,GAP,LT,=F'1'     if gap<1 then  -----------+     |
MVC    GAP,=F'1'              gap=1                   |     |
ENDIF  ,                    end if  <-----------------+     |
MVI    SWAPS,X'00'          swaps=false                     |
LA     RI,1                 i=1                             |
DO     UNTIL=(C,R3,GT,N)    do i=1 by 1 until i+gap>n  ---+ |
LR     R7,RI                  i                           | |
SLA    R7,2                   .                           | |
LA     R7,A-4(R7)             r7=@a(i)                    | |
LR     R8,RI                  i                           | |
A      R8,GAP                 i+gap                       | |
SLA    R8,2                   .                           | |
LA     R8,A-4(R8)             r8=@a(i+gap)                | |
L      R2,0(R7)               temp=a(i)                   | |
IF     C,R2,GT,0(R8)          if a(i)>a(i+gap) then  ---+ | |
MVC    0(4,R7),0(R8)            a(i)=a(i+gap)           | | |
ST     R2,0(R8)                 a(i+gap)=temp           | | |
MVI    SWAPS,X'01'              swaps=true              | | |
ENDIF  ,                      end if  <-----------------+ | |
LA     RI,1(RI)               i=i+1                       | |
LR     R3,RI                  i                           | |
A      R3,GAP                 i+gap                       | |
ENDDO  ,                    end do  <---------------------+ |
ENDDO  ,                  until gap=1 and not swaps  <------+
LA     R3,PG              pgi=0
LA     RI,1               i=1
DO     WHILE=(C,RI,LE,N)  do i=1 to n  -------+
LR     R1,RI                i                 |
SLA    R1,2                 .                 |
L      R2,A-4(R1)           a(i)              |
XDECO  R2,XDEC              edit a(i)         |
MVC    0(4,R3),XDEC+8       output a(i)       |
LA     R3,4(R3)             pgi=pgi+4         |
LA     RI,1(RI)             i=i+1             |
ENDDO  ,                  end do  <-----------+
XPRNT  PG,L'PG            print buffer
L      R13,4(0,R13)       epilog
LM     R14,R12,12(R13)    "
XR     R15,R15            "
BR     R14                exit
A     DC F'4',F'65',F'2',F'-31',F'0',F'99',F'2',F'83',F'782',F'1'
DC F'45',F'82',F'69',F'82',F'104',F'58',F'88',F'112',F'89',F'74'
N        DC     A((N-A)/L'A)       number of items of a
GAP      DS     F                  gap
SWAPS    DS     X                  flag for swaps
PG       DS     CL80               output buffer
XDEC     DS     CL12               temp for edit
YREGS
RI       EQU    6                  i
END    COMBSORT
Output:
 -31   0   1   2   2   4  45  58  65  69  74  82  82  83  88  89  99 104 112 782


AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program combSort64.s  */

/*******************************************/
/* Constantes file                         */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeConstantesARM64.inc"

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessSortOk:       .asciz "Table sorted.\n"
szMessSortNok:      .asciz "Table not sorted !!!!!.\n"
sMessResult:        .asciz "Value  : @ \n"
szCarriageReturn:   .asciz "\n"

.align 4
#TableNumber:      .quad   1,3,6,2,5,9,10,8,4,7
TableNumber:     .quad   10,9,8,7,6,-5,4,3,2,1
.equ NBELEMENTS, (. - TableNumber) / 8
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss
sZoneConv:       .skip 24
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main
main:                                              // entry of program
ldr x0,qAdrTableNumber                         // address number table
mov x1,0
mov x2,NBELEMENTS                              // number of élements
bl combSort
ldr x0,qAdrTableNumber                         // address number table
bl displayTable

ldr x0,qAdrTableNumber                         // address number table
mov x1,NBELEMENTS                              // number of élements
bl isSorted                                    // control sort
cmp x0,1                                       // sorted ?
beq 1f
ldr x0,qAdrszMessSortNok                       // no !! error sort
bl affichageMess
b 100f
1:                                                 // yes
ldr x0,qAdrszMessSortOk
bl affichageMess
100:                                               // standard end of the program
mov x0,0                                       // return code
mov x8,EXIT                                    // request to exit program
svc 0                                          // perform the system call

qAdrsZoneConv:            .quad sZoneConv
qAdrszCarriageReturn:     .quad szCarriageReturn
qAdrsMessResult:          .quad sMessResult
qAdrTableNumber:          .quad TableNumber
qAdrszMessSortOk:         .quad szMessSortOk
qAdrszMessSortNok:        .quad szMessSortNok
/******************************************************************/
/*     control sorted table                                   */
/******************************************************************/
/* x0 contains the address of table */
/* x1 contains the number of elements  > 0  */
/* x0 return 0  if not sorted   1  if sorted */
isSorted:
stp x2,lr,[sp,-16]!              // save  registers
stp x3,x4,[sp,-16]!              // save  registers
mov x2,0
ldr x4,[x0,x2,lsl 3]
1:
add x2,x2,1
cmp x2,x1
bge 99f
ldr x3,[x0,x2, lsl 3]
cmp x3,x4
blt 98f
mov x4,x3
b 1b
98:
mov x0,0                       // not sorted
b 100f
99:
mov x0,1                       // sorted
100:
ldp x3,x4,[sp],16              // restaur  2 registers
ldp x2,lr,[sp],16              // restaur  2 registers
ret                            // return to address lr x30
/******************************************************************/
/*         comb sort                                              */
/******************************************************************/
/* x0 contains the address of table */
/* x1 contains the first element    */
/* x2 contains the number of element */
/* this routine use à factor to 1.28  see wikipedia for best factor */
combSort:
stp x1,lr,[sp,-16]!        // save  registers
stp x2,x3,[sp,-16]!        // save  registers
stp x4,x5,[sp,-16]!        // save  registers
stp x6,x7,[sp,-16]!        // save  registers
stp x8,x9,[sp,-16]!        // save  registers
sub x9,x2,x1               // compute gap
sub x2,x2,1                // compute end index n - 1
mov x7,100
1:                             // start loop 1
mul x9,x7,x9               // gap multiply by 100
lsr x9,x9,7                // divide by 128
cmp x9,0
mov x3,1
csel x9,x9,x3,ne
mov x3,x1                  // start index
mov x8,0                   // swaps
2:                             // start loop 2
add x4,x3,x9               // add gap to indice
cmp x4,x2
bgt 4f
ldr x5,[x0,x3,lsl 3]       // load value A[j]
ldr x6,[x0,x4,lsl 3]       // load value A[j+1]
cmp x6,x5                  // compare value
bge 3f
str x6,[x0,x3,lsl 3]       // if smaller inversion
str x5,[x0,x4,lsl 3]
mov x8,1                   // swaps
3:
add x3,x3,1                // increment index j
b 2b

4:
//bl displayTable
cmp x9,1                   // gap = 1 ?
bne 1b                     // no loop
cmp x8,1                   // swaps ?
beq 1b                     // yes -> loop 1

100:
ldp x8,x9,[sp],16          // restaur  2 registers
ldp x6,x7,[sp],16          // restaur  2 registers
ldp x4,x5,[sp],16          // restaur  2 registers
ldp x2,x3,[sp],16          // restaur  2 registers
ldp x1,lr,[sp],16          // restaur  2 registers
ret                        // return to address lr x30

/******************************************************************/
/*      Display table elements                                */
/******************************************************************/
/* x0 contains the address of table */
displayTable:
stp x1,lr,[sp,-16]!              // save  registers
stp x2,x3,[sp,-16]!              // save  registers
mov x2,x0                        // table address
mov x3,0
1:                                   // loop display table
ldr x0,[x2,x3,lsl 3]
ldr x1,qAdrsZoneConv
bl conversion10S                  // décimal conversion
ldr x0,qAdrsMessResult
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc            // insert result at @ character
bl affichageMess                 // display message
add x3,x3,1
cmp x3,NBELEMENTS - 1
ble 1b
ldr x0,qAdrszCarriageReturn
bl affichageMess
mov x0,x2
100:
ldp x2,x3,[sp],16               // restaur  2 registers
ldp x1,lr,[sp],16               // restaur  2 registers
ret                             // return to address lr x30
/********************************************************/
/*        File Include fonctions                        */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"

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 CombSort(INT ARRAY a INT size)
INT gap,i,tmp
BYTE swaps

gap=size swaps=0
WHILE gap#1 OR swaps#0
DO
gap=(gap*5)/4
IF gap<1 THEN gap=1 FI

i=0
swaps=0

WHILE i+gap<size
DO
IF a(i)>a(i+1) THEN
tmp=a(i) a(i)=a(i+1) a(i+1)=tmp
swaps=1
FI
i==+1
OD
OD
RETURN

PROC Test(INT ARRAY a INT size)
PrintE("Array before sort:")
PrintArray(a,size)
CombSort(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
Output:
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]


ActionScript

function combSort(input:Array)
{
var gap:uint = input.length;
var swapped:Boolean = false;
while(gap > 1 || swapped)
{
gap /= 1.25;
swapped = false;
for(var i:uint = 0; i + gap < input.length; i++)
{
if(input[i] > input[i+gap])
{
var tmp = input[i];
input[i] = input[i+gap];
input[i+gap]=tmp;
swapped = true;
}
}
}
return input;
}


Ada

with Ada.Text_IO;
procedure Comb_Sort is
generic
type Element_Type is private;
type Index_Type is range <>;
type Array_Type is array (Index_Type range <>) of Element_Type;
with function ">" (Left, Right : Element_Type) return Boolean is <>;
with function "+" (Left : Index_Type; Right : Natural) return Index_Type is <>;
with function "-" (Left : Index_Type; Right : Natural) return Index_Type is <>;
procedure Comb_Sort (Data: in out Array_Type);

procedure Comb_Sort (Data: in out Array_Type) is
procedure Swap (Left, Right : in Index_Type) is
Temp : Element_Type := Data(Left);
begin
Data(Left)  := Data(Right);
Data(Right) := Temp;
end Swap;
Gap : Natural := Data'Length;
Swap_Occured : Boolean;
begin
loop
Gap := Natural (Float(Gap) / 1.25 - 0.5);
if Gap < 1 then
Gap := 1;
end if;
Swap_Occured := False;
for I in Data'First .. Data'Last - Gap loop
if Data (I) > Data (I+Gap) then
Swap (I, I+Gap);
Swap_Occured := True;
end if;
end loop;
exit when Gap = 1 and not Swap_Occured;
end loop;
end Comb_Sort;

type Integer_Array is array (Positive range <>) of Integer;
procedure Int_Comb_Sort is new Comb_Sort (Integer, Positive, Integer_Array);
Test_Array : Integer_Array := (1, 3, 256, 0, 3, 4, -1);
begin
Int_Comb_Sort (Test_Array);
for I in Test_Array'Range loop
Ada.Text_IO.Put (Integer'Image (Test_Array (I)));
end loop;
Ada.Text_IO.New_Line;
end Comb_Sort;


Output:

-1 0 1 3 3 4 256

ALGOL 68

Library: ALGOL 68-rows
BEGIN # comb sort #
PR read "rows.incl.a68" PR # include row (array) utilities - SHOW is used to display the array #
# comb-sorts in-place the array of integers input #
PROC comb sort = ( REF[]INT input )VOID:
IF INT  input size = ( UPB input - LWB input ) + 1;
input size > 1
THEN # more than one element, so must sort #
INT  gap     := input size; # initial gap is the whole array size #
BOOL swapped := TRUE;
WHILE gap /= 1 OR swapped DO
# update the gap value for a next comb #
gap := ENTIER ( gap / 1.25 );
IF gap < 1 THEN
# ensure the gap is at least 1 #
gap := 1
FI;
INT i := LWB input;
swapped := FALSE;
# a single "comb" over the input list #
FOR i FROM LWB input WHILE i + gap <= UPB input DO
INT t     = input[ i ];
INT i gap = i + gap;
IF t > input[ i gap ] THEN
# need to swap out-of-order items #
input[ i     ] := input[ i gap ];
input[ i gap ] := t;
swapped := TRUE # Flag a swap has occurred, so the list is not guaranteed sorted yet #
FI
OD
OD
FI # comb sort # ;
# test #
[ 1 : 7 ]INT data := ( 9, -4, 0, 2, 3, 77, 1 );  # data to sort #
SHOW data;
comb sort( data );
print( ( " -> " ) );
SHOW data
END
Output:
 9 -4 0 2 3 77 1 ->  -4 0 1 2 3 9 77


ALGOL W

Translation of: ALGOL 68
begin % comb sort %
% comb-sorts in-place the array of integers input with bounds lb :: ub %
procedure combSort ( integer array input ( * )
; integer value lb, ub
) ;
begin
integer inputSize, gap, i;
inputSize := ( ub - lb ) + 1;
if inputSize > 1 then begin
% more than one element, so must sort %
logical swapped;
gap     := inputSize; % initial gap is the whole array size %
swapped := true;
while gap not = 1 or swapped do begin
% update the gap value for a next comb %
gap := entier( gap / 1.25 );
if gap < 1 then begin
% ensure the gap is at least 1 %
gap := 1
end if_gap_lt_1 ;
swapped := false;
% a single "comb" over the input list %
i := lb;
while i + gap <= ub do begin
integer t, iGap;
t    := input( i );
iGap := i + gap;
if t > input( iGap ) then begin
% need to swap out-of-order items %
input( i    ) := input( iGap );
input( iGap ) := t;
swapped := true % Flag a swap has occurred, so the list is not guaranteed sorted yet %
end if_t_gt_input__iGap ;
i := i + 1
end while_i_plus_gap_le_ub
end while_gap_ne_1_or_swapped
end if_inputSize_gt_1
end combSort ;
begin % test %
integer array data ( 1 :: 7 );
integer       dPos;
dPos := 0;
for v := 9, -4, 0, 2, 3, 77, 1 do begin dPos := dPos + 1; data( dPos ) := v end;
for i := 1 until 7 do writeon( i_w := 1, s_w := 0, " ", data( i ) );
combSort( data, 1, 7 );
writeon( ( " -> " ) );
for i := 1 until 7 do writeon( i_w := 1, s_w := 0, " ", data( i ) )
end
end.
Output:
 9 -4 0 2 3 77 1 ->  -4 0 1 2 3 9 77


AppleScript

-- Comb sort with insertion sort finish.
-- Comb sort algorithm: Włodzimierz Dobosiewicz and Artur Borowy, 1980. Stephen Lacey and Richard Box, 1991.

on combSort(theList, l, r) -- Sort items l thru r of theLIst.
set listLen to (count theList)
if (listLen < 2) then return
-- Negative and/or transposed range indices.
if (l < 0) then set l to listLen + l + 1
if (r < 0) then set r to listLen + r + 1
if (l > r) then set {l, r} to {r, l}

script o
property lst : theList
end script

-- This implementation performs fastest with a comb gap divisor of 1.4
-- and the insertion sort taking over when the gap's down to 8 or less.
set divisor to 1.4
set gap to (r - l + 1) div divisor
repeat while (gap > 8)
repeat with i from l to (r - gap)
set j to i + gap
set lv to o's lst's item i
set rv to o's lst's item j
if (lv > rv) then
set o's lst's item i to rv
set o's lst's item j to lv
end if
end repeat
set gap to gap div divisor
end repeat

insertionSort(theList, l, r)

return -- nothing.
end combSort

on insertionSort(theList, l, r) -- Sort items l thru r of theList.
set listLength to (count theList)
if (listLength < 2) then return
if (l < 0) then set l to listLength + l + 1
if (r < 0) then set r to listLength + r + 1
if (l > r) then set {l, r} to {r, l}

script o
property lst : theList
end script

set highestSoFar to o's lst's item l
set rv to o's lst's item (l + 1)
if (highestSoFar > rv) then
set o's lst's item l to rv
else
set highestSoFar to rv
end if
repeat with j from (l + 2) to r
set rv to o's lst's item j
if (highestSoFar > rv) then
repeat with i from (j - 2) to l by -1
set lv to o's lst's item i
if (lv > rv) then
set o's lst's item (i + 1) to lv
else
set i to i + 1
exit repeat
end if
end repeat
set o's lst's item i to rv
else
set o's lst's item (j - 1) to highestSoFar
set highestSoFar to rv
end if
end repeat
set o's lst's item r to highestSoFar

return -- nothing.
end insertionSort

-- Demo:
local aList
set aList to {7, 56, 70, 22, 94, 42, 5, 25, 54, 90, 29, 65, 87, 27, 4, 5, 86, 8, 2, 30, 87, 12, 85, 86, 7}
combSort(aList, 1, -1) -- Sort items 1 thru -1 of aList.
aList

Output:
{2, 4, 5, 5, 7, 7, 8, 12, 22, 25, 27, 29, 30, 42, 54, 56, 65, 70, 85, 86, 86, 87, 87, 90, 94}


ARM Assembly

Works with: as version Raspberry Pi
/* ARM assembly Raspberry PI  */
/*  program combSort.s  */

/* REMARK 1 : this program use routines in a include file
see task Include a file language arm assembly
for the routine affichageMess conversion10
see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes                       */
/************************************/
.include "../constantes.inc"

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessSortOk:       .asciz "Table sorted.\n"
szMessSortNok:      .asciz "Table not sorted !!!!!.\n"
sMessResult:        .asciz "Value  : @ \n"
szCarriageReturn:   .asciz "\n"

.align 4
#TableNumber:      .int   1,3,6,2,5,9,10,8,4,7
TableNumber:       .int   10,9,8,7,6,5,4,3,2,1
.equ NBELEMENTS, (. - TableNumber) / 4
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss
sZoneConv:            .skip 24
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main
main:                                              @ entry of program

1:
ldr r0,iAdrTableNumber                         @ address number table
mov r1,#0
mov r2,#NBELEMENTS                             @ number of élements
bl combSort
ldr r0,iAdrTableNumber                         @ address number table
bl displayTable

ldr r0,iAdrTableNumber                         @ address number table
mov r1,#NBELEMENTS                             @ number of élements
bl isSorted                                    @ control sort
cmp r0,#1                                      @ sorted ?
beq 2f
ldr r0,iAdrszMessSortNok                       @ no !! error sort
bl affichageMess
b 100f
2:                                                 @ yes
ldr r0,iAdrszMessSortOk
bl affichageMess
100:                                               @ standard end of the program
mov r0, #0                                     @ return code
mov r7, #EXIT                                  @ request to exit program
svc #0                                         @ perform the system call

iAdrszCarriageReturn:     .int szCarriageReturn
iAdrsMessResult:          .int sMessResult
iAdrTableNumber:          .int TableNumber
iAdrszMessSortOk:         .int szMessSortOk
iAdrszMessSortNok:        .int szMessSortNok
/******************************************************************/
/*     control sorted table                                   */
/******************************************************************/
/* r0 contains the address of table */
/* r1 contains the number of elements  > 0  */
/* r0 return 0  if not sorted   1  if sorted */
isSorted:
push {r2-r4,lr}                                    @ save registers
mov r2,#0
ldr r4,[r0,r2,lsl #2]
1:
add r2,#1
cmp r2,r1
movge r0,#1
bge 100f
ldr r3,[r0,r2, lsl #2]
cmp r3,r4
movlt r0,#0
blt 100f
mov r4,r3
b 1b
100:
pop {r2-r4,lr}
bx lr                                              @ return
/******************************************************************/
/*         comb Sort                                          */
/******************************************************************/
/* r0 contains the address of table */
/* r1 contains the first element    */
/* r2 contains the number of element */
/* this routine use à factor to 1.28  see wikipedia for best factor */
combSort:
push {r1-r9,lr}           @ save registers
sub r9,r2,r1              @ compute gap
sub r2,r2,#1              @ compute end index = n - 1
mov r7,#100
1:                            @ start loop 1
mul r9,r7,r9              @ gap multiply by 100
lsrs r9,#7                @ divide by 128   equi * 0,78125 equi divide by 1,28
moveq r9,#1               @ if gap = 0 -> gap = 1
mov r8,#0                 @ swaps
mov r3,r1                 @ indice
2:                            @ start loop 2
add r4,r3,r9
cmp r4,r2                 @ end ?
bgt 3f
ldr r5,[r0,r3,lsl #2]     @ load value A[j]
ldr r6,[r0,r4,lsl #2]     @ load value A[j+1]
cmp r6,r5                 @ compare value
strlt r6,[r0,r3,lsl #2]   @ if smaller inversion
strlt r5,[r0,r4,lsl #2]
movlt r8,#1               @ swaps = 1
add r3,#1                 @ increment indice
b 2b                      @ loop 2

3:
@ bl displayTable
cmp r9,#1                 @ gap = 1 ?
bne 1b
cmp r8,#1                 @ swaps ?
beq 1b                    @ yes -> loop 1

100:
pop {r1-r9,lr}
bx lr                                                  @ return

/******************************************************************/
/*      Display table elements                                */
/******************************************************************/
/* r0 contains the address of table */
displayTable:
push {r0-r3,lr}                                    @ save registers
mov r2,r0                                          @ table address
mov r3,#0
1:                                                     @ loop display table
ldr r0,[r2,r3,lsl #2]
ldr r1,iAdrsZoneConv                               @
bl conversion10S                                    @ décimal conversion
ldr r0,iAdrsMessResult
ldr r1,iAdrsZoneConv                               @ insert conversion
bl strInsertAtCharInc
bl affichageMess                                   @ display message
add r3,#1
cmp r3,#NBELEMENTS - 1
ble 1b
ldr r0,iAdrszCarriageReturn
bl affichageMess
100:
pop {r0-r3,lr}
bx lr
iAdrsZoneConv:           .int sZoneConv
/***************************************************/
/*      ROUTINES INCLUDE                           */
/***************************************************/
.include "../affichage.inc"

Arturo

combSort: function [items][
a: new items
gap: size a
swapped: true

while [or? gap > 1 swapped][
gap: (gap * 10) / 13
if or? gap=9 gap=10 -> gap: 11
if gap<1 -> gap: 1
swapped: false
i: 0
loop gap..dec size items 'j [
if a\[i] > a\[j] [
tmp: a\[i]
a\[i]: a\[j]
a\[j]: tmp
swapped: true
]
i: i + 1
]
]
return a
]

print combSort [3 1 2 8 5 7 9 4 6]

Output:
1 2 3 4 5 6 7 8 9

AutoHotkey

List1 = 23,76,99,58,97,57,35,89,51,38,95,92,24,46,31,24,14,12,57,78
List2 = 88,18,31,44,4,0,8,81,14,78,20,76,84,33,73,75,82,5,62,70

List2Array(List1, "MyArray")
CombSort("MyArray")
MsgBox, % List1 "n" Array2List("MyArray")

List2Array(List2, "MyArray")
CombSort("MyArray")
MsgBox, % List2 "n" Array2List("MyArray")

;---------------------------------------------------------------------------
CombSort(Array) { ; CombSort of Array %Array%, length = %Array%0
;---------------------------------------------------------------------------
Gap := %Array%0
While Gap > 1 Or Swaps {
If (Gap > 1)
Gap := 4 * Gap // 5
i := Swaps := False
While (j := ++i + Gap) <= %Array%0 {
If (%Array%%i% > %Array%%j%) {
Swaps := True
%Array%%i% := (%Array%%j% "", %Array%%j% := %Array%%i%)
}
}
}
}

;---------------------------------------------------------------------------
List2Array(List, Array) { ; creates an array from a comma separated list
;---------------------------------------------------------------------------
global
StringSplit, %Array%, List, ,
}

;---------------------------------------------------------------------------
Array2List(Array) { ; returns a comma separated list from an array
;---------------------------------------------------------------------------
Loop, % %Array%0
List .= (A_Index = 1 ? "" : ",") %Array%%A_Index%
Return, List
}


Message (1) box shows:

23,76,99,58,97,57,35,89,51,38,95,92,24,46,31,24,14,12,57,78
12,14,23,24,24,31,35,38,46,51,57,57,58,76,78,89,92,95,97,99

Message (2) box shows:

88,18,31,44,4,0,8,81,14,78,20,76,84,33,73,75,82,5,62,70
0,4,5,8,14,18,20,31,33,44,62,70,73,75,76,78,81,82,84,88

AWK

function combsort( a, len,    gap, igap, swap, swaps, i )
{
gap = len
swaps = 1

while( gap > 1 || swaps )
{
gap /= 1.2473;
if ( gap < 1 ) gap = 1
i = swaps = 0
while( i + gap < len )
{
igap = i + int(gap)
if ( a[i] > a[igap] )
{
swap = a[i]
a[i] = a[igap]
a[igap] = swap
swaps = 1
}
i++;
}
}
}

BEGIN {
a[0] = 5
a[1] = 2
a[2] = 7
a[3] = -11
a[4] = 6
a[5] = 1

combsort( a, length(a) )

for( i=0; i<length(a); i++ )
print a[i]
}


BBC BASIC

DEF PROC_CombSort11(Size%)

gap%=Size%
REPEAT
IF gap% > 1 THEN
gap%=gap% / 1.3
IF gap%=9 OR gap%=10 gap%=11
ENDIF
I% = 1
Finished%=TRUE
REPEAT
IF data%(I%) > data%(I%+gap%) THEN
SWAP data%(I%),data%(I%+gap%)
Finished% = FALSE
ENDIF
I%+=1
UNTIL I%+gap% > Size%
UNTIL gap%=1 AND Finished%

ENDPROC

C

Implementation of Combsort11. Its efficiency can be improved by just switching to Insertion sort when the gap size becomes less than 10.

void Combsort11(double a[], int nElements)
{
int i, j, gap, swapped = 1;
double temp;

gap = nElements;
while (gap > 1 || swapped == 1)
{
gap = gap * 10 / 13;
if (gap == 9 || gap == 10) gap = 11;
if (gap < 1) gap = 1;
swapped = 0;
for (i = 0, j = gap; j < nElements; i++, j++)
{
if (a[i] > a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
swapped = 1;
}
}
}
}


C#

using System;

namespace CombSort
{
class Program
{
static void Main(string[] args)
{
int[] unsorted = new int[] { 3, 5, 1, 9, 7, 6, 8, 2, 4 };
Console.WriteLine(string.Join(",", combSort(unsorted)));
}
public static int[] combSort(int[] input)
{
double gap = input.Length;
bool swaps = true;
while (gap > 1 || swaps)
{
gap /= 1.247330950103979;
if (gap < 1) { gap = 1; }
int i = 0;
swaps = false;
while (i + gap < input.Length)
{
int igap = i + (int)gap;
if (input[i] > input[igap])
{
int swap = input[i];
input[i] = input[igap];
input[igap] = swap;
swaps = true;
}
i++;
}
}
return input;
}
}
}


C++

This is copied from the Wikipedia article.

template<class ForwardIterator>
void combsort ( ForwardIterator first, ForwardIterator last )
{
static const double shrink_factor = 1.247330950103979;
typedef typename std::iterator_traits<ForwardIterator>::difference_type difference_type;
difference_type gap = std::distance(first, last);
bool swaps = true;

while ( (gap > 1) || (swaps == true) ){
if (gap > 1)
gap = static_cast<difference_type>(gap/shrink_factor);

swaps = false;
ForwardIterator itLeft(first);
ForwardIterator itRight(first); std::advance(itRight, gap);

for ( ; itRight!=last; ++itLeft, ++itRight ){
if ( (*itRight) < (*itLeft) ){
std::iter_swap(itLeft, itRight);
swaps = true;
}
}
}
}


COBOL

This excerpt contains just enough of the procedure division to show the workings. See the example for the bubble sort for a more complete program.

       C-PROCESS SECTION.
C-000.
DISPLAY "SORT STARTING".

MOVE WC-SIZE TO WC-GAP.

PERFORM E-COMB UNTIL WC-GAP = 1 AND FINISHED.

DISPLAY "SORT FINISHED".

C-999.
EXIT.

E-COMB SECTION.
E-000.
IF WC-GAP > 1
DIVIDE WC-GAP BY 1.3 GIVING WC-GAP
IF WC-GAP = 9 OR 10
MOVE 11 TO WC-GAP.

MOVE 1   TO WC-SUB-1.
MOVE "Y" TO WF-FINISHED.

PERFORM F-SCAN UNTIL WC-SUB-1 + WC-GAP > WC-SIZE.

E-999.
EXIT.

F-SCAN SECTION.
F-000.
ADD WC-SUB-1 WC-GAP GIVING WC-SUB-2.
IF WB-ENTRY(WC-SUB-1) > WB-ENTRY(WC-SUB-2)
MOVE WB-ENTRY(WC-SUB-1) TO WC-TEMP
MOVE WB-ENTRY(WC-SUB-2) TO WB-ENTRY(WC-SUB-1)
MOVE WC-TEMP            TO WB-ENTRY(WC-SUB-2)
MOVE "N"                TO WF-FINISHED.

ADD 1 TO WC-SUB-1.

F-999.
EXIT.


Common Lisp

(defparameter *shrink* 1.3)

(defun comb-sort (input)
(loop with input-size = (length input)
with gap = input-size
with swapped
do (when (> gap 1)
(setf gap (floor gap *shrink*)))
(setf swapped nil)
(loop for lo from 0
for hi from gap below input-size
when (> (aref input lo) (aref input hi))
do (rotatef (aref input lo) (aref input hi))
(setf swapped t))
while (or (> gap 1) swapped)
finally (return input)))


D

Translation of: Python
import std.stdio, std.algorithm;

void combSort(T)(T[] input) pure nothrow @safe @nogc {
int gap = input.length;
bool swaps = true;

while (gap > 1 || swaps) {
gap = max(1, cast(int)(gap / 1.2473));
swaps = false;
foreach (immutable i; 0 .. input.length - gap)
if (input[i] > input[i + gap]) {
input[i].swap(input[i + gap]);
swaps = true;
}
}
}

void main() {
auto data = [28, 44, 46, 24, 19, 2, 17, 11, 25, 4];
data.combSort;
data.writeln;
}

Output:
[2, 4, 11, 17, 19, 24, 25, 28, 44, 46]

Delphi

Adaptation of Pascal

program Comb_sort;

{APPTYPE CONSOLE} uses System.SysUtils, System.Types; type THelperIntegerDynArray = record helper for TIntegerDynArray public procedure CombSort; procedure FillRange(Count: integer); procedure Shuffle; function ToString: string; end; { THelperIntegerDynArray } procedure THelperIntegerDynArray.CombSort; var i, gap, temp: integer; swapped: boolean; begin gap := length(self); swapped := true; while (gap > 1) or swapped do begin gap := trunc(gap / 1.3); if (gap < 1) then gap := 1; swapped := false; for i := 0 to length(self) - gap - 1 do if self[i] > self[i + gap] then begin temp := self[i]; self[i] := self[i + gap]; self[i + gap] := temp; swapped := true; end; end; end; procedure THelperIntegerDynArray.FillRange(Count: integer); var i: Integer; begin SetLength(self, Count); for i := 0 to Count - 1 do Self[i] := i; end; procedure THelperIntegerDynArray.Shuffle; var i, j, tmp: integer; count: integer; begin Randomize; count := Length(self); for i := 0 to count - 1 do begin j := i + Random(count - i); tmp := self[i]; self[i] := self[j]; self[j] := tmp; end; end; function THelperIntegerDynArray.ToString: string; var value: Integer; begin Result := ''; for value in self do begin Result := Result + ' ' + Format('%4d', [value]); end; Result := '[' + Result.Trim + ']'; end; var data: TIntegerDynArray; begin data.FillRange(10); data.Shuffle; writeln('The data before sorting:'); Writeln(data.ToString, #10); data.CombSort; writeln('The data after sorting:'); Writeln(data.ToString, #10); Readln; end.  Output: The data before sorting: [1 9 0 6 2 7 3 5 4 8] The data after sorting: [0 1 2 3 4 5 6 7 8 9]  Eiffel class COMB_SORT [G -> COMPARABLE] feature combsort (ar: ARRAY [G]): ARRAY [G] -- Sorted array in ascending order. require array_not_void: ar /= Void local gap, i: INTEGER swap: G swapped: BOOLEAN shrink: REAL_64 do create Result.make_empty Result.deep_copy (ar) gap := Result.count from until gap = 1 and swapped = False loop from i := Result.lower swapped := False until i + gap > Result.count loop if Result [i] > Result [i + gap] then swap := Result [i] Result [i] := Result [i + gap] Result [i + gap] := swap swapped := True end i := i + 1 end shrink := gap / 1.3 gap := shrink.floor if gap < 1 then gap := 1 end end ensure Result_is_set: Result /= Void Result_is_sorted: is_sorted (Result) end feature {NONE} is_sorted (ar: ARRAY [G]): BOOLEAN --- Is 'ar' sorted in ascending order? require ar_not_empty: ar.is_empty = False local i: INTEGER do Result := True from i := ar.lower until i = ar.upper loop if ar [i] > ar [i + 1] then Result := False end i := i + 1 end end end  Test: class APPLICATION create make feature make do test := <<1, 5, 99, 2, 95, 7, -7>> io.put_string ("unsorted" + "%N") across test as ar loop io.put_string (ar.item.out + "%T") end io.put_string ("%N" + "sorted:" + "%N") create combsort test := combsort.combsort (test) across test as ar loop io.put_string (ar.item.out + "%T") end end combsort: COMB_SORT [INTEGER] test: ARRAY [INTEGER] end  Output: unsorted: 1 5 99 2 95 7 -7 sorted: -7 1 2 5 7 95 99  Elena ELENA 5.0 : import extensions; import system'math; import system'routines; extension op { combSort() { var list := self.clone(); real gap := list.Length; bool swaps := true; while (gap > 1 || swaps) { gap /= 1.247330950103979r; if (gap<1) { gap := 1 }; int i := 0; swaps := false; while (i + gap.RoundedInt < list.Length) { int igap := i + gap.RoundedInt; if (list[i] > list[igap]) { list.exchange(i,igap); swaps := true }; i += 1 } }; ^ list } } public program() { var list := new int[]{3, 5, 1, 9, 7, 6, 8, 2, 4 }; console.printLine("before:", list.asEnumerable()); console.printLine("after :", list.combSort().asEnumerable()) } Output: before:3,5,1,9,7,6,8,2,4 after :1,2,3,4,5,6,7,8,9  Elixir defmodule Sort do def comb_sort([]), do: [] def comb_sort(input) do comb_sort(List.to_tuple(input), length(input), 0) |> Tuple.to_list end defp comb_sort(output, 1, 0), do: output defp comb_sort(input, gap, _) do gap = max(trunc(gap / 1.25), 1) {output,swaps} = Enum.reduce(0..tuple_size(input)-gap-1, {input,0}, fn i,{acc,swap} -> if (x = elem(acc,i)) > (y = elem(acc,i+gap)) do {acc |> put_elem(i,y) |> put_elem(i+gap,x), 1} else {acc,swap} end end) comb_sort(output, gap, swaps) end end (for _ <- 1..20, do: :rand.uniform(20)) |> IO.inspect |> Sort.comb_sort |> IO.inspect  Output: [10, 7, 8, 13, 4, 11, 13, 12, 18, 11, 5, 7, 3, 4, 15, 1, 17, 16, 7, 14] [1, 3, 4, 4, 5, 7, 7, 7, 8, 10, 11, 11, 12, 13, 13, 14, 15, 16, 17, 18]  Forth This is an implementation of Comb sort with a different ending. Here Gnome sort is used, since it is rather small. The dataset is rather large, because otherwise the Comb sort routine would never kick in, passing control to Gnome sort almost right away. Note Comb sort can be kept much simpler this way, because Combsort11 optimizations and swapped flags can be discarded. defer precedes defer exchange : gnomesort ( a n) swap >r 1 ( n c) begin ( n c) over over > ( n c f) while ( n c) dup if ( n c) dup dup 1- over over r@ precedes if r@ exchange 1- else drop drop 1+ then else 1+ then ( n c) repeat drop drop r> drop ( --) ; : combsort ( a n --) dup begin ( a n g) 10 13 */ tuck >r >r 0 ( a g 0) begin ( a g 0) over r@ < ( a g 0 f) while ( a g 0) rot >r over over r@ precedes ( g 0 f) if over over r@ exchange then ( g 0) r> rot 1+ rot 1+ ( a g 0) repeat drop drop r> r> ( a n g) dup 9 < ( a n g f) until drop gnomesort ( --) ; create example 8 93 69 52 50 79 33 52 19 77 , , , , , , , , , , 72 85 11 61 64 80 64 76 47 65 , , , , , , , , , , 13 47 23 40 87 45 2 48 22 69 , , , , , , , , , , 1 53 33 60 57 14 76 32 59 12 , , , , , , , , , , 74 38 39 22 87 28 37 93 71 88 , , , , , , , , , , 56 35 48 99 21 35 26 28 58 85 , , , , , , , , , , 27 16 54 88 82 18 45 64 45 87 , , , , , , , , , , 98 97 60 77 43 1 64 0 32 89 , , , , , , , , , , 77 90 68 83 9 76 10 10 95 12 , , , , , , , , , , 99 23 74 58 54 25 50 9 94 1 , , , , , , , , , , :noname >r cells r@ + @ swap cells r> + @ swap < ; is precedes :noname >r cells r@ + swap cells r> + over @ over @ swap rot ! swap ! ; is exchange : .array 100 0 do example i cells + ? loop cr ; .array example 100 combsort .array  Less Clever Version This version is an academic demonstration that aligns with the algorithm. As is, it is limited to use one static array and sorts in ascending order only. \ combsort for the Forth Newbie (GForth) HEX \ gratuitous variables for clarity 0 VALUE GAP VARIABLE SORTED DECIMAL 100 CONSTANT SIZE \ allocate a small array of cells CREATE Q SIZE 2+ CELLS ALLOT \ operator to index into the array : ]Q ( n -- adr) CELLS Q + ; \ fill array and see array : INITDATA ( -- ) SIZE 0 DO SIZE I - I ]Q ! LOOP ; : SEEDATA ( -- ) CR SIZE 0 DO I ]Q @ U. LOOP ; \ divide by 1.35 using Forth's scaling operator \ found this ratio to be the fastest : 1.35/ ( n -- n' ) 100 135 */ ; : XCHG ( adr1 adr2 -- ) OVER @ OVER @ SWAP ROT ! SWAP ! ; : COMBSORT ( n -- ) DUP TO GAP \ set GAP to n BEGIN GAP 1.35/ TO GAP \ re-compute the gap SORTED ON DUP ( -- n) GAP - 0 \ n-gap is loop limit DO I GAP + ]Q @ I ]Q @ < IF I GAP + ]Q I ]Q XCHG \ Exchange the data in the cells SORTED OFF \ flag we are not sorted THEN LOOP SORTED @ GAP 0= AND \ test for complete UNTIL DROP ;  Fortran Works with: Fortran version 90 and later program Combsort_Demo implicit none integer, parameter :: num = 20 real :: array(num) call random_seed call random_number(array) write(*,*) "Unsorted array:-" write(*,*) array write(*,*) call combsort(array) write(*,*) "Sorted array:-" write(*,*) array contains subroutine combsort(a) real, intent(in out) :: a(:) real :: temp integer :: i, gap logical :: swapped = .true. gap = size(a) do while (gap > 1 .or. swapped) gap = gap / 1.3 if (gap < 1) gap = 1 swapped = .false. do i = 1, size(a)-gap if (a(i) > a(i+gap)) then temp = a(i) a(i) = a(i+gap) a(i+gap) = temp; swapped = .true. end if end do end do end subroutine combsort end program Combsort_Demo  FreeBASIC ' version 21-10-2016 ' compile with: fbc -s console ' for boundary checks on array's compile with: fbc -s console -exx Sub compsort(bs() As Long) ' sort from lower bound to the highter bound ' array's can have subscript range from -2147483648 to +2147483647 Dim As Long lb = LBound(bs) Dim As Long ub = UBound(bs) Dim As Long gap = ub - lb Dim As Long done, i Do gap = Int (gap / 1.3) If gap < 1 Then gap = 1 done = 0 For i = lb To ub - gap If bs(i) > bs(i + gap) Then Swap bs(i), bs(i + gap) done = 1 End If Next Loop Until ((gap = 1) And (done = 0)) End Sub Sub comp11sort(bs() As Long) ' sort from lower bound to the higher bound ' array's can have subscript range from -2147483648 to +2147483647 Dim As Long lb = LBound(bs) Dim As Long ub = UBound(bs) Dim As Long gap = ub - lb Dim As Long done, i Do gap = Int(gap / 1.24733) If gap = 9 Or gap = 10 Then gap = 11 ElseIf gap < 1 Then gap = 1 End If done = 0 For i = lb To ub - gap If bs(i) > bs(i + gap) Then Swap bs(i), bs(i + gap) done = 1 End If Next Loop Until ((gap = 1) And (done = 0)) End Sub ' ------=< MAIN >=------ 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 For i = a To b ' little shuffle Swap array(i), array(Int(Rnd * (b - a +1)) + a) Next Print "normal comb sort" Print "unsorted "; For i = a To b : Print Using "####"; array(i); : Next : Print compsort(array()) ' sort the array Print " sorted "; For i = a To b : Print Using "####"; array(i); : Next : Print Print Print "comb11 sort" For i = a To b ' little shuffle Swap array(i), array(Int(Rnd * (b - a +1)) + a) Next Print "unsorted "; For i = a To b : Print Using "####"; array(i); : Next : Print comp11sort(array()) ' sort the array Print " sorted "; For i = a To b : Print Using "####"; array(i); : Next : Print ' empty keyboard buffer While Inkey <> "" : Wend Print : Print "hit any key to end program" Sleep End  Output: normal comb sort unsorted -6 5 -1 -3 -7 6 1 7 -4 3 4 -2 -5 0 2 sorted -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 comb11 sort unsorted 4 -7 -1 1 2 3 -3 7 0 -2 6 -5 5 -6 -4 sorted -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 Gambas Public Sub Main() Dim siToSort As Short[] = [249, 28, 111, 36, 171, 98, 29, 448, 44, 147, 154, 46, 102, 183, 24, 120, 19, 123, 2, 17, 226, 11, 211, 25, 191, 205, 77] Dim siStart As Short Dim siGap As Short = siToSort.Max Dim bSorting, bGap1 As Boolean Print "To sort: -" ShowWorking(siToSort) Print Repeat bSorting = False siStart = 0 If siGap = 1 Then bGap1 = True Repeat If siToSort[siStart] > siToSort[siStart + siGap] Then Swap siToSort[siStart], siToSort[siStart + siGap] bSorting = True End If Inc siStart Until siStart + siGap > siToSort.Max If bSorting Then ShowWorking(siToSort) siGap /= 1.3 If siGap < 1 Then siGap = 1 Until bSorting = False And bGap1 = True End '----------------------------------------- Public Sub ShowWorking(siToSort As Short[]) Dim siCount As Short For siCount = 0 To siToSort.Max Print Str(siToSort[siCount]); If siCount <> siToSort.Max Then Print ","; Next Print End  Output: To sort: - 249,28,111,36,171,98,29,448,44,147,154,46,102,183,24,120,19,123,2,17,226,11,211,25,191,205,77 77,28,111,36,171,98,29,448,44,147,154,46,102,183,24,120,19,123,2,17,226,11,211,25,191,205,249 77,11,111,25,171,98,29,448,44,147,154,46,102,183,24,120,19,123,2,17,226,28,211,36,191,205,249 77,11,111,2,17,98,28,211,36,147,154,46,102,183,24,120,19,123,25,171,226,29,448,44,191,205,249 46,11,111,2,17,19,28,25,36,147,29,77,44,183,24,120,98,123,211,171,226,154,448,102,191,205,249 36,11,29,2,17,19,24,25,46,123,111,77,44,154,28,102,98,147,211,171,226,183,448,120,191,205,249 24,11,29,2,17,19,36,25,28,102,98,77,44,154,46,123,111,120,191,171,226,183,448,147,211,205,249 17,11,29,2,24,19,36,25,28,102,46,77,44,120,98,123,111,154,191,147,211,183,249,171,226,205,448 2,11,19,17,24,28,36,25,29,44,46,77,102,111,98,123,120,154,183,147,171,191,205,211,226,249,448 2,11,19,17,24,25,29,28,36,44,46,77,98,111,102,123,120,147,171,154,183,191,205,211,226,249,448 2,11,17,19,24,25,28,29,36,44,46,77,98,102,111,120,123,147,154,171,183,191,205,211,226,249,448  Go package main import "fmt" func main() { a := []int{170, 45, 75, -90, -802, 24, 2, 66} fmt.Println("before:", a) combSort(a) fmt.Println("after: ", a) } func combSort(a []int) { if len(a) < 2 { return } for gap := len(a); ; { if gap > 1 { gap = gap * 4 / 5 } swapped := false for i := 0; ; { if a[i] > a[i+gap] { a[i], a[i+gap] = a[i+gap], a[i] swapped = true } i++ if i+gap >= len(a) { break } } if gap == 1 && !swapped { break } } }  More generic version that sorts anything that implements sort.Interface: package main import ( "sort" "fmt" ) func main() { a := []int{170, 45, 75, -90, -802, 24, 2, 66} fmt.Println("before:", a) combSort(sort.IntSlice(a)) fmt.Println("after: ", a) } func combSort(a sort.Interface) { if a.Len() < 2 { return } for gap := a.Len(); ; { if gap > 1 { gap = gap * 4 / 5 } swapped := false for i := 0; ; { if a.Less(i+gap, i) { a.Swap(i, i+gap) swapped = true } i++ if i+gap >= a.Len() { break } } if gap == 1 && !swapped { break } } }  Groovy Combsort solution: def makeSwap = { a, i, j -> print "."; a[i] ^= a[j]; a[j] ^= a[i]; a[i] ^= a[j] } def checkSwap = { a, i, j -> [(a[i] > a[j])].find { it }.each { makeSwap(a, i, j) } } def combSort = { input -> def swap = checkSwap.curry(input) def size = input.size() def gap = size def swapped = true while (gap != 1 || swapped) { gap = (gap / 1.247330950103979) as int gap = (gap < 1) ? 1 : gap swapped = (0..<(size-gap)).any { swap(it, it + gap) } } input }  Combsort11 solution: def combSort11 = { input -> def swap = checkSwap.curry(input) def size = input.size() def gap = size def swapped = true while (gap != 1 || swapped) { gap = (gap / 1.247330950103979) as int gap = ((gap < 1) ? 1 : ([10,9].contains(gap) ? 11 : gap)) swapped = (0..<(size-gap)).any { swap(it, it + gap) } } input }  Test: println (combSort([23,76,99,58,97,57,35,89,51,38,95,92,24,46,31,24,14,12,57,78,4])) println (combSort11([23,76,99,58,97,57,35,89,51,38,95,92,24,46,31,24,14,12,57,78,4])) println () println (combSort([88,18,31,44,4,0,8,81,14,78,20,76,84,33,73,75,82,5,62,70,12,7,1])) println (combSort11([88,18,31,44,4,0,8,81,14,78,20,76,84,33,73,75,82,5,62,70,12,7,1]))  Output: ..................................................................................................................[4, 12, 14, 23, 24, 24, 31, 35, 38, 46, 51, 57, 57, 58, 76, 78, 89, 92, 95, 97, 99] ..........................................................................................................................[4, 12, 14, 23, 24, 24, 31, 35, 38, 46, 51, 57, 57, 58, 76, 78, 89, 92, 95, 97, 99] ...............................................................................................[0, 1, 4, 5, 7, 8, 12, 14, 18, 20, 31, 33, 44, 62, 70, 73, 75, 76, 78, 81, 82, 84, 88] ...............................................................................................[0, 1, 4, 5, 7, 8, 12, 14, 18, 20, 31, 33, 44, 62, 70, 73, 75, 76, 78, 81, 82, 84, 88]  Haskell import Data.List import Control.Arrow import Control.Monad flgInsert x xs = ((x:xs==) &&& id) insert x xs

gapSwapping k = (and *** concat. transpose). unzip
. map (foldr (\x (b,xs) -> first (b &&)$flgInsert x xs) (True,[])) . transpose. takeWhile (not.null). unfoldr (Just. splitAt k) combSort xs = (snd. fst)$ until (\((b,_),g)-> b && g==1)
(\((_,xs),g) ->(gapSwapping g xs, fg g)) ((False,xs), fg $length xs) where fg = max 1. truncate. (/1.25). fromIntegral  Example: *Main> combSort [23,76,99,58,97,57,35,89,51,38,95,92,24,46,31,24,14,12,57,78] [12,14,23,24,24,31,35,38,46,51,57,57,58,76,78,89,92,95,97,99]  Haxe class CombSort { @:generic public static function sort<T>(arr:Array<T>) { var gap:Float = arr.length; var swaps = true; while (gap > 1 || swaps) { gap /= 1.247330950103979; if (gap < 1) gap = 1.0; var i = 0; swaps = false; while (i + gap < arr.length) { var igap = i + Std.int(gap); if (Reflect.compare(arr[i], arr[igap]) > 0) { var temp = arr[i]; arr[i] = arr[igap]; arr[igap] = temp; swaps = true; } i++; } } } } class Main { static function main() { var integerArray = [1, 10, 2, 5, -1, 5, -19, 4, 23, 0]; var floatArray = [1.0, -3.2, 5.2, 10.8, -5.7, 7.3, 3.5, 0.0, -4.1, -9.5]; var stringArray = ['We', 'hold', 'these', 'truths', 'to', 'be', 'self-evident', 'that', 'all', 'men', 'are', 'created', 'equal']; Sys.println('Unsorted Integers: ' + integerArray); CombSort.sort(integerArray); Sys.println('Sorted Integers: ' + integerArray); Sys.println('Unsorted Floats: ' + floatArray); CombSort.sort(floatArray); Sys.println('Sorted Floats: ' + floatArray); Sys.println('Unsorted Strings: ' + stringArray); CombSort.sort(stringArray); Sys.println('Sorted Strings: ' + stringArray); } }  Output: Unsorted Integers: [1,10,2,5,-1,5,-19,4,23,0] Sorted Integers: [-19,-1,0,1,2,4,5,5,10,23] Unsorted Floats: [1,-3.2,5.2,10.8,-5.7,7.3,3.5,0,-4.1,-9.5] Sorted Floats: [-9.5,-5.7,-4.1,-3.2,0,1,3.5,5.2,7.3,10.8] Unsorted Strings: [We,hold,these,truths,to,be,self-evident,that,all,men,are,created,equal] Sorted Strings: [We,all,are,be,created,equal,hold,men,self-evident,that,these,to,truths]  Icon and Unicon procedure main() #: demonstrate various ways to sort a list and string demosort(combsort,[3, 14, 1, 5, 9, 2, 6, 3],"qwerty") end procedure combsort(X,op) #: return sorted X local gap,swapped,i op := sortop(op,X) # select how and what we sort swappped := gap := *X # initialize gap size and say swapped until /swapped & gap = 1 do { gap := integer(gap / 1.25) # update the gap value for a next comb gap <:= 1 # minimum gap of 1 swapped := &null i := 0 until (i +:= 1) + gap > *X do # a single "comb" over the input list if op(X[i+gap],X[i]) then X[i+1] :=: X[swapped := i] # swap and flag as unsorted } return X end  Note: This example relies on the supporting procedures 'sortop', and 'demosort' in Bubble Sort. The full demosort exercises the named sort of a list with op = "numeric", "string", ">>" (lexically gt, descending),">" (numerically gt, descending), a custom comparator, and also a string. Abbreviated sample output: Sorting Demo using procedure combsort on list : [ 3 14 1 5 9 2 6 3 ] with op = &null: [ 1 2 3 3 5 6 9 14 ] (0 ms) ... on string : "qwerty" with op = &null: "eqrtwy" (0 ms) Io List do( combSortInPlace := method( gap := size swap := true while(gap > 1 or swap, swap = false gap = (gap / 1.25) floor for(i, 0, size - gap, if(at(i) > at(i + gap), swap = true swapIndices(i, i + gap) ) ) ) self) ) lst := list(23, 76, 99, 58, 97, 57, 35, 89, 51, 38, 95, 92, 24, 46, 31, 24, 14, 12, 57, 78) lst combSortInPlace println # ==> list(12, 14, 23, 24, 24, 31, 35, 38, 46, 51, 57, 57, 58, 76, 78, 89, 92, 95, 97, 99)  IS-BASIC 100 PROGRAM "CombSrt.bas" 110 RANDOMIZE 120 NUMERIC ARRAY(11 TO 30) 130 CALL INIT(ARRAY) 140 CALL WRITE(ARRAY) 150 CALL COMBSORT(ARRAY) 160 CALL WRITE(ARRAY) 170 DEF INIT(REF A) 180 FOR I=LBOUND(A) TO UBOUND(A) 190 LET A(I)=RND(98)+1 200 NEXT 210 END DEF 220 DEF WRITE(REF A) 230 FOR I=LBOUND(A) TO UBOUND(A) 240 PRINT A(I); 250 NEXT 260 PRINT 270 END DEF 280 DEF COMBSORT(REF A) 290 LET N,GAP=UBOUND(A):LET SW=1 300 DO WHILE GAP>1 OR SW 310 LET GAP=MAX(INT(GAP/1.3),1):LET SW=0 320 FOR I=LBOUND(A) TO N-GAP 330 IF A(I)>A(I+GAP) THEN 340 LET T=A(I):LET A(I)=A(I+GAP):LET A(I+GAP)=T 350 LET SW=1 360 END IF 370 NEXT 380 LOOP 390 END DEF J Generally, this task should be accomplished in J using /:~. Here we take an approach that's more comparable with the other examples on this page. Large gap sizes allow some parallelism in comparisons and swaps. (If the gap size is G, then G pairs can be compared and swapped in parallel.) Beyond that, however, the data flow complexity of this algorithm requires a fair bit of micro-management. combSort=:3 :0 gap=. #y whilst.1 < gap+swaps do. swaps=. 0 i=. i.2,gap=. 1 >. <.gap%1.25 while.{:$i=.i #"1~ ({: i) < #y do.
swaps=.swaps+#{:k=.i #"1~b=. >/ i{y
i=. i+gap
y=.((|.k){y) k} y
end.
end.
y
)


Example use:

   combSort 23 76 99 58 97 57 35 89 51 38 95 92 24 46 31 24 14 12 57 78
12 14 23 24 24 31 35 38 46 51 57 57 58 76 78 89 92 95 97 99
combSort 88 18 31 44 4 0 8 81 14 78 20 76 84 33 73 75 82 5 62 70
0 4 5 8 14 18 20 31 33 44 62 70 73 75 76 78 81 82 84 88


Java

This is copied from the Wikipedia article.

public static <E extends Comparable<? super E>> void sort(E[] input) {
int gap = input.length;
boolean swapped = true;
while (gap > 1 || swapped) {
if (gap > 1) {
gap = (int) (gap / 1.3);
}
swapped = false;
for (int i = 0; i + gap < input.length; i++) {
if (input[i].compareTo(input[i + gap]) > 0) {
E t = input[i];
input[i] = input[i + gap];
input[i + gap] = t;
swapped = true;
}
}
}
}


JavaScript

  // Node 5.4.1 tested implementation (ES6)
function is_array_sorted(arr) {
var sorted = true;
for (var i = 0; i < arr.length - 1; i++) {
if (arr[i] > arr[i + 1]) {
sorted = false;
break;
}
}
return sorted;
}

// Array to sort
var arr = [4, 9, 0, 3, 1, 5];

var iteration_count = 0;
var gap = arr.length - 2;
var decrease_factor = 1.25;

// Until array is not sorted, repeat iterations
while (!is_array_sorted(arr)) {
// If not first gap
if (iteration_count > 0)
// Calculate gap
gap = (gap == 1) ? gap : Math.floor(gap / decrease_factor);

// Set front and back elements and increment to a gap
var front = 0;
var back = gap;
while (back <= arr.length - 1) {
// If elements are not ordered swap them
if (arr[front] > arr[back]) {
var temp = arr[front];
arr[front] = arr[back];
arr[back] = temp;
}

// Increment and re-run swapping
front += 1;
back += 1;
}
iteration_count += 1;
}

// Print the sorted array
console.log(arr);
}


Output:
 [0, 1, 3, 4, 5, 9]


jq

Works with: jq version 1.4

An implementation of the pseudo-code in the task description:

# Input should be the array to be sorted.
def combsort:

# As soon as "condition" is true, emit . and stop:
def do_until(condition; next):
def u: if condition then . else (next|u) end;
u;

def swap(i;j):
if i==j then . else .[i] as $tmp | .[i] = .[j] | .[j] =$tmp end;

. as $in | length as$length
# state: [gap, swaps, array] where:
#   gap is the gap size;
#   swaps is a boolean flag indicating a swap has occurred,
#         implying that the array might not be sorted;
#   array is the current state of the array being sorted
| [ $length, false,$in ]
| do_until( .[0] == 1 and .[1] == false;
# update the gap value for the next "comb":
([1, ((.[0] / 1.25) | floor)] | max) as $gap # minimum gap is 1 # state: [i, swaps, array] | [0, false, .[2]] # a single "comb" over the input list: | do_until( (.[0] +$gap) >= $length; .[0] as$i
| if .[2][$i] > .[2][$i+$gap] then [$i+1, true, (.[2]|swap($i;$i+$gap))] else .[0] += 1 end) | .[0] =$gap )
| .[2] ;

Julia

# v0.6

function combsort!(x::Array)::Array
gap, swaps = length(x), true
while gap > 1 || swaps
gap = floor(Int, gap / 1.25)
i, swaps = 0, false
while i + gap < length(x)
if x[i+1] > x[i+1+gap]
x[i+1], x[i+1+gap] = x[i+1+gap], x[i+1]
swaps = true
end
i += 1
end
end
return x
end

x = randn(100)
@show x combsort!(x)
@assert issorted(x)

Output:
x = [1.41167, 1.19626, 0.821703, 0.336024, -0.708447, 0.694578, 1.49075, -1.07124, -1.59686, -0.720135]
combsort!(x) = [-1.59686, -1.07124, -0.720135, -0.708447, 0.336024, 0.694578, 0.821703, 1.19626, 1.41167, 1.49075]

Kotlin

// version 1.1.2

fun <T : Comparable<T>> combSort(input: Array<T>) {
var gap = input.size
if (gap <= 1) return  // already sorted
var swaps = false
while (gap > 1 || swaps) {
gap = (gap / 1.247331).toInt()
if (gap < 1) gap = 1
var i = 0
swaps = false
while (i + gap < input.size) {
if (input[i] > input[i + gap]) {
val tmp = input[i]
input[i] = input[i + gap]
input[i + gap] = tmp
swaps = true
}
i++
}
}
}

fun main(args: Array<String>) {
val ia = arrayOf(28, 44, 46, 24, 19, 2, 17, 11, 25, 4)
println("Unsorted : ${ia.contentToString()}") combSort(ia) println("Sorted :${ia.contentToString()}")
println()
val ca = arrayOf('X', 'B', 'E', 'A', 'Z', 'M', 'S', 'L', 'Y', 'C')
println("Unsorted : ${ca.contentToString()}") combSort(ca) println("Sorted :${ca.contentToString()}")
}

Output:
Unsorted : [28, 44, 46, 24, 19, 2, 17, 11, 25, 4]
Sorted   : [2, 4, 11, 17, 19, 24, 25, 28, 44, 46]

Unsorted : [X, B, E, A, Z, M, S, L, Y, C]
Sorted   : [A, B, C, E, L, M, S, X, Y, Z]


Liberty BASIC

'randomize 0.5
itemCount = 20
dim item(itemCount)
for i = 1 to itemCount
item(i) = int(rnd(1) * 100)
next i
print "Before Sort"
for i = 1 to itemCount
print item(i)
next i
print: print
't0=time$("ms") gap=itemCount while gap>1 or swaps <> 0 gap=int(gap/1.25) 'if gap = 10 or gap = 9 then gap = 11 'uncomment to get Combsort11 if gap <1 then gap = 1 i = 1 swaps = 0 for i = 1 to itemCount-gap if item(i) > item(i + gap) then temp = item(i) item(i) = item(i + gap) item(i + gap) = temp swaps = 1 end if next wend print "After Sort" 't1=time$("ms")
'print t1-t0

for i = 1 to itemCount
print item(i)
next i
end

Lua

function combsort(t)
local gapd, gap, swaps = 1.2473, #t, 0
while gap + swaps > 1 do
local k = 0
swaps = 0
if gap > 1 then gap = math.floor(gap / gapd) end
for k = 1, #t - gap do
if t[k] > t[k + gap] then
t[k], t[k + gap], swaps = t[k + gap], t[k], swaps + 1
end
end
end
return t
end

print(unpack(combsort{3,5,1,2,7,4,8,3,6,4,1}))


Maple

swap := proc(arr, a, b)
local temp;
temp := arr[a]:
arr[a] := arr[b]:
arr[b] := temp:
end proc:
newGap := proc(gap)
local new;
new := trunc(gap*10/13);
if (new < 1) then return 1; end if;
return new;
end proc;
combsort := proc(arr, len)
local gap, swapped,i, temp;
swapped := true:
gap := len:
while ((not gap = 1) or swapped) do
gap := newGap(gap):
swapped := false:
for i from 1 to len-gap by 1 do
if (arr[i] > arr[i+gap]) then
temp := arr[i]:
arr[i] := arr[i+gap]:
arr[i+gap] := temp:
swapped:= true:
end if:
end do:
end do:
end proc:
arr := Array([17,3,72,0,36,2,3,8,40,0]);
combsort(arr, numelems(arr));
arr;
Output:
[0,0,2,3,3,8,17,36,40,72]

Mathematica/Wolfram Language

combSort[list_] := Module[{ gap = 0, listSize = 0, swaps = True},
gap = listSize = Length[list];
While[ !((gap <= 1) && (swaps == False)),

gap = Floor@Divide[gap, 1.25];
If[ gap < 1, gap = 1]; i = 1; swaps = False;

While[ ! ((i + gap - 1) >= listSize),
If[ list[[i]] > list[[i + gap]], swaps = True;
list[[i ;; i + gap]] = list[[i + gap ;; i ;; -1]];
];
i++;
]
]
]

combSort@{2, 1, 3, 7, 6}
->{1, 2, 3, 6, 7}

MATLAB / Octave

function list = combSort(list)

listSize = numel(list);
gap = int32(listSize); %Coerce gap to an int so we can use the idivide function
swaps = true; %Swap flag

while not((gap <= 1) && (swaps == false))

gap = idivide(gap,1.25,'floor'); %Int divide, floor the resulting operation

if gap < 1
gap = 1;
end

i = 1; %i equals 1 because all arrays are 1 based in MATLAB
swaps = false;

%i + gap must be subtracted by 1 because the pseudo-code was writen
%for 0 based arrays
while not((i + gap - 1) >= listSize)

if (list(i) > list(i+gap))
list([i i+gap]) = list([i+gap i]); %swap
swaps = true;
end
i = i + 1;

end %while
end %while
end %combSort


Sample Output:

>> combSort([4 3 1 5 6 2])

ans =

1     2     3     4     5     6


MAXScript

fn combSort arr =
(
local gap = arr.count
local swaps = 1
while not (gap == 1 and swaps == 0) do
(
gap = (gap / 1.25) as integer
if gap < 1 do
(
gap = 1
)
local i = 1
swaps = 0
while not (i + gap > arr.count) do
(
if arr[i] > arr[i+gap] do
(
swap arr[i] arr[i+gap]
swaps = 1
)
i += 1

)

)
return arr
)

Output:

a = for i in 1 to 10 collect random 1 10
#(2, 6, 5, 9, 10, 7, 2, 6, 1, 4)
combsort a
#(1, 2, 2, 4, 5, 6, 6, 7, 9, 10)

NetRexx

/* NetRexx */

options replace format comments java crossref savelog symbols binary

placesList = [String -
"UK  London",     "US  New York"   -
, "US  Boston",     "US  Washington" -
, "UK  Washington", "US  Birmingham" -
, "UK  Birmingham", "UK  Boston"     -
]
sortedList = combSort(String[] Arrays.copyOf(placesList, placesList.length))

lists = [placesList, sortedList]
loop ln = 0 to lists.length - 1
cl = lists[ln]
loop ct = 0 to cl.length - 1
say cl[ct]
end ct
say
end ln

return

method combSort(input = String[]) public constant binary returns String[]

swaps = isTrue
gap = input.length
loop label comb until gap = 1 & \swaps
gap = int gap / 1.25
if gap < 1 then
gap = 1
i_ = 0
swaps = isFalse
loop label swaps until i_ + gap >= input.length
if input[i_].compareTo(input[i_ + gap]) > 0 then do
swap            = input[i_]
input[i_]       = input[i_ + gap]
input[i_ + gap] = swap
swaps           = isTrue
end
i_ = i_ + 1
end swaps
end comb

return input

method isTrue public constant binary returns boolean
return 1 == 1

method isFalse public constant binary returns boolean
return \isTrue

Output
UK  London
US  New York
US  Boston
US  Washington
UK  Washington
US  Birmingham
UK  Birmingham
UK  Boston

UK  Birmingham
UK  Boston
UK  London
UK  Washington
US  Birmingham
US  Boston
US  New York
US  Washington


Nim

proc combSort[T](a: var openarray[T]) =
var gap = a.len
var swapped = true
while gap > 1 or swapped:
gap = gap * 10 div 13
if gap == 9 or gap == 10: gap = 11
if gap < 1: gap = 1
swapped = false
var i = 0
for j in gap ..< a.len:
if a[i] > a[j]:
swap a[i], a[j]
swapped = true
inc i

var a = @[4, 65, 2, -31, 0, 99, 2, 83, 782]
combSort a
echo a


Output:

@[-31, 0, 2, 2, 4, 65, 83, 99, 782]

Objeck

bundle Default {
class Stooge {
function : Main(args : String[]) ~ Nil {
nums := [3, 5, 1, 9, 7, 6, 8, 2, 4];
CombSort(nums);
each(i : nums) {
IO.Console->Print(nums[i])->Print(",");
};
IO.Console->PrintLine();
}

function : CombSort(input : Int[]) ~ Nil {
gap : Float := input->Size();
swaps := true;
while(gap > 1 | swaps) {
gap /= 1.247330950103979;
if(gap < 1) { gap := 1; };
i : Int := 0;
swaps := false;
while(i + gap < input->Size()) {
igap : Int := i + gap->As(Int);
if (input[i] > input[igap]) {
swap : Int := input[i];
input[i] := input[igap];
input[igap] := swap;
swaps := true;
};
i += 1;
};
};
}
}
}

OCaml

let comb_sort ~input =
let input_length = Array.length input in
let gap = ref(input_length) in
let swapped = ref true in
while (!gap > 1 || !swapped) do
if (!gap > 1) then
gap := int_of_float (float !gap /. 1.3);

swapped := false;
for i = 0 to input_length - !gap do
if input.(i) > input.(i + !gap) then begin
let tmp = input.(i) in
input.(i) <- input.(i + !gap);
input.(i + !gap) <- tmp;
swapped := true;
end
done
done
;;


Oz

declare
proc {CombSort Arr}
Low = {Array.low Arr}
High = {Array.high Arr}
Size = High - Low + 1
Gap = {NewCell Size}
Swapped = {NewCell true}
proc {Swap I J}
Arr.J := (Arr.I := Arr.J)
end
in
for while:@Gap>1 orelse @Swapped do
if @Gap > 1 then
Gap := {Float.toInt {Floor {Int.toFloat @Gap} / 1.3}}
end
Swapped := false
for I in Low..High-@Gap do
if Arr.I > Arr.(I+@Gap) then
{Swap I I+@Gap}
Swapped := true
end
end
end
end
Arr = {Tuple.toArray unit(3 1 4 1 5 9 2 6 5)}
in
{CombSort Arr}
{Show {Array.toRecord unit Arr}}

PARI/GP

combSort(v)={
my(phi=(1+sqrt(5))/2,magic=1/(1-exp(-phi)),g=#v,swaps);
while(g>1 | swaps,
if(g>1, g\=magic);
swaps=0;
for(i=1,#v-g,
if(v[i]>v[i+g],
my(t=v[i]);
v[i]=v[i+g];
v[i+g]=t;
swaps++
)
)
);
v
};

Pascal

program CombSortDemo;

// NOTE: The array is 1-based
//       If you want to use this code on a 0-based array, see below
type
TIntArray = array[1..40] of integer;

var
data: TIntArray;
i: integer;

procedure combSort(var a: TIntArray);
var
i, gap, temp: integer;
swapped: boolean;
begin
gap := length(a);
swapped := true;
while (gap > 1) or swapped do
begin
gap := trunc(gap / 1.3);
if (gap < 1) then
gap := 1;
swapped := false;
for i := 1 to length(a) - gap do
if a[i] > a[i+gap] then
begin
temp := a[i];
a[i] := a[i+gap];
a[i+gap] := temp;
swapped := true;
end;
end;
end;

begin
Randomize;
writeln('The data before sorting:');
for i := low(data) to high(data) do
begin
data[i] := Random(high(data));
write(data[i]:4);
end;
writeln;
combSort(data);
writeln('The data after sorting:');
for i := low(data) to high(data) do
begin
write(data[i]:4);
end;
writeln;
end.


Output:

The data before sorting:
10  26  32  10   9  32  38  37  12   9  16   7  25   1  37   7  24  22   7  36   2   5  10   5  33  35  32  18   5  28   7   5  36  12  16  36  24   3  29  15
The data after sorting:
1   2   3   5   5   5   5   7   7   7   7   9   9  10  10  10  12  12  15  16  16  18  22  24  24  25  26  28  29  32  32  32  33  35  36  36  36  37  37  38

program CombSortDemo;

// NOTE: The array is 0-based
//       If you want to use this code on a 1-based array, see above
type
TIntArray = array[0..39] of integer;

var
data: TIntArray;
i: integer;

procedure combSort(var a: TIntArray);
var
i, gap, temp: integer;
swapped: boolean;
begin
gap := length(a);
swapped := true;
while (gap > 1) or swapped do
begin
gap := trunc(gap / 1.3);
if (gap < 1) then
gap := 1;
swapped := false;
for i := 0 to length(a) - gap - 1 do
if a[i] > a[i+gap] then
begin
temp := a[i];
a[i] := a[i+gap];
a[i+gap] := temp;
swapped := true;
end;
end;
end;

begin
Randomize;
writeln('The data before sorting:');
for i := low(data) to high(data) do
begin
data[i] := Random(high(data));
write(data[i]:4);
end;
writeln;
combSort(data);
writeln('The data after sorting:');
for i := low(data) to high(data) do
begin
write(data[i]:4);
end;
writeln;
end.


Perl

sub combSort {
my @arr = @_;
my $gap = @arr; my$swaps = 1;
while ($gap > 1 ||$swaps) {
$gap /= 1.25 if$gap > 1;
$swaps = 0; foreach my$i (0 .. $#arr -$gap) {
if ($arr[$i] > $arr[$i+$gap]) { @arr[$i, $i+$gap] = @arr[$i+$gap, $i];$swaps = 1;
}
}
}
return @arr;
}


Phix

with javascript_semantics

function comb_sort(sequence s)
integer gap = length(s)-1
while 1 do
gap = max(floor(gap/1.3),1)
integer swapped = 0
for i=1 to length(s)-gap do
object si = s[i]
if si>s[i+gap] then
s[i] = s[i+gap]
s[i+gap] = si
swapped = 1
end if
end for
if gap=1 and swapped=0 then exit end if
end while
return s
end function

?comb_sort(shuffle(tagset(10)))

Output:
{1,2,3,4,5,6,7,8,9,10}


PHP

function combSort($arr){$gap = count($arr);$swap = true;
while ($gap > 1 ||$swap){
if($gap > 1)$gap /= 1.25;

$swap = false;$i = 0;
while($i+$gap < count($arr)){ if($arr[$i] >$arr[$i+$gap]){
list($arr[$i], $arr[$i+$gap]) = array($arr[$i+$gap],$arr[$i]);
$swap = true; }$i++;
}
}
return arr; }  PicoLisp (de combSort (Lst) (let (Gap (length Lst) Swaps NIL) (while (or (> Gap 1) Swaps) (setq Gap (max 1 (/ (* Gap 4) 5))) (off Swaps) (use Lst (for (G (cdr (nth Lst Gap)) G (cdr G)) (when (> (car Lst) (car G)) (xchg Lst G) (on Swaps) ) (pop 'Lst) ) ) ) ) Lst ) Output: : (combSort (88 18 31 44 4 0 8 81 14 78 20 76 84 33 73 75 82 5 62 70)) -> (0 4 5 8 14 18 20 31 33 44 62 70 73 75 76 78 81 82 84 88) PL/I /* From the pseudocode. */ comb_sort: procedure (A); declare A(*) fixed; declare t fixed; declare (i, gap) fixed binary (31); declare swaps bit (1) aligned; gap = hbound(A,1) - lbound(A,1); /* initialize the gap size. */ do until (gap <= 1 & swaps); /* update the gap value for a next comb. */ put skip data (gap); gap = gap / 1.25e0; put skip data (gap); swaps = '1'b; /* a single "comb" over the array. */ do i = lbound(A,1) by 1 until (i + gap >= hbound(A,1)); if A(i) > A(i+gap) then do; t = A(i); A(i) = A(i+gap); A(i+gap) = t; swaps = '0'b; /* Flag a swap has occurred, so */ /* the list is not guaranteed sorted. */ end; end; end; end comb_sort; PowerShell Massaging gap to always hit 11. Based on PowerShell from Cocktail Sort function CombSort (a) {
$l =$a.Length
$gap = 11 while($gap -lt $l ) {$gap = [Math]::Floor( $gap*1.3 ) } if($l -gt 1 )
{
$hasChanged =$true
:outer while ($hasChanged -or ($gap -gt 1 ) ) {
$count = 0$hasChanged = $false if($gap -gt 1 ) {
$gap = [Math]::Floor($gap/1.3 )
} else {
$l-- } for ($i = 0; $i -lt ($l - $gap );$i++) {
if ($a[$i] -gt $a[$i+$gap]) {$a[$i],$a[$i+$gap] = $a[$i+$gap],$a[$i]$hasChanged = $true$count++
}
}
}
}
$a }$l = 100; CombSort ( 1..$l | ForEach-Object {$Rand = New-Object Random }{ $Rand.Next( -($l - 1 ), $l - 1 ) } )  PureBasic Implementation of CombSort11. ;sorts an array of integers Procedure combSort11(Array a(1)) Protected i, gap, swaps = 1 Protected nElements = ArraySize(a()) gap = nElements While (gap > 1) Or (swapped = 1) gap * 10 / 13 If gap = 9 Or gap = 10: gap = 11: EndIf If gap < 1: gap = 1: EndIf i = 0 swaps = 0 While (i + gap) <= nElements If a(i) > a(i + gap) Swap a(i), a(i + gap) swaps = 1 EndIf i + 1 Wend Wend EndProcedure  Implementation of CombSort. ;sorts an array of integers Procedure combSort(Array a(1)) Protected i, gap, swaps = 1 Protected nElements = ArraySize(a()) gap = nElements While (gap > 1) Or (swaps = 1) gap = Int(gap / 1.25) i = 0 swaps = 0 While (i + gap) <= nElements If a(i) > a(i + gap) Swap a(i), a(i + gap) swaps = 1 EndIf i + 1 Wend Wend EndProcedure  Python >>> def combsort(input): gap = len(input) swaps = True while gap > 1 or swaps: gap = max(1, int(gap / 1.25)) # minimum gap is 1 swaps = False for i in range(len(input) - gap): j = i+gap if input[i] > input[j]: input[i], input[j] = input[j], input[i] swaps = True >>> y = [88, 18, 31, 44, 4, 0, 8, 81, 14, 78, 20, 76, 84, 33, 73, 75, 82, 5, 62, 70] >>> combsort(y) >>> assert y == sorted(y) >>> y [0, 4, 5, 8, 14, 18, 20, 31, 33, 44, 62, 70, 73, 75, 76, 78, 81, 82, 84, 88] >>>  R comb.sort<-function(a){ gap<-length(a) swaps<-1 while(gap>1 & swaps==1){ gap=floor(gap/1.3) if(gap<1){ gap=1 } swaps=0 i=1 while(i+gap<=length(a)){ if(a[i]>a[i+gap]){ a[c(i,i+gap)] <- a[c(i+gap,i)] swaps=1 } i<-i+1 } } return(a) }  Racket #lang racket (require (only-in srfi/43 vector-swap!)) (define (comb-sort xs) (define (ref i) (vector-ref xs i)) (define (swap i j) (vector-swap! xs i j)) (define (new gap) (max 1 (exact-floor (/ gap 1.25)))) (define size (vector-length xs)) (let loop ([gap size] [swaps 0]) (unless (and (= gap 1) (= swaps 0)) (loop (new gap) (for/fold ([swaps 0]) ([i (in-range 0 (- size gap))]) (cond [(> (ref i) (ref (+ i gap))) (swap i (+ i gap)) (+ swaps 1)] [swaps]))))) xs)  Raku (formerly Perl 6) Translation of: Perl sub comb_sort ( @a is copy ) { my$gap = +@a;
my $swaps = 1; while$gap > 1 or $swaps {$gap = ( ($gap * 4) div 5 ) || 1 if$gap > 1;

$swaps = 0; for ^(+@a -$gap) -> $i { my$j = $i +$gap;
if @a[$i] > @a[$j] {
@a[$i,$j] .= reverse;
if @.j>@.$then do; _= @.j; @.j= @.$;   @.$= _; done= 0; end end /*j*/ end /*until*/ /* [↑] swap two elements in the array.*/ return /*──────────────────────────────────────────────────────────────────────────────────────*/ gen: @.=; @.1 = '----polygon--- sides' ; @.12 = "dodecagon 12" @.2 = '============== =======' ; @.13 = "tridecagon 13" @.3 = 'triangle 3' ; @.14 = "tetradecagon 14" @.4 = 'quadrilateral 4' ; @.15 = "pentadecagon 15" @.5 = 'pentagon 5' ; @.16 = "hexadecagon 16" @.6 = 'hexagon 6' ; @.17 = "heptadecagon 17" @.7 = 'heptagon 7' ; @.18 = "octadecagon 18" @.8 = 'octagon 8' ; @.19 = "enneadecagon 19" @.9 = 'nonagon 9' ; @.20 = "icosagon 20" @.10 = 'decagon 10' ; @.21 = "hectogon 100" @.11 = 'hendecagon 11' ; @.22 = "chiliagon 1000" @.23 = "myriagon 10000" do #=1 while @.#\==''; end /*find how many elements in @ */ #= #-1; w= length(#); return /*adjust # because of DO loop.*/ /*──────────────────────────────────────────────────────────────────────────────────────*/ show: do k=1 for #; say right('element',15) right(k,w) arg(1)":" @.k; end; return  Data trivia: A hendecagon (also known as an undecagon or unidecagon) is from the Greek word hendeka [eleven] and gon─ [corner]. output: (Shown at three-quarter size.)  element 1 before sort: ----polygon--- sides element 2 before sort: ============== ======= element 3 before sort: triangle 3 element 4 before sort: quadrilateral 4 element 5 before sort: pentagon 5 element 6 before sort: hexagon 6 element 7 before sort: heptagon 7 element 8 before sort: octagon 8 element 9 before sort: nonagon 9 element 10 before sort: decagon 10 element 11 before sort: hendecagon 11 element 12 before sort: dodecagon 12 element 13 before sort: tridecagon 13 element 14 before sort: tetradecagon 14 element 15 before sort: pentadecagon 15 element 16 before sort: hexadecagon 16 element 17 before sort: heptadecagon 17 element 18 before sort: octadecagon 18 element 19 before sort: enneadecagon 19 element 20 before sort: icosagon 20 element 21 before sort: hectogon 100 element 22 before sort: chiliagon 1000 element 23 before sort: myriagon 10000 ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ element 1 after sort: ----polygon--- sides element 2 after sort: ============== ======= element 3 after sort: chiliagon 1000 element 4 after sort: decagon 10 element 5 after sort: dodecagon 12 element 6 after sort: enneadecagon 19 element 7 after sort: hectogon 100 element 8 after sort: hendecagon 11 element 9 after sort: heptadecagon 17 element 10 after sort: heptagon 7 element 11 after sort: hexadecagon 16 element 12 after sort: hexagon 6 element 13 after sort: icosagon 20 element 14 after sort: myriagon 10000 element 15 after sort: nonagon 9 element 16 after sort: octadecagon 18 element 17 after sort: octagon 8 element 18 after sort: pentadecagon 15 element 19 after sort: pentagon 5 element 20 after sort: quadrilateral 4 element 21 after sort: tetradecagon 14 element 22 after sort: triangle 3 element 23 after sort: tridecagon 13  Ring aList = [3,5,1,2,7,4,8,3,6,4,1] see combsort(aList) func combsort t gapd = 1.2473 gap = len(t) swaps = 0 while gap + swaps > 1 k = 0 swaps = 0 if gap > 1 gap = floor(gap / gapd) ok for k = 1 to len(t) - gap if t[k] > t[k + gap] temp = t[k] t[k] = t[k + gap] t[k + gap] = temp swaps = swaps + 1 ok next end return t Ruby class Array def combsort! gap = size swaps = true while gap > 1 or swaps gap = [1, (gap / 1.25).to_i].max swaps = false 0.upto(size - gap - 1) do |i| if self[i] > self[i+gap] self[i], self[i+gap] = self[i+gap], self[i] swaps = true end end end self end end p [23, 76, 99, 58, 97, 57, 35, 89, 51, 38, 95, 92, 24, 46, 31, 24, 14, 12, 57, 78].combsort!  results in [12, 14, 23, 24, 24, 31, 35, 38, 46, 51, 57, 57, 58, 76, 78, 89, 92, 95, 97, 99] Rust fn comb_sort<T: PartialOrd>(a: &mut [T]) { let len = a.len(); let mut gap = len; let mut swapped = true; while gap > 1 || swapped { gap = (4 * gap) / 5; if gap < 1 { gap = 1; } let mut i = 0; swapped = false; while i + gap < len { if a[i] > a[i + gap] { a.swap(i, i + gap); swapped = true; } i += 1; } } } fn main() { let mut v = vec![10, 8, 4, 3, 1, 9, 0, 2, 7, 5, 6]; println!("before: {:?}", v); comb_sort(&mut v); println!("after: {:?}", v); }  Output: before: [10, 8, 4, 3, 1, 9, 0, 2, 7, 5, 6] after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  Sather class SORT{T <$IS_LT{T}} is

private swap(inout a, inout b:T) is
temp ::= a;
a := b;
b := temp;
end;

-- ---------------------------------------------------------------------------------
comb_sort(inout a:ARRAY{T}) is
gap ::= a.size;
swapped ::= true;
loop until!(gap <= 1 and ~swapped);
if gap > 1 then
gap := (gap.flt / 1.25).int;
end;
i ::= 0;
swapped := false;
loop until! ( (i + gap) >= a.size );
if (a[i] > a[i+gap]) then
swap(inout a[i], inout a[i+gap]);
swapped := true;
end;
i := i + 1;
end;
end;
end;
end;

class MAIN is
main is
a:ARRAY{INT} := |88, 18, 31, 44, 4, 0, 8, 81, 14, 78, 20, 76, 84, 33, 73, 75, 82, 5, 62, 70|;
b ::= a.copy;
SORT{INT}::comb_sort(inout b);
#OUT + b + "\n";
end;
end;

Scala

Imperative version (Ugly, side effects)

object CombSort extends App {
val ia = Array(28, 44, 46, 24, 19, 2, 17, 11, 25, 4)
val ca = Array('X', 'B', 'E', 'A', 'Z', 'M', 'S', 'L', 'Y', 'C')

def sorted[E](input: Array[E])(implicit ord: Ordering[E]): Array[E] = {
import ord._
var gap = input.length
var swapped = true
while (gap > 1 || swapped) {
if (gap > 1) gap = (gap / 1.3).toInt
swapped = false
for (i <- 0 until input.length - gap)
if (input(i) >= input(i + gap)) {
val t = input(i)
input(i) = input(i + gap)
input(i + gap) = t
swapped = true
}
}
input
}

println(s"Unsorted : ${ia.mkString("[", ", ", "]")}") println(s"Sorted :${sorted(ia).mkString("[", ", ", "]")}\n")

println(s"Unsorted : ${ca.mkString("[", ", ", "]")}") println(s"Sorted :${sorted(ca).mkString("[", ", ", "]")}")

}

Output:
See it in running in your browser by ScalaFiddle (JavaScript) or by Scastie (JVM).

Sidef

func comb_sort(arr) {
var gap = arr.len;
var swaps = true;
while (gap > 1 || swaps) {
gap.div!(1.25).int! if (gap > 1);
swaps = false;
for i in ^(arr.len - gap) {
if (arr[i] > arr[i+gap]) {
arr[i, i+gap] = arr[i+gap, i];
swaps = true;
}
}
}
return arr;
}


Swift

Translation of: C
func combSort(inout list:[Int]) {
var swapped = true
var gap = list.count

while gap > 1 || swapped {
gap = gap * 10 / 13

if gap == 9 || gap == 10 {
gap = 11
} else if gap < 1 {
gap = 1
}

swapped = false

for var i = 0, j = gap; j < list.count; i++, j++ {
if list[i] > list[j] {
(list[i], list[j]) = (list[j], list[i])
swapped = true
}
}
}
}


Tcl

proc combsort {input} {
set gap [llength $input] while 1 { set gap [expr {int(floor($gap / 1.3))}]
set swaps 0
for {set i 0} {$i+$gap < [llength $input]} {incr i} { set j [expr {$i+$gap}] if {[lindex$input $i] > [lindex$input $j]} { set tmp [lindex$input $i] lset input$i [lindex $input$j]
lset input $j$tmp
incr swaps
}
}
if {$gap <= 1 && !$swaps} break
}
return $input } set data {23 76 99 58 97 57 35 89 51 38 95 92 24 46 31 24 14 12 57 78} puts [combsort$data]


Produces this output:

12 14 23 24 24 31 35 38 46 51 57 57 58 76 78 89 92 95 97 99

TI-83 BASIC

Requires prgmSORTINS. Gap division of 1.3. Switches to Insertion sort when gap is less than 5.

:L1→L2
:dim(L2)→A
:While A>5 and B=0
:int(A/1.3)→A
:1→C
:0→B
:While (C+A)≥dim(L2)
:If L2(C)>L2(C+A)
:Then
:L2(C)→D
:L2(C+A)→L2(C)
:D→L2(C+A)
:1→B
:End
:C+1→C
:End
:DelVar A
:DelVar B
:DelVar C
:DelVar D
:L1→L3
:L2→L1
:prgmSORTINS
:L3→L1
:DelVar L3
:Return


uBasic/4tH

PRINT "Comb sort:"
n = FUNC (_InitArray)
PROC _ShowArray (n)
PROC _Combsort (n)
PROC _ShowArray (n)
PRINT

END

_Combsort PARAM (1)                    ' Combsort subroutine
LOCAL(4)
b@ = a@
c@ = 1

DO WHILE (b@ > 1) + c@

b@ = (b@ * 10) / 13

IF (b@ = 9) + (b@ = 10) THEN b@ = 11
IF b@ < 1 THEN b@ = 1

c@ = 0
d@ = 0
e@ = b@

DO WHILE e@ < a@
IF @(d@) > @(e@) THEN PROC _Swap (d@, e@) : c@ = 1
d@ = d@ + 1
e@ = e@ + 1
LOOP
LOOP
RETURN

_Swap PARAM(2)                         ' Swap two array elements
PUSH @(a@)
@(a@) = @(b@)
@(b@) = POP()
RETURN

_InitArray                             ' Init example array
PUSH 4, 65, 2, -31, 0, 99, 2, 83, 782, 1

FOR i = 0 TO 9
@(i) = POP()
NEXT

RETURN (i)

_ShowArray PARAM (1)                   ' Show array subroutine
FOR i = 0 TO a@-1
PRINT @(i),
NEXT

PRINT
RETURN


VBA

{[trans|Phix}}
Function comb_sort(ByVal s As Variant) As Variant
Dim gap As Integer: gap = UBound(s)
Dim swapped As Integer
Do While True
gap = WorksheetFunction.Max(WorksheetFunction.Floor_Precise(gap / 1.3), 1)
swapped = False
For i = 0 To UBound(s) - gap
si = Val(s(i))
If si > Val(s(i + gap)) Then
s(i) = s(i + gap)
s(i + gap) = CStr(si)
swapped = True
End If
Next i
If gap = 1 And Not swapped Then Exit Do
Loop
comb_sort = s
End Function

Public Sub main()
Dim s(9) As Variant
For i = 0 To 9
s(i) = CStr(Int(1000 * Rnd))
Next i
Debug.Print Join(s, ", ")
Debug.Print Join(comb_sort(s), ", ")
End Sub

Output:
45, 414, 862, 790, 373, 961, 871, 56, 949, 364
45, 56, 364, 373, 414, 790, 862, 871, 949, 961

V (Vlang)

Translation of: go
fn main() {
mut a := [170, 45, 75, -90, -802, 24, 2, 66]
println("before: $a") comb_sort(mut a) println("after:$a")
}

fn comb_sort(mut a []int) {
if a.len < 2 {
return
}
for gap := a.len; ; {
if gap > 1 {
gap = gap * 4 / 5
}
mut swapped := false
for i := 0; ; {
if a[i] > a[i+gap] {
a[i], a[i+gap] = a[i+gap], a[i]
swapped = true
}
i++
if i+gap >= a.len {
break
}
}
if gap == 1 && !swapped {
break
}
}
}

Wren

var combSort = Fn.new { |a|
var gap = a.count
while (true) {
gap = (gap/1.25).floor
if (gap < 1) gap = 1
var i = 0
var swaps = false
while (true) {
if (a[i] > a[i+gap]) {
var t = a[i]
a[i] = a[i+gap]
a[i+gap] = t
swaps = true
}
i = i + 1
if (i + gap >= a.count) break
}
if (gap == 1 && !swaps) return
}
}

var as = [ [4, 65, 2, -31, 0, 99, 2, 83, 782, 1], [7, 5, 2, 6, 1, 4, 2, 6, 3] ]
for (a in as) {
System.print("Before: %(a)")
combSort.call(a)
System.print("After : %(a)")
System.print()
}

Output:
Before: [4, 65, 2, -31, 0, 99, 2, 83, 782, 1]
After : [-31, 0, 1, 2, 2, 4, 65, 83, 99, 782]

Before: [7, 5, 2, 6, 1, 4, 2, 6, 3]
After : [1, 2, 2, 3, 4, 5, 6, 6, 7]


XPL0

Translation of: ALGOL W
    \Comb sorts in-place the array of integers Input with bounds LB :: UB
procedure CombSort ( Input, LB, UB );
integer   Input, LB, UB;
integer   InputSize, Gap, I, Swapped, T, IGap;
begin
InputSize := ( UB - LB ) + 1;
if InputSize > 1 then begin
\more than one element, so must sort
Gap     := InputSize; \initial Gap is the whole array size
Swapped := true;
while Gap # 1 or Swapped do begin
\update the Gap value for a next comb
Gap := fix( Floor(float(Gap) / 1.25) );
if Gap < 1 then begin
\ensure the Gap is at least 1
Gap := 1
end; \if_Gap_lt_1
Swapped := false;
\a single "comb" over the input list
I := LB;
while I + Gap <= UB do begin
T    := Input( I );
IGap := I + Gap;
if T > Input( IGap ) then begin
\need to swap out-of-order items
Input( I    ) := Input( IGap );
Input( IGap ) := T;
\Flag a swap has occurred, so the list is not guaranteed sorted yet
Swapped := true
end; \if_t_gt_input__iGap
I := I + 1
end \while_I_plus_Gap_le_UB
end \while_Gap_ne_1_or_swapped
end \if_inputSize_gt_1
end; \combSort

integer Data, I;
begin \test
Data:= [0, 9, -4, 0, 2, 3, 77, 1];
for I := 1 to 7 do begin Text(0, " ");  IntOut(0, Data( I ) ) end;
CombSort( Data, 1, 7 );
Text(0, ( " -> " ) );
for I := 1 to 7 do begin Text(0, " ");  IntOut(0, Data( I ) ) end;
end
Output:
 9 -4 0 2 3 77 1 ->  -4 0 1 2 3 9 77

zkl

Translation of: D
fcn combSort(list){
len,gap,swaps:=list.len(),len,True;
while(gap>1 or swaps){
gap,swaps=(1).max(gap.toFloat()/1.2473), False;
foreach i in (len - gap){
if(list[i]>list[i + gap]){
list.swap(i,i + gap);
swaps=True;
}
}
}
list
}
combSort(List(28, 44, 46, 24, 19, 2, 17, 11, 25, 4)).println();
combSort("This is a test".toData()).text.println();
Output:
L(2,4,11,17,19,24,25,28,44,46)
Taehiissstt
`