Data update

Task/Sorting-algorithms-Quicksort/11l/sorting-algorithms-quicksort.11l

@@ -1,4 +1,4 @@
-F _quicksort(&array, start, stop) -> N
+F _quicksort(&array, start, stop) -> Void
    I stop - start > 0
       V pivot = array[start]
       V left = start

Task/Sorting-algorithms-Quicksort/ANSI-BASIC/sorting-algorithms-quicksort.basic

@@ -0,0 +1,51 @@
+100 REM Sorting algorithms/Quicksort
+110 DECLARE EXTERNAL SUB QuickSort
+120 DIM Arr(0 TO 19)
+130 LET A = LBOUND(Arr)
+140 LET B = UBOUND(Arr)
+150 RANDOMIZE
+160 FOR I = A TO B
+170    LET Arr(I) = ROUND(INT(RND * 99))
+180 NEXT I
+190 PRINT "Unsorted:"
+200 FOR I = A TO B
+210    PRINT USING "## ": Arr(I);
+220 NEXT I
+230 PRINT
+240 PRINT "Sorted:"
+250 CALL QuickSort(Arr, A, B)
+260 FOR I = A TO B
+270    PRINT USING "## ": Arr(I);
+280 NEXT I
+290 PRINT
+300 END
+310 REM **
+320 EXTERNAL SUB QuickSort (Arr(), L, R)
+330 LET LIndex = L
+340 LET RIndex = R
+350 IF R > L THEN
+360    LET Pivot = INT((L + R) / 2)
+370    DO WHILE (LIndex <= Pivot) AND (RIndex >= Pivot)
+380       DO WHILE (Arr(LIndex) < Arr(Pivot)) AND (LIndex <= Pivot)
+390          LET LIndex = LIndex + 1
+400       LOOP
+410       DO WHILE (Arr(RIndex) > Arr(Pivot)) AND (RIndex >= Pivot)
+420          LET RIndex = RIndex - 1
+430       LOOP
+440       LET Temp = Arr(LIndex)
+450       LET Arr(LIndex) = Arr(RIndex)
+460       LET Arr(RIndex) = Temp
+470       LET LIndex = LIndex + 1
+480       LET RIndex = RIndex - 1
+490       IF (LIndex - 1) = Pivot THEN
+500          LET RIndex = RIndex + 1
+510          LET Pivot = RIndex
+520       ELSEIF (RIndex + 1) = Pivot THEN
+530          LET LIndex = LIndex - 1
+540          LET Pivot = LIndex
+550       END IF
+560    LOOP
+570    CALL QuickSort (Arr, L, Pivot - 1)
+580    CALL QuickSort (Arr, Pivot + 1, R)
+590 END IF
+600 END SUB

Task/Sorting-algorithms-Quicksort/EasyLang/sorting-algorithms-quicksort.easy

@@ -1,24 +1,17 @@
 proc qsort left right . d[] .
-   while left < right
-      # partition
-      piv = d[left]
-      mid = left
-      for i = left + 1 to right
-         if d[i] < piv
-            mid += 1
-            swap d[i] d[mid]
-         .
-      .
-      swap d[left] d[mid]
-      #
-      if mid < (right + left) / 2
-         qsort left mid - 1 d[]
-         left = mid + 1
-      else
-         qsort mid + 1 right d[]
-         right = mid - 1
+   if left >= right
+      return
+   .
+   mid = left
+   for i = left + 1 to right
+      if d[i] < d[left]
+         mid += 1
+         swap d[i] d[mid]
       .
    .
+   swap d[left] d[mid]
+   qsort left mid - 1 d[]
+   qsort mid + 1 right d[]
 .
 proc sort . d[] .
    qsort 1 len d[] d[]

Task/Sorting-algorithms-Quicksort/PascalABC.NET/sorting-algorithms-quicksort.pas

