Arrays

Extras

Use array helpers to search, sort, combine, and inspect values.

Reference

Edit the source, then Run. Checks start after your first Run. Ctrl/⌘ + Enter runs; Tab indents. Preview services use sample data and never contact a real service.

Sourceupstream/arrays/extras.vibe
type RunResult = {
  accumulate_with_shovel: array<int>,
  chunk_values: array<array<int>>,
  concat_values: array<int>,
  count_large: int,
  count_value: int,
  double_sum: int,
  first_match: int?,
  first_match_index: int?,
  first_two: array<int>,
  group_by_stable_status: array<array<string | array<{ name: string, status: string }>>>,
  group_by_status: hash<string, array<{ name: string, status: string }>>,
  include_value: bool,
  intersect_values: array<int>,
  last_three: array<int>,
  numeric_sum: int,
  partition_even: array<array<int>>,
  predicate_snapshot: { all_positive: bool, any_large: bool, none_negative: bool },
  push_and_pop: { array: array<int>, popped: int? },
  shovel_value: array<int>,
  sort_desc: array<int>,
  sort_values: array<int>,
  sort_words_by_length: array<string>,
  subtract_values: array<int>,
  tally_statuses: hash<string, int>,
  uniq_values: array<int>,
  window_values: array<array<int>>
}

def first_two(values: array<int>) -> array<int>
  values.first(2)
end

def last_three(values: array<int>) -> array<int>
  values.last(3)
end

def numeric_sum(values: array<int>) -> int
  values.sum
end

def double_sum(values: array<int>) -> int
  values.reduce(0) { |total, value|
    total + (value * 2)
  }
end

def push_and_pop(values: array<int>, extra: int) -> { array: array<int>, popped: int? }
  values.push(extra)
  popped = values.pop
  {
    array: values,
    popped: popped
  }
end

def uniq_values(values: array<int>) -> array<int>
  values.uniq
end

def concat_values(first: array<int>, second: array<int>) -> array<int>
  first + second
end

def subtract_values(first: array<int>, second: array<int>) -> array<int>
  first - second
end

def shovel_value(values: array<int>, extra: int) -> array<int>
  values << extra
end

def accumulate_with_shovel(values: array<int>) -> array<int>
  result: array<int> = []
  for value in values
    result << value
  end
  result
end

def intersect_values(first: array<int>, second: array<int>) -> array<int>
  first & second
end

def include_value(values: array<int>, value: int) -> bool
  values.include?(value)
end

def first_match(values: array<int>, threshold: int) -> int?
  values.find { |value|
    value > threshold
  }
end

def first_match_index(values: array<int>, threshold: int) -> int?
  values.index { |value|
    value > threshold
  }
end

def count_value(values: array<int>, value: int) -> int
  values.count(value)
end

def count_large(values: array<int>, threshold: int) -> int
  values.count { |value|
    value > threshold
  }
end

def predicate_snapshot(
  values: array<int>
) -> { all_positive: bool, any_large: bool, none_negative: bool }
  any_large = values.any? { |value|
    value > 10
  }
  all_positive = values.all? { |value|
    value > 0
  }
  none_negative = values.none? { |value|
    value < 0
  }

  {
    any_large: any_large,
    all_positive: all_positive,
    none_negative: none_negative
  }
end

def sort_values(values: array<int>) -> array<int>
  values.sort
end

def sort_desc(values: array<int>) -> array<int>
  values.sort { |a, b|
    b - a
  }
end

def sort_words_by_length(words: array<string>) -> array<string>
  words.sort_by { |word|
    word.length
  }
end

def partition_even(values: array<int>) -> array<array<int>>
  values.partition { |value|
    value % 2 == 0
  }
end

def group_by_status(
  players: array<{ name: string, status: string }>
) -> hash<string, array<{ name: string, status: string }>>
  players.group_by { |player|
    player["status"]
  }
end

def tally_statuses(statuses: array<string>) -> hash<string, int>
  statuses.tally
end

def chunk_values(values: array<int>, size: int) -> array<array<int>>
  values.chunk(size)
end

def window_values(values: array<int>, size: int) -> array<array<int>>
  values.window(size)
end

def group_by_stable_status(
  players: array<{ name: string, status: string }>
) -> array<array<string | array<{ name: string, status: string }>>>
  players.group_by_stable { |player|
    player["status"]
  }
end

def run -> RunResult
  values = [2, 4, 4, 7, 12, 15]
  words = ["pear", "kiwi", "banana", "fig"]
  players = [
    { name: "Ada", status: "active" },
    { name: "Lin", status: "inactive" },
    { name: "Sol", status: "active" }
  ]

  {
    first_two: first_two(values),
    last_three: last_three(values),
    numeric_sum: numeric_sum(values),
    double_sum: double_sum(values),
    push_and_pop: push_and_pop(values.dup, 20),
    uniq_values: uniq_values(values),
    concat_values: concat_values([1, 2], [3, 4]),
    subtract_values: subtract_values(values, [4, 15]),
    shovel_value: shovel_value([1, 2], 3),
    accumulate_with_shovel: accumulate_with_shovel(values),
    intersect_values: intersect_values([1, 2, 3, 4], [2, 4, 6]),
    include_value: include_value(values, 12),
    first_match: first_match(values, 10),
    first_match_index: first_match_index(values, 10),
    count_value: count_value(values, 4),
    count_large: count_large(values, 5),
    predicate_snapshot: predicate_snapshot(values),
    sort_values: sort_values([5, 2, 9, 1]),
    sort_desc: sort_desc([5, 2, 9, 1]),
    sort_words_by_length: sort_words_by_length(words),
    partition_even: partition_even(values),
    group_by_status: group_by_status(players),
    tally_statuses: tally_statuses(["active", "active", "inactive"]),
    chunk_values: chunk_values(values, 2),
    window_values: window_values(values, 3),
    group_by_stable_status: group_by_stable_status(players)
  }
end

Output

Click Run example to see the result.

Code checks

Run once to load the checker. Your code stays in this browser.