June 2018 Update
This commit is contained in:
Ingy döt Net
parent
ba8067c3b7
commit
22f33d4004
5278 changed files with 84726 additions and 14379 deletions
|
|
@ -1,10 +1,10 @@
|
|||
#include <stdio.h>
|
||||
|
||||
void bubble_sort (int *a, int n) {
|
||||
int i, t, s = 1;
|
||||
int i, t, j = n, s = 1;
|
||||
while (s) {
|
||||
s = 0;
|
||||
for (i = 1; i < n; i++) {
|
||||
for (i = 1; i < j; i++) {
|
||||
if (a[i] < a[i - 1]) {
|
||||
t = a[i];
|
||||
a[i] = a[i - 1];
|
||||
|
|
@ -12,6 +12,7 @@ void bubble_sort (int *a, int n) {
|
|||
s = 1;
|
||||
}
|
||||
}
|
||||
j--;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,145 @@
|
|||
IDENTIFICATION DIVISION.
|
||||
PROGRAM-ID. BUBBLESORT.
|
||||
AUTHOR. DAVE STRATFORD.
|
||||
DATE-WRITTEN. MARCH 2010.
|
||||
INSTALLATION. HEXAGON SYSTEMS LIMITED.
|
||||
|
||||
ENVIRONMENT DIVISION.
|
||||
CONFIGURATION SECTION.
|
||||
SOURCE-COMPUTER. ICL VME.
|
||||
OBJECT-COMPUTER. ICL VME.
|
||||
|
||||
INPUT-OUTPUT SECTION.
|
||||
FILE-CONTROL.
|
||||
SELECT FA-INPUT-FILE ASSIGN FL01.
|
||||
SELECT FB-OUTPUT-FILE ASSIGN FL02.
|
||||
|
||||
DATA DIVISION.
|
||||
FILE SECTION.
|
||||
|
||||
FD FA-INPUT-FILE.
|
||||
01 FA-INPUT-REC.
|
||||
03 FA-DATA PIC S9(6).
|
||||
|
||||
FD FB-OUTPUT-FILE.
|
||||
01 FB-OUTPUT-REC PIC S9(6).
|
||||
|
||||
WORKING-STORAGE SECTION.
|
||||
01 WA-IDENTITY.
|
||||
03 WA-PROGNAME PIC X(10) VALUE "BUBBLESORT".
|
||||
03 WA-VERSION PIC X(6) VALUE "000001".
|
||||
|
||||
01 WB-TABLE.
|
||||
03 WB-ENTRY PIC 9(8) COMP SYNC OCCURS 100000
|
||||
INDEXED BY WB-IX-1.
|
||||
|
||||
01 WC-VARS.
|
||||
03 WC-SIZE PIC S9(8) COMP SYNC.
|
||||
03 WC-TEMP PIC S9(8) COMP SYNC.
|
||||
03 WC-END PIC S9(8) COMP SYNC.
|
||||
03 WC-LAST-CHANGE PIC S9(8) COMP SYNC.
|
||||
|
||||
01 WF-CONDITION-FLAGS.
|
||||
03 WF-EOF-FLAG PIC X.
|
||||
88 END-OF-FILE VALUE "Y".
|
||||
03 WF-EMPTY-FILE-FLAG PIC X.
|
||||
88 EMPTY-FILE VALUE "Y".
|
||||
|
||||
PROCEDURE DIVISION.
|
||||
A-MAIN SECTION.
|
||||
A-000.
|
||||
PERFORM B-INITIALISE.
|
||||
IF NOT EMPTY-FILE
|
||||
PERFORM C-SORT.
|
||||
PERFORM D-FINISH.
|
||||
|
||||
A-999.
|
||||
STOP RUN.
|
||||
|
||||
B-INITIALISE SECTION.
|
||||
B-000.
|
||||
DISPLAY "*** " WA-PROGNAME " VERSION "
|
||||
WA-VERSION " STARTING ***".
|
||||
|
||||
MOVE ALL "N" TO WF-CONDITION-FLAGS.
|
||||
OPEN INPUT FA-INPUT-FILE.
|
||||
SET WB-IX-1 TO 0.
|
||||
|
||||
READ FA-INPUT-FILE AT END MOVE "Y" TO WF-EOF-FLAG
|
||||
WF-EMPTY-FILE-FLAG.
|
||||
|
||||
PERFORM BA-READ-INPUT UNTIL END-OF-FILE.
|
||||
|
||||
CLOSE FA-INPUT-FILE.
|
||||
|
||||
SET WC-SIZE TO WB-IX-1.
|
||||
|
||||
B-999.
|
||||
EXIT.
|
||||
|
||||
BA-READ-INPUT SECTION.
|
||||
BA-000.
|
||||
SET WB-IX-1 UP BY 1.
|
||||
MOVE FA-DATA TO WB-ENTRY(WB-IX-1).
|
||||
|
||||
READ FA-INPUT-FILE AT END MOVE "Y" TO WF-EOF-FLAG.
|
||||
|
||||
BA-999.
|
||||
EXIT.
|
||||
|
||||
C-SORT SECTION.
|
||||
C-000.
|
||||
DISPLAY "SORT STARTING".
|
||||
|
||||
MOVE WC-SIZE TO WC-END.
|
||||
PERFORM E-BUBBLE UNTIL WC-END = 1.
|
||||
|
||||
DISPLAY "SORT FINISHED".
|
||||
|
||||
C-999.
|
||||
EXIT.
|
||||
|
||||
D-FINISH SECTION.
|
||||
D-000.
|
||||
OPEN OUTPUT FB-OUTPUT-FILE.
|
||||
SET WB-IX-1 TO 1.
|
||||
|
||||
PERFORM DA-WRITE-OUTPUT UNTIL WB-IX-1 > WC-SIZE.
|
||||
|
||||
CLOSE FB-OUTPUT-FILE.
|
||||
|
||||
DISPLAY "*** " WA-PROGNAME " FINISHED ***".
|
||||
|
||||
D-999.
|
||||
EXIT.
|
||||
|
||||
DA-WRITE-OUTPUT SECTION.
|
||||
DA-000.
|
||||
WRITE FB-OUTPUT-REC FROM WB-ENTRY(WB-IX-1).
|
||||
SET WB-IX-1 UP BY 1.
|
||||
|
||||
DA-999.
|
||||
EXIT.
|
||||
|
||||
E-BUBBLE SECTION.
|
||||
E-000.
|
||||
MOVE 1 TO WC-LAST-CHANGE.
|
||||
|
||||
PERFORM F-PASS VARYING WB-IX-1 FROM 1 BY 1
|
||||
UNTIL WB-IX-1 = WC-END.
|
||||
|
||||
MOVE WC-LAST-CHANGE TO WC-END.
|
||||
|
||||
E-999.
|
||||
EXIT.
|
||||
|
||||
F-PASS SECTION.
|
||||
F-000.
|
||||
IF WB-ENTRY(WB-IX-1) > WB-ENTRY(WB-IX-1 + 1)
|
||||
SET WC-LAST-CHANGE TO WB-IX-1
|
||||
MOVE WB-ENTRY(WB-IX-1) TO WC-TEMP
|
||||
MOVE WB-ENTRY(WB-IX-1 + 1) TO WB-ENTRY(WB-IX-1)
|
||||
MOVE WC-TEMP TO WB-ENTRY(WB-IX-1 + 1).
|
||||
|
||||
F-999.
|
||||
EXIT.
|
||||
|
|
@ -1,22 +1,24 @@
|
|||
import std.stdio, std.algorithm;
|
||||
import std.stdio, std.algorithm : swap;
|
||||
|
||||
void bubbleSort(T)(T[] data) pure nothrow {
|
||||
auto itemCount = data.length;
|
||||
bool hasChanged = false;
|
||||
|
||||
do {
|
||||
hasChanged = false;
|
||||
itemCount--;
|
||||
foreach (immutable i; 0 .. itemCount)
|
||||
T[] bubbleSort(T)(T[] data) pure nothrow
|
||||
{
|
||||
foreach_reverse (n; 0 .. data.length)
|
||||
{
|
||||
bool swapped;
|
||||
foreach (i; 0 .. n)
|
||||
if (data[i] > data[i + 1]) {
|
||||
swap(data[i], data[i + 1]);
|
||||
hasChanged = true;
|
||||
swapped = true;
|
||||
}
|
||||
} while (hasChanged);
|
||||
if (!swapped)
|
||||
break;
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
void main() {
|
||||
|
||||
void main()
|
||||
{
|
||||
auto array = [28, 44, 46, 24, 19, 2, 17, 11, 25, 4];
|
||||
array.bubbleSort();
|
||||
writeln(array);
|
||||
writeln(array.bubbleSort());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,17 +1,11 @@
|
|||
defmodule Sort do
|
||||
def bubble_sort(list) when length(list)<=1, do: list
|
||||
def bubble_sort(list) when is_list(list), do: bubble_sort(list, [])
|
||||
def bsort(list) when is_list(list) do
|
||||
t = bsort_move(list)
|
||||
|
||||
def bubble_sort([x], sorted), do: [x | sorted]
|
||||
def bubble_sort(list, sorted) do
|
||||
{rest, [max]} = Enum.split(bubble_move(list), -1)
|
||||
bubble_sort(rest, [max | sorted])
|
||||
if t == list do t else bsort(t) end
|
||||
end
|
||||
|
||||
def bubble_move([x]), do: [x]
|
||||
def bubble_move([x, y | t]) when x > y, do: [y | bubble_move([x | t])]
|
||||
def bubble_move([x, y | t]) , do: [x | bubble_move([y | t])]
|
||||
|
||||
def bsort_move([x, y | t]) when x > y, do: [y | bsort_move([x | t])]
|
||||
def bsort_move([x, y | t]), do: [x | bsort_move([y | t])]
|
||||
def bsort_move(list), do: list
|
||||
end
|
||||
|
||||
IO.inspect Sort.bubble_sort([3,2,1,4,5,2])
|
||||
|
|
|
|||
|
|
@ -0,0 +1,32 @@
|
|||
Public Sub Main()
|
||||
Dim byToSort As Byte[] = [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 byCount As Byte
|
||||
Dim bSorting As Boolean
|
||||
|
||||
Print "To sort: -"
|
||||
ShowWorking(byToSort)
|
||||
Print
|
||||
Repeat
|
||||
bSorting = False
|
||||
For byCount = 0 To byToSort.Max - 1
|
||||
If byToSort[byCount] > byToSort[byCount + 1] Then
|
||||
Swap byToSort[byCount], byToSort[byCount + 1]
|
||||
bSorting = True
|
||||
Endif
|
||||
Next
|
||||
If bSorting Then ShowWorking(byToSort)
|
||||
Until bSorting = False
|
||||
End
|
||||
'-----------------------------------------
|
||||
Public Sub ShowWorking(byToSort As Byte[])
|
||||
Dim byCount As Byte
|
||||
|
||||
For byCount = 0 To byToSort.Max
|
||||
Print Str(byToSort[byCount]);
|
||||
If byCount <> byToSort.Max Then Print ",";
|
||||
Next
|
||||
|
||||
Print
|
||||
|
||||
End
|
||||
|
|
@ -1,22 +1,11 @@
|
|||
function bubblesort!{T}(x::AbstractArray{T})
|
||||
|
||||
for i in 2:length(x)
|
||||
for j in 1:length(x)-1
|
||||
if x[j] > x[j+1]
|
||||
tmp = x[j]
|
||||
x[j] = x[j+1]
|
||||
x[j+1] = tmp
|
||||
end
|
||||
function bubblesort!(arr::AbstractVector)
|
||||
for _ in 2:length(arr), j in 1:length(arr)-1
|
||||
if arr[j] > arr[j+1]
|
||||
arr[j], arr[j+1] = arr[j+1], arr[j]
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return x
|
||||
return arr
|
||||
end
|
||||
|
||||
|
||||
a = [rand(-100:100) for i in 1:20]
|
||||
println("Before bubblesort:")
|
||||
println(a)
|
||||
a = bubblesort!(a)
|
||||
println("\nAfter bubblesort:")
|
||||
println(a)
|
||||
v = rand(-10:10, 10)
|
||||
println("# unordered: $v\n -> ordered: ", bubblesort!(v))
|
||||
|
|
|
|||
|
|
@ -0,0 +1,16 @@
|
|||
arr := Array([17,3,72,0,36,2,3,8,40,0]):
|
||||
len := numelems(arr):
|
||||
while(true) do
|
||||
change := false:
|
||||
len--;
|
||||
for i from 1 to len do
|
||||
if (arr[i] > arr[i+1]) then
|
||||
temp := arr[i]:
|
||||
arr[i] := arr[i+1]:
|
||||
arr[i+1] := temp:
|
||||
change := true:
|
||||
end if:
|
||||
end do:
|
||||
if (not change) then break end if:
|
||||
end do:
|
||||
arr;
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
.ig
|
||||
Bubble sort algorithm in Troff
|
||||
==============================
|
||||
|
||||
:For: Rosetta Code
|
||||
:Author: Stephanie Björk (Katt)
|
||||
:Date: December 1, 2017
|
||||
..
|
||||
.ig
|
||||
Array implementation: \(*A
|
||||
---------------------------
|
||||
This is an array implementation that takes advantage of Troff's numerical
|
||||
registers. Registers ``Ax``, where ``x`` is a base-10 Hindu-Arabic numeral and
|
||||
0 < ``x`` < \(if, are used by array \(*A. The array counter which holds the
|
||||
number of items in the array is stored in register ``Ac``. This array
|
||||
implementation is one-indexed (array elements count from 1), though it could be
|
||||
hardcoded again to become zero-indexed depending on what the programmer favours.
|
||||
..
|
||||
.nr Ac 0 1 \" Array counter
|
||||
.
|
||||
.de APUSH
|
||||
.nr A\\n+(Ac \\$1
|
||||
.. \" de APUSH
|
||||
.
|
||||
.de AREADLN
|
||||
.APUSH \\$1
|
||||
.if \\n(.$>1 \{ \
|
||||
. shift
|
||||
. AREADLN \\$*
|
||||
\} \" if \\n(.$>1
|
||||
.. \" de AREADLN
|
||||
.
|
||||
.de ASWAP
|
||||
.nr tmp \\n[A\\$1]
|
||||
.nr A\\$1 \\n[A\\$2]
|
||||
.nr A\\$2 \\n[tmp]
|
||||
.rm tmp
|
||||
.. \" de ASWAP
|
||||
.
|
||||
.de ASORT
|
||||
.nr swapped 1
|
||||
.nr Ad \\n(Ac+1
|
||||
.while \\n[swapped] \{ \
|
||||
. nr swapped 0
|
||||
. nr Ai 1
|
||||
. nr Ad -1
|
||||
. while \\n(Ai<\\n(Ad \{ \
|
||||
. nr Aj \\n(Ai+1
|
||||
. if \\n[A\\n(Ai]>\\n[A\\n(Aj] \{ \
|
||||
. ASWAP \\n(Ai \\n(Aj
|
||||
. nr swapped 1
|
||||
\} \" if \\n[A\\n(Ai]>\\n[A\\n(Aj]
|
||||
. nr Ai +1
|
||||
\} \" while \\n(Ai<\\n(Ac
|
||||
\} \" while \\n[swapped]
|
||||
.. \" de ASORT
|
||||
.
|
||||
.ig
|
||||
Begin Program
|
||||
-------------
|
||||
The program's procedural body. Here, we push all our potentially-unsorted
|
||||
integer tokens sequentially, call a subroutine to sort them, and print all the
|
||||
sorted items.
|
||||
..
|
||||
.AREADLN 12 87 23 77 0 66 45 92 3 0 2 1 9 9 5 4 4 4 \" Our input items to sort.
|
||||
.ASORT \" Sort all items in the array.
|
||||
.
|
||||
.\" Output sorted items
|
||||
.nr Ai 0 1
|
||||
.while \n(Ai<\n(Ac \n[A\n+[Ai]]
|
||||
|
|
@ -7,10 +7,10 @@ call show ' after sort:' /*show the after array ele
|
|||
exit /*stick a fork in it, we're all done. */
|
||||
/*──────────────────────────────────────────────────────────────────────────────────────*/
|
||||
bSort: procedure expose @.; parse arg n; m=n-1 /*N: is the number of @ array elements.*/
|
||||
do m=m for m by -1 until ok; ok=1 /*keep sorting the @ array until done.*/
|
||||
do m=m by -1 until ok; ok=1 /*keep sorting the @ array until done.*/
|
||||
do j=1 for m; k=j+1; if @.j>@.k then parse value @.j @.k 0 with @.k @.j ok
|
||||
end /*j*/ /* [↑] swap 2 elements, flag as ¬done.*/
|
||||
end /*m*/; return
|
||||
/*──────────────────────────────────────────────────────────────────────────────────────*/
|
||||
gen: w=1; do j=1 for N; @.j=random(min(N+N,1e5)); w=max(w,length(@.j)); end; return
|
||||
gen: h=min(N+N,1e5); w=length(h); do j=1 for N; @.j=random(h); end; return
|
||||
show: parse arg $; do k=1 for N; $=$ right(@.k, w); end; say $; return
|
||||
|
|
|
|||
|
|
@ -0,0 +1,27 @@
|
|||
(tc +)
|
||||
|
||||
(define swap
|
||||
{ (vector number) --> number --> number --> (vector number) }
|
||||
A I1 I2 -> (let Z (<-vector A I1)
|
||||
(do (vector-> A I1 (<-vector A I2))
|
||||
(vector-> A I2 Z))))
|
||||
|
||||
(define one-pass
|
||||
{ (vector number) --> number --> boolean --> number --> boolean }
|
||||
A N Swapped N -> (do (if (> (<-vector A (- N 1)) (<-vector A N))
|
||||
(swap A (- N 1) N))
|
||||
Swapped)
|
||||
A N Swapped I -> (if (> (<-vector A (- I 1)) (<-vector A I))
|
||||
(do (swap A (- I 1) I)
|
||||
(one-pass A N true (+ I 1)))
|
||||
(one-pass A N Swapped (+ I 1))))
|
||||
|
||||
(define bubble-h
|
||||
{ boolean --> (vector number) --> number --> (vector number) }
|
||||
true A N -> (bubble-h (one-pass A N false 2) A N)
|
||||
false A N -> A)
|
||||
|
||||
(define bubble-sort
|
||||
{ (vector number) --> (vector number) }
|
||||
A -> (let N (limit A)
|
||||
(bubble-h (one-pass A N false 2) A N)))
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
(datatype some-globals
|
||||
|
||||
__________
|
||||
(value *arr*) : (vector number);)
|
||||
|
||||
(set *arr* (vector 5))
|
||||
(vector-> (value *arr*) 1 5)
|
||||
(vector-> (value *arr*) 2 1)
|
||||
(vector-> (value *arr*) 3 4)
|
||||
(vector-> (value *arr*) 4 2)
|
||||
(vector-> (value *arr*) 5 8)
|
||||
(bubble-sort (value *arr*))
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
(tc +)
|
||||
|
||||
(define bubble-shot
|
||||
{ (vector number) --> (vector number) }
|
||||
(@v A <>) -> (@v A <>)
|
||||
(@v A B R) -> (@v B (bubble-shot (@v A R))) where (> A B)
|
||||
(@v A R) -> (@v A (bubble-shot R)))
|
||||
|
||||
(define bubble-sort
|
||||
{ (vector number) --> (vector number) }
|
||||
X -> (fix (function bubble-shot) X))
|
||||
|
|
@ -0,0 +1 @@
|
|||
(bubble-sort (@v 5 1 4 2 3 <>))
|
||||
Loading…
Add table
Add a link
Reference in a new issue