@@ -0,0 +1,41 @@
+function Partition(a: array of integer; l,r: integer): integer;
+begin
+  var i := l - 1;
+  var j := r + 1;
+  var x := a[l];
+  while True do
+  begin
+    repeat
+      i += 1;
+    until a[i]>=x;
+    repeat
+      j -= 1;
+    until a[j]<=x;
+    if i<j then
+      Swap(a[i],a[j])
+    else
+    begin
+      Result := j;
+      exit;
+    end;
+  end;
+end;
+
+procedure QuickSort(a: array of integer; l,r: integer);
+begin
+  if l>=r then exit;
+  var j := Partition(a,l,r);
+  QuickSort(a,l,j);
+  QuickSort(a,j+1,r);
+end;
+
+const n = 20;
+
+begin
+  var a := ArrRandom(n);
+  Println('Before: ');
+  Println(a);
+  QuickSort(a,0,a.Length-1);
+  Println('After sorting: ');
+  Println(a);
+end.

Task/Sorting-algorithms-Quicksort/Python/sorting-algorithms-quicksort-8.py

@@ -0,0 +1,9 @@
+def quicksort(unsorted_list):
+   if len(unsorted_list) == 0:
+       return []
+   pivot = unsorted_list[0]
+   less = list(filter(lambda x: x <  pivot, unsorted_list))
+   same = list(filter(lambda x: x == pivot, unsorted_list))
+   more = list(filter(lambda x: x >  pivot, unsorted_list))
+
+   return quicksort(less) + same + quicksort(more)

Task/Sorting-algorithms-Quicksort/XBasic/sorting-algorithms-quicksort.basic

@@ -0,0 +1,75 @@
+' Sorting algorithms/Quicksort
+PROGRAM "quicksort"
+VERSION "1.0"
+
+IMPORT "xst"
+
+DECLARE FUNCTION Entry ()
+DECLARE FUNCTION QuickSort (@arr%[], l%%, r%%)
+' Pseudo-random number generator
+' Based on the rand, srand functions from Kernighan & Ritchie's book
+' 'The C Programming Language'
+DECLARE FUNCTION Rand()
+DECLARE FUNCTION SRand(seed%%)
+
+FUNCTION Entry ()
+  DIM arr%[19]
+  a%% = 0
+  b%% = UBOUND(arr%[])
+  XstGetSystemTime (@msec)
+  SRand(INT(msec) MOD 32768)
+  FOR i%% = a%% TO b%%
+    arr%[i%%] = INT(Rand() / 32768.0 * 99.0)
+  NEXT i%%
+  PRINT "Unsorted:"
+  FOR i%% = a%% TO b%%
+    PRINT FORMAT$("## ", arr%[i%%]);
+  NEXT i%%
+  PRINT
+  PRINT "Sorted:"
+  QuickSort(@arr%[], a%%, b%%)
+  FOR i%% = a%% TO b%%
+    PRINT FORMAT$("## ", arr%[i%%]);
+  NEXT i%%
+  PRINT
+END FUNCTION
+
+FUNCTION QuickSort (@arr%[], l%%, r%%)
+  leftIndex%% = l%%
+  rightIndex%% = r%%
+  IF r%% > l%% THEN
+    pivot%% = (l%% + r%%) \ 2
+    DO WHILE (leftIndex%% <= pivot%%) AND (rightIndex%% >= pivot%%)
+      DO WHILE (arr%[leftIndex%%] < arr%[pivot%%]) AND (leftIndex%% <= pivot%%)
+        INC leftIndex%%
+      LOOP
+      DO WHILE (arr%[rightIndex%%] > arr%[pivot%%]) AND (rightIndex%% >= pivot%%)
+        DEC rightIndex%%
+      LOOP
+      SWAP arr%[leftIndex%%], arr%[rightIndex%%]
+      INC leftIndex%%
+      DEC rightIndex%%
+      SELECT CASE TRUE
+        CASE leftIndex%% - 1 = pivot%%:
+          INC rightIndex%%
+          pivot%% = rightIndex%%
+        CASE rightIndex%% + 1 = pivot%%:
+          DEC leftIndex%%
+          pivot%% = leftIndex%%
+      END SELECT
+    LOOP
+    QuickSort (@arr%[], l%%, pivot%% - 1)
+    QuickSort (@arr%[], pivot%% + 1, r%%)
+  END IF
+END FUNCTION
+
+' Return pseudo-random integer on 0..32767
+FUNCTION Rand()
+  #next&& = #next&& * 1103515245 + 12345
+END FUNCTION USHORT(#next&& / 65536) MOD 32768
+
+' Set seed for Rand()
+FUNCTION SRand(seed%%)
+  #next&& = seed%%
+END FUNCTION
+END PROGRAM