順番を保って重複を消す

<?php
// 受け取った文字列から、2回目以降に出たものを消し、初めて出た順に出す
$items = array_slice($argv, 1);

// array_unique は初めて出たものを残し、既定（SORT_STRING）では文字列として比べるので "1" と "01" は別になる。
// in_array($x, $out) を第3引数なしで使うと「==」で比べ、"1" と "01" と "1.0" が同じ数とみなされる
$out = array_unique($items);
foreach ($out as $s) {
    echo ($s === '' ? '（空）' : $s) . "\n";
}
// 消した分の添字が飛ぶので、数は count で数える
echo count($out) . '件（' . (count($items) - count($out)) . "件を消した）\n";

# 受け取った文字列から、2回目以降に出たものを消し、初めて出た順に出す
import sys

items = sys.argv[1:]
# dict は入れた順を覚えている（3.7 から言語の決まり）。set は順を覚えないので、list(set(...)) は並びが変わる
out = list(dict.fromkeys(items))
for s in out:
    print("（空）" if s == "" else s)
print(f"{len(out)}件（{len(items) - len(out)}件を消した）")

// 受け取った文字列から、2回目以降に出たものを消し、初めて出た順に出す
package main

import (
	"fmt"
	"os"
)

func main() {
	items := os.Args[1:]
	// map を range で回す順はわざと毎回ばらばらにしてある。見たかどうかだけ map で覚え、出す順はスライスに残す
	seen := map[string]bool{}
	out := []string{}
	for _, s := range items {
		if !seen[s] {
			seen[s] = true
			out = append(out, s)
		}
	}
	for _, s := range out {
		if s == "" {
			s = "（空）"
		}
		fmt.Println(s)
	}
	fmt.Printf("%d件（%d件を消した）\n", len(out), len(items)-len(out))
}

// 受け取った文字列から、2回目以降に出たものを消し、初めて出た順に出す
const items = process.argv.slice(2);
// Set は入れた順を覚えている。オブジェクトのキーで覚えると "1" "3" のような整数に見えるキーが小さい順に前へ並ぶ
const out = [...new Set(items)];
for (const s of out) {
  console.log(s === "" ? "（空）" : s);
}
console.log(`${out.length}件（${items.length - out.length}件を消した）`);

// 受け取った文字列から、2回目以降に出たものを消し、初めて出た順に出す
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;

public class Unique {
    public static void main(String[] args) {
        // HashSet は並びがハッシュ値で決まる。入れた順を覚えるのは LinkedHashSet。
        // String の equals は char を1つずつ比べるので、「が」1文字と「か」＋濁点は別になる
        Set<String> out = new LinkedHashSet<>(Arrays.asList(args));
        for (String s : out) {
            System.out.println(s.isEmpty() ? "（空）" : s);
        }
        System.out.println(out.size() + "件（" + (args.length - out.size()) + "件を消した）");
    }
}

// 受け取った文字列から、2回目以降に出たものを消し、初めて出た順に出す
// Distinct は初めて出た順に返し、既定では文字の並び（ordinal）で比べる。
// string.Compare(a, b) == 0 で比べると、カルチャの規則で「が」1文字と「か」＋濁点を同じとみなすことがある
var kept = args.Distinct().ToList();
foreach (string s in kept)
{
    Console.WriteLine(s == "" ? "（空）" : s);
}
Console.WriteLine($"{kept.Count}件（{args.Length - kept.Count}件を消した）");

// 受け取った文字列から、2回目以降に出たものを消し、初めて出た順に出す
use std::collections::HashSet;

fn main() {
    let items: Vec<String> = std::env::args().skip(1).collect();
    // dedup は隣り合う重複しか消さないので、sort してから使うと並びが変わる。
    // HashSet の insert は初めて入れたときだけ true を返すので、retain で初めてのものだけ残す
    let mut seen = HashSet::new();
    let mut out = items.clone();
    out.retain(|s| seen.insert(s.clone()));
    for s in &out {
        println!("{}", if s.is_empty() { "（空）" } else { s });
    }
    println!("{}件（{}件を消した）", out.len(), items.len() - out.len());
}

# 受け取った文字列から、2回目以降に出たものを消し、初めて出た順に出す
items = ARGV
# uniq は初めて出た順を保つ。比べるのは文字の並び（バイト）なので、「が」1文字と「か」＋濁点は別になる
out = items.uniq
out.each { |s| puts(s.empty? ? "（空）" : s) }
puts "#{out.size}件（#{items.size - out.size}件を消した）"

// 受け取った文字列から、2回目以降に出たものを消し、初めて出た順に出す
fun main(args: Array<String>) {
    // distinct は初めて出た順を保つ（中は LinkedHashSet）。hashSetOf に入れて出すと並びがハッシュ値の順になる
    val out = args.distinct()
    for (s in out) {
        println(if (s.isEmpty()) "（空）" else s)
    }
    println("${out.size}件（${args.size - out.size}件を消した）")
}

// 受け取った文字列から、2回目以降に出たものを消し、初めて出た順に出す
let items = Array(CommandLine.arguments.dropFirst())
// Swift の String の == と Set<String> は、見た目が同じ（正規化して同じ）なら同じとみなす。
// 「が」1文字と「か」＋濁点を別にするため、UTF-8 のバイトの並びで覚える
var seen = Set<[UInt8]>()
let out = items.filter { seen.insert(Array($0.utf8)).inserted }
for s in out {
    print(s.isEmpty ? "（空）" : s)
}
print("\(out.count)件（\(items.count - out.count)件を消した）")