画面にこう出れば正解
どの言語で書いても、同じ入力なら画面に出る文字は1文字も違わない、というのが正解の決め方です(例は Python で動かしたときのコマンドです)。
基本(部署の昇順、同じなら給与の降順)
input.txt の中身
name,dept,salary 佐藤,営業,500 鈴木,開発,900 高橋,営業,1000 田中,開発,900 伊藤,営業,500
$ python3 multi_sort.py dept:asc:text,salary:desc:num < input.txt
name,dept,salary
高橋,営業,1000
佐藤,営業,500
伊藤,営業,500
鈴木,開発,900
田中,開発,900数として比べる(文字として比べると 1000 が 900 より先になる)
input.txt の中身
name,dept,salary 佐藤,営業,500 鈴木,開発,900 高橋,営業,1000 田中,開発,900 伊藤,営業,500
$ python3 multi_sort.py salary:asc:num < input.txt
name,dept,salary
佐藤,営業,500
伊藤,営業,500
鈴木,開発,900
田中,開発,900
高橋,営業,1000キーの値がどれも同じ20行は、入力の順のまま(安定な並べ替え)
input.txt の中身
name,dept,salary r01,営業,100 r02,営業,100 r03,営業,100 r04,営業,100 r05,営業,100 r06,営業,100 r07,営業,100 r08,営業,100 r09,営業,100 r10,営業,100 r11,営業,100 r12,営業,100 r13,営業,100 r14,営業,100 r15,営業,100 r16,営業,100 r17,営業,100 r18,営業,100 r19,営業,100 r20,営業,100
$ python3 multi_sort.py dept:asc:text < input.txt
name,dept,salary
r01,営業,100
r02,営業,100
r03,営業,100
r04,営業,100
r05,営業,100
r06,営業,100
r07,営業,100
r08,営業,100
r09,営業,100
r10,営業,100
r11,営業,100
r12,営業,100
r13,営業,100
r14,営業,100
r15,営業,100
r16,営業,100
r17,営業,100
r18,営業,100
r19,営業,100
r20,営業,100text の降順
input.txt の中身
name,dept,salary 佐藤,営業,500 鈴木,開発,900 高橋,営業,1000 田中,開発,900 伊藤,営業,500
$ python3 multi_sort.py name:desc:text < input.txt
name,dept,salary
高橋,営業,1000
鈴木,開発,900
田中,開発,900
佐藤,営業,500
伊藤,営業,500text はコードポイント順(UTF-16 の並びとは変わる)
input.txt の中身
id,name 1,🍣 2,¥ 3,私
$ python3 multi_sort.py name:asc:text < input.txt
id,name
3,私
2,¥
1,🍣数として読めない値は後ろ(読めない値同士は入力の順)
input.txt の中身
name,salary a,300 b, c,1e3 d,100 e,100 f, 200 g,-50
$ python3 multi_sort.py salary:asc:num < input.txt
name,salary
g,-50
d,100
a,300
b,
c,1e3
e,100
f, 200降順でも読めない値は後ろ。007 と 7、-0 と 0 は数として同じ
input.txt の中身
name,salary a,7 b,007 c,10 d,-0 e,0 f,x
$ python3 multi_sort.py salary:desc:num < input.txt
name,salary
c,10
a,7
b,007
d,-0
e,0
f,x16桁の数は読めない扱い(15桁までが数)
input.txt の中身
name,salary a,999999999999999 b,1000000000000000 c,100
$ python3 multi_sort.py salary:asc:num < input.txt
name,salary
c,100
a,999999999999999
b,10000000000000003つのキーで並べる
input.txt の中身
name,dept,grade,salary A,開発,2,500 B,開発,1,900 C,営業,1,500 D,開発,1,500 E,営業,1,500
$ python3 multi_sort.py dept:asc:text,grade:asc:num,salary:desc:num < input.txt
name,dept,grade,salary
C,営業,1,500
E,営業,1,500
B,開発,1,900
D,開発,1,500
A,開発,2,500列の数が違う行と空の行が混ざる
input.txt の中身
name,dept,salary 佐藤,営業,500 鈴木,開発,900 高橋,営業,1000 田中,開発,900 伊藤,営業,500 佐藤,営業 田中,開発,900,余分
$ python3 multi_sort.py salary:asc:num < input.txt
name,dept,salary
佐藤,営業,500
伊藤,営業,500
鈴木,開発,900
田中,開発,900
高橋,営業,1000
読めない行 22つ目のキーが見出しに無い
input.txt の中身
name,dept,salary 佐藤,営業,500 鈴木,開発,900 高橋,営業,1000 田中,開発,900 伊藤,営業,500
$ python3 multi_sort.py dept:asc:text,bonus:desc:num < input.txt
NG: 列 bonus がありません向きが asc でも desc でもない
input.txt の中身
name,dept,salary 佐藤,営業,500 鈴木,開発,900 高橋,営業,1000 田中,開発,900 伊藤,営業,500
$ python3 multi_sort.py salary:up:num < input.txt
NG: 並べ方の指定が読めません空の入力
input.txt の中身
(空)
$ python3 multi_sort.py dept:asc:text < input.txt
NG: 列 dept がありません見出しだけ(データの行が無い)
input.txt の中身
name,dept,salary
$ python3 multi_sort.py dept:asc:text < input.txt
name,dept,salary改行が \r\n で、最後に改行が無い
input.txt の中身
name,dept,salary[CR] 佐藤,営業,500[CR] 鈴木,開発,900[CR] 高橋,営業,1000[CR] 田中,開発,900[CR] 伊藤,営業,500
$ python3 multi_sort.py dept:asc:text,salary:desc:num < input.txt
name,dept,salary
高橋,営業,1000
佐藤,営業,500
伊藤,営業,500
鈴木,開発,900
田中,開発,90010言語のプログラム
どれもそのまま保存して動かせます。毎朝、上の正解の例をすべて実際に動かして確かめています。
multi_sort.php8.4.26 で 15 / 15 件の出力が正解と一致
<?php
// 標準入力の CSV を、指定した複数のキーで並べ替えて出す
$spec = $argv[1];
// 「<列>:<向き>:<比べ方>」をカンマで区切った指定を読む。形が違えばここで終わり
$keys = [];
foreach (explode(',', $spec) as $part) {
$bits = explode(':', $part);
if (count($bits) !== 3 || $bits[0] === ''
|| !in_array($bits[1], ['asc', 'desc'], true)
|| !in_array($bits[2], ['text', 'num'], true)) {
echo "NG: 並べ方の指定が読めません\n";
exit;
}
$keys[] = $bits;
}
// \r\n と \n のどちらでも区切り、空の行を落とす。残った最初の行が見出し
$lines = array_values(array_filter(preg_split('/\r?\n/', stream_get_contents(STDIN)), fn($l) => $l !== ''));
$header = $lines === [] ? [] : explode(',', $lines[0]);
$idx = [];
foreach ($keys as [$col, , ]) {
// in_array や array_search は、第3引数を付けないと "0" と "" を同じとみなす
$at = array_search($col, $header, true);
if ($at === false) {
echo "NG: 列 {$col} がありません\n";
exit;
}
$idx[$col] = $at;
}
$rows = [];
$bad = 0;
foreach (array_slice($lines, 1) as $line) {
$fields = explode(',', $line);
if (count($fields) !== count($header)) {
$bad++;
continue;
}
$rows[] = [$line, $fields];
}
// 数として読めるのは「-?[0-9]{1,15}」の形だけ。読めなければ null(向きによらず後ろに置く)
$num = fn(string $s): ?int => preg_match('/^-?[0-9]{1,15}$/', $s) === 1 ? (int) $s : null;
// PHP 8.0 から usort は安定(同じと答えた行の順は変わらない)
usort($rows, function ($a, $b) use ($keys, $idx, $num) {
foreach ($keys as [$col, $dir, $kind]) {
$x = $a[1][$idx[$col]];
$y = $b[1][$idx[$col]];
if ($kind === 'num') {
$nx = $num($x);
$ny = $num($y);
if ($nx === null && $ny === null) {
$c = 0;
} elseif ($nx === null) {
return 1;
} elseif ($ny === null) {
return -1;
} else {
$c = $nx <=> $ny;
}
} else {
// strcmp はバイトで比べる(UTF-8 なのでコードポイント順)。<=> は数字だけの文字列を数として比べるので使わない
$c = strcmp($x, $y) <=> 0;
}
if ($c !== 0) {
return $dir === 'desc' ? -$c : $c;
}
}
return 0;
});
echo $lines[0] . "\n";
foreach ($rows as [$line, ]) {
echo $line . "\n";
}
if ($bad > 0) {
echo "読めない行 {$bad}\n";
}
動かし方(ファイルを保存したフォルダで)
$ php multi_sort.php dept:asc:text,salary:desc:num < input.txt
multi_sort.py3.14.7 で 15 / 15 件の出力が正解と一致
# 標準入力の CSV を、指定した複数のキーで並べ替えて出す
import functools
import re
import sys
spec = sys.argv[1]
# 「<列>:<向き>:<比べ方>」をカンマで区切った指定を読む。形が違えばここで終わり
keys = []
for part in spec.split(","):
bits = part.split(":")
if len(bits) != 3 or bits[0] == "" or bits[1] not in ("asc", "desc") or bits[2] not in ("text", "num"):
print("NG: 並べ方の指定が読めません")
sys.exit()
keys.append(tuple(bits))
# \r を落としてから空の行を捨てる。残った最初の行が見出し
lines = [x for x in (line.rstrip("\r") for line in sys.stdin.read().split("\n")) if x != ""]
header = lines[0].split(",") if lines else []
idx = {}
for col, _, _ in keys:
if col not in header:
print(f"NG: 列 {col} がありません")
sys.exit()
idx[col] = header.index(col)
rows = []
bad = 0
for line in lines[1:]:
fields = line.split(",")
if len(fields) != len(header):
bad += 1
continue
rows.append((line, fields))
NUM = re.compile(r"^-?[0-9]{1,15}$")
# 数として読めるのは「-?[0-9]{1,15}」の形だけ。int() は "1e3" を断るが " 200" や全角の数字を受けるので使わない
def num(s):
return int(s) if NUM.match(s) else None
def compare(a, b):
for col, direction, kind in keys:
x, y = a[1][idx[col]], b[1][idx[col]]
if kind == "num":
nx, ny = num(x), num(y)
if nx is None and ny is None:
c = 0
elif nx is None:
return 1 # 読めない値は向きによらず後ろ
elif ny is None:
return -1
else:
c = (nx > ny) - (nx < ny)
else:
# Python の文字列の比較はコードポイント順(Java・JavaScript・C# は UTF-16 の並び)
c = (x > y) - (x < y)
if c != 0:
return -c if direction == "desc" else c
return 0
# Python の sort は安定(同じと答えた行の順は変わらない)
rows.sort(key=functools.cmp_to_key(compare))
print(lines[0])
for line, _ in rows:
print(line)
if bad:
print(f"読めない行 {bad}")
動かし方(ファイルを保存したフォルダで)
$ python3 multi_sort.py dept:asc:text,salary:desc:num < input.txt
multi_sort.go1.27.2 で 15 / 15 件の出力が正解と一致
// 標準入力の CSV を、指定した複数のキーで並べ替えて出す
package main
import (
"bufio"
"fmt"
"os"
"regexp"
"sort"
"strconv"
"strings"
)
type sortKey struct {
col string
dir string
kind string
}
type row struct {
line string
fields []string
}
var numRe = regexp.MustCompile(`^-?[0-9]{1,15}$`)
// 数として読めるのは「-?[0-9]{1,15}」の形だけ。ParseInt は "+5" や前後の空白も受けるので、形を先に確かめる
func num(s string) (int64, bool) {
if !numRe.MatchString(s) {
return 0, false
}
n, err := strconv.ParseInt(s, 10, 64)
return n, err == nil
}
func main() {
// 「<列>:<向き>:<比べ方>」をカンマで区切った指定を読む。形が違えばここで終わり
var keys []sortKey
for _, part := range strings.Split(os.Args[1], ",") {
bits := strings.Split(part, ":")
if len(bits) != 3 || bits[0] == "" ||
(bits[1] != "asc" && bits[1] != "desc") ||
(bits[2] != "text" && bits[2] != "num") {
fmt.Println("NG: 並べ方の指定が読めません")
return
}
keys = append(keys, sortKey{bits[0], bits[1], bits[2]})
}
// bufio.Scanner は行の終わりの \n と、その手前の \r を取って返す
var lines []string
sc := bufio.NewScanner(os.Stdin)
for sc.Scan() {
if sc.Text() != "" {
lines = append(lines, sc.Text())
}
}
if err := sc.Err(); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
var header []string
if len(lines) > 0 {
header = strings.Split(lines[0], ",")
}
idx := map[string]int{}
for _, k := range keys {
at := -1
for i, h := range header {
if h == k.col {
at = i
break
}
}
if at == -1 {
fmt.Printf("NG: 列 %s がありません\n", k.col)
return
}
idx[k.col] = at
}
var rows []row
bad := 0
for _, line := range lines[1:] {
fields := strings.Split(line, ",")
if len(fields) != len(header) {
bad++
continue
}
rows = append(rows, row{line, fields})
}
// sort.Slice は安定ではない(同じと答えた行の順が入れ替わる)。SliceStable を使う
sort.SliceStable(rows, func(i, j int) bool {
for _, k := range keys {
x, y := rows[i].fields[idx[k.col]], rows[j].fields[idx[k.col]]
c := 0
if k.kind == "num" {
nx, okx := num(x)
ny, oky := num(y)
switch {
case !okx && !oky:
c = 0
case !okx:
return false // 読めない値は向きによらず後ろ
case !oky:
return true
case nx < ny:
c = -1
case nx > ny:
c = 1
}
} else {
// Go の string の比較はバイトの並び(UTF-8 なのでコードポイントの小さい順)
if x < y {
c = -1
} else if x > y {
c = 1
}
}
if c != 0 {
if k.dir == "desc" {
return c > 0
}
return c < 0
}
}
return false
})
fmt.Println(lines[0])
for _, r := range rows {
fmt.Println(r.line)
}
if bad > 0 {
fmt.Printf("読めない行 %d\n", bad)
}
}
動かし方(ファイルを保存したフォルダで)
$ go run multi_sort.go dept:asc:text,salary:desc:num < input.txt
multi_sort.js24.15.0 で 15 / 15 件の出力が正解と一致
// 標準入力の CSV を、指定した複数のキーで並べ替えて出す
const spec = process.argv[2];
// 「<列>:<向き>:<比べ方>」をカンマで区切った指定を読む。形が違えばここで終わり
const keys = [];
for (const part of spec.split(",")) {
const bits = part.split(":");
if (bits.length !== 3 || bits[0] === "" || !["asc", "desc"].includes(bits[1]) || !["text", "num"].includes(bits[2])) {
console.log("NG: 並べ方の指定が読めません");
process.exit(0);
}
keys.push(bits);
}
// \r\n と \n のどちらでも区切り、空の行を落とす。残った最初の行が見出し
const lines = require("fs").readFileSync(0, "utf8").split(/\r?\n/).filter((l) => l !== "");
const header = lines.length > 0 ? lines[0].split(",") : [];
const idx = {};
for (const [col] of keys) {
const at = header.indexOf(col);
if (at === -1) {
console.log(`NG: 列 ${col} がありません`);
process.exit(0);
}
idx[col] = at;
}
const rows = [];
let bad = 0;
for (const line of lines.slice(1)) {
const fields = line.split(",");
if (fields.length !== header.length) {
bad++;
continue;
}
rows.push([line, fields]);
}
// 数として読めるのは「-?[0-9]{1,15}」の形だけ。Number() は " 200" や "1e3" を受け、"" を 0 にするので使わない
const num = (s) => (/^-?[0-9]{1,15}$/.test(s) ? Number(s) : null);
// 文字列の < は UTF-16 の並びで比べるので、UTF-8 のバイトで比べ直す(コードポイント順になる)
const cmpText = (a, b) => Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
// Array#sort は ES2019 から安定(同じと答えた行の順は変わらない)
rows.sort((a, b) => {
for (const [col, dir, kind] of keys) {
const x = a[1][idx[col]];
const y = b[1][idx[col]];
let c;
if (kind === "num") {
const nx = num(x);
const ny = num(y);
if (nx === null && ny === null) c = 0;
else if (nx === null) return 1; // 読めない値は向きによらず後ろ
else if (ny === null) return -1;
else c = Math.sign(nx - ny);
} else {
c = cmpText(x, y);
}
if (c !== 0) return dir === "desc" ? -c : c;
}
return 0;
});
console.log(lines[0]);
for (const [line] of rows) console.log(line);
if (bad > 0) console.log(`読めない行 ${bad}`);
動かし方(ファイルを保存したフォルダで)
$ node multi_sort.js dept:asc:text,salary:desc:num < input.txt
MultiSort.java21.0.12 で 15 / 15 件の出力が正解と一致
// 標準入力の CSV を、指定した複数のキーで並べ替えて出す
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
public class MultiSort {
static final Pattern NUM = Pattern.compile("-?[0-9]{1,15}");
// 数として読めるのは「-?[0-9]{1,15}」の形だけ。読めなければ null(向きによらず後ろに置く)
static Long num(String s) {
return NUM.matcher(s).matches() ? Long.valueOf(s) : null;
}
public static void main(String[] args) throws IOException {
// 「<列>:<向き>:<比べ方>」をカンマで区切った指定を読む。形が違えばここで終わり
List<String[]> keys = new ArrayList<>();
// split は第2引数を付けないと、末尾の空の欄を捨てる。欄の数を数えるので -1 を付ける
for (String part : args[0].split(",", -1)) {
String[] bits = part.split(":", -1);
if (bits.length != 3 || bits[0].isEmpty()
|| !(bits[1].equals("asc") || bits[1].equals("desc"))
|| !(bits[2].equals("text") || bits[2].equals("num"))) {
System.out.println("NG: 並べ方の指定が読めません");
return;
}
keys.add(bits);
}
// readLine は \n でも \r\n でも行を区切り、行の終わりの記号を取って返す
List<String> lines = new ArrayList<>();
BufferedReader in = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
String line;
while ((line = in.readLine()) != null) {
if (!line.isEmpty()) {
lines.add(line);
}
}
String[] header = lines.isEmpty() ? new String[0] : lines.get(0).split(",", -1);
Map<String, Integer> idx = new HashMap<>();
for (String[] k : keys) {
int at = Arrays.asList(header).indexOf(k[0]);
if (at < 0) {
System.out.println("NG: 列 " + k[0] + " がありません");
return;
}
idx.put(k[0], at);
}
List<String[]> rows = new ArrayList<>(); // [0] が元の行、[1] からが欄
int bad = 0;
for (String l : lines.subList(1, lines.size())) {
String[] fields = l.split(",", -1);
if (fields.length != header.length) {
bad++;
continue;
}
rows.add(fields);
}
// List.sort は安定(TimSort。同じと答えた行の順は変わらない)
rows.sort((a, b) -> {
for (String[] k : keys) {
String x = a[idx.get(k[0])];
String y = b[idx.get(k[0])];
int c;
if (k[2].equals("num")) {
Long nx = num(x);
Long ny = num(y);
if (nx == null && ny == null) {
c = 0;
} else if (nx == null) {
return 1; // 読めない値は向きによらず後ろ
} else if (ny == null) {
return -1;
} else {
c = nx.compareTo(ny);
}
} else {
// String.compareTo は UTF-16 の並びで比べるので、🍣(サロゲートペア)が ¥ より先に来てしまう。
// UTF-8 のバイトで比べるとコードポイント順になる。byte は符号付きなので compareUnsigned を使う
c = Arrays.compareUnsigned(x.getBytes(StandardCharsets.UTF_8), y.getBytes(StandardCharsets.UTF_8));
}
if (c != 0) {
return k[1].equals("desc") ? -c : c;
}
}
return 0;
});
System.out.println(lines.get(0));
for (String[] fields : rows) {
System.out.println(String.join(",", fields));
}
if (bad > 0) {
System.out.println("読めない行 " + bad);
}
}
}
動かし方(ファイルを保存したフォルダで)
$ java MultiSort.java dept:asc:text,salary:desc:num < input.txt
multi_sort.cs10.0.402 で 15 / 15 件の出力が正解と一致
// 標準入力の CSV を、指定した複数のキーで並べ替えて出す
using System.Text;
using System.Text.RegularExpressions;
// 「<列>:<向き>:<比べ方>」をカンマで区切った指定を読む。形が違えばここで終わり
var keys = new List<string[]>();
foreach (string part in args[0].Split(','))
{
string[] bits = part.Split(':');
if (bits.Length != 3 || bits[0] == ""
|| (bits[1] != "asc" && bits[1] != "desc")
|| (bits[2] != "text" && bits[2] != "num"))
{
Console.WriteLine("NG: 並べ方の指定が読めません");
return;
}
keys.Add(bits);
}
// Console.ReadLine は \n でも \r\n でも行を区切り、行の終わりの記号を取って返す
var lines = new List<string>();
string? line;
while ((line = Console.ReadLine()) != null)
{
if (line != "")
{
lines.Add(line);
}
}
string[] header = lines.Count > 0 ? lines[0].Split(',') : [];
var idx = new Dictionary<string, int>();
foreach (string[] k in keys)
{
int at = Array.IndexOf(header, k[0]);
if (at < 0)
{
Console.WriteLine($"NG: 列 {k[0]} がありません");
return;
}
idx[k[0]] = at;
}
var rows = new List<(string Line, string[] Fields)>();
int bad = 0;
foreach (string l in lines.Skip(1))
{
string[] fields = l.Split(',');
if (fields.Length != header.Length)
{
bad++;
continue;
}
rows.Add((l, fields));
}
// 数として読めるのは「-?[0-9]{1,15}」の形だけ。long.TryParse は "+5" や前後の空白も受けるので、形を先に確かめる
long? Num(string s) => Regex.IsMatch(s, "^-?[0-9]{1,15}$") ? long.Parse(s) : null;
int Compare((string Line, string[] Fields) a, (string Line, string[] Fields) b)
{
foreach (string[] k in keys)
{
string x = a.Fields[idx[k[0]]];
string y = b.Fields[idx[k[0]]];
int c;
if (k[2] == "num")
{
long? nx = Num(x);
long? ny = Num(y);
if (nx is null && ny is null)
{
c = 0;
}
else if (nx is null)
{
return 1; // 読めない値は向きによらず後ろ
}
else if (ny is null)
{
return -1;
}
else
{
c = nx.Value.CompareTo(ny.Value);
}
}
else
{
// 文字列の CompareTo や OrderBy は国の設定に従う(a が A より先になる)。Ordinal にしても UTF-16 の
// 並びなので、🍣(サロゲートペア)が ¥ より先に来る。UTF-8 のバイトで比べるとコードポイント順になる
c = Encoding.UTF8.GetBytes(x).AsSpan().SequenceCompareTo(Encoding.UTF8.GetBytes(y));
}
if (c != 0)
{
return k[1] == "desc" ? -c : c;
}
}
return 0;
}
// List.Sort は安定ではない(同じと答えた行の順が入れ替わる)。LINQ の OrderBy は安定
var sorted = rows.OrderBy(r => r, Comparer<(string Line, string[] Fields)>.Create(Compare));
Console.WriteLine(lines[0]);
foreach (var r in sorted)
{
Console.WriteLine(r.Line);
}
if (bad > 0)
{
Console.WriteLine($"読めない行 {bad}");
}
動かし方(ファイルを保存したフォルダで)
$ dotnet run multi_sort.cs -- dept:asc:text,salary:desc:num < input.txt
multi_sort.rs1.99.0 で 15 / 15 件の出力が正解と一致
// 標準入力の CSV を、指定した複数のキーで並べ替えて出す
use std::cmp::Ordering;
use std::io::BufRead;
// 数として読めるのは「-?[0-9]{1,15}」の形だけ(標準に正規表現が無いので文字で確かめる)。
// parse だけに任せると "+5" も読めてしまう
fn num(s: &str) -> Option<i64> {
let body = s.strip_prefix('-').unwrap_or(s);
if body.is_empty() || body.len() > 15 || !body.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
s.parse::<i64>().ok()
}
fn main() {
// 「<列>:<向き>:<比べ方>」をカンマで区切った指定を読む。形が違えばここで終わり
let spec = std::env::args().nth(1).unwrap();
let mut keys: Vec<(String, String, String)> = Vec::new();
for part in spec.split(',') {
let bits: Vec<&str> = part.split(':').collect();
if bits.len() != 3
|| bits[0].is_empty()
|| !matches!(bits[1], "asc" | "desc")
|| !matches!(bits[2], "text" | "num")
{
println!("NG: 並べ方の指定が読めません");
return;
}
keys.push((bits[0].to_string(), bits[1].to_string(), bits[2].to_string()));
}
// lines() は \n でも \r\n でも行を区切り、行の終わりの記号を取って返す
let lines: Vec<String> = std::io::stdin()
.lock()
.lines()
.map(|l| l.unwrap())
.filter(|l| !l.is_empty())
.collect();
let header: Vec<&str> = match lines.first() {
Some(l) => l.split(',').collect(),
None => Vec::new(),
};
let mut idx: Vec<usize> = Vec::new();
for (col, _, _) in &keys {
match header.iter().position(|h| *h == col.as_str()) {
Some(at) => idx.push(at),
None => {
println!("NG: 列 {} がありません", col);
return;
}
}
}
let mut rows: Vec<(&String, Vec<&str>)> = Vec::new();
let mut bad = 0;
for line in &lines[1..] {
let fields: Vec<&str> = line.split(',').collect();
if fields.len() != header.len() {
bad += 1;
continue;
}
rows.push((line, fields));
}
// sort_by は安定(同じと答えた行の順は変わらない)。sort_unstable_by は安定ではない
rows.sort_by(|a, b| {
for (i, (_, dir, kind)) in keys.iter().enumerate() {
let (x, y) = (a.1[idx[i]], b.1[idx[i]]);
let c = if kind == "num" {
match (num(x), num(y)) {
(None, None) => Ordering::Equal,
(None, Some(_)) => return Ordering::Greater, // 読めない値は向きによらず後ろ
(Some(_), None) => return Ordering::Less,
(Some(nx), Some(ny)) => nx.cmp(&ny),
}
} else {
// str の比較はバイトの並び(UTF-8 なのでコードポイントの小さい順)
x.cmp(y)
};
if c != Ordering::Equal {
return if dir == "desc" { c.reverse() } else { c };
}
}
Ordering::Equal
});
println!("{}", lines[0]);
for (line, _) in &rows {
println!("{}", line);
}
if bad > 0 {
println!("読めない行 {}", bad);
}
}
動かし方(ファイルを保存したフォルダで)
$ rustc multi_sort.rs && ./multi_sort dept:asc:text,salary:desc:num < input.txt
multi_sort.rb4.0.7 で 15 / 15 件の出力が正解と一致
# 標準入力の CSV を、指定した複数のキーで並べ替えて出す
NUM = /\A-?[0-9]{1,15}\z/
# 「<列>:<向き>:<比べ方>」をカンマで区切った指定を読む。形が違えばここで終わり
parts = ARGV[0].to_s.split(",", -1)
keys = parts.map do |part|
bits = part.split(":", -1)
bits.length == 3 && !bits[0].empty? && %w[asc desc].include?(bits[1]) && %w[text num].include?(bits[2]) ? bits : nil
end
if parts.empty? || keys.any?(&:nil?)
puts "NG: 並べ方の指定が読めません"
exit
end
# 文字コードを UTF-8 と決めて読む。chomp は行の終わりの \n も \r\n も取る
lines = $stdin.read.force_encoding("UTF-8").each_line.map(&:chomp).reject(&:empty?)
# split は第2引数を付けないと、末尾の空の欄を捨てる("a,b," が2個になる)。列の数を数えるので -1 を付ける
header = lines.empty? ? [] : lines[0].split(",", -1)
idx = {}
keys.each do |col, _, _|
at = header.index(col)
if at.nil?
puts "NG: 列 #{col} がありません"
exit
end
idx[col] = at
end
rows = []
bad = 0
lines.drop(1).each do |line|
fields = line.split(",", -1)
if fields.length != header.length
bad += 1
next
end
rows << [line, fields]
end
# 数として読めるのは「-?[0-9]{1,15}」の形だけ。to_i は "x" を 0 に、" 200" を 200 にしてしまうので使わない
num = ->(s) { s.match?(NUM) ? s.to_i : nil }
compare = lambda do |a, b|
keys.each do |col, dir, kind|
x = a[1][idx[col]]
y = b[1][idx[col]]
if kind == "num"
nx = num.call(x)
ny = num.call(y)
c = if nx.nil? && ny.nil?
0
elsif nx.nil?
return 1 # 読めない値は向きによらず後ろ
elsif ny.nil?
return -1
else
nx <=> ny
end
else
# String の <=> はバイトで比べる(UTF-8 なのでコードポイント順)
c = x <=> y
end
return dir == "desc" ? -c : c unless c.zero?
end
0
end
# Array#sort と sort_by は安定ではない。何番目に出てきたかを最後の決め手に足す
sorted = rows.each_with_index.sort { |a, b| compare.call(a[0], b[0]).nonzero? || (a[1] <=> b[1]) }
puts lines[0]
sorted.each { |(line, _), _| puts line }
puts "読めない行 #{bad}" if bad > 0
動かし方(ファイルを保存したフォルダで)
$ ruby multi_sort.rb dept:asc:text,salary:desc:num < input.txt
multi_sort.kt2.4.21 で 15 / 15 件の出力が正解と一致
// 標準入力の CSV を、指定した複数のキーで並べ替えて出す
val NUM = Regex("^-?[0-9]{1,15}$")
// 数として読めるのは「-?[0-9]{1,15}」の形だけ。toLongOrNull は "+5" も受けるので、形を先に確かめる
fun num(s: String): Long? = if (NUM.matches(s)) s.toLong() else null
fun compare(a: List<String>, b: List<String>, keys: List<List<String>>, idx: Map<String, Int>): Int {
for (k in keys) {
val x = a[idx[k[0]]!!]
val y = b[idx[k[0]]!!]
val c: Int
if (k[2] == "num") {
val nx = num(x)
val ny = num(y)
if (nx == null && ny == null) {
c = 0
} else if (nx == null) {
return 1 // 読めない値は向きによらず後ろ
} else if (ny == null) {
return -1
} else {
c = nx.compareTo(ny)
}
} else {
// compareTo は UTF-16 の並びで比べるので、🍣(サロゲートペア)が ¥ より先に来てしまう。
// UTF-8 のバイトで比べるとコードポイント順になる。byte は符号付きなので compareUnsigned を使う
c = java.util.Arrays.compareUnsigned(x.toByteArray(), y.toByteArray())
}
if (c != 0) return if (k[1] == "desc") -c else c
}
return 0
}
fun main(args: Array<String>) {
// 「<列>:<向き>:<比べ方>」をカンマで区切った指定を読む。形が違えばここで終わり
val keys = mutableListOf<List<String>>()
for (part in args[0].split(",")) {
val bits = part.split(":")
if (bits.size != 3 || bits[0].isEmpty() || bits[1] !in listOf("asc", "desc") || bits[2] !in listOf("text", "num")) {
println("NG: 並べ方の指定が読めません")
return
}
keys.add(bits)
}
// readLine は \n でも \r\n でも行を区切り、行の終わりの記号を取って返す
val lines = mutableListOf<String>()
while (true) {
val line = readLine() ?: break
if (line.isNotEmpty()) lines.add(line)
}
// Kotlin の split は末尾の空の欄も残す(Java の String.split は捨てるので限界値 -1 が要る)
val header = if (lines.isEmpty()) emptyList() else lines[0].split(",")
val idx = mutableMapOf<String, Int>()
for (k in keys) {
val at = header.indexOf(k[0])
if (at < 0) {
println("NG: 列 ${k[0]} がありません")
return
}
idx[k[0]] = at
}
val rows = mutableListOf<Pair<String, List<String>>>()
var bad = 0
for (line in lines.drop(1)) {
val fields = line.split(",")
if (fields.size != header.size) {
bad++
continue
}
rows.add(line to fields)
}
// sortedWith は安定(Java の TimSort。同じと答えた行の順は変わらない)
val sorted = rows.sortedWith { a, b -> compare(a.second, b.second, keys, idx) }
println(lines[0])
for ((line, _) in sorted) println(line)
if (bad > 0) println("読めない行 $bad")
}
動かし方(ファイルを保存したフォルダで)
$ kotlinc multi_sort.kt -include-runtime -d multi_sort.jar && java -jar multi_sort.jar dept:asc:text,salary:desc:num < input.txt
multi_sort.swift6.3.3 で 15 / 15 件の出力が正解と一致
// 標準入力の CSV を、指定した複数のキーで並べ替えて出す
// 数として読めるのは「-?[0-9]{1,15}」の形だけ。Int64() だけに任せると "+5" も読めてしまう
func num(_ s: String) -> Int64? {
let body = s.hasPrefix("-") ? String(s.dropFirst()) : s
if body.isEmpty || body.count > 15 || !body.allSatisfy({ $0.isASCII && $0.isNumber }) {
return nil
}
return Int64(s)
}
func compare(_ a: [String], _ b: [String], _ keys: [[String]], _ idx: [String: Int]) -> Int {
for k in keys {
let x = a[idx[k[0]]!]
let y = b[idx[k[0]]!]
var c = 0
if k[2] == "num" {
let nx = num(x)
let ny = num(y)
if nx == nil && ny == nil {
c = 0
} else if nx == nil {
return 1 // 読めない値は向きによらず後ろ
} else if ny == nil {
return -1
} else {
c = nx! < ny! ? -1 : (nx! > ny! ? 1 : 0)
}
} else {
// String の < は正規化して比べるので、見た目が同じ文字が同じ扱いになる。
// UTF-8 のバイトの並びで比べるとコードポイント順になる
let bx = Array(x.utf8)
let by = Array(y.utf8)
c = bx == by ? 0 : (bx.lexicographicallyPrecedes(by) ? -1 : 1)
}
if c != 0 {
return k[1] == "desc" ? -c : c
}
}
return 0
}
func run() {
// 「<列>:<向き>:<比べ方>」をカンマで区切った指定を読む。形が違えばここで終わり
let spec = CommandLine.arguments[1]
var keys: [[String]] = []
for part in spec.split(separator: ",", omittingEmptySubsequences: false) {
let bits = part.split(separator: ":", omittingEmptySubsequences: false).map(String.init)
if bits.count != 3 || bits[0].isEmpty
|| !["asc", "desc"].contains(bits[1])
|| !["text", "num"].contains(bits[2]) {
print("NG: 並べ方の指定が読めません")
return
}
keys.append(bits)
}
// readLine は \n でも \r\n でも行を区切り、行の終わりの記号を取って返す
var lines: [String] = []
while let line = readLine() {
if !line.isEmpty { lines.append(line) }
}
// split は既定で空の欄を捨てる("a,,b" が2個になる)。列の数を数えるので omittingEmptySubsequences: false
let header = (lines.first?.split(separator: ",", omittingEmptySubsequences: false) ?? []).map(String.init)
var idx: [String: Int] = [:]
for k in keys {
guard let at = header.firstIndex(of: k[0]) else {
print("NG: 列 \(k[0]) がありません")
return
}
idx[k[0]] = at
}
var rows: [(line: String, fields: [String])] = []
var bad = 0
for line in lines.dropFirst() {
let fields = line.split(separator: ",", omittingEmptySubsequences: false).map(String.init)
if fields.count != header.count {
bad += 1
continue
}
rows.append((line, fields))
}
// sorted(by:) は安定とは決まっていない。何番目に出てきたかを最後の決め手に足す
let sorted = rows.enumerated().sorted { a, b in
let c = compare(a.element.fields, b.element.fields, keys, idx)
return c != 0 ? c < 0 : a.offset < b.offset
}
print(lines[0])
for item in sorted { print(item.element.line) }
if bad > 0 {
print("読めない行 \(bad)")
}
}
run()
動かし方(ファイルを保存したフォルダで)
$ swift multi_sort.swift dept:asc:text,salary:desc:num < input.txt
サンプルを持ち帰る
この書き方の10言語のプログラムと正解表を、zip でお送りします。利用条件を読んで同意のうえ、メールアドレスを入れてください。
よく見かける書き方で試すと
仕事でよく見かける書き方(標準の関数をそのまま使う形や、よく紹介される正規表現など)を、同じ正解表で動かした結果です。言語を出した答えごとにまとめ、赤い字はその言語が実際に出した間違った行です。
| 入力 | よく見かける書き方の答え(10言語) |
|---|---|
基本(部署の昇順、同じなら給与の降順)dept:asc:text,salary:desc:num | ✓10言語すべて正解 |
数として比べる(文字として比べると 1000 が 900 より先になる)salary:asc:num | ✓10言語すべて正解 |
キーの値がどれも同じ20行は、入力の順のまま(安定な並べ替え)dept:asc:text |
|
text の降順name:desc:text | ✓10言語すべて正解 |
text はコードポイント順(UTF-16 の並びとは変わる)name:asc:text |
|
数として読めない値は後ろ(読めない値同士は入力の順)salary:asc:num |
|
降順でも読めない値は後ろ。007 と 7、-0 と 0 は数として同じsalary:desc:num |
|
16桁の数は読めない扱い(15桁までが数)salary:asc:num | ✓10言語すべて正解 |
3つのキーで並べるdept:asc:text,grade:asc:num,salary:desc:num | ✓10言語すべて正解 |
列の数が違う行と空の行が混ざるsalary:asc:num |
|
2つ目のキーが見出しに無いdept:asc:text,bonus:desc:num | ✓10言語すべて正解 |
向きが asc でも desc でもないsalary:up:num | ✓10言語すべて正解 |
空の入力dept:asc:text | ✓10言語すべて正解 |
見出しだけ(データの行が無い)dept:asc:text | ✓10言語すべて正解 |
改行が \r\n で、最後に改行が無いdept:asc:text,salary:desc:num | ✓10言語すべて正解 |
この書き方の決まり
- 引数は並べ方の指定1つ。「<列>:<向き>:<比べ方>」をカンマで区切って並べる(向きは asc か desc、比べ方は text か num。例
dept:asc:text,salary:desc:num) - 標準入力は CSV(1行目が見出し。値にカンマ・引用符・改行は入らない)
- 1行目に見出しをそのまま出し、そのあとにデータの行を並べ替えて、元の行の文字列のまま1行ずつ出す
- 指定した列を左から順に比べる。text は Unicode のコードポイントの小さい順(UTF-8 のバイトの並びの順と同じ)、num は数として小さい順。desc はその逆
- 指定した列の値がどれも同じ行は、入力に出てきた順のまま(安定な並べ替え)
- num は「
-?[0-9]{1,15}」の形(符号は-だけ、桁は15桁まで)だけを数として読む。その形でない値(空・1e3・全角・前後に空白・16桁以上)は数として読めないものとして扱い、asc でも desc でも読めた値より後ろに置く(読めない値同士は入力の順のまま) - 値の前後の空白は取らない
- 空の行は無いものとして捨てる。列の数が見出しと違う行は並べ替えず、その行は出さずに、最後に「読めない行 <数>」の1行を出す
- まず指定の形を調べ、形が違ったら「NG: 並べ方の指定が読めません」の1行だけ。次に列を左から見て、最初に見つからなかった列の名前で「NG: 列 <名前> がありません」の1行だけ(空の入力は見出しが無いので、これになる)
解説
「同じ値の行」の順番は、並べ方の指定では決まらない
dept:asc:text だけで並べると、同じ部署の行の並びは並べ替えの実装が決めます。入力の順のまま残るか(安定)、入れ替わるか(安定でない)は言語ごとに違います。20行すべてのキーが同じ入力(c003)で、よく見かける書き方は検証に使っている Linux のコンテナでC# だけが順番を崩しました(先頭の行はそのままで、2行目以降が逆向きに並び、最後の2行だけ元の位置に残る形)。
| 言語 | 既定の並べ替え | 安定か |
|---|---|---|
| Python・JavaScript・PHP・Java・Kotlin・Rust | sort・sorted・usort・List.sort・sortedWith・sort_by | 安定(JavaScript は ES2019 から、PHP は 8.0 から) |
| Go | sort.Slice | 安定ではない(sort.SliceStable が別にある) |
| Ruby | sort・sort_by | 安定ではない(仕様として決まっていない) |
| Swift | sorted(by:) | 安定ではない(仕様として決まっていない) |
| C# | List.Sort・Array.Sort | 安定ではない(LINQ の OrderBy は安定) |
Go・Swift は、この20行では順番が変わりませんでした。件数が少ないうちは挿入ソートで済むため、崩れないこともあるだけです。Ruby は同じ 4.0.7 でも、手元の Mac では15件中12件(c003 で先頭と末尾の行が入れ替わった)、コンテナでは15件中13件で、場所によって結果が変わりました。「今は順番が合っている」は、安定だという証拠になりません。
決めどころは2つです。出力の順番を最後まで決める(同じ値なら入力の順、あるいは id の順)か、安定な並べ替えを選ぶ(Go は SliceStable、C# は OrderBy、Ruby と Swift は「何番目に出てきたか」を最後の決め手に足す)。この回のコードは後者で書きました。
# Ruby: Array#sort は安定ではないので、何番目に出てきたかを最後の決め手に足す
rows.each_with_index.sort { |a, b| compare.call(a[0], b[0]).nonzero? || (a[1] <=> b[1]) }// Swift: sorted(by:) も安定とは決まっていない
rows.enumerated().sorted { a, b in
let c = compare(a.element.fields, b.element.fields, keys, idx)
return c != 0 ? c < 0 : a.offset < b.offset
}数として読めない値を、0 として並べてしまう(10言語中10言語)
給与の列に空・1e3・全角の100・前に空白が付いた 200を混ぜたケース(c006)は、よく見かける書き方が10言語すべて落ちました。しかも答えが4通りに割れました。
| よく見かける書き方の答え(昇順) | 言語 |
|---|---|
-50 → (空) → 100 → 100 → 200 → 300 → 1e3 | PHP・JavaScript・C#・Kotlin(10言語中4言語) |
-50 → (空) → 100 → 200 → 100 → 300 → 1e3 | Go・Rust・Swift |
-50 → (空) → 100 → 100 → 200 → 300 → 1e3 | Python |
-50 → 100 → 100 → 200 → 300 → 1e3(空の値の行が消えた) | Java・Ruby |
| 決まり(読めない値は後ろ) | -50 → 100 → 300 → (空) → 1e3 → 100 → 200 |
言語ごとの数値変換のくせがそのまま出ています。
- 空の値を 0 にする: PHP の
(int)""、JavaScript のNumber("")、Python の例外を拾って 0 にする書き方。0 は「いちばん小さい給与」として並ぶので、未入力の行が先頭に来ます 1e3を 1000 として読む: ほぼすべての言語の浮動小数の変換が受け付けます。1e3と書かれた給与を 1000 として扱っていいかは仕様の話です- 前後の空白を飛ばす: Java の
Double.parseDouble(" 200")と C#・Kotlin の変換は空白を飛ばして 200 にします。Go・Rust・Swift は断って 0 になりました - 全角の数字を読む言語がある: Python の
float("100")は 100.0 を返します。他の9言語は読めずに 0 でした - 末尾の空の欄が消える: Java の
String.split(",")と Ruby のsplit(",")は末尾の空の欄を捨てるので、b,の行は「列が1つしかない行」になり、行ごと消えました(第2引数に-1を付けると残ります)
数の列を並べるときは、「どの形を数とみなすか」を先に決めて、その形だけを受けるのが安全です。この回のコードは -?[0-9]{1,15} を正規表現で確かめてから変換し、読めない値は向きによらず後ろに置きました。
// PHP: (int) に任せると "1e3" が 1000、" 200" が 200、"" が 0 になる
$num = fn(string $s): ?int => preg_match('/^-?[0-9]{1,15}$/', $s) === 1 ? (int) $s : null;Java と Kotlin は -0 を 0 より小さいと答えた
10・7・007・-0・0・x を降順に並べたケース(c007)で、Java と Kotlin(10言語中2言語)だけが -0 を 0 の後ろに置きました。決まりでは -0 と 0 は数として同じなので、入力の順(-0 が先)のままです。
Double.compare(-0.0, 0.0) は -1 を返します。IEEE 754 の -0.0 == 0.0 は真ですが、Double.compare と Double.compareTo は「全順序」を作るために -0.0 < 0.0 と決めています。double で金額や件数を並べていると、マイナスの0が混ざった日に順番が変わります。
整数として扱える値なら、整数で比べるのが確実です(この回のコードは long・int64 で比べています。007 と 7、-0 と 0 はどちらも同じ値になります)。
文字の順は、UTF-16 で比べる4言語で変わる
text の比較で 私・¥・🍣 を並べたケース(c005)は、08 キーでまとめて数える と同じ割れ方になりました。
| よく見かける書き方 | 答え | 言語 |
|---|---|---|
| 決まり(コードポイント順) | 私 → ¥ → 🍣 | PHP・Python・Go・Ruby・Rust・Swift |
| UTF-16 の並び | 私 → 🍣 → ¥ | Java・Kotlin・JavaScript・C#(10言語中4言語) |
🍣 は U+1F363、¥ は U+FFE5 です。この4言語の文字列は中身が UTF-16 で、🍣 は U+D83C U+DF63 のサロゲートペアとして入っているので、先頭の 0xD83C が 0xFFE5 より小さく、🍣 が先に来ます。UTF-8 のバイトの並びで比べ直すとコードポイント順になります。
C# の string.Compare は、さらに動かす場所の国の設定(カルチャ)に従います。検証に使っている Linux のコンテナは ICU(国ごとの並べ方の表)を持たない作りなので15件中11件でしたが、手元の Mac では漢字が辞書の順に並び、name:desc:text(c004)も落ちて15件中10件でした。機械が読む出力を作るときは、国の設定に左右されない比べ方を選びます。
壊れた行を黙って捨てる(10言語中10言語)
列が1つ足りない行と1つ多い行を混ぜたケース(c010)で、よく見かける書き方は10言語すべてが、その2行を黙って落とし、「読めない行 2」を出しませんでした。並べ替えの結果は決まりと同じなので、出力を見ても何も起きていないように見えます。
並べ替えは集計と違って合計が出ないので、行が減っても気づきにくいところです。読めなかった行の数を必ず出す(または標準エラーに出す)ようにしておくと、取り込みの元を直すきっかけになります。
元の行をそのまま出すか、組み立て直すか
この回は「元の行の文字列のまま出す」と決めました。欄に分けて並べ替えたあと join(",") で組み立て直すと、入力と1文字も同じにならないことがあります。末尾の空の欄が消える言語(Java・Ruby の split)や、空の欄をすべて捨てる言語(Swift の split(separator:))では、a,b, が a,b になって出てきます。
どちらでもよい場面は多いですが、「入力をそのまま並べ替えて返す」仕事(CSV の行の並べ替え、ログの整列)では、元の行を持ったまま並べ替えるほうが事故が起きません。