sort

import sort

func main:
    data := [9, 4, 7, 1, 8, 2, 6, 3, 5, 0]
    repeat 13 in round:
        mut v := Vector {} as Vector<int>
        each n in data:
            v.push(n)
        end
        switch round:
            0: sort.QuickSort(v) break end
            1: sort.MergeSort(v) break end
            2: sort.HeapSort(v) break end
            3: sort.InsertionSort(v) break end
            4: sort.BinaryInsertionSort(v) break end
            5: sort.SelectionSort(v) break end
            6: sort.BubbleSort(v) break end
            7: sort.ShellSort(v) break end
            8: sort.CombSort(v) break end
            9: sort.CocktailSort(v) break end
            10: sort.GnomeSort(v) break end
            11: sort.OddEvenSort(v) break end
            12: sort.PancakeSort(v) break end
        end
        print sort.IsSorted(v), ""
        v.free()
    end
    println ""
    mut d := Vector {} as Vector<int>
    defer d.free()
    each n in data:
        d.push(n)
    end
    sort.IntroSort(d)
    println d
end

import sort

func main:
    repeat 3 in round:
        mut v := Vector {} as Vector<int>
        defer v.free()
        each n in [170, 45, 75, 90, 802, 24, 2, 66]:
            v.push(n)
        end
        if round == 0:
            sort.RadixSort(v)
        else round == 1:
            sort.CountingSort(v)
        else:
            sort.BucketSort(v)
        end
        println v
    end
end

import sort

func main:
    mut numbers := Vector {} as Vector<int>
    defer numbers.free()
    each n in [1, 3, 3, 3, 7, 9]:
        numbers.push(n)
    end
    println sort.BinarySearch(numbers, 7), sort.BinarySearch(numbers, 4)
    println sort.LowerBound(numbers, 3), sort.UpperBound(numbers, 3)
end

import sort

struct Student:
    pub name: str = ""
    pub mark: int = 0
end

func main:
    mut class := Vector {} as Vector<Student>
    defer class.free()
    class.push(Student { name = "Sara", mark = 18 })
    class.push(Student { name = "Ali", mark = 15 })
    class.push(Student { name = "Reza", mark = 18 })
    class.push(Student { name = "Maryam", mark = 20 })
    higher := (a: Student, b: Student): ret a.mark > b.mark end
    sort.StableSortBy(class, higher)
    each s in class:
        print s.name, ""
    end
    println ""
    println sort.IsSortedBy(class, higher)
    lower := (a: Student, b: Student): ret a.mark < b.mark end
    ascending := sort.SortedBy(class, lower)
    println ascending.get(0).name
    sort.SortBy(class, lower)
    println class.get(0).name
end

import sort

func main:
    mut numbers := Vector {} as Vector<int>
    defer numbers.free()
    each n in [5, 3, 9, 1, 7]:
        numbers.push(n)
    end
    println sort.IsSorted(numbers)
    ordered := sort.Sorted(numbers)
    println ordered, numbers
    sort.Sort(numbers)
    println numbers, sort.IsSorted(numbers)
    sort.SortDesc(numbers)
    println numbers
    sort.Reverse(numbers)
    println numbers, sort.Min(numbers), sort.Max(numbers)
    sort.Swap(numbers, 0, 4)
    println numbers
end

import sort

func main:
    names := ["Tehran", "Shiraz", "Tabriz"]
    mut population := Vector {} as Vector<f64>
    mut order := Vector {} as Vector<int>
    defer population.free()
    defer order.free()
    population.push(8.7)
    population.push(1.6)
    population.push(1.65)
    repeat 3 in i:
        order.push(i)
    end
    sort.SortIndex(order, population)
    each i in order:
        print names[i], ""
    end
    println ""
    sort.SortIndexDesc(order, population)
    each i in order:
        print names[i], ""
    end
    println ""
end