AtCoder Beginner ContestのB問題の最短コードを読む(021-040)

# はじめに

AtCoderで使用できる言語のバージョンアップ・追加が2020/06/18の夕方に行われました。（実際には、2020/05/13の夜から2020/05/14の昼にかけて一度アップデートされたあと、問題が発生したために巻き戻されていました。）
このアップデートによって、この記事で紹介しているコードの大半が更新されたため、以下の内容は現在のAtCoderにおけるコードゴルフ環境に比べて古いものになります。（定期的な記事の更新は諦めました。）

## 言語別索引

各問題の最短コードであるものにはByte数が書かれています。

### Bash

[ABC022](#abc022-bumble-bee) 23Byte
[ABC029](#abc029-カキ) 11Byte

### Perl

[ABC026](#abc026-n重丸) 39Byte
[ABC035](#abc035-ドローン) 77Byte
[ABC037](#abc037-編集) 52Byte

[ABC022](#abc022-bumble-bee)
[ABC024](#abc024-自動ドア)
[ABC028](#abc028-文字数カウント)
[ABC031](#abc031-運動管理)
[ABC032](#abc032-高橋君とパスワード)
[ABC038](#abc038-ディスプレイ)


### Ruby

[ABC023](#abc023-手芸王) 45Byte

[ABC022](#abc022-bumble-bee)

### Sed

[ABC021](#abc021-嘘つきの高橋くん) 36Byte
[ABC038](#abc038-ディスプレイ) 30Byte

### Awk

[ABC024](#abc024-自動ドア) 43Byte
[ABC025](#abc025-双子とスイカ割り) 82Byte
[ABC030](#abc030-時計盤) 37Byte
[ABC031](#abc031-運動管理) 38Byte
[ABC033](#abc033-町の合併) 48Byte
[ABC034](#abc034-ペア) 12Byte
[ABC039](#abc039-エージェント高橋君) 7Byte

[ABC027](#abc027-島と橋)
[ABC038](#abc038-ディスプレイ)
[ABC040](#abc040-)

### Octave

[ABC024](#abc024-自動ドア)
[ABC027](#abc027-島と橋)
[ABC036](#abc036-回転)
[ABC040](#abc040-)

### Perl6

[ABC027](#abc027-島と橋) 57Byte
[ABC028](#abc028-文字数カウント) 23Byte
[ABC032](#abc032-高橋君とパスワード) 36Byte
[ABC036](#abc036-回転) 25Byte
[ABC040](#abc040-) 41Byte

[ABC026](#abc026-n重丸)
[ABC034](#abc034-ペア)
[ABC039](#abc039-エージェント高橋君)



# 問題

## [ABC021 嘘つきの高橋くん](https://beta.atcoder.jp/contests/abc021/tasks/abc021_b)

> $N$
> $a \quad b$
> $K$
> $P_1 \quad P_2 \quad ... \quad P_K$

$a,b,P_1,P_2,...,P_K$に重複する要素があれば`NO`を、なければ`YES`を出力します。

```sed:Sed(36Byte)
2h
4!d
G
/\<\(.*\) .*\<\1\>/cNO
cYES
```

コードを読む前に、sedの重要な機能「ホールドスペース」を知る必要があります。

ABC-Aでさんざん使ってきたように、sedは基本的に入力を1行ごとにパターンスペースに読み込み、コマンドを実行して加工されたパターンスペースの内容を出力することを繰り返す言語です。
これに対して「ホールドスペース」は、行をまたいで情報を保持する、パターンスペースの対になるものであり、1行ごとに自動的に内容が更新されたり、内容を出力されたりすることのないものです。

コマンドを使ってホールドスペースに文字列を保存することで、上書きされたり取り出されるまでは以降のどの行でも同じ文字列を得ることができます。

さて、それぞれのコマンドは以下のような意味になります。
`h`：パターンスペースの内容をホールドスペースに上書きする。
`d`：現在のパターンスペースの内容を全削除し、次の行の処理を始める。
`G`：ホールドスペースの内容をパターンスペースに追加する。

まず、2行目を処理するときのみ`h`が実行されます。$P_1,P_2,...,P_K$と$a,b$に重複する要素がないか確認するため、$a,b$を一時的に保存しています。
次に、4行目「以外（`!`による効果です）」を処理しているとき`d`が実行されます。これによって即座に次の行の処理が始まるため、以降のスクリプトは入力の4行目でのみ実行されます。
`G`を実行すると、現在のパターンスペース$P_1,P_2,...,P_K$の後ろに改行と$a,b$が追加されます。

ここで、パターンスペースにまったく同じ単語が2つ存在すれば重複する要素が存在するとわかります。
これは、`/\<\(\w*\)\>.*\<\1\>/`という正規表現で判定できます。`\<`は単語の先頭の位置、`\>`は単語の末尾の位置にマッチします。
`\(\w*\)`と`\1`の間に何文字存在しても良いように、間に`.*`を置いています。

`/\<\(\w*\)\>.*\<\1\>/`をさらに縮めます。
まず、`\w`は`.`でも構いません。こうすると、`\1`は`'2 3'`という2つ以上の単語の列になり得ますが、これが複数回文字列中に出現する場合も単語が重複していることに変わりありません。
次に、こちらはテストケースハックですが、最初の`\>`を` `にしてもACできます。このとき、$P_K$は右に空白ではなく改行が存在するので`\(.*\)`にマッチできなくなってしまいますが、幸い、$P_K$と$a$（制約より$P_K \ne b$です）が重複しているテストケースは存在しないため影響しませんでした。

以上2つの更新を加えて、`/\<\(.*\) .*\<\1\>/`が得られました。これにマッチすれば`NO`を出力します。


## [ABC022 Bumble Bee](https://beta.atcoder.jp/contests/abc022/tasks/abc022_b)

> $N$
> $A_1$
> $A_2$
> $:$
> $A_N$

$\\{A_1,A_2,...,A_{i-1}\\} \ni A_i$を満たすような$i$の個数を出力します。

```bash:Bash(23Byte)
read;awk a[\$0]++|wc -l
```

1行目を`read`で読み捨てし、2行目以降を`awk`で処理します。
配列`a`に`$0`でアクセスすると、以前に出現した要素のどれかと等しければ（つまり、$\\{A_1,A_2,...,A_{i-1}\\} \ni A_i$を満たしていれば）`a[$0]`はインクリメントされているため正の数となり、その行が出力されます。
後置インクリメントを使うことで更新のタイミングをずらし、判定と処理をまとめています。

こうして出力された行の数を`wc -l`でカウントすると、答えが得られます。

```perl:Perl(26Byte)
print<>-(grep!$$_++,<>),$/
```

AWKの解法と同じく出現回数をカウントするのですが、perlでは以前に出現したことのあるものではなく以前に出現したことの「ない」もの（つまり、リストのユニークな要素数です）を数え、$N$から引くことで答えを得ています。

1番目の`<>`はスカラ値が期待される文脈（「スカラコンテキスト」といいます）で評価されるので、1行読み込んだ値である$N$になります。
2番目の`<>`ですが、これは`grep`という関数の第2引数であり、リストコンテキストなので、以降の入力すべてを読み込んで改行区切りにしたリストになります。

`grep`という関数は[ABC015-B](https://qiita.com/kotatsugame/items/a1703bba780717897bf6#abc015-高橋くんの集計)でも出てきました。第1引数で受け取った式やブロックに第2引数以降を次々と適用し、`true`を返すもののみからなるリストを作ります。今回は、`!$$_++`という式を実行しています。こちらでも引数が自動的に`$_`に代入されます。
`$$_`については[ABC008-B](https://qiita.com/kotatsugame/items/a1703bba780717897bf6#abc008-投票)で出てきました。後置デクリメントでカウントするのはAWKと同じですが、`!`で真偽を反転しています。こうすることで、リストのユニークな値を抽出することができます。

`grep`を$N$から引くというスカラコンテキストで評価すると、返り値は得られたリストのサイズとなるので、これで答えが得られました。改行文字`$/`とともに出力します。

```ruby:Ruby(27Byte)
p gets.to_i-([*$<]|[]).size
```

Perlと同じく、リストのユニークな要素数を数え$N$から引いています。
最初に`gets.to_i`で入力の1行目（$N$）を読み込みます。

`$<`を`*`で`splat展開`し、展開されたものを`[]`でくくることで1つの配列にまとめています。これのユニークな要素を得るために、空の配列`[]`と[集合の和演算](https://docs.ruby-lang.org/ja/latest/method/Array/i/=7c.html)（`|`）をしています。（実際には、`size`を呼び出すために括弧でくくる必要があり、`uniq`を呼び出すのと文字数は変わりません。）

$N$から`[*$<]|[]`の`size`を引いたものが答えなので、`p`で出力します。


## [ABC023 手芸王](https://beta.atcoder.jp/contests/abc023/tasks/abc023_b)

> $N$
> $S$

`s1 ::= "b" | "b" <s3> "b"`
`s2 ::= "a" <s1> "c"`
`s3 ::= "c" <s2> "a"`
としたときに、$S$が`s1`または`s2`または`s3`であれば$(N-1)/2$、そうでなければ$-1$を出力します。

```ruby:Ruby(45Byte)
p~-`dd`[/.*
((?=ab|bc|ca).\g<1>.|b)$/].to_i/2
```

嘘解法です。まず下のRuby 53Byteの元最短コードを読んでください。

`/(?=pat)/`は肯定先読みで、続く2文字が`/ab|bc|ca/`にマッチすることを表します。`\g<1>`がどんどんコピーされ、文字列全体にマッチできたとき、`/(?=ab|bc|ca)/`によって**文字列の前半分については**連続する2文字がすべて`/ab|bc|ca/`のどれかであったことが言えます。
文字列の後ろ半分には何の制約もありませんが、これですべてのテストケースに正解することができました。

```ruby:Ruby(53Byte)
p~-`dd`[/.*
(?!.*(?!ab|bc|ca)..)(.\g<1>.|b)$/].to_i/2
```

`` `dd` ``で入力をすべて読んでいます。
文字列のインデックスに正規表現を使用すると、マッチングに成功すればマッチした部分文字列、失敗した場合は`nil`が得られます。
今回は改行文字が含まれた正規表現を使用しています。正規表現中の改行文字は文字列中の改行文字にマッチングします。

まず、改行前の`.*`は、できるだけ長くマッチするという法則から、$N$の全体にマッチします。
次に改行の後ですが、実は$S$についての条件は「連続する2文字は必ず`/ab|bc|ca/`のどれかである」「文字列長は奇数で、中央の文字は`'b'`である」の2つで表すことができます。2つ目の条件により、中央から文字がどんどん決まっていくので、このような文字列は文字列長に応じてただ1つに定まります。

1つ目の条件は`/(?!.*(?!ab|bc|ca)..)/`で確認できます。`/(?!pat)/`は「否定先読み」と言って、`/pat/`が続かないような文字列中の位置にマッチします。詳しくは[正規表現](https://docs.ruby-lang.org/ja/latest/doc/spec=2fregexp.html)ページ内の「先読み、後読み(lookahead, lookbehind)」を参照してください。
よって`/(?!ab|bc|ca)../`は後ろに`/ab|bc|ca/`が続かない位置から2文字、つまり「`/ab|bc|ca/`にマッチしない2文字」にマッチします。これが存在すれば$S$は条件を満たしません。
そこで、このような2文字が存在しないという条件を表すため、さらに`/(?!pat)/`を使います。文字列中の何文字目に表れてもいいように`/.*/`を加え、`/(?!.*(?!ab|bc|ca)..)/`で「この先のいかなる2文字も`/ab|bc|ca/`にマッチしないことがない（つまりマッチする）」位置が表せました。
直前の改行が`/^/`の役割を果たしているので、これで入力の2行目において連続する2文字が必ず`/ab|bc|ca/`のどれかであることが言えました。

2つ目の条件は`/(.\g<1>.|b)/`で表せます。`\g<1>`は別の場所の正規表現をそのままコピーしてくるように働きます。
ここで、マッチした文字列ではなく、マッチする正規表現自体がコピーされることに注意してください。こちらも詳しくは[正規表現](https://docs.ruby-lang.org/ja/latest/doc/spec=2fregexp.html)ページ内の「部分式呼び出し(subexpression call)」を参照してください。
`\g<1>`によって、1番目の括弧内の正規表現である`/.\g<1>.|b/`がコピーされます。（`/(?!.*(?!ab|bc|ca)..)/`の括弧がカウントされていないことに注意してください。）
こうやってどんどん`\g<1>`がコピーされると同時に、先頭と末尾から1文字ずつ`/./`にマッチしていきます。文字列長が奇数であれば、最後に残るのは文字列の中央の文字であり、さらにそれが`/b/`にマッチすれば条件を満たします。文字列長が偶数であれば、最後に空文字列が残ってしまい、マッチングに失敗します。

マッチングに成功すると、入力全体が得られます。これを`to_i`すると、改行文字以降は無視され、$N$が得られます。`~-a`で`a-1`を表し、2で割ると答えが得られます。
マッチングに失敗すると、`nil`が得られます。これを`to_i`すると`0`になり、`~-0/2`すなわち`-1/2`はRubyが切り捨ての割り算を行うため`-1`になります。
条件を満たす場合$N$は必ず奇数なので、切り捨てが行われるのにわざわざ`~-`をつけているのはマッチングに失敗したときのためだけです。

こうして場合分けをせずに答えが得られたため、`p`で出力します。


## [ABC024 自動ドア](https://beta.atcoder.jp/contests/abc024/tasks/abc024_b)

> $N \quad T$
> $A_1$
> $A_2$
> $:$
> $A_N$

$A_{N+1}=\infty$として、$\sum_{i=1}^N {\rm min}(A_{i+1}-A_i,T)$を出力します。

```awk:Awk(43Byte)
{a-=$1<s-T?s-$1:T;s=T?$1:T=-$2}END{print a}
```

実は、$A_0=-T$として$\sum_{i=0}^{N-1} {\rm min}(A_{i+1}-A_i,T)$も同じ値になります。
なぜなら$A_1 \ge 1$より${\rm min}(\infty-A_N,T)={\rm min}(A_1-(-T),T)=T$であるからです。
入力の1行目で$A_0$を計算できるため、$A_{N+1}$よりも$A_0$のほうが扱いやすいので、後者の式を用います。

まず、先に`s=T?$1:T=-$2`を読みます。
`s`は直前の$A$の値を覚えておく変数であり、変数`T`が未定義であれば入力の1行目を処理していると判断して$-T$を代入します。そうでなければ`$1`を代入します。
ここで、`-T=$2`が文法的に正しくないので、`T=-$2`とする必要がありました。

`a-=$1<s-T?s-$1:T`ですが、`$1<s-T`は`T<s-$1`と等しいため、`s-$1`と`T`のうち大きな方を`a`から引いています。
$-{\rm max}(A_i-A_{i+1},-T)={\rm min}(A_{i+1}-A_i,T)$より、示した計算式通りの値を足すことになります。

入力の1行目を処理している場合、`$1>0`、`s-T==0`が成り立つので、`a-=T`が実行されますが、`T==0`なので`a`の値に余計なものが足されることはありません。

`a`が求める答えなので、`END`ブロックで出力します。

```perl:Perl(48Byte)
<>=~$";$s+=$-=$_-$a,$a=$_+$' for<>;print$a-$s,$/
```

まず[ABC014-B](https://qiita.com/kotatsugame/items/a1703bba780717897bf6#abc014-価格の合計)で用いたテクニックを使って$N$、$T$を読み込みます。

このコードでは、$A_0=-T$として$\sum_{i=0}^{N-1} {\rm min}(A_{i+1}-A_i,T)=\sum_{i=0}^{N-1} (A_{i+1}-A_i-{\rm max}(A_{i+1}-A_i-T,0))=A_N+T-\sum_{i=0}^{N-1} {\rm max}(A_{i+1}-(A_i+T),0)$を計算しています。

`$a`が$A_i+T$を保存するとすると、$A_0+T=0$なので、`$a`は初期化しなくてもよいです。
`for<>`で`$s+=$-=$_-$a,$a=$_+$'`をループします。

まず`$s+=$-=$_-$a`ですが、これは実は`$s`に${\rm max}(A_{i+1}-(A_i+T),0)$を足しています。
`$-`というのはPerlの組み込み変数で、代入された値は整数への切り捨てが行われ、負の数が代入されたときは0になるというとても便利な変数です。
つまり、`$-=$a`とするだけで`0`と`$a`の`max`が得られるのです。

そのあと、`$a=$_+$'`で`$a`の値を更新します。
`$'`と`for`の間にはスペースが必要です。詳しくは[Perl でコードゴルフをする時に空白が必要なのはどういう場合か](http://i-i.hatenablog.jp/entry/2017/02/28/194559)を参照してください。

ループが終了した時点で、`$a`は$A_N+T$、`$s`は$\sum_{i=0}^{N-1} {\rm max}(A_{i+1}-(A_i+T),0)$となっているので、`$a-$s`を改行付きで出力します。

```octave:Octave(60Byte)
disp(int32(sum(min(t=(a=scanf("%d"))(2),diff(a(3:end))))+t))
```

$T+\sum_{i=1}^{N-1} {\rm min}(T,A_{i+1}-A_i)$を求めます。

`scanf("%d")`を使いフォーマット`"%d"`で入力をすべて読み、列ベクトルにして変数`a`に保存します。$T$はその2番目の要素なので、`t=a(2)`とします。
この操作を1度に行うと`t=(a=scanf("%d"))(2)`になります。

次に、$A_{i+1}-A_i$を求めます。これは隣接要素の差なので、[diff関数](https://octave.sourceforge.io/octave/function/diff.html)が使えます。
変数`a`の3番目から最後までの要素が$A$を表すので、`a(3:end)`として取り出します。`:`は範囲を表し、`end`は行列のインデックス中で用いると最後の要素のインデックスになります。

こうして得られた`t`と`diff(a(3:end))`の`min`を取り、`sum`で総和を計算します。`min`関数の引数は片方がスカラ、もう片方がベクトルですが、これは意図したとおりに動作します。

これまでの操作をまとめると、`sum(min(t=(a=scanf("%d"))(2),diff(a(3:end))))`になります。（関数の引数部分で`t`に代入しているため、余計な括弧が必要ありません。）

最後に`t`を足し、`disp`で出力するのですが、今回のジャッジでは先頭に空白があるとWAになってしまいます。それを避けるために、実数型で得られた答え（`"%d"`で読み込んでいようと内部的には実数型です）を`int32`という関数で整数型に直しています。


## [ABC025 双子とスイカ割り](https://beta.atcoder.jp/contests/abc025/tasks/abc025_b)

> $N \quad A \quad B$
> $s_1 \quad d_1$
> $s_2 \quad d_2$
> $:$
> $s_N \quad d_N$

最初$0$にいて、$s_i$が`'East'`ならば東に、`'West'`ならば西に${\rm min}({\rm max}(d_i,A),B)$だけ移動します。
最後にいる場所を$East\quad X$または$West \quad X$または$0$と出力します。

```awk:Awk(82Byte)
d=A>$2?A:$2>B?B:$2{c+=/E/?d:-d}$3{A=$2;B=$3}END{print c?c<0?"West "e-c:"East "c:0}
```

まず、変数`d`に今回の移動距離を代入します。$A>d_i$ならば$A$、そうでなければ${\rm min}(d_i,B)$となります。
入力の1行目を処理しているときは`A`も`B`も未定義の変数なので`d`の値は`0`になり、続くブロックが実行されません。

`c`に移動距離を加えていきます。`/E/`は`$0~/E/`の省略形であり、入力中に`E`の文字があるかどうかを判定しています。
存在すれば$s_i$が`'East'`だとわかるので`c+=d`、存在しなければ`c+=-d`が実行されます。

`$3`が存在するときだけ、`{A=$2;B=$3}`というブロックが実行されます。`$3`が存在するのは入力の1行目だけなので、ここで`A`と`B`をそれぞれ入力の$A$と$B$で初期化しています。

最後に`END`ブロックで答えを出力しています。
`c`が`0`であれば`0`を、`c<0`であれば`"West "`と`-c`を文字列連結して、`c>0`であれば`"East "`と`c`を文字列連結して出力します。
`"West "-c`は数値の引き算と解釈されてしまうので、`"West "e-c`という書き方になっています。ここで`e`は`0`の代わりであり、未定義変数ならば何でもよいです。（`0`そのもので`"West "0-c`と書いてもよいです。）
今回は条件に`c>0`ではなく`c<0`を使っているので問題ないですが、`print`の後ろに`>`という記号が存在すると[リダイレクト](http://www.kt.rim.or.jp/~kbk/gawk-30/gawk_7.html#SEC65)であると解釈されて文法エラーになることがあります。


## [ABC026 N重丸](https://beta.atcoder.jp/contests/abc026/tasks/abc026_b)

> $N$
> $R_1$
> $R_2$
> $:$
> $R_N$

$R$を昇順にソートし、$\pi \times ({R_N}^2-{R_{N-1}}^2+...+(-1)^i \times{R_{N-i}}^2+...+(-1)^{N-1} \times {R_1}^2)$を出力します。

```perl:Perl(39Byte)
<>;$\=$_*$_/.31831-$\for`sort -n`;print
```

[ABC006-B](https://qiita.com/kotatsugame/items/a1703bba780717897bf6#abc006-トリボナッチ数列)と同じく、`$\`に計算結果を保存することで出力を短縮しています。

上に示した式のように交互に符号を入れ替えつつ足し合わせる操作は、最初$now=0$として$now = {R_i}^2-now$を$i$の昇順に行うことで実現できます。

昇順ソートは、外部コマンドの`sort`を実行するのが1番短いです。1行目を読み飛ばしてあるので、`sort -n`は残りの$R$すべてを読み込み、数値として（これは`-n`オプションによります）昇順に並べて返します。
後置`for`で使われているので、`sort -n`を実行した結果はリストコンテキストで評価され、改行で区切られたリストになります。

よって、昇順に並べられた$R$がそれぞれ`$_`に代入されつつ`$\=$_*$_/.31831-$\`が実行されます。

出力を短縮したことにより出力部で$\pi$を掛けるのは不可能なので計算途中に掛けていますが、ここでも`3.14159...`をそのまま掛けるのではなく、その逆数`0.31831...`で割り算をしています。こうすることで、Perlにおいては先頭の`0`が省略できるので、1Byteの短縮になります。また、`0.31831`はこれ以上精度を落とすとWAになるというギリギリの数値になっています。

```perl:Perl6(41Byte)
say pi*reduce -*+* **2,sort !get,+<<lines
```

上と同じく$now = {R_i}^2-now$を行っています。`reduce`は、関数とリストを受け取ってHaskellなどで言う`fold`を行います。

まず、`reduce`に渡しているリストである`sort !get,+<<lines`を見ます。
1行目だけを先に読んで`!`で論理否定をし（`False`になります）、残りの入力を`lines`で一気に読みこみます。これは入力を改行区切りでリストにして返す関数です。
この二つをひとまとめに`sort`するのですが、数値として比較したいため、`+<<`を使っています。（これについては[ABC066-A](https://qiita.com/kotatsugame/items/184bfd63d9b21f214475#abc066-ringring)を参照してください。）
$now=0$とするために、わざわざ`!get`も一緒に`sort`しています。

`reduce`に渡している関数は、引数を2つとる必要があります。それが`-*+* **2`です。
これは[WhateverCode](https://docs.perl6.org/type/Whatever)と呼ばれる機能で、`*`が演算子と一緒に現れた場合に関数が作られます。
`* + *`と書くと、これは2つ引数をとって和を返す関数になります。

`-*+* **2`は関数としては`-> $x,$y {-$x+$y**2}`と等しくなります。累乗の演算子`**`にも`*`が使われていますが、これは演算子であると正しく判定されます。

こうして`fold`することで得られた値に`pi`（$\pi$）を掛けて出力します。


## [ABC027 島と橋](https://beta.atcoder.jp/contests/abc027/tasks/abc027_b)

> $N$
> $a_1 \quad a_2 \quad ... \quad a_N$

$\sum_{i=1}^N a_i \bmod N \ne 0$ならば$-1$を、そうでなければ$\sum_{j=1}^i a_j \ne i \times {\rm mean}(a)$であるような$i$の個数を出力します。

```perl:Perl6(57Byte)
say ($/=1/get*[+] $_=+<<get.words)%%1*-+^.grep($+=*-$/)-1
```

`1/get`は$1/N$であり、これに${\rm sum}(a)$を掛けることで${\rm mean}(a)$が得られます。
${\rm sum}(a)$は`[+] $_=+<<get.words`と書けます。ここで、$a$はもう1回使うのでリスト型に強制（[ABC015-B](https://qiita.com/kotatsugame/items/a1703bba780717897bf6#abc015-高橋くんの集計)参照）した後`$_`に保存しています。
こうして得られた平均値を`$/`に保存します。

`$/`が整数でなければ$\sum_{i=1}^N a_i \bmod N \ne 0$だとわかります。
`$/%%1`で「`$/`が`1`で割り切れるかどうか」を表し、これが`False`であった場合（小数部分が存在するため`$/`は整数ではありません）、`$/%%1*-+^.grep($+=*-$/)`は全体として`0`になるため、`say 0-1`が実行されます。

`$/%%1`が`True`であった場合は、`say -+^.grep($+=*-$/)-1`が実行されます。
`.grep`は`$_.grep`の省略形です。`$+=*-$/`という関数を実行した結果が`True`のものを集めたリストを返します。
$\sum_{j=1}^i a_j \ne i \times {\rm mean}(a) \Leftrightarrow \sum_{j=1}^i (a_j-{\rm mean}(a)) \ne 0$ですから、$a$のそれぞれの値から平均値を引いたものを足し合わせつつ、`0`でないものを数えればよいです。

`$+=*-$/`は、[ABC026](#abc026-n重丸)で見たように、引数を1つとる関数になります。`*-$/`が$a_j-{\rm mean}(a)$に相当します。
累積和を保存する変数が`$`1文字になっていますが、これは明示的な宣言なしに使える無名の変数です。（[variable $](https://docs.perl6.org/syntax/$)）
コード中の出現する場所ごとに異なる変数として認識されますが（例えば`say $++,++$`は「01」と出力する）、今回は関数の一部として使っているので、問題なく同じ変数として扱われます。
`$`に累積した和が`0`でなければ何もしなくとも`True`になります。

`-+^.grep($+=*-$/)-1`は[ABC009-A](https://qiita.com/kotatsugame/items/184bfd63d9b21f214475#abc009-引越し作業)で見たように`.grep($+=*-$/)+1-1`と等しく、リストはスカラコンテキストではその大きさを表すので、無事答えが得られました。

```awk:Awk(65Byte)
z{for(;n<NF;)s+=$++n;for(;i<n;r+=c*n!=s*i)c+=$++i;$0=s%n?-1:r}z++
```

1行目を処理する際、先頭の`z`は未定義の変数なので、ブロックは実行されません。末尾の`z++`は後置インクリメントなので、出力も行われません。
対して、2行目を処理する際はすでにインクリメントされているので、ブロックも実行されるし出力も行われます。

ブロック内部を読みます。
まず、`for(;n<NF;)s+=$++n`で$a$の総和を求め、変数`s`に保存しています。
ここで、`NF`はフィールド数を表し、`$++n`は`$(++n)`とパースされます。
`n`をインクリメントするタイミングを調整して、`$1`から`$NF`までアクセスしています。

次に、`for(;i<n;r+=c*n!=s*i)c+=$++i`で$\sum_{j=1}^i a_j \ne i \times {\rm mean}(a)$を満たす$i$をカウントしています。
先のループを抜けた時点で`n==NF`が成り立っているので、こちらのループでは`NF`の代わりに`n`を使用しています。
`c`に$a$をどんどん足しつつ、`c*n!=s*i`であれば`r`に`1`足しています。この式は`c!=i*s/n`、つまり上の条件の式と等しいです。

最後に、`$0`に答えを代入します。
`s%n!=0`であれば`s%n`は`true`となり、`-1`が代入されます。`s%n==0`であれば前のループでカウントに使われた変数`r`が代入されます。
末尾の`z++`によって出力が行われます。

```octave:Octave(71Byte)
disp(int8((nnz(cumsum(a=center(dlmread(0)(2,:))))+1)*!any(mod(a,1))-1))
```

`dlmread(0)(2,:)`は[ABC015-B](https://qiita.com/kotatsugame/items/a1703bba780717897bf6#abc015-高橋くんの集計)と全く同じ使われ方をしています。

[center](https://octave.sourceforge.io/octave/function/center.html)はベクトルの要素それぞれから平均値を引いたものを返す関数で、[cumsum](https://octave.sourceforge.io/octave/function/cumsum.html)は累積和を計算する関数なので、これですべての$i$に対して$\sum_{j=1}^i(a_j-{\rm mean}(a))$が求まりました。
このうち値が`0`以外のものの個数を求めるのですが、ちょうど[nnz関数](https://octave.sourceforge.io/octave/function/nnz.html)があるので、これを使います。

さて、平均値が整数でない場合、`center(dlmread(0)(2,:))`の要素で整数でないものが存在します。
整数かどうかを確かめるのに、Octaveでも`1`で割ったあまりを使えます。
`a`を`center(dlmread(0)(2,:))`として、`mod(a,1)`でベクトルの要素それぞれの`1`で割ったあまりが一気に求まり、`0`でないものが存在するかは`any`でわかります。これの真偽を反転すると、ちょうどPerl6のコードでいう`$/%%1`になるので、あとはPerl6と同じように`nnz(a)+1`を掛けて`1`を引けば場合分けをせず$-1$の出力ができます。

そのまま`disp`関数で出力すると先頭の空白でWAになるので、`int`関数をかませるのですが、今回出力する値は`-1`から`100`の間です。このとき、`int32`という関数ではなくて`int8`という関数（8bit整数に変換する関数）を用いることで1Byte短縮することができます。


## [ABC028 文字数カウント](https://beta.atcoder.jp/contests/abc028/tasks/abc028_b)

> $S$

`'A'`、`'B'`、`'C'`、`'D'`、`'E'`、`'F'`が文字列$S$中にそれぞれ何回出現したかを空白区切りで出力します。

```perl:Perl6(23Byte)
get.ords.Bag{^6+65}.put
```

`ords`は文字列を各文字の文字コードのリストにする関数です。
`Bag`は整数の重みがついた集合のようなもので、値ごとに何個存在するかをカウントして重みにします。
`ords`から呼び出すことで、文字コードのリストから集合を構成します。
`'A'`、`'B'`、`'C'`、`'D'`、`'E'`、`'F'`はそれぞれ文字コードで`65`、`66`、`67`、`68`、`69`、`70`なので、これら6つの要素の重みを空白区切りで出力すればよいです。
要素の重みを得るには、`Bag`に`{}`でアクセスすればよいです。

文字コードは連続した値なので`65..70`と書くことができますが、さらに縮めて`^6+65`となります。
これは`^6=0..5`（[prefix ^](https://docs.perl6.org/language/operators#prefix_^)）という範囲に`65`を加えていると読めて、範囲に数値を加えると始点と終点をシフトしたように動作します。（[Shifting and scaling intervals](https://docs.perl6.org/type/Range#Shifting_and_scaling_intervals)）つまり、`(0+65)..(5+65)=65..70`です。

こうして、求める6つの値を配列として得ることができました。`put`という出力関数を使うと配列は空白区切りで出力されるので、フォーマットも正しく出力できます。

```perl:Perl(40Byte)
$s=<>;print"@{[map$s=~s/$_//g+0,A..F]}
"
```

`$s`に入力を読み込みます。
`map$s=~s/$_//g+0,A..F`についてですが、まず`A..F`は裸の単語であり`'A'..'F'`と書いたのと等しく、これは[マジカルインクリメント](http://perldoc.jp/docs/perl/5.8.8/perlop.pod#Auto-increment32and32Auto-decrement)と呼ばれる機能を用いて`'A'`、`'B'`、`'C'`、`'D'`、`'E'`、`'F'`と展開されます。
そのそれぞれに対して、`$s=~s/$_//g+0`が実行されます。`$s`の`$_`（`'A'`、`'B'`、……がそれぞれ入ります）にマッチする部分文字列がすべて（`g`）空文字列に置換され、置換に成功すれば置換した数が、失敗すれば空文字列が返されます。これを数値型に強制するために`0`を足しています。

こうして得られた値たちは`map`関数によって配列にまとめられているので、それを空白区切りにして出力すればよいです。
配列`@a`を空白区切りの文字列に直したいときは、文字列展開を利用して`"@a"`と書きます。今回、`map`の返り値は変数に代入されていませんが、このようなときも文字列展開を行う方法があります。それが`@{[ ]}`でくくるというものです。
まず配列を`[]`でくくることでリファレンス（参照）にし、次に`@{}`でくくることで配列のデリファレンスをします。

空白区切りの文字列を作った後、文字列の末尾で改行をするのですが、これは文字列に埋め込んだ方が短くなります。


## [ABC029 カキ](https://beta.atcoder.jp/contests/abc029/tasks/abc029_b)

> $S_1$
> $S_2$
> $:$
> $S_{12}$

12個の文字列のうち文字`'r'`が含まれるものの個数を出力します。

```bash:Bash(11Byte)
grep r -c;:
```

bashのコマンド`grep`は、テキスト中から正規表現にマッチする部分文字列が含まれる行を抜き出すものです。
`grep r -c`には引数が2つ渡されていて、このうち`r`が今回使用する正規表現です。意味はそのまま「文字`'r'`」です。
`-c`はオプションで、これはマッチした行ではなくその数を出力させるものです。つまり、このオプションを指定して実行すれば望む答えがいとも簡単に得られるということです。

ところが、`grep`の終了ステータス（C言語でいう`return n;`）は、1行もマッチしなかったときは`1`になります。つまり、`grep r -c`とだけ書くと、REになってしまうテストケースが存在するということです。
これを解消するために、セミコロンで区切ってコマンド`:`を実行しています。このコマンドは一切何もせずに正常終了する（終了ステータスが`0`である）だけのコマンドなので、これを最後に実行することでREを回避しています。


## [ABC030 時計盤](https://beta.atcoder.jp/contests/abc030/tasks/abc030_b)

> $n \quad m$

$d=((\frac{360}{12}n+\frac{360}{12 \times 60}m)-(\frac{360}{60}m))\bmod 360$として、${\rm min}(d,360-d)$を出力します。

```awk:Awk(37Byte)
180<$0=($1*60+$2)*5.5%360{$0=360-$0}1
```

${\rm min}(d,360-d)={\rm min}(360-d,360-(360-d))$なので$d$の代わりに$360-d$を求めることにします。
すると$360-d \equiv 360+5.5m-30n \equiv 5.5m+330n = (60n+m)\times 5.5 \pmod{360}$です。

$(60n+m)\times 5.5 \ge 0$なので、負の数の剰余などを気にせず$360$で割ったあまりを求められます。
そうして`$0`に代入しているのが、`$0=($1*60+$2)*5.5%360`の部分です。（AWKでは小数の剰余も正しく計算できます。）

$d>360-d \Leftrightarrow d>180$なので、`$0>180`が成り立つ場合は`$0=360-$0`を実行します。`$0`への代入文もまとめて書くと、条件の部分は`180<$0=($1*60+$2)*5.5%360`となり、これが`true`であればブロックが実行されます。

こうして`$0`に答えが代入されたため、`1`を評価して出力します。


## [ABC031 運動管理](https://beta.atcoder.jp/contests/abc031/tasks/abc031_b)

> $L \quad H$
> $N$
> $A_1$
> $A_2$
> $:$
> $A_N$

すべての$i$について$\begin{cases}
L-A_i & (A_i<L) \\\\
0 & (L \le A_i \le H) \\\\
-1 & (H \lt A_i)
\end{cases}$ を各行に出力します。

```awk:Awk(38Byte)
$2{L=$1;H=$2}NR>2,$0=$1<L?L-$1:-($1>H)
```

`$2`が`true`であるのは2番目のフィールドが存在する入力の1行目だけなので、`$2{L=$1;H=$2}`で変数`L`と`H`の初期化が行えます。

範囲パターンを使って、`NR>2`つまり3行目以降で出力が行われるようにしています。3行目以降であれば`NR>2`は常に成り立つので、`,`の右辺の値にかかわらず毎回出力が行われます。

出力の内容ですが、まず`$1<L`であれば`L-$1`となります。`L<=$1`のときに`0`または`-1`にしたいのですが、これは`H<$1`が`0`または`1`と評価されることを利用して、それの符号を反転させたものを出力します。`$1<=H`であれば`-0`となりますが、これは`0`と区別されず、`0`と出力されます。`H<$1`であれば`-1`が出力されるので、これで正しく場合分け出来ています。

```perl:Perl(40Byte)
? ??<>:print$_<=$'?$-=$`-$_:-1,$/while<>
```

後置`while`を使っています。通常、`while`文は変数`$_`に値を代入することはないのですが、唯一`while<>`という形で使ったときのみ、各行が`$_`に代入されます。
今回なぜ後置`for`を使っていないかというと、2行目の読み飛ばしをするためです。`for`はいったんすべての入力を読み込みますが、`while`は毎回読み込みを行うのです。
`while`でも入力をすべて読み込むまでループが回ります。

``? ??<>:print$_<=$'?$-=$`-$_:-1,$/``という式は三項演算子を用いており、``(? ?) ? <> : print( ($_<=$'?$-=$`-$_:-1), $/)``とパースされます。順に読んでいきます。

`? ?`というのは、特殊な正規表現の演算子です。[正規表現のクォート風の演算子](http://perldoc.jp/docs/perl/5.26.1/perlop.pod#Regexp32Quote-Like32Operators)の「`m?PATTERN?msixpodualngc`」というところに説明がありますが、これは「1度だけしかマッチングを行わない」ということを除いて、通常のマッチングとまったく同じです。
暗黙的に`$_`とマッチングが行われるので、`? ?`は最初の1回（つまり、入力の1行目です）において`$_=~/ /`と等しく、$L$と$H$の間のスペースにマッチします。以降はマッチングを行うことなく偽となります。

`? ?`が真だった場合は、`<>`が実行されます。これは2行目の読み飛ばしを行います。（`? ?`を使っているので1度しか実行されません。）
`<>`はスカラコンテキストとリストコンテキストで読み込み方が異なります。このコードでは`<>`は読み込んだ値を全く使用しない場所に置かれています。これは`void context`と呼ばれ、スカラコンテキストの1種なので、1行だけ読み捨てが行われます。

``print$_<=$'?$-=$`-$_:-1,$/``で出力を行います。
$A_i \le H$（`$_<=$'`）のとき${\rm max}(L-A_i,0)$を出力したいので、[ABC024-B](#abc024-自動ドア)で使用した`$-`を使い、``$-=$`-$_``とします。
$A_i \gt H$であれば`-1`を出力します。
`print`関数の引数には改行文字として`$/`も入れておきます。

これで望む出力が得られます。`while`で読み込むことになるのは1行目と3行目以降で、3行目以降は毎回`print`関数が呼ばれます。


## [ABC032 高橋君とパスワード](https://beta.atcoder.jp/contests/abc032/tasks/abc032_b)

> $s$
> $k$

$s$の、$k$文字の連続した部分文字列の種類を出力します。

```perl:Perl6(36Byte)
say +set ~<<(get~~m:ov/.**{$+=get}/)
```

`get~~m:ov/.**{$+=get}/`でマッチングを行っています。`m:ov`というのはマッチングのオプションとして`:ov`を指定する書き方です。
`:ov`というのは`:overlap`の略で、重なった文字列を個別にマッチングさせるオプションです。（[Overlap](https://docs.perl6.org/language/regexes#Overlap)）
$k$文字の連続した部分文字列すべてを正規表現で見つけようとすると、互いに重ならないようなものしか得られませんが、`:overlap`を指定することですべて見つけることができます。

使用する正規表現は`/.**{$+=get}/`です。`.`で任意の1文字、`**`で「$n$回繰り返す」ことを表現できます。その$n$にあたる部分が`{$+=get}`で、[ABC027-B](#abc027-島と橋)でも使った変数`$`に`get`を足しています。
なぜわざわざ変数に足しているのかというと、この`{}`の内部にはPerl6コードを書けるのですが、それがマッチングのたびに評価されるからです。
最初の評価のときに`$`が$k$になり、以降は読み込みがEOFに達しているため`get`が`Nil`しか返さず、`Nil`は数値としては`0`なので、`$`の値は変わらず$k$であり続けるというわけです。

こうして$k$文字の連続した部分文字列が取り出せました。
リストになっているのでそのユニークな要素数を求めたいのですが、実はマッチングによって得られる部分文字列は`Match`というクラスに属しており、`Set`（集合）を作ったり`unique`を実行するときに値の同値性を調べる演算子`===`ではすべて同じものであると判定されてしまうのです。

そのため、いったん`~<<`でリストのすべての要素に文字列化の単項演算子`~`を前置し、文字列に直しています。こうすることで正しく同値性が判定されるようになったので、`set`を構成し、それを数値として評価することで重複しない要素の個数が得られました。

```perl:Perl(47Byte)
($_,$=)=<>;/.{$=}(??{$%+=!${$&}++})/;print$%,$/
```

まず入力部の`($_,$=)=<>`を読みます。この`<>`は代入先がリストになっているので、リストコンテキストで評価されます。よって、この1文で`$_`に$s$を、`$=`に$k$をそれぞれ代入できます。

次の`/.{$=}(??{$%+=!${$&}++})/`は`$_`にマッチングを試みる正規表現です。
Perl6では`:overlap`というオプションを使って$k$文字の部分文字列すべてを取り出しました。Perlにはそんな便利な機能はありません。そこでテクニックとして、「マッチングを失敗させる」というものがあります。

正規表現として「任意の$k$文字」＋「文字列中に現れないもの」を指定すると、当然マッチングは失敗します。しかし、その失敗に至るまでに、ありうるすべての$k$文字の部分文字列を取り出しているはずです。なぜなら、指定した正規表現のうち最後の「文字列中に現れないもの」を確かめるまでは、マッチングは成功しているからです。

よって、マッチングの途中でPerlコードを実行することができれば、取り出している途中の文字列を見ることによって、すべての$k$文字の部分文字列が得られます。
これは実は、Perl特有の[正規表現の拡張パターン](http://perldoc.jp/docs/perl/5.14.1/perlre.pod#Extended32Patterns)を使用して実現できます。

何をやりたいかが分かったところで、実際の正規表現を読みます。
`.`は任意の1文字を表し、`{$=}`は直前の要素の`$=`回の繰り返しを表します。ここで、`$=`は正規表現自体によって展開されるので、もし末尾に改行がついたままであるなら、
`/.{k
}(??...`
というふうに正しくない位置で改行しているとみなされてREになります。
今は`$=`を使っていますが、これは整数を保持する組み込み変数であり、値が代入された時点で数値として評価されるため、末尾の不要な文字（ここでは改行文字）が自動的に削除されます。この機能を使うために、$k$は`$=`に代入されました。

`(??{$%+=!${$&}++})`は、上の議論によれば「文字列中に現れないもの」のはずです。
`(??{ code })`というのがマッチングの途中でPerlコードを実行する方法であり、実際にマッチングする際に内部のブロックが評価され、その戻り値が正規表現として使用されます。
後で述べますが、今回の戻り値は必ず数値になるので、それで「文字列中に現れないもの」が指定できます。

`code`の部分、`$%+=!${$&}++`を読みます。
まず、`$&`というのは正規表現にマッチングした部分の文字列を表します。ここではまだマッチングは終了していませんが、取り出している途中の文字列が入っているので、これを使うことで$k$文字の部分文字列が得られます。
`${$&}`には、[ABC008-B](https://qiita.com/kotatsugame/items/a1703bba780717897bf6#abc008-投票)と同じテクニックを使っています。`$%+=!${$&}++`によって、ある文字列の最初の出現でのみカウント変数`$%`に`1`足されるようになります。（文法エラーが起こるため`$$&`とは書けません。）
戻り値は加算が行われた後の`$%`なので、先に言ったように必ず数値になります。

このマッチングが無事終了すれば、`$%`には答えが入っているので、改行文字とともに出力を行います。

$k$が文字列$s$の長さより大きい場合は、そもそも`(??{ code })`が1回も実行されず、カウント変数が未定義値のままになってしまい、`0`ではなく空文字列を出力してしまいます。そのWAを防ぐために、`$=`と同じく整数を保持する組み込み変数`$%`がカウント変数に選ばれています。（`$=`は初期値が`60`なので、この用途には向きません。）

ところで、`$$&`とは書けず、`${$&}`と書いていると述べました。実はAtCoderの`Perl (v5.18.2)`のインタプリタは不思議な挙動をし、
`$
$&`
と間に改行を入れることで`${$&}`と同じ意味になります。新しいバージョンではこういう挙動をしなくなっています。
今回は改行を入れると文法エラーを起こすため使用できませんでした。


## [ABC033 町の合併](https://beta.atcoder.jp/contests/abc033/tasks/abc033_b)

> $N$
> $S_1 \quad P_1$
> $S_2 \quad P_2$
> $:$
> $S_N \quad P_N$

$2P_i \gt \sum_{j=1}^N P_j$が成り立つような$i$が存在すれば$S_i$、しなければ`atcoder`と出力します。

```awk:Awk(48Byte)
a+p<a+=$2{s=$1;p=$2}END{print a<p*2?s:"atcoder"}
```

条件を満たすような$i$が存在するとき、明らかに$P_i$は$P$の最大値なので、その最大値を求めます。

`a+p<a+=$2`ですが、これの両辺から`a`を引くと`p<$2`になり、これまでの$P$の最大値`p`と今見ている`$2`の値を比較しています。
変数`a`に$P$の総和を計算するのを同時に行うために、こういう書き方になっています。

`p<$2`であれば、ブロックの中で`p`の値を更新するとともにそのときの$S$を`s`に保存しています。
1行目を処理しているとき、`$2`は数値としては`0`なので、$P$の総和を計算することに影響を与えませんし、ブロックも実行されません。

`END`ブロックで出力を行います。`a<p*2`が成り立てば`s`に保存されている$S_i$を、成り立たなければ`"atcoder"`を出力します。


## [ABC034 ペア](https://beta.atcoder.jp/contests/abc034/tasks/abc034_b)

> $n$

$ \begin{cases}
n+1 & \text{if $n$ is odd} \\\\
n-1 & \text{if $n$ is even}
\end{cases}$を出力します。

```awk:Awk(12Byte)
$0-=1-$0%2*2
```

$n \bmod 2$を使って場合分けをなくすことを考えます。
$n \bmod 2$が$1$ならば$1$を、$0$ならば$-1$を$n$に足せばよいですが、これは$(n \bmod 2)\times 2-1$で得られます。
上に示したコードでは、`$0%2*2-1`を足す代わりに`1-$0%2*2`を引いています。

```perl:Perl6(14Byte)
say get+1+^1-1
```

Perl6では`+`と`+^`（`bitwise XOR`）の優先順位が同じなので、上のコードは`((get+1)+^1)-1`と解釈されます。
場合分けをして読みます。

- $n$が偶数のとき）`get+1`は奇数であり、`(get+1)+^1`で下1ビットが`0`に戻るため`get`に等しく、最終的に`get-1`となる。
- $n$が奇数のとき）`get+1`は偶数であり、`(get+1)+^1`は下1ビットが`1`にセットされて`get+2`となるため、最終的に`get+1`となる。

よって偶奇どちらも正しい答えが得られていることがわかりました。


## [ABC035 ドローン](https://beta.atcoder.jp/contests/abc035/tasks/abc035_b)

> $S$
> $T$

文字列$S$中の文字$a$の個数を$C_a$として、$\begin{cases}
|C_L-C_R|+|C_U-C_D|+C_? & (T=1)\\\\
|C_L-C_R|+|C_U-C_D|-C_? & (T=2 \land |C_L-C_R|+|C_U-C_D| \ge C_?)\\\\
(|C_L-C_R|+|C_U-C_D|-C_?)\bmod 2 & (T=2 \land |C_L-C_R|+|C_U-C_D| \lt C_?)
\end{cases}$を出力します。

```perl:Perl(77Byte)
$_=<>;$d=abs(y/R//-y/L//)+y/?//*(3-<>*2)+abs y/U//-y/D//;print$d<0?$d%2:$d,$/
```

入力を`$_`に読み込み、[ABC003-B](https://qiita.com/kotatsugame/items/a1703bba780717897bf6#abc003-atcoderトランプ)で用いたのと同じ方法で、`y///`を利用して文字数を数えています。

`3-<>*2`では$T$を読み込んでいて、$T=1$のときは`1`を、$T=2$のときは`-1`を`y/?//`に掛けています。これは、上で示した場合分けで$C_?$の係数が$T$の値によって異なることを反映しています。

また、`abs(y/R//-y/L//)`と`abs(y/U//-y/D//)`の片方を式の1番後ろに持ってくることによって、関数呼び出しの括弧を省いています。

$T=1$のとき$|C_L-C_R|+|C_U-C_D|+C_?$、$T=2$のとき$|C_L-C_R|+|C_U-C_D|-C_?$が得られ、`$d`に代入しています。上の場合分けですが、$T=1$のときの$|C_L-C_R|+|C_U-C_D|+C_?$は明らかに`0`なので、結局`$d`の値が`0`以上ならばそのまま、`0`未満ならば`2`で割った余りが答えであるとわかります。

よって、`$d<0?$d%2:$d`と改行を出力すればよいです。


## [ABC036 回転](https://beta.atcoder.jp/contests/abc036/tasks/abc036_b)

> $N$
> $s_{1,1} \quad ... \quad s_{1,N}$
> $:$
> $s_{N,1} \quad ... \quad s_{N,N}$

マス目を時計回りに`90`度回転させて出力します。

```perl:Perl6(25Byte)
put [RZ~] get.comb xx get
```

`xx`はリストを作成する演算子です。先に右の項`get`が評価され、左項`get.comb`は繰り返すたびに評価されるので、`get.comb xx get`は$N$回入力を読み込んでそれぞれ文字のリストに分解した「リストのリスト」になります。

`[RZ~]`はリストを`RZ~`という演算子で`fold`する書き方です。この`RZ~`という演算子はややこしくて、まず`~`という文字列連結の演算子があり、それを「リストを2つ受け取って要素ごとに演算する」ようにするメタ演算子`Z`で修飾し、最後に「左項と右項を入れ替える」ようにするメタ演算子`R`で修飾したものです。

例示をします。
`'a' ~ 'b'`は`'ab'`になります。
`( 'a', 'b' ) Z~ ( '1', '2' )`は`( 'a1', 'b2' )`になります。
`( 'a', 'b' ) RZ~ ( '1', '2' )`は`( '1a', '2b' )`になります。

`fold`すると以下のようになります。
`[ RZ~ ] ( ( 'a', 'b', 'c' ), ( 'd', 'e', 'f' ), ( 'g', 'h', 'i' ) )`
-> `( 'a', 'b', 'c' ) RZ~ ( 'd', 'e', 'f' ) RZ~ ( 'g', 'h', 'i' )`
-> `( 'a', 'b', 'c' ) RZ~ ( 'gd', 'he', 'if' )`
-> `( 'gda', 'heb', 'ifc' )`

これは、左の入力が右の状態になったのと同じであり、`90`度回転されています。
`abc` -> `gda`
`def` -> `heb`
`ghi` -> `ifc`
`[Z~]`によってもともと$s_{i,1} \quad ... \quad s_{i,N}$（横方向）と繋がっていた文字列を$s_{1,i} \quad ... \quad s_{N,i}$（縦方向）に繋ぎ変えており、その繋ぎ変える順番を`R`で逆転させたことにより、`90`度回転が実現されています。

最後に得たリストの要素を出力するのですが、この問題のジャッジでは改行区切りの代わりに空白区切りにしてもACすることができます。[ABC028-B](#abc028-文字数カウント)でも使った`put`という出力関数を使えば、デフォルトで空白区切りになって出力されます。

```octave:Octave(39Byte)
disp(rot90(scanf("%s",[input(0),99]))')
```

まず最初に1番内側の`input(0)`が実行されます。これは入力を1行読み込み、それをOctaveの式として評価します。引数には入力を受け付ける際に出力するプロンプトを指定するのですが、ここに`0`を書くとアスキーコードで`0`つまり`NULL`文字が指定されたと見なされ、余計な出力がされなくなります。

次に`scanf("%s",[input(0),99])`が実行されます。`scanf`関数は、第1引数に与えられたフォーマット文字列に従って読み込めるだけ入力を読み込むのですが、第2引数に数値または数値のベクトルを指定すると、必要な分だけ読み込んでその次元の行列に成形してくれます。

フォーマット文字列の"%s"は空白に類しない1文字を表します。サイズは$N$行$99$列行列を指定しているのですが、入力にはそんなに文字がないので、途中で読み込みが打ち切られて$N$行$N$列の行列が返ります。

左の入力は右のように読み込まれます。
`abc` -> `adg`
`def` -> `beh`
`ghi` -> `cfi`
何が起こっているかというと、`scanf`関数はデフォルトでは列ベクトル（縦のベクトル）を返すので、その方向に優先的に詰めているのです。まず$N$文字読み込んで$1$列目に詰め、次に$N$文字読み込んで$2$列目に詰め……$99$列目に詰める前に入力が尽きるので$N$行$N$列の行列が返るのであり、もしも`[input(0),99]`ではなく`[99,input(0)]`と指定していたら$99$行の崩れた行列が返ります。
また、文字の行ベクトルは文字列と等価なので、行ごとに連結されているように見えます。

さて、出力は行単位なのであとは行ごとに文字列を反転すればよいのですが、上のコードでは（文字数は変わりませんが）別の方法を使っています。それが`rot90( )'`であり、まず`rot90`で反時計回りに`90`度回転させた後`'`で行列を転置しています。

先ほどの入力の例を使ってどうなるか確認します。順に`scanf`で読んだ状態、`rot90`、転置です。
`adg` -> `ghi` -> `gda`
`beh` -> `def` -> `heb`
`cfi` -> `abc` -> `ifc`

これでも行ごとに反転できることが確かめられました。`disp`関数は文字列を出力する際に余計な空白をつけず、また行列は行ごとに改行されるので、正しい出力が行われます。


## [ABC037 編集](https://beta.atcoder.jp/contests/abc037/tasks/abc037_b)

> $N \quad Q$
> $L_1 \quad R_1 \quad T_1$
> $:$
> $L_Q \quad R_Q \quad T_Q$

最初、大きさが$N$ですべての要素が$0$の数列があります。これの$L_i$番目から$R_i$番目（`1-indexed`）を$T_i$に書き換える操作を$Q$回行ったあとの数列を、改行区切りで出力します。

```perl:Perl(52Byte)
@_=(0)x<>;@_[$`-/ .* /..$&-1]=($')x99for<>;print"@_"
```

改行区切りでと書きましたが、改行区切りである必要はありません。

入力の1行目をそのまま数値として評価すると、最初の空白以降の$Q$が無視されて$N$になるので、`(0)x<>`で$N$個の`0`を表せます。これを`@_`に代入します。

残りの入力を`for<>`でループします。各ループごとに``@_[$`-/ .* /..$&-1]=($')x99``が評価されます。

``$`-/ .* /..$&-1``ですが、これは[ABC018-B](https://qiita.com/kotatsugame/items/a1703bba780717897bf6#abc018-文字列の反転)の``$`-/ /..$'-1``と同じテクニックを使っています。
正規表現`/ .* /`は「空白」＋「任意の文字列」＋「空白」にマッチします。入力の各行には空白が2つずつしかないので、「任意の文字列」の部分には空白に挟まれた$R_i$が当てはまります。
したがって、`/ .* /`を実行するだけで``$` ``には$L_i$が、`$&`には$R_i$が、`$'`には$T_i$がそれぞれ代入されます。（`$&`の先頭と末尾に空白文字も入っていますが、これは数値として扱う際は読み飛ばされるので問題になりません。）
`1-indexed`を`0-indexed`に直す方法はABC018-Bと変わっていません。

こうしてアクセスした`@_`のスライスに、それぞれ`$'`を代入します。代入演算子の左項はリストなので、右項はリストコンテキストで評価されます。
そのまま`$'`を代入すると、大きさ1のリストを代入しているとみなされ、スライスの残りの部分が未定義値になってしまいます。これを防ぐために`$'`を$R_i-L_i+1$個用意するのですが、実はスライスに代入するリストがスライスより大きいと、余剰分は無視されます。つまり、わざわざ``($')x($&-$`+1)``とぴったり用意する必要はなく、十分に大きければ何でもよいのです。

制約より$R_i-L_i+1 \le 100$です。`$<`はAtCoderにおいて常に`1000`を表すので、これを使えば十分です。（テストケースハックをすると`99`で十分である（$R_i-L_i+1 = 100$であるテストケースが存在しない）ことがわかるので、1Byte縮みます。また、数字と`for`の間は`99for`と空白を開けずに書いてもパースができます。）

こうしてすべての処理を行ったあとの`@_`を出力します。`"@_"`と書くと、リストの要素が空白区切りになるので、これでACできます。
実をいうと、リストに代入した`$'`には元の文字列の末尾の改行がくっついたままになっているので、実際の出力は改行と空白が一緒になってしまい、けっこう崩れています。それでも要素同士がくっついてしまうことはないので、ジャッジに正しく読み取ってもらえ、ACできました。


## [ABC038 ディスプレイ](https://beta.atcoder.jp/contests/abc038/tasks/abc038_b)

> $H_1 \quad W_1$
> $H_2 \quad W_2$

$H_1 = H_2 \lor H_1 = W_2 \lor W_1 = H_2 \lor W_1 = W_2$ならば`YES`、そうでなければ`NO`を出力します。

```sed:Sed(30Byte)
N
/\<\(.*\)\>.*\n.*\1/cYES
cNO
```

シンタックスハイライトが壊れていますが、`N`は「パターンスペースに改行と次の行を追加する」コマンドです。

上の条件は、単純に言えば改行を挟んで同じ単語が2つ存在すれば`YES`であるというものです。
それを`/\<\(.*\)\>.*\n.*\1/`で判定していますが、この正規表現はほとんど[ABC021-B](#abc021-嘘つきの高橋くん)で使用したものと同じです。

`\<\(\w*\)\>`で単語をキャプチャし、`\1`との間に`.*\n.*`を指定して改行（`\n`）を挟んでいることを表しています。改行とそれぞれの単語の間に何文字あってもいいように`.*`を書いています。
そして、`\w`を`.`にしてもいい理由もABC021-Bと変わりません。

入力は2行しかなく、最初に`N`を使い1行追加で読み込んでいるので、このスクリプトが実行されるのは1度きりとなります。当然出力も1回だけです。

```perl:Perl(31Byte)
<>=~$";print<>=~/$`|$'/x?YES:NO
```

`<>=~$"`で入力の1行目を``$` ``と`$'`に代入します。

入力の2行目が``$` ``または`$'`にマッチすれば`YES`です。正規表現としては``/$`|$'/``で表せます。……とはならず、`$'`の末尾に改行がついたままなので、それも含めてマッチする必要が出てきてしまい、正しくありません。正規表現にオプション`x`をつけると、改行を無視してくれるようになるので、これで正しく判定ができるようになりました。（[/xについて](http://perldoc.jp/docs/perl/5.14.1/perlre.pod#47x)）

2行目の`<>`にマッチングすれば`'YES'`、しなければ`'NO'`を出力します。裸の単語機能を使ってクオートする手間を省いています。

```awk:Awk(32Byte)
s?$0=s~$1"|"$2?"YES":"NO":0>s=$0
```

三項演算子を使って、入力の1行目と2行目で処理を変えています。

1行目の時点では変数`s`は未定義なので、`0>s=$0`が実行されます。`s`に`$0`を代入していますが、うっかり`$0`が出力されないよう`0>$0`という必ず`false`の式を評価するようにしています。

2行目では`$0=s~$1"|"$2?"YES":"NO"`が実行されます。
`~`はマッチングの演算子なので、`s`（入力の1行目）が`$1"|"$2`にマッチするかを確かめています。これは1行目と2行目が逆転した以外はPerlと同じ方法をとっています。
正規表現中で変数を展開できないので、文字列として正規表現を構成します。といっても`$1`、`"|"`、`$2`をこの順で連結するだけです。`|`は他の言語の正規表現と同じく「または」という意味です。

これにマッチングすれば`"YES"`を、しなければ`"NO"`を出力する、というのもPerlと一緒です。


## [ABC039 エージェント高橋君](https://beta.atcoder.jp/contests/abc039/tasks/abc039_b)

> $X$

$\sqrt[4]X$を出力します。この値は整数であることが保証されています。

```awk:Awk(7Byte)
$0^=.25
```

$1/4$、つまり$0.25$乗すればよいです。`0.25`の先頭の`0`は省けます（`.25`と`1/4`でByte数は変わりませんが）。
`$0`の値は必ず`1`以上になるので出力は行われます。


```perl:Perl6(11Byte)
say get**¼
```

このコードの面白い点は`¼`、この1文字がすべてです。

Unicodeで数字として登録されている文字は、Perl6において数値リテラルとして使用できます。
`.25`も`1/4`も3Byteですが、`¼`は2Byteです。


## [ABC040 □□□□□](https://beta.atcoder.jp/contests/abc040/tasks/abc040_b)

> $n$

$| n - \lfloor n/i \rfloor|+(n \bmod i) \quad (1 \le i \le n)$の最小値を出力します。

```perl:Perl6(41Byte)
say min $!/++$/+|0-$/+$!%$/xx sqrt $!=get
```

$n \le 10^5$なので、Perl6では$n$回ループするとTLEしてしまいます。実は$1 \le i \le \sqrt n$の範囲だけ試せばよいので、上のコードではそうしています。

コードをパースすると`say( min( ($!/++$/+|0-$/+$!%$/) xx sqrt($!=get) ) )`となります。まず`$!`に入力を読み込み、それの`sqrt`回`$!/++$/+|0-$/+$!%$/`を実行します。そうすると、各実行ごとの`$!/++$/+|0-$/+$!%$/`の値がリストになって得られるので、最小値を求めて出力しています。

では`$!/++$/+|0-$/+$!%$/`は何をやっているのでしょうか。
これもパースすると、`(($! / ++$/) +| 0) - $/ + ($! % $/)`になります。
ループを回すたびに`$/`をインクリメントすることで$i$の代わりに`$/`を使っています。

`$!`には$n$が入っているので、`$! / ++$/`で`$/`をインクリメントしつつ$n/i$を求めています。これを`0`と`bitwise OR`（`+|`）することで、整数に切り捨てています。つまり`(($! / ++$/) +| 0)`で$\lfloor n/i \rfloor$となります。

$1 \le i \le \sqrt n$ならば$| n - \lfloor n/i \rfloor|=\lfloor n/i \rfloor-n$なので、`(($! / ++$/) +| 0)`から`$/`を引いています。
最後に、`$! % $/`（$n \bmod i$）を足して、各$i$に対する$| n - \lfloor n/i \rfloor|+(n \bmod i)$が求められました。

それらの最小値が答えなので、先に述べたように求めて出力しています。

```awk:Awk(46Byte)
{for(m=$1;i++<j=int(m/i);$1>j&&$1=j)j+=m%i-i}1
```

変数`m`には最初`$1`、つまり$n$が代入されます。

`i++<j=int(m/i)`で$1 \le i \le \sqrt n$のループを行っています。
本来は`i`を`1`に初期化して`i<=int(m/i)`とするところですが、`i-1<int(m/i)`と読み替えることでインクリメントをまとめることができ、初期化も必要なくなります。

$| n - \lfloor n/i \rfloor|+(n \bmod i)$を求めるために`j=int(m/i)-i+m%i`とするのですが、このうち`int(m/i)`はループ条件式のところで出現しているので先に代入しておき、後から`m%i-i`を足しています。

`$1`を最小値を持っておく変数としており（`$0`ではなく`$1`である理由はありません）、`$1>j&&$1=j`という式は`$1>j`であれば`$1=j`を実行します。この短絡評価を利用した書き方は三項演算子より短くなっています。

最後に`1`を評価して出力するのですが、答えは`$0`ではなく`$1`に入っています。
フィールド変数が個別に書き換えられた場合、AWKはフィールド変数を順番に並べ、変数`OFS`（デフォルトは`" "`）で連結して`$0`とします。（[フィールドの内容を変更する](http://www.kt.rim.or.jp/~kbk/gawk-30/gawk_6.html#SEC37)参照）
今回はフィールドが1つしかないので、`$2`や`$3`の部分に余計なものがなく、正しい出力が得られました。

```octave:Octave(49Byte)
disp(min(mod(n=input(0),a=1:n)+abs(a-fix(n./a))))
```

`n=input(0)`で入力を読み、`n`に代入しています。`1:n`は`1`から`n`までの`1`刻みの行ベクトルを表します。

`mod(n,1:n)`で、`n`を`1`から`n`までのそれぞれで割ったあまりが1度に得られます。
`./`は「要素ごと」の除算を表すので、`n./(1:n)`でこれまた`n`を`1`から`n`までのそれぞれで割った商が得られます。
`fix`は実数を`0`に向かって丸める関数で、`0`以上の数に対しては`floor`関数と同じ役割を果たす2Byte短い関数として使えます。
`fix`も`abs`もベクトルを与えられると要素ごとに計算します。
`(1:n)-fix(n./(1:n))`は要素ごとの引き算をするので、例えば最初の要素は`1-fix(n/1)`を表し、2番目の要素は`2-fix(n/2)`を表す……というふうに計算されます。

結局、`mod(n=input(0),a=1:n)+abs(a-fix(n./a))`というのは$(n \bmod i)+| n - \lfloor n/i \rfloor|$をすべての$1 \le i \le n$に対して一斉に計算している式です。こうしてループを回さずに並列的に計算できるのが、Octaveの強みです。

そうして得られたベクトルの最小値を求めて出力すればよいです。