Something went wrong. Try again.
a fast, general-purpose, persistent array structure for Gleam.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149import gleam/intimport gleam/listimport gleeunit/shouldimport ivimport test_utils
pub fn move_zeros_test() { let cases = [ #(iv.from_list([1, 2, 0, 4, 3, 0, 5, 0]), [1, 2, 4, 3, 5, 0, 0, 0]), #(iv.from_list([10, 20, 30]), [10, 20, 30]), #(iv.from_list([0, 0]), [0, 0]), ]
use #(input, expected) <- list.each(cases) let actual = move_zeros(input, 0, 0) test_utils.equal_elements(actual:, expected:)}
fn move_zeros(array, i, zeros) { case iv.get(array, i) { Ok(0) -> { let assert Ok(array) = iv.delete(array, i) move_zeros(array, i + 1, zeros + 1) } Ok(_) -> move_zeros(array, i + 1, zeros) Error(Nil) -> iv.concat(array, iv.repeat(0, times: zeros)) }}
pub fn reverse_consecutive_subarrays_test() { let cases = [ #(iv.from_list([1, 2, 3, 4, 5, 6, 7, 8, 9]), 3, [3, 2, 1, 6, 5, 4, 9, 8, 7]), #(iv.from_list([1, 2, 3, 4, 5, 6, 7, 8]), 5, [5, 4, 3, 2, 1, 8, 7, 6]), #(iv.from_list([1, 2, 3, 4, 5, 6]), 1, [1, 2, 3, 4, 5, 6]), #(iv.from_list([1, 2, 3, 4, 5, 6, 7, 8]), 10, [8, 7, 6, 5, 4, 3, 2, 1]), ]
use #(input, k, expected) <- list.each(cases)
let actual = reverse_consecutive_subarrays(input, k, 0) test_utils.equal_elements(actual:, expected:)}
fn reverse_consecutive_subarrays(array, k, i) { case i < iv.size(array) { True -> { let #(before, after) = iv.split(array, i) let #(slice, after) = iv.split(after, k) let array = iv.concat_list([before, iv.reverse(slice), after]) reverse_consecutive_subarrays(array, k, i + k) } False -> array }}
pub fn rotate_array_test() { let cases = [ #(iv.from_list([1, 2, 3, 4, 5, 6]), 2, [3, 4, 5, 6, 1, 2]), #(iv.from_list([1, 2, 3]), 4, [2, 3, 1]), ]
use #(input, d, expected) <- list.each(cases) let rotation = d % iv.size(input) let #(before, after) = iv.split(input, rotation) let actual = iv.concat(after, before) test_utils.equal_elements(actual:, expected:)}
pub fn wave_sort_test() { let cases = [ #(iv.from_list([10, 5, 6, 3, 2, 20, 100, 80]), [10, 5, 6, 2, 20, 3, 100, 80]), #(iv.from_list([20, 10, 8, 6, 4, 2]), [20, 8, 10, 4, 6, 2]), ]
use #(input, expected) <- list.each(cases) let actual = wave_sort(input, 0) test_utils.equal_elements(actual:, expected:)}
fn wave_sort(array, i) { case iv.get(array, i) { Ok(curr) -> { let array = case i > 0 { True -> { let assert Ok(prev) = iv.get(array, i - 1) case prev > curr { True -> swap(array, i, i - 1) False -> array } } False -> array }
let array = case i < iv.size(array) - 1 { True -> { let assert Ok(next) = iv.get(array, i + 1) case curr < next { True -> swap(array, i, i + 1) False -> array } } False -> array } wave_sort(array, i + 2) } Error(Nil) -> array }}
pub fn bubble_sort_test() { use size <- test_utils.loop(100) let size = int.random(100 + size) let array = iv.initialise(size, int.random) let sorted = bubble_sort(array, 1, size, False)
iv.size(sorted) |> should.equal(iv.size(array))
iv.to_list(sorted) |> should.equal(iv.to_list(array) |> list.sort(int.compare))}
fn bubble_sort(array, i, n, swapped) { case n > 1 { True -> case iv.get(array, i), iv.get(array, i - 1) { Ok(curr), Ok(prev) if prev > curr -> { swap(array, i, i - 1) |> bubble_sort(i + 1, n, True) } Ok(_), Ok(_) -> bubble_sort(array, i + 1, n, swapped) _, _ if swapped -> bubble_sort(array, 1, n - 1, False) _, _ -> array } False -> array }}
fn swap(array, i, j) { case iv.get(array, i), iv.get(array, j) { Ok(iv), Ok(jv) -> { let assert Ok(array) = iv.set(array, i, jv) let assert Ok(array) = iv.set(array, j, iv) array } _, _ -> array }}