Person = Struct.new(:name, :age)
people = [
  Person.new("Alice", 30),
  Person.new("Bob", 25),
  Person.new("Charlie", 35)
]

# Find the oldest person
oldest = people.max_by(&:age)
oldest.name # => "Charlie"

# Find the youngest person
youngest = people.min_by(&:age)
youngest.name # => "Bob"

first_in_the_phonebook = people.min_by(&:name)
first_in_the_phonebook.name # => "Alice"

last_in_the_phonebook = people.max_by(&:name)
last_in_the_phonebook.name # => "Charlie"

# Just like with min and max we can also get more than one result
oldest_two = people.max_by(2, &:age)
oldest_two.map(&:name) # => ["Charlie", "Alice"]
      

const people = [
  { name: "Alice", age: 30 },
  { name: "Bob", age: 25 },
  { name: "Charlie", age: 35 }
];

const oldest = people.reduce(
  (oldest, person) => person.age > oldest.age ? person : oldest
);
oldest.name; // "Charlie"

const youngest = people.reduce(
  (youngest, person) => person.age < youngest.age ? person : youngest
);
youngest.name; // "Bob"

const firstInThePhonebook = people.reduce(
  (first, person) => person.name < first.name ? person : first
);
firstInThePhonebook.name; // "Alice"

const lastInThePhonebook = people.reduce(
  (last, person) => person.name > last.name ? person : last
);
lastInThePhonebook.name; // "Charlie"

// To get more than one result, we can sort the array and take
// the top N elements:
const oldestTwo = [...people].sort(
  (a, b) => b.age - a.age
).slice(0, 2);
oldestTwo.map(person => person.name); // ["Charlie", "Alice"]
      

youngest, oldest = people.minmax_by(&:age)
youngest.name # => "Bob"
oldest.name   # => "Charlie"
      

const { min: youngest, max: oldest } = people.reduce(
  (result, person) => {
    if (person.age < result.min.age) result.min = person;
    if (person.age > result.max.age) result.max = person;
    return result;
  },
  { min: people[0], max: people[0] }
);
youngest.name; // "Bob"
oldest.name;   // "Charlie"