配列の最大値と最小値を求めるには

nums = [3, 1, 4, 1, 5, 9, 2, 6]
print(max(nums), min(nums))  # -> 9 1
 
words = ["banana", "fig", "apple"]
print(max(words))            # -> fig（文字列は辞書順で比べる）
print(max(words, key=len))   # -> banana（key で比べる基準を指定する）
 
empty = []
print(max(empty, default=None))  # -> None（default が無いと ValueError になる）

const nums = [3, 1, 4, 1, 5, 9, 2, 6];
console.log(Math.max(...nums), Math.min(...nums)); // -> 9 1
 
// 空配列はエラーにならず -Infinity / Infinity が返る
console.log(Math.max(...[]), Math.min(...[])); // -> -Infinity Infinity
 
// 要素数が非常に多いと、スプレッドで展開した引数が多すぎて例外になる
const big = Array.from({ length: 1_000_000 }, (_, i) => i);
try {
  Math.max(...big);
} catch (e) {
  console.log(e.name); // -> RangeError
}
 
// 大きな配列は reduce で 1 つずつ比べる
console.log(big.reduce((a, b) => (a > b ? a : b))); // -> 999999

type Item = { name: string; price: number };
 
const items: Item[] = [
  { name: "pen", price: 120 },
  { name: "note", price: 300 },
  { name: "eraser", price: 80 },
];
 
// 最大の「値」だけなら map してから Math.max に渡す
console.log(Math.max(...items.map((x) => x.price))); // -> 300
 
// 最大の「要素」が欲しいときは reduce で比べる。空配列は undefined を返すようにする
function maxBy<T>(arr: readonly T[], key: (x: T) => number): T | undefined {
  if (arr.length === 0) return undefined; // 初期値なしの reduce は空配列で TypeError になる
  return arr.reduce((a, b) => (key(b) > key(a) ? b : a));
}
 
console.log(maxBy(items, (x) => x.price)?.name); // -> note
console.log(maxBy([] as Item[], (x) => x.price)); // -> undefined

package main
 
import (
	"fmt"
	"slices"
)
 
func main() {
	nums := []int{3, 1, 4, 1, 5, 9, 2, 6}
	fmt.Println(slices.Max(nums), slices.Min(nums)) // -> 9 1
 
	// 空のスライスを渡すと panic するので、長さを先に確かめる
	var empty []int
	if len(empty) == 0 {
		fmt.Println("empty") // -> empty
	} else {
		fmt.Println(slices.Max(empty))
	}
 
	// 値を並べて比べるだけなら組み込みの max / min が使える
	fmt.Println(max(3, 7, 5), min(3, 7, 5)) // -> 7 3
}

fn main() {
    let nums = vec![3, 1, 4, 1, 5, 9, 2, 6];
    // iter() は借用なので、max / min のあとも nums を使える
    println!("{:?} {:?}", nums.iter().max(), nums.iter().min()); // -> Some(9) Some(1)
    println!("{}", nums.len()); // -> 8
 
    let empty: Vec<i32> = Vec::new();
    println!("{:?}", empty.iter().max()); // -> None
 
    // f64 は Ord を実装していないので max() は使えない。fold で比べる
    let temps = [21.5, 18.0, 25.25];
    let hottest = temps.iter().copied().fold(f64::NEG_INFINITY, f64::max);
    println!("{}", hottest); // -> 25.25
}

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(3, 1, 4, 1, 5, 9, 2, 6);
        System.out.println(Collections.max(nums) + " " + Collections.min(nums)); // -> 9 1
 
        // プリミティブの配列は IntStream で求める。空に備えて OptionalInt が返る
        int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
        System.out.println(Arrays.stream(arr).max().getAsInt()); // -> 9
 
        int[] empty = {};
        System.out.println(Arrays.stream(empty).max().orElse(-1)); // -> -1
 
        // 文字列は辞書順で比べるので、数値として比べたいなら Comparator を渡す
        List<String> codes = List.of("10", "9", "100");
        System.out.println(Collections.max(codes)); // -> 9
        System.out.println(Collections.max(codes, Comparator.comparingInt(Integer::parseInt))); // -> 100
    }
}

int[] nums = { 3, 1, 4, 1, 5, 9, 2, 6 };
Console.WriteLine($"{nums.Max()} {nums.Min()}"); // -> 9 1
 
var items = new[] { (Name: "pen", Price: 120), (Name: "note", Price: 300), (Name: "eraser", Price: 80) };
Console.WriteLine(items.Max(x => x.Price));        // -> 300（キーの最大値）
Console.WriteLine(items.MaxBy(x => x.Price).Name); // -> note（最大の要素そのもの）
 
// int の Max() は空だと InvalidOperationException を投げるので、既定値を入れてから求める
int[] empty = { };
Console.WriteLine(empty.DefaultIfEmpty(-1).Max()); // -> -1