Sorting arrays

const stringArray = ['a', 'd', 'z', 'b', 'c', 'y']
const stringSortedAsc = stringArray.toSorted((a, b) => (a > b ? 1 : -1))
console.log(stringSortedAsc) // ['a', 'b', 'c', 'd', 'y', 'z']
 
const numberArray = [1, 3, 5, 9, 4, 2, 0]
const numberSortedAsc = numberArray.toSorted((a, b) => a - b)
console.log(numberSortedAsc) // [0, 1, 2, 3, 4, 5, 9]
 
const numberSortedDesc = numberArray.toSorted((a, b) => b - a)
console.log(numberSortedDesc) // [9, 5, 4, 3, 2, 1, 0]

package main
 
import (
	"fmt"
	"slices"
)
 
func main() {
	intList := []int{1, 3, 5, 9, 4, 2, 0}
 
	slices.Sort(intList) // asc
	fmt.Println(intList) // [0 1 2 3 4 5 9]
 
	slices.Reverse(intList) // desc: reverse the slice that's now sorted ascending
	fmt.Println(intList)    // [9 5 4 3 2 1 0]
 
	stringList := []string{"a", "d", "z", "b", "c", "y"}
	slices.Sort(stringList)
	fmt.Println(stringList) // [a b c d y z]
}

fn main() {
    let mut int_list = vec![1, 3, 5, 9, 4, 2, 0];
 
    int_list.sort(); // asc
    println!("{int_list:?}"); // [0, 1, 2, 3, 4, 5, 9]
 
    int_list.reverse(); // desc: reverse the vec that's now sorted ascending
    println!("{int_list:?}"); // [9, 5, 4, 3, 2, 1, 0]
 
    let mut string_list = vec!["a", "d", "z", "b", "c", "y"];
    string_list.sort();
    println!("{string_list:?}"); // ["a", "b", "c", "d", "y", "z"]
}

var intList = [1, 3, 5, 9, 4, 2, 0]
 
intList.sort() // asc, in place
print(intList) // [0, 1, 2, 3, 4, 5, 9]
 
intList.reverse() // desc: reverse the array that's now sorted ascending
print(intList) // [9, 5, 4, 3, 2, 1, 0]
 
var stringList = ["a", "d", "z", "b", "c", "y"]
stringList.sort()
print(stringList) // ["a", "b", "c", "d", "y", "z"]

void main() {
    List<Integer> intList = new ArrayList<>(List.of(1, 3, 5, 9, 4, 2, 0));
 
    Collections.sort(intList); // asc
    IO.println(intList); // [0, 1, 2, 3, 4, 5, 9]
 
    Collections.reverse(intList); // desc: reverse the list that's now sorted ascending
    IO.println(intList); // [9, 5, 4, 3, 2, 1, 0]
 
    List<String> stringList = new ArrayList<>(List.of("a", "d", "z", "b", "c", "y"));
    Collections.sort(stringList);
    IO.println(stringList); // [a, b, c, d, y, z]
}

const collection = [
  { name: 'Li L', age: 8 },
  { name: 'Json C', age: 3 },
  { name: 'Zack W', age: 15 },
  { name: 'Yi M', age: 2 }
]
 
const sortedByAge = collection.toSorted((a, b) => a.age - b.age)
console.log(sortedByAge)
// [{ name: 'Yi M', age: 2 }, { name: 'Json C', age: 3 }, { name: 'Li L', age: 8 }, { name: 'Zack W', age: 15 }]

import "cmp"
 
type Person struct {
	Name string
	Age  int
}
 
collection := []Person{
	{"Li L", 8},
	{"Json C", 3},
	{"Zack W", 15},
	{"Yi M", 2},
}
 
slices.SortFunc(collection, func(a, b Person) int {
	return cmp.Compare(a.Age, b.Age)
})
fmt.Println(collection)
// [{Yi M 2} {Json C 3} {Li L 8} {Zack W 15}]

#[derive(Debug)]
struct Person {
    #[allow(dead_code)] // only read through Debug — derives are ignored by dead-code analysis
    name: String,
    age: u32,
}
 
let mut collection = vec![
    Person { name: "Li L".into(), age: 8 },
    Person { name: "Json C".into(), age: 3 },
    Person { name: "Zack W".into(), age: 15 },
    Person { name: "Yi M".into(), age: 2 },
];
 
collection.sort_by_key(|p| p.age);
println!("{collection:?}");
// [Person { name: "Yi M", age: 2 }, Person { name: "Json C", age: 3 }, Person { name: "Li L", age: 8 }, Person { name: "Zack W", age: 15 }]

struct Person {
    let name: String
    let age: Int
}
 
var collection = [
    Person(name: "Li L", age: 8),
    Person(name: "Json C", age: 3),
    Person(name: "Zack W", age: 15),
    Person(name: "Yi M", age: 2),
]
 
collection.sort { $0.age < $1.age }
print(collection.map { ($0.name, $0.age) })
// [("Yi M", 2), ("Json C", 3), ("Li L", 8), ("Zack W", 15)]

record Person(String name, int age) {}
 
List<Person> collection = new ArrayList<>(List.of(
        new Person("Li L", 8),
        new Person("Json C", 3),
        new Person("Zack W", 15),
        new Person("Yi M", 2)
));
 
collection.sort(Comparator.comparingInt(Person::age));
IO.println(collection);
// [Person[name=Yi M, age=2], Person[name=Json C, age=3], Person[name=Li L, age=8], Person[name=Zack W, age=15]]