Add tasks for all the new languages
This commit is contained in:
Tina Müller
parent
9dc3c2bb62
commit
bba7bfd280
13208 changed files with 134745 additions and 0 deletions
|
|
@ -0,0 +1,9 @@
|
|||
def quick_sort(a : Array(Int32)) : Array(Int32)
|
||||
return a if a.size <= 1
|
||||
p = a[0]
|
||||
lt, rt = a[1 .. -1].partition { |x| x < p }
|
||||
return quick_sort(lt) + [p] + quick_sort(rt)
|
||||
end
|
||||
|
||||
a = [7, 6, 5, 9, 8, 4, 3, 1, 2, 0]
|
||||
puts quick_sort(a) # => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
PROGRAM QUICKSORT_DEMO
|
||||
|
||||
DIM ARRAY[21]
|
||||
|
||||
!$DYNAMIC
|
||||
DIM QSTACK[0]
|
||||
|
||||
!$INCLUDE="PC.LIB"
|
||||
|
||||
PROCEDURE QSORT(ARRAY[],START,NUM)
|
||||
FIRST=START ! initialize work variables
|
||||
LAST=START+NUM-1
|
||||
LOOP
|
||||
REPEAT
|
||||
TEMP=ARRAY[(LAST+FIRST) DIV 2] ! seek midpoint
|
||||
I=FIRST
|
||||
J=LAST
|
||||
REPEAT ! reverse both < and > below to sort descending
|
||||
WHILE ARRAY[I]<TEMP DO
|
||||
I=I+1
|
||||
END WHILE
|
||||
WHILE ARRAY[J]>TEMP DO
|
||||
J=J-1
|
||||
END WHILE
|
||||
EXIT IF I>J
|
||||
IF I<J THEN SWAP(ARRAY[I],ARRAY[J]) END IF
|
||||
I=I+1
|
||||
J=J-1
|
||||
UNTIL NOT(I<=J)
|
||||
IF I<LAST THEN ! Done
|
||||
QSTACK[SP]=I ! Push I
|
||||
QSTACK[SP+1]=LAST ! Push Last
|
||||
SP=SP+2
|
||||
END IF
|
||||
LAST=J
|
||||
UNTIL NOT(FIRST<LAST)
|
||||
|
||||
EXIT IF SP=0
|
||||
SP=SP-2
|
||||
FIRST=QSTACK[SP] ! Pop First
|
||||
LAST=QSTACK[SP+1] ! Pop Last
|
||||
END LOOP
|
||||
END PROCEDURE
|
||||
|
||||
BEGIN
|
||||
RANDOMIZE(TIMER) ! generate a new series each run
|
||||
|
||||
! create an array
|
||||
FOR X=1 TO 21 DO ! fill with random numbers
|
||||
ARRAY[X]=RND(1)*500 ! between 0 and 500
|
||||
END FOR
|
||||
PRIMO=6 ! sort starting here
|
||||
NUM=10 ! sort this many elements
|
||||
CLS
|
||||
PRINT("Before Sorting:";TAB(31);"After sorting:")
|
||||
PRINT("===============";TAB(31);"==============")
|
||||
FOR X=1 TO 21 DO ! show them before sorting
|
||||
IF X>=PRIMO AND X<=PRIMO+NUM-1 THEN
|
||||
PRINT("==>";)
|
||||
END IF
|
||||
PRINT(TAB(5);)
|
||||
WRITE("###.##";ARRAY[X])
|
||||
END FOR
|
||||
|
||||
! create a stack
|
||||
!$DIM QSTACK[INT(NUM/5)+10]
|
||||
QSORT(ARRAY[],PRIMO,NUM)
|
||||
!$ERASE QSTACK
|
||||
|
||||
LOCATE(2,1)
|
||||
FOR X=1 TO 21 DO ! print them after sorting
|
||||
LOCATE(2+X,30)
|
||||
IF X>=PRIMO AND X<=PRIMO+NUM-1 THEN
|
||||
PRINT("==>";) ! point to sorted items
|
||||
END IF
|
||||
LOCATE(2+X,35)
|
||||
WRITE("###.##";ARRAY[X])
|
||||
END FOR
|
||||
END PROGRAM
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
(lib 'list) ;; list-partition
|
||||
|
||||
(define compare 0) ;; counter
|
||||
|
||||
(define (quicksort L compare-predicate: proc aux: (part null))
|
||||
(if (<= (length L) 1) L
|
||||
(begin
|
||||
;; counting the number of comparisons
|
||||
(set! compare (+ compare (length (rest L))))
|
||||
;; pivot = first element of list
|
||||
(set! part (list-partition (rest L) proc (first L)))
|
||||
(append (quicksort (first part) proc )
|
||||
(list (first L))
|
||||
(quicksort (second part) proc)))))
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
(shuffle (iota 15))
|
||||
→ (10 0 14 11 13 9 2 5 4 8 1 7 12 3 6)
|
||||
(quicksort (shuffle (iota 15)) <)
|
||||
→ (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)
|
||||
|
||||
;; random list of numbers in [0 .. n[
|
||||
;; count number of comparisons
|
||||
(define (qtest (n 10000))
|
||||
(set! compare 0)
|
||||
(quicksort (shuffle (iota n)) >)
|
||||
(writeln 'n n 'compare# compare ))
|
||||
|
||||
(qtest 1000)
|
||||
n 1000 compare# 12764
|
||||
(qtest 10000)
|
||||
n 10000 compare# 277868
|
||||
(qtest 100000)
|
||||
n 100000 compare# 6198601
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#import <Foundation/Foundation.h>
|
||||
|
||||
void quicksortInPlace(MutableArray array, const long first, const long last)
|
||||
if first >= last
|
||||
return
|
||||
Value pivot = array[(first + last) / 2]
|
||||
left := first
|
||||
right := last
|
||||
while left <= right
|
||||
while array[left] < pivot
|
||||
left++
|
||||
while array[right] > pivot
|
||||
right--
|
||||
if left <= right
|
||||
array.exchangeObjectAtIndex: left++, withObjectAtIndex: right--
|
||||
|
||||
quicksortInPlace(array, first, right)
|
||||
quicksortInPlace(array, left, last)
|
||||
|
||||
Array quicksort(Array unsorted)
|
||||
a := []
|
||||
a.addObjectsFromArray: unsorted
|
||||
quicksortInPlace(a, 0, a.count - 1)
|
||||
return a
|
||||
|
||||
|
||||
int main(int argc, const char * argv[])
|
||||
autoreleasepool
|
||||
a := [1, 3, 5, 7, 9, 8, 6, 4, 2]
|
||||
Log( 'Unsorted: %@', a)
|
||||
Log( 'Sorted: %@', quicksort(a) )
|
||||
b := ['Emil', 'Peg', 'Helen', 'Juergen', 'David', 'Rick', 'Barb', 'Mike', 'Tom']
|
||||
Log( 'Unsorted: %@', b)
|
||||
Log( 'Sorted: %@', quicksort(b) )
|
||||
|
||||
return 0
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#import <Foundation/Foundation.h>
|
||||
|
||||
implementation Array (Quicksort)
|
||||
|
||||
plus: Array array, return Array =
|
||||
self.arrayByAddingObjectsFromArray: array
|
||||
|
||||
filter: BOOL (^)(id) predicate, return Array
|
||||
array := []
|
||||
for id item in self
|
||||
if predicate(item)
|
||||
array.addObject: item
|
||||
return array.copy
|
||||
|
||||
quicksort, return Array = self
|
||||
if self.count > 1
|
||||
id x = self[self.count / 2]
|
||||
lesser := self.filter: (id y | return y < x)
|
||||
greater := self.filter: (id y | return y > x)
|
||||
return lesser.quicksort + [x] + greater.quicksort
|
||||
|
||||
end
|
||||
|
||||
int main()
|
||||
autoreleasepool
|
||||
a := [1, 3, 5, 7, 9, 8, 6, 4, 2]
|
||||
Log( 'Unsorted: %@', a)
|
||||
Log( 'Sorted: %@', a.quicksort )
|
||||
b := ['Emil', 'Peg', 'Helen', 'Juergen', 'David', 'Rick', 'Barb', 'Mike', 'Tom']
|
||||
Log( 'Unsorted: %@', b)
|
||||
Log( 'Sorted: %@', b.quicksort )
|
||||
|
||||
return 0
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
' version 23-10-2016
|
||||
' compile with: fbc -s console
|
||||
|
||||
' sort from lower bound to the highter bound
|
||||
' array's can have subscript range from -2147483648 to +2147483647
|
||||
|
||||
Sub quicksort(qs() As Long, l As Long, r As Long)
|
||||
|
||||
Dim As ULong size = r - l +1
|
||||
If size < 2 Then Exit Sub
|
||||
|
||||
Dim As Long i = l, j = r
|
||||
Dim As Long pivot = qs(l + size \ 2)
|
||||
|
||||
Do
|
||||
While qs(i) < pivot
|
||||
i += 1
|
||||
Wend
|
||||
While pivot < qs(j)
|
||||
j -= 1
|
||||
Wend
|
||||
If i <= j Then
|
||||
Swap qs(i), qs(j)
|
||||
i += 1
|
||||
j -= 1
|
||||
End If
|
||||
Loop Until i > j
|
||||
|
||||
If l < j Then quicksort(qs(), l, j)
|
||||
If i < r Then quicksort(qs(), i, r)
|
||||
|
||||
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 "unsorted ";
|
||||
For i = a To b : Print Using "####"; array(i); : Next : Print
|
||||
|
||||
quicksort(array(), LBound(array), UBound(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
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
def
|
||||
qsort( [] ) = []
|
||||
qsort( p:xs ) = qsort( xs.filter((< p)) ) + [p] + qsort( xs.filter((>= p)) )
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
def
|
||||
qsort( [] ) = []
|
||||
qsort( x:xs ) =
|
||||
val (ys, zs) = xs.partition( (< x) )
|
||||
qsort( ys ) + (x : qsort( zs ))
|
||||
|
||||
println( qsort([4, 2, 1, 3, 0, 2]) )
|
||||
println( qsort(["Juan", "Daniel", "Miguel", "William", "Liam", "Ethan", "Jacob"]) )
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
include "std.lobster"
|
||||
|
||||
def quicksort(xs, lt):
|
||||
if xs.length <= 1:
|
||||
xs
|
||||
else:
|
||||
pivot := xs[0]
|
||||
tail := xs.slice(1, -1)
|
||||
f1 := filter tail: lt(_, pivot)
|
||||
f2 := filter tail: !lt(_, pivot)
|
||||
append(append(quicksort(f1, lt), [ pivot ]),
|
||||
quicksort(f2, lt))
|
||||
|
||||
sorted := [ 3, 9, 5, 4, 1, 3, 9, 5, 4, 1 ].quicksort(): _a < _b
|
||||
print sorted
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
fun quicksort( arr, cmp )
|
||||
{
|
||||
if( arr.length() < 2 )
|
||||
return arr;
|
||||
|
||||
if( !cmp )
|
||||
cmp = ( a, b ) -> a - b;
|
||||
|
||||
var a = [ ], b = [ ];
|
||||
var pivot = arr[0];
|
||||
var len = arr.length();
|
||||
|
||||
for( var i = 1; i < len; ++i )
|
||||
{
|
||||
var item = arr[i];
|
||||
|
||||
if( cmp( item, pivot ) < cmp( pivot, item ) )
|
||||
a.add( item );
|
||||
else
|
||||
b.add( item );
|
||||
}
|
||||
|
||||
a = quicksort( a, cmp );
|
||||
b = quicksort( b, cmp );
|
||||
|
||||
a.add( pivot );
|
||||
|
||||
foreach( var item in b )
|
||||
a.add( item );
|
||||
|
||||
return a;
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
var array = [ 532, 16, 153, 3, 63.60, 925, 0.214 ];
|
||||
var sorted = quicksort( array );
|
||||
|
||||
printLn( sorted );
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
proc quickSort[T](a: var openarray[T], inl = 0, inr = -1) =
|
||||
var r = if inr >= 0: inr else: a.high
|
||||
var l = inl
|
||||
let n = r - l + 1
|
||||
if n < 2: return
|
||||
let p = a[l + 3 * n div 4]
|
||||
while l <= r:
|
||||
if a[l] < p:
|
||||
inc l
|
||||
continue
|
||||
if a[r] > p:
|
||||
dec r
|
||||
continue
|
||||
if l <= r:
|
||||
swap a[l], a[r]
|
||||
inc l
|
||||
dec r
|
||||
quickSort(a, inl, r)
|
||||
quickSort(a, l, inr)
|
||||
|
||||
var a = @[4, 65, 2, -31, 0, 99, 2, 83, 782]
|
||||
quickSort a
|
||||
echo a
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
let
|
||||
qs = l:
|
||||
if l == [] then []
|
||||
else
|
||||
with builtins;
|
||||
let x = head l;
|
||||
xs = tail l;
|
||||
low = filter (a: a < x) xs;
|
||||
high = filter (a: a >= x) xs;
|
||||
in qs low ++ [x] ++ qs high;
|
||||
in
|
||||
qs [4 65 2 (-31) 0 99 83 782]
|
||||
|
|
@ -0,0 +1 @@
|
|||
[ 5, 8, 2, 3, 4, 1 ] sort
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
function quick_sort(sequence x)
|
||||
--
|
||||
-- put x into ascending order using recursive quick sort
|
||||
--
|
||||
integer n, last, mid
|
||||
object xi, midval
|
||||
|
||||
n = length(x)
|
||||
if n<2 then
|
||||
return x -- already sorted (trivial case)
|
||||
end if
|
||||
|
||||
mid = floor((n+1)/2)
|
||||
midval = x[mid]
|
||||
x[mid] = x[1]
|
||||
|
||||
last = 1
|
||||
for i=2 to n do
|
||||
xi = x[i]
|
||||
if xi<midval then
|
||||
last += 1
|
||||
x[i] = x[last]
|
||||
x[last] = xi
|
||||
end if
|
||||
end for
|
||||
|
||||
return quick_sort(x[2..last]) & {midval} & quick_sort(x[last+1..n])
|
||||
end function
|
||||
|
||||
?quick_sort({5,"oranges","and",3,"apples"})
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
func quicksort (a) {
|
||||
a.len < 2 && return(a);
|
||||
var p = a.pop_rand; # to avoid the worst cases
|
||||
__FUNC__(a.grep{ .< p}) + [p] + __FUNC__(a.grep{ .>= p});
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
func quicksort<T where T : Comparable>(inout elements: [T], range: Range<Int>) {
|
||||
if (range.endIndex - range.startIndex > 1) {
|
||||
let pivotIndex = partition(&elements, range)
|
||||
quicksort(&elements, range.startIndex ..< pivotIndex)
|
||||
quicksort(&elements, pivotIndex+1 ..< range.endIndex)
|
||||
}
|
||||
}
|
||||
|
||||
func quicksort<T where T : Comparable>(inout elements: [T]) {
|
||||
quicksort(&elements, indices(elements))
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
def (qsort (pivot ... ns))
|
||||
(+ (qsort+keep (fn(_) (_ < pivot)) ns)
|
||||
list.pivot
|
||||
(qsort+keep (fn(_) (_ > pivot)) ns))
|
||||
|
||||
def (qsort x) :case x=nil
|
||||
nil
|
||||
|
|
@ -0,0 +1 @@
|
|||
[1, 1.1, [1,2], true, false, null, {"a":1}, null] | sort
|
||||
|
|
@ -0,0 +1 @@
|
|||
[null,null,false,true,1,1.1,[1,2],{"a":1}]
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
def quicksort:
|
||||
if length < 2 then . # it is already sorted
|
||||
else .[0] as $pivot
|
||||
| reduce .[] as $x
|
||||
# state: [less, equal, greater]
|
||||
( [ [], [], [] ]; # three empty arrays:
|
||||
if $x < $pivot then .[0] += [$x] # add x to less
|
||||
elif $x == $pivot then .[1] += [$x] # add x to equal
|
||||
else .[2] += [$x] # add x to greater
|
||||
end
|
||||
)
|
||||
| (.[0] | quicksort ) + .[1] + (.[2] | quicksort )
|
||||
end ;
|
||||
Loading…
Add table
Add a link
Reference in a new issue