単語を数える — 辞書（連想配列）と、出てきた順

<?php
// 受け取った単語がそれぞれ何回出てきたかを、はじめて出てきた順に出す
$words = array_slice($argv, 1);
if (count($words) === 0) {
    echo "単語がありません\n";
    exit;
}

// 連想配列は入れた順を保つが、"10" のようなキーは整数の 10 に変わる。順番は別の配列 $order に記録する
$counts = [];
$order = []; // はじめて出てきた順
foreach ($words as $w) {
    if (!isset($counts[$w])) {
        $order[] = $w;
        $counts[$w] = 0;
    }
    $counts[$w]++;
}

foreach ($order as $w) {
    echo $w . ": " . $counts[$w] . "\n";
}

# 受け取った単語がそれぞれ何回出てきたかを、はじめて出てきた順に出す
import sys

words = sys.argv[1:]
if not words:
    print("単語がありません")
    sys.exit()

counts = {}
order = []  # はじめて出てきた順
for w in words:
    if w not in counts:
        order.append(w)
        counts[w] = 0
    counts[w] += 1

# Python 3.7 からの dict は入れた順を保つが、ほかの言語でも同じ考え方で書けるように、順番は order から取る
for w in order:
    print(f"{w}: {counts[w]}")

// 受け取った単語がそれぞれ何回出てきたかを、はじめて出てきた順に出す
package main

import (
	"fmt"
	"os"
)

func main() {
	words := os.Args[1:]
	if len(words) == 0 {
		fmt.Println("単語がありません")
		return
	}

	// Go の map は range で回す順番が決まっておらず、動かすたびに変わる。順番は別のスライス order に記録する
	counts := map[string]int{}
	order := []string{} // はじめて出てきた順
	for _, w := range words {
		if _, ok := counts[w]; !ok {
			order = append(order, w)
		}
		counts[w]++
	}

	for _, w := range order {
		fmt.Printf("%s: %d\n", w, counts[w])
	}
}

// 受け取った単語がそれぞれ何回出てきたかを、はじめて出てきた順に出す
const words = process.argv.slice(2);
if (words.length === 0) {
  console.log("単語がありません");
  process.exit();
}

// オブジェクト {} は「2」「10」のような数字に見えるキーを小さい順で先に並べるので、入れた順を保つ Map を使う
const counts = new Map();
const order = []; // はじめて出てきた順
for (const w of words) {
  if (!counts.has(w)) {
    order.push(w);
    counts.set(w, 0);
  }
  counts.set(w, counts.get(w) + 1);
}

for (const w of order) {
  console.log(`${w}: ${counts.get(w)}`);
}

// 受け取った単語がそれぞれ何回出てきたかを、はじめて出てきた順に出す
import java.util.LinkedHashMap;
import java.util.Map;

public class WordCount {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("単語がありません");
            return;
        }
        // HashMap は取り出す順番が決まっていない。LinkedHashMap は入れた順に取り出せる
        Map<String, Integer> counts = new LinkedHashMap<>();
        for (String w : args) {
            counts.put(w, counts.getOrDefault(w, 0) + 1);
        }
        for (Map.Entry<String, Integer> e : counts.entrySet()) {
            System.out.println(e.getKey() + ": " + e.getValue());
        }
    }
}

// 受け取った単語がそれぞれ何回出てきたかを、はじめて出てきた順に出す
if (args.Length == 0)
{
    Console.WriteLine("単語がありません");
    return;
}
var counts = new Dictionary<string, int>();
// Dictionary を回したときの順番は決まりになっていないので、はじめて出てきた順を別のリストに記録する
var order = new List<string>();
foreach (string w in args)
{
    if (!counts.ContainsKey(w))
    {
        counts[w] = 0;
        order.Add(w);
    }
    counts[w]++;
}
foreach (string w in order)
{
    Console.WriteLine($"{w}: {counts[w]}");
}

// 受け取った単語がそれぞれ何回出てきたかを、はじめて出てきた順に出す
use std::collections::HashMap;

fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    if args.is_empty() {
        println!("単語がありません");
        return;
    }
    let mut counts: HashMap<String, i32> = HashMap::new();
    // HashMap を回す順番は決まっておらず、動かすたびに変わるので、はじめて出てきた順を別の Vec に記録する
    let mut order: Vec<String> = Vec::new();
    for w in &args {
        if !counts.contains_key(w) {
            order.push(w.clone());
        }
        *counts.entry(w.clone()).or_insert(0) += 1;
    }
    for w in &order {
        println!("{}: {}", w, counts[w]);
    }
}

# 受け取った単語がそれぞれ何回出てきたかを、はじめて出てきた順に出す
words = ARGV
if words.empty?
  puts "単語がありません"
  exit
end

counts = Hash.new(0) # まだ無いキーを引くと 0 が返る
order = [] # はじめて出てきた順
words.each do |w|
  order << w unless counts.key?(w)
  counts[w] += 1
end

# Ruby の Hash は入れた順を保つが、ほかの言語でも同じ考え方で書けるように、順番は order から取る
order.each do |w|
  puts "#{w}: #{counts[w]}"
end

// 受け取った単語がそれぞれ何回出てきたかを、はじめて出てきた順に出す
fun main(args: Array<String>) {
    if (args.isEmpty()) {
        println("単語がありません")
        return
    }
    // HashMap は取り出す順番が決まっていない。LinkedHashMap は入れた順に取り出せる
    // （mutableMapOf() の中身も LinkedHashMap だが、順番が大事なことを型の名前で示す）
    val counts = LinkedHashMap<String, Int>()
    for (w in args) {
        counts[w] = counts.getOrDefault(w, 0) + 1
    }
    for ((w, n) in counts) {
        println("$w: $n")
    }
}

// 受け取った単語がそれぞれ何回出てきたかを、はじめて出てきた順に出す
let args = CommandLine.arguments.dropFirst()
if args.isEmpty {
    print("単語がありません")
} else {
    var counts: [String: Int] = [:]
    // Dictionary を回す順番は決まっておらず、動かすたびに変わるので、はじめて出てきた順を別の配列に記録する
    var order: [String] = []
    for w in args {
        if counts[w] == nil {
            order.append(w)
        }
        counts[w, default: 0] += 1
    }
    for w in order {
        print("\(w): \(counts[w]!)")
    }
}