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

# はじめに

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

## 言語別索引

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

### Bash

[ABC002](#abc002-罠) 11Byte
[ABC004](#abc004-回転) 7Byte
[ABC005](#abc005-おいしいたこ焼きの食べ方) 18Byte
[ABC009](#abc009-心配性な富豪ファミリーレストランに行く) 22Byte
[ABC010](#abc010-花占い) 27Byte
[ABC012](#abc012-入浴時間) 17Byte

[ABC019](#abc019-高橋くんと文字列圧縮)

### Perl

[ABC003](#abc003-atcoderトランプ) 58Byte
[ABC015](#abc015-高橋くんの集計) 36Byte
[ABC018](#abc018-文字列の反転) 54Byte
[ABC019](#abc019-高橋くんと文字列圧縮) 33Byte

[ABC006](#abc006-トリボナッチ数列)
[ABC008](#abc008-投票)
[ABC014](#abc014-価格の合計)

### Python2

[ABC001](#abc001-視程の通報) 55Byte

### Ruby

[ABC003](#abc003-atcoderトランプ)
[ABC018](#abc018-文字列の反転)

### Sed

[ABC007](#abc007-辞書式順序) 11Byte
[ABC011](#abc011-名前の確認) 11Byte
[ABC017](#abc017-choku語) 24Byte

### Awk

[ABC006](#abc006-トリボナッチ数列) 42Byte
[ABC008](#abc008-投票) 28Byte
[ABC014](#abc014-価格の合計) 40Byte
[ABC016](#abc016-ab-problem) 39Byte
[ABC020](#abc020-足し算) 11Byte

[ABC002](#abc002-罠)
[ABC015](#abc015-高橋くんの集計)

### Octave

[ABC015](#abc015-高橋くんの集計)

### Perl6

[ABC013](#abc013-錠) 25Byte

[ABC014](#abc014-価格の合計)
[ABC015](#abc015-高橋くんの集計)
[ABC018](#abc018-文字列の反転)



# 問題

## [ABC001 視程の通報](https://beta.atcoder.jp/contests/abc001/tasks/abc001_2)

> $m$

$m \le 70000$のとき${\rm min}(\lfloor m/100 \rfloor,m/1000+50,m/5000+74)$、$m \gt 70000$のとき$89$を2桁に0埋めして出力します。この値が整数でないような入力は与えられません。

```python:Python2(55Byte)
i=input()/1e3;print"%02d"%min(i*10,i+50,i/5-2e-5+75,89)
```

$70000 \lt m \lt 75000 \Rightarrow m/5000+74 \lt 89$なので、${\rm min}(\lfloor m/100 \rfloor,m/1000+50,m/5000+74,89)$を出力しようとするとそのケースだけWAになってしまいます。このコードでは、$70000/5000+75-2 \times 10^{-5} \lt 89 \lt 70001/5000+75-2 \times 10^{-5}$ということを利用して、$ m = 70001$であってもギリギリで$89$が出力されるようにしています。小数点以下を切り捨てると$70000/5000+75-2 \times 10^{-5}$は$88$となり、これも正しい出力が得られます。

こうすると4数の最小値を出力すればよくなります。
`i=input()/1e3`で変数`i`に$m/1000$を代入し、`min(i*10,i+50,i/5-2e-5+75,89)`を`"%02d"`というフォーマットで出力します。これで小数点以下が切り捨てられます。


## [ABC002 罠](https://beta.atcoder.jp/contests/abc002/tasks/abc002_2)

> $W$

文字列$W$中から`aiueo`の5文字をすべて削除して出力します。

```bash:Bash(11Byte)
tr -d aiueo
```

`tr`コマンドに`-d`オプションを与えることで、置換ではなく削除を行っています。

```awk:Awk(19Byte)
gsub(/[aiueo]/,a)a
```

`gsub`は第3引数、今回のようになければ`$0`を対象にして、第1引数のパターンにマッチする部分文字列すべてを第2引数に置換し、その置換の回数を返します。
置き換える文字列には空文字列を指定し、`gsub`の返り値を文字列化することで置換の回数が0であっても処理後の`$0`が出力されるようにしています。


## [ABC003 AtCoderトランプ](https://beta.atcoder.jp/contests/abc003/tasks/abc003_2)

> $S$
> $T$

文字列中の`@`を`atcoder`のいずれかの文字に置換することで$S=T$とできれば`You can win`、できなければ`You will lose`と出力します。

```perl:Perl(58Byte)
print"You ",y,\0!#-%/24,,c?"will lose
":"can win
"for<>^<>
```

構造は`print(A) for(B)`です。

forが後ろにあるのは後置forと言って、for文で実行するのが1つの式のみである場合に使えるものです。今回は`print(A)`がその実行する式にあたり、for文では`(B)`をリストとして解釈して、その値を順番に`$_`に代入して`print(A)`を実行します。

`print(A)`では、まず共通する`"You "`がくくりだされていて、残りの部分の出力を三項演算子`y,\0!#-%/24,,c ? "..." : "..." `で分けています。
この判定の部分には`y,\0!#-%/24,,c`というものが使われています。これは置換を行うもので、`(文字列)=~y...`という形で使われていない場合、自動的に`(文字列)`の部分に`$_`を補うので、`$_=~y,\0!#-%/24,,c`、つまり`$_`の値を置換しています。

`(B)`すなわち`<>^<>`では入力される2つの文字列のXORを取ります。文字列のXORとはどういう値を表すかというと、同じ位置にある文字の文字コードをXORし、そうして得られた数列のそれぞれの値を文字コードとして見ることでまた文字に戻した列です。
これは単一の文字列であり、そういったリストではない値が`(B)`に来た場合には、1要素のリストであるかのように扱われます。よって、`$_`に`<>^<>`が代入されて`print(A)`が1回だけ実行されます。
結局`print "You ",( (<>^<>)=~/[^\0!#-%\/24]/ ? "..." : "..." )`と書いたのと等しいです。

`y,\0!#-%/24,,c`について説明しますが、その前に、このコードより1Byte長いコードで使われていた`/[^\0!#-%\/24]/`を用いて、何をしたいかについて説明します。これも`$_=~/[^\0!#-%\/24]/`という形で評価され、正規表現でパターンにマッチするか否かを返します。

わざわざ文字列のXORを取ったわけですが、これは今回どのような性質を持つかというと、まず同じ文字同士のXORは0になりますから、ある箇所が`"\0"`であればその位置の文字は$S$、$T$で等しいです。
次に、「一方が`@`、もう一方が`atcoder`のいずれかの文字」であるとき、`@`のアスキーコードは64ですから、文字のXORは以下のようになります。

|| a | c | d | e | o | r | t |
|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
|アスキーコード|97|99|100|101|111|114|116|
|XOR|33|35|36|37|47|50|52|
|文字| ! | # | $ | % | / | 2 | 4 |

以上2通り以外の文字の組み合わせが存在する場合$S=T$は達成できないので、結局文字列をXORして得られた中に`\0 ! # $ % / 2 4`以外の文字が存在しないかどうかを確かめることになります。
それが`/[^\0!#-%\/24]/`というパターンです。

`[]`で文字集合を表しますが、先頭に`^`があると、補集合を指定したのと同じ扱いになります。つまり、`[^abc]`は「`abc`のいずれでもない文字」を表します。

上で列挙した文字をそのまま書くなら、（`/`を指定するにはエスケープが必要であることを踏まえて）`/[^\0!#$%\/24]/`になりますが、これは`$%`が変数として解釈されてしまい上手くいきません。`$`もエスケープすれば良いのですが、実は今回はそれを非常に鮮やかに回避する方法があります。それが`-`、「範囲」です。

`#-%`とすると「`#`から`%`までの文字」を表すことができ、`#`と`%`のアスキーコードでの間には`$`しか存在しないので、`#-%`は`#$%`の3文字を指定したのとまったく等しくなります。これはエスケープを使って`#\$%`と書くよりも1B短いです。

以上より、`(<>^<>)`が`/[^\0!#-%\/24]/`にマッチするのは$S=T$となりえないことと同値であることがわかりました。
では`y,\0!#-%/24,,c`は何だったのでしょうか。

置換の演算子`y`は通常は`y/A/B/`として使います。`A`に指定された文字を、対応する位置の`B`の文字に置き換える役割を持ちます。
ここで、このスラッシュ記号は他の記号に変更することができます。今回は、`,`をスラッシュの代わりに使っています。こうすることで、`/[^\0!#-%\/24]/`ではエスケープが必要だったスラッシュ記号がそのまま書けます。この1Byteが短縮ポイントです。

文字集合の補集合を指定するには、`y///c`という風に`c`フラグを付けます。
`y/A/B/`として使う、と言いましたが、この`B`の部分を今回のように省略すると、`A`とまったく同じ文字に置換しようとします。これでは`$_`に変更が加わりませんが、`y`を使って行いたいのは別のことです。
実は、`y`は置換が行われた文字数を返すのです。これさえわかれば`$_`が変更されようがされなかろうが関係ありません。

`y`で置換するように指定されたのは、上に列挙した8つの文字「でない」文字すべてです。これで置換が行われた文字数が0より大である、つまり`y`が`true`に評価されれば、$S=T$となりえないことを示す文字が存在したということで、`You will lose`を出力します。1回も置換が行われなければ`You can win`と出力します。

`(<>^<>)=~y,\0!#-%/24,,c ? "will lose" : "can win"`で望む出力を選択して`print`します。

わざわざ後置forを使ったのは、マッチングを行うのには`(<>^<>)=~y...`とするのと`$_=<>^<>;y...`のように変数`$_`に代入してマッチング対象を暗黙的に指定するのが同じ長さであり、`$_`に値を代入するときに後置forを使うことでそれらよりも1B短くなるからです。

```ruby:Ruby(99Byte)
a,b=*$<;puts (0..9).all?{|i|a[i]==b[i]||"@a@t@c@o@d@e@r@"[a[i]+b[i]]}?"You can win":"You will lose"
```

`$<`は標準入力で、`*`（`splat展開`）をすることで入力をすべて読んで改行で区切ったものに展開されます。`a,b=*$<`によって`a`に1行目、`b`に2行目が代入されます。

`(0..9).all?`は続くブロックの戻り値が`0,1,...,9`（文字列長は10以下だと保証されています）のすべてにわたって真である場合に真となります。`i`にそれぞれの数字が代入されてブロックが評価されます。

まず`a[i]==b[i]`、これは$S$と$T$の同じ位置に同じ文字がある場合を表すほかに、文字列長を超えたインデックスで文字を取得しようとしたときにRubyでは`nil`が返ってくるので、このときも`true`となることで後ろの評価を行わないようにしています。

次に、`"@a@t@c@o@d@e@r@"[a[i]+b[i]]`では、文字列のインデックスが`a[i]+b[i]`という「2文字の文字列」になっています。このような指定をした場合、等しい部分文字列があればそれを、なければ`nil`を返しますが、これは真偽値で言うとそれぞれ`true`と`false`です。つまり`"@a@t@c@o@d@e@r@"[a[i]+b[i]]`は「`a[i]+b[i]`が`"@a@t@c@o@d@e@r@"`の部分文字列として存在するか？」という意味です。

$S=T$となれるような互いに異なる`a[i]`と`b[i]`の組み合わせは、一方が`@`でもう一方が`atcoder`のいずれかの文字ですが、このような組み合わせはすべて`"@a@t@c@o@d@e@r@"`の部分文字列として存在します。逆に他の組み合わせは部分文字列として存在しません。よって$S=T$となれるかが正しく判定できます。

以上2通りで`true`となるような条件式が`a[i]==b[i]||"@a@t@c@o@d@e@r@"[a[i]+b[i]]`であり、文字列中のすべての箇所でこれを満たせば`You can win`を、そうでなければ`You will lose`を出力します。


## [ABC004 回転](https://beta.atcoder.jp/contests/abc004/tasks/abc004_2)

> $c_{0,0}\quad c_{0,1}\quad c_{0,2}\quad c_{0,3}$
> $c_{1,0}\quad c_{1,1}\quad c_{1,2}\quad c_{1,3}$
> $c_{2,0}\quad c_{2,1}\quad c_{2,2}\quad c_{2,3}$
> $c_{3,0}\quad c_{3,1}\quad c_{3,2}\quad c_{3,3}$

入力を180度回転させて出力します。

```bash:Bash(7Byte)
rev|tac
```

それぞれ`rev`は左右を、`tac`は上下を反転するコマンドです。


## [ABC005 おいしいたこ焼きの食べ方](https://beta.atcoder.jp/contests/abc005/tasks/abc005_2)

> $N$
> $T_1$
> $T_2$
> $:$
> $T_N$

$T_{1..N}$の最小値を出力します。

```bash:Bash(18Byte)
read;sort -n|sed q
```

1行目も一緒にsortしてしまうと答えが変わってしまうので、`read`で読み飛ばしています。`sort -n`で残りの行を数値としてsortした後、`sed`に渡しています。

この`sed q`というのはsedコマンドにスクリプト`q`を与えたもので、`q`というのは実行されるとその時点でパターンスペースの内容を出力してsedを終了する命令です。つまり、まずsedは1行目を読み込んでスクリプトを実行するのですが、今持っている行の内容を出力して終了せよという命令が一番最初に実行され、その通りに1行目だけ出力して残りの行の処理を行わないのです。これで入力の1行目だけが抜き出せて、sort済みであるため求める答えとなります。

入力の1行目だけ抜き出すというのを実現するために、例えば`sed`で1行目以外を削除したり、コマンド`head`を使ったりする方法がありますが、最も短いのが`sed q`です。


## [ABC006 トリボナッチ数列](https://beta.atcoder.jp/contests/abc006/tasks/abc006_2)

> $n$

初項、第2項が$0$で第3項が$1$であるトリボナッチ数列の第$n$項を$10007$で割った余りを出力します。

```awk:Awk(42Byte)
{for(r=1;--$1;r=p+(p=q)+(q=r%10007))}$0=0p
```

計算部分を読みます。順に`p`、`q`、`r`を持って、`(p,q,r)->(q,r,p+q+r)`と更新していきます。初期値は`(p,q,r)=(0,0,1)`ですが、未定義の変数は数値としては`0`なので`r=1`だけ実行しています。

`r=p+(p=q)+(q=r)`とすることで、左から順番に評価されるため更新がうまくいきます。`q`に代入するときだけ余りを取ると`r`の値が$10007$を超える可能性がありますが、出力には関係なく、誤差が生じない大きさであるため問題ありません。

このループでは1回ごとに数列が1項ずつ進んでいくので、ループ回数は$n-1$回であるべきです。前置デクリメント`--$1`を使い、評価に先んじて1減算することで実現されています。後置デクリメントであれば、ループは$n$回回ることになります。

出力の部分ですが、`p`は0となる場合だけでなく、空文字列である場合もあります。この場合、通常であれば`+`を前置して数値化し、それをさらに文字列化する必要があるのですが、この問題のジャッジはleading zeroを許すので、`0p`と書いて先頭に0をくっつけた文字列にしています。これを`$0`に代入することで出力が行われます。

```perl:Perl(49Byte)
($%,$c)=($c%10007,$\+$c+($\=$%))for++$\..<>;print
```

`($%,$c)=($c%10007,$\+$c+($\=$%))`をループで実行しています。`$\`、`$%`、`$c`の順に数列になっていて、これを更新して1項ずつ進めていくのですが、AWKとは式の評価の方法が微妙に違うので、`$c=$\+($\=$%)+($%=$c%10007)`と書いても変数の更新のタイミングがAWKとは変わって上手くいきません。（これについて、tailsさんと%20さんに理由を教えていただいたので、最後に書いておきます。）
ただ、`$\+$c+($\=$%)`は望んだとおりに（`$\`の値が取り出されてから`$\`に`$%`が代入されるように）評価されるので、`$%`と`$c`についてのみリストの代入（`($%,$c)=($c,$\+$%+$c)`）という形で更新しています。

トリボナッチ数列の第0項として1を追加しても、残りの要素は等しくなります。よって、`$\`を第0項と見て1を代入してから数列を進めるループを$n$回回すことによって、`$\`が第$n$項を表すようにできます。（わざわざこうしているのは、ループを$n$回回す方が$n-1$回回すより短く書けるからです。）

$n$回のループは、for文に$1..n$という範囲を使うことで行えます。それが`for(++$\..<>)`で、先ほどの`$\`に1を代入するという操作も前置インクリメントを使って一緒に書いています。

ループが1回だけ回るとき、`$\`は`$%`の初期値となります。未定義変数は空文字列になってしまうのですが、`$%`は初期値が0の組み込み変数であるため、`$b`や`$x`ではなく`$%`であるからこそ、`$\`は正しい「数値」を持つことができます。

最後に出力をするのですが、`print`関数は`$\`という変数に値が存在すればそれを出力の末尾に追加で出力します。これを期待して`$\`に答えとなるべき数列の項を保存してあるので、`print`関数を引数なしで呼び出すだけで出力できます。改行が出力できませんが、この問題では出力の末尾に改行が必要ではないのでACできました。

さて、`$\+($\=$%)+($%=$c%10007)`が思うように動作せず、`$\+$c+($\=$%)`は動作することの理由についてです。

まず、`$\+($\=$%)`という式の断片は、演算子`+`の左右にそれぞれ「左辺値`$\`」と「左辺値`$\`に影響を与える式」が来ています。このように、2項演算するときに「左項が左辺値」かつ「右項が『 "左項である左辺値" に影響を与えるような式』」であれば、その"左項である左辺値" は値を取り出される前に影響を受けます。
つまり、`$\+($\=$%)`は、「`$%`を代入する」という右項が`$\`に与える影響が左項にも伝播してしまい、`$%+$%`と同じ値になってしまうということです。

`$\+$c+($\=$%)`については、2項演算子`+`が左結合であることを踏まえて`(($\+$c)+($\=$%))`と解釈されます。このとき、`($\+$c)`が先に解釈され、特に影響を与える代入などは存在しないためにそのまま値が得られます。
この得られた値と`($\=$%)`を足し算するのですが、左項はもはや左辺値ではなく右辺値であるため、これも影響は伝播しません。結局、`$\=$%`を実行しながらも`$\+$c+$%`という望み通りの値が得られるということです。

これを利用して、`-$x+($x=$_)`と書くことで、前のループの値と今のループの値の差を計算しつつ変数`$x`を更新するということが可能です。
`-$x`は`+`を評価するタイミングではすでに計算された右辺値であって左辺値ではないため、`($x=$_)`の影響が伝播しないということです。

Perlで左辺値になるのは、「変数そのもの」「変数への代入」「前置インクリメント/デクリメントされた変数」「`+`が前置された変数」のみです。


## [ABC007 辞書式順序](https://beta.atcoder.jp/contests/abc007/tasks/abc007_2)

> $A$

小文字アルファベットを使った$A$よりも辞書順比較で真に小さい空でない文字列を、存在しなければ`-1`を出力します。

```sed:Sed(11Byte)
/^a$/c-1
ca
```

`/^a$/`というパターンは`"a"`という文字列にマッチします。入力が`"a"`であるとき、条件を満たす出力すべき文字列は存在しないので`-1`を出力します。
そうでなければ、`"a"`という文字列は他のいかなる入力より真に小さいので、これを出力します。


## [ABC008 投票](https://beta.atcoder.jp/contests/abc008/tasks/abc008_2)

> $N$
> $S_1$
> $S_2$
> $:$
> $S_N$

$S_{1..n}$に最も多い回数出現したものから1つ出力します。

```awk:Awk(28Byte)
NR>n+=$0=s=++a[$1]<a[s]?s:$1
```

配列`a`によって出現回数をカウントしています（AWKの配列は常に連想配列です）。`s=++a[$1]<a[s]?s:$1`によって、変数`s`にその時点で最も多く出現した文字列が保存されます。（出力のため、`$0`にも代入しています。）

1行目も一緒に処理していますが、制約から1行目と等しい文字列は$S_{1..n}$に存在しないことを利用して、1行目が答えとして出力されないようにしています。というのは、境界条件を調節して、出現回数が同じ文字列については常に1番最後に出現したものが保存されるようにすることで、$S_{1..n}$がすべて異なる場合（出現回数1回が最大である場合）も最初に出現した1行目ではなく$S_N$が出力されるようになっているということです。

最終行を処理した後に出力をしたいので、最終行であるかどうかの判定をします。

変数`n`に、行ごとの`s`の値が数値として加算されていきます。`s`は、1行目の$N$という文字列を処理した時点では$N$であり、その後は常にアルファベットの文字列（`=0`）ですから、`n`はプログラムの実行中常に$N$という値を持ちます。

変数`NR`は1-indexedで今何行目を処理しているかを表す変数です。$N+1$行目を処理し終わった後に出力を行いたいので、`NR>n`とすることでそのような条件があらわせます。これを満たした時点で`$0`（`s`が代入されている）が出力されます。

```perl:Perl(30Byte)
$_[++$$_]=$_ for<>;print$_[-1]
```

これはコードゴルフという点において非常に教育的なコードだと思います。

まず`$$_`ですが、これは`${$_}`の短縮形です。ここで、`$_`には何か文字列が入っているとします。（空文字列でも良いですし、数値も文字列ですが、今回のコードでは文字列です。）

`${}`というのはデリファレンス（dereference）と言って、いろいろ使い方がありますが、文字列という「何かへのリファレンス（reference、参照）」になっていない値をデリファレンスするとどういうことが起こるのでしょうか？
これは[シンボリックリファレンス](http://perldoc.jp/docs/perl/5.8.8/perlref.pod#Symbolic32references)と呼ばれ、単にそれを変数名に持つ変数となります。
例えば、`$_=="hoge"`であった場合、`$$_`は`$hoge`と同じ変数を表します。

次に`$_[++$$_]=$_`です。

これは、配列`@_`の`++$$_`番目に`$_`を代入していると読むことができます。配列を表すのは`@`ですが、それに添え字でアクセスした時点で配列ではなくスカラ（単一の値）になるので、`@_[++$$_]`ではなく`$_[++$$_]`です。（`@_`と`$_`は同じ変数名のように見えますが、配列とスカラは名前空間が違うので問題ありません。）

これを後置for、`for<>`でループしています。

`<>`は`for`のようなリストが期待される文脈（「リストコンテキスト」といいます）に置かれると入力をすべて読んで改行区切りにしたリストになりますから、`$_`に入力が1行ごとに格納されて`$_[++$$_]=$_`が実行されます。
`$_for`は有効な変数名なので、パースが行われるように`$_ for`と空白を開けています。

同じ文字列をデリファレンスしたものは当然同じ変数を表しますから、結局デリファレンスを短く書けるハッシュのように扱って出現回数をカウントし、それに応じて配列`@_`に保存しているということです。

ループが終了した後、配列`@_`の$i$番目には、$i$回出現した文字列の中で最も最後に出現したものが代入されています。配列は必要な分だけの長さがぴったり確保されるので、`@_`の一番後ろ（インデックスが最も大きな場所）が出力すべき文字列を表しますが、これは負の数が配列の後ろから数えることを利用して`-1`で添え字づけることで取得できます。
`<>`は読み込んだ文字列の改行を削除しないので、そのまま`print$_[-1]`とすることで改行付きで出力することができます。

この改行について1つ注意点があります。それは、`${"a\n"}`と`${"a"}`は異なる変数であるということです。今回、これは良い方に作用しています。
そもそも、記号や数字から始まる変数名`$%`や`$262144`は組み込みの特殊変数であり、特に数字の変数は自由に書き込みができないように設定されています。
改行がなければ$N$を読み込んだときの`$$_`は数字名の変数であり、インクリメントできないためREとなるのですが、改行がついているため別の変数であると認識され、REを免れました。


## [ABC009 心配性な富豪、ファミリーレストランに行く。](https://beta.atcoder.jp/contests/abc009/tasks/abc009_2)

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

$A_{1..N}$の重複を除いたうえで、2番目に大きな値を出力します。

```bash:Bash(22Byte)
read;sort -nru|sed 2!d
```

まず`read`で1行読み飛ばします。$N$も数値であるため、混ざっているとうまくsortできないからです。
残りの入力を、`sort`にオプションを与えて並び替えます。

`-n`はそれぞれの行を数値として解釈して比較させます。
`-r`は逆順、つまり大きな順に並べ替えさせます。
`-u`は同じ要素を1回だけ出力させるようにします。

これらのオプションを与えて並び替えると、上から2行目が出力すべき値になります。

`sed`で`2!d`というスクリプトを実行します。これは「2行目（`2`）でないとき（`!`）行の内容を削除（`d`）する」という風に分解できます。つまり望む行以外を削除するということです。
`!`を書くのにエスケープが必要でないことも短縮ポイントです。


## [ABC010 花占い](https://beta.atcoder.jp/contests/abc010/tasks/abc010_2)

> $n$
> $a_1 \quad a_2 \quad ... \quad a_n$

数列のそれぞれの要素を、偶数でも3で割って2余る数でもなくするために減じる必要のある数の合計を出力します。

```bash:Bash(27Byte)
read;tr 1-9\  010123010+|bc
```

$a_{1..n}$は1以上9以下の数なので、それを対応する数に置き換え、和を求めればよいです。

`tr`コマンドで、`1-9`とエスケープした` `を、それぞれ`010123010`の対応した数と`+`に置換すると、それを式として評価した値が答えになります。`bc`コマンドは標準入力から式を読み込む計算機なので、それに計算させます。

実は、式を評価するだけの問題が[ABC050-A](https://qiita.com/kotatsugame/items/184bfd63d9b21f214475#abc050-addition-and-subtraction-easy)にあります。また、上のコードは範囲をうまく使って`010123010`->`010-3010`とすることで1Byte縮む余地があります。ではなぜ、ABC050-Aでは`bc`が使われていないのでしょうか？また、なぜ上のコードが最短コードとなっているのでしょうか？

実は、現在AtCoderのbashでコマンド`bc`を呼び出すことはできないのです。どの時点からかはわかりませんが、`bc`を呼び出そうとするとコマンドが見つからないとしてREになってしまいます。


## [ABC011 名前の確認](https://beta.atcoder.jp/contests/abc011/tasks/abc011_2)

> $S$

$S$の先頭1文字を大文字に、他の文字を小文字にして出力します。

```sed:Sed(11Byte)
s/.*/\L\u&/
```

`s/pattern/replacement/`中の`replacement`では、`&`で`pattern`にマッチングした文字列全体を表すことができます。
`\L`は続く文字列をすべて小文字にする効果を、`\u`は続く1文字だけを大文字にする効果を持ちます。この2つをこの順番で書くことによってのみ、望む変換、つまり先頭以外すべて小文字で先頭1文字だけを大文字にする変換ができます。


## [ABC012 入浴時間](https://beta.atcoder.jp/contests/abc012/tasks/abc012_2)

> $N$

$N$（秒）を$hh : mm : ss$の形式に変換して出力します。

```bash:Bash(17Byte)
date +%T -ud@`dd`
```

`date`は時刻を表示するコマンドです。表示形式を`+%T`で指定していて、これはまさに$hh : mm : ss$という形式です。
`-d`オプションで表示する時刻を変えることができて、`-d@秒数`として1970年1月1日午前0時0分0秒からの経過秒数を与えることができます。日付は関係ないので、今回はこれで事足ります。`` `dd` ``で入力を読み、`date`への引数に埋め込んでいます。

ところが、これはローカル時間であるため、UTC+9にあるAtCoderのジャッジサーバーでは9時間先の時間が表示されてしまいます。それを防ぐために`-u`オプションを与えてUTC+0にしています。


## [ABC013 錠](https://beta.atcoder.jp/contests/abc013/tasks/abc013_2)

> $a$
> $b$

${\rm min}(|a-b|,10-|a-b|)$を出力します。

```perl:Perl6(25Byte)
say 5-abs (get- get)%10-5
```

場合分けをします。

- $a \ge b$のとき）`(get- get)%10`は$a-b$となります。
  - $a-b \ge 5$のとき）`abs (get- get)%10-5`は$a-b-5$となり、出力は$10-a+b = 10-|a-b|$です。$|a-b|\ge 5$より$|a-b|\ge 10-|a-b|$です。
  - $a-b \lt 5$のとき）`abs (get- get)%10-5`は$5-a+b$となり、出力は$a-b=|a-b|$です。$|a-b|\lt 5$より$|a-b|\lt 10-|a-b|$です。
- $a \lt b$のとき）`(get- get)%10`は$a-b+10$となります。
  - $a-b+10 \ge 5$のとき）`abs (get- get)%10-5`は$a-b+5$となり、出力は$b-a=|a-b|$です。$|a-b|\le 5$より$|a-b| \le 10-|a-b|$です。
  - $a-b+10 \lt 5$のとき）`abs (get- get)%10-5`は$b-a-5$となり、出力は$10+a-b=10-|a-b|$です。$|a-b|\gt 5$より$|a-b|\gt 10-|a-b|$です。

よって正しい答えを出力できることが確かめられました。


## [ABC014 価格の合計](https://beta.atcoder.jp/contests/abc014/tasks/abc014_2)

> $n \quad X$
> $a_0 \quad a_1 \quad ... \quad a_{n-1}$

$i \in \\{0,1,...,n-1\\}$で$X$の$i$bit目が立っている$i$について、$a_i$を足し合わせた値を出力します。

```awk:Awk(40Byte)
RS=FS{x%2<1||a+=$1;x=x/2+$2}END{print+a}
```

`FS`のデフォルト値は`" "`です。`RS`に`" "`を代入することで、入力を空白区切りで読み込むようになります。
この`RS`への代入は1行目の処理中に初めて行われるので、そのときすでに読み込まれている`$1`$=n$、`$2`$=X$には影響しません。
また、`" "`という文字列は`true`と解釈されるので、毎回ブロックが実行されます。

入力の1行目を処理しているとき、ブロック内部ではどのような処理が行われるか確かめます。
`x`はこの時点では未定義なので、`x%2<1`は`true`です。したがって`a+=$1`は実行されません。
`x=x/2+$2`によって`x`に`$2`$=X$が代入されます。

以降の処理では`RS`が`" "`となっているので、各$a_i$が各行に1個ずつあるような具合で読み込まれ、処理されます。
`x`には$X$が代入されているのでした。これを毎回2で割っていけば、2で割った余りを見ることで順に各bitを取り出すことができます。
またこのときわざわざ整数に切り捨てなくても、`x%2>=1`であればbitが立っていると判定できます。
よって`x%2<1||a+=$1`で正しい条件分岐が行え、bitが立っているときだけ$a_i$を`a`に加算できます。
`RS`が`" "`であるため`$2`は存在せず、`x=x/2+$2`はただ`x/=2`と同じ意味になります。

`END`ブロックで答えを出力します。`a`への加算が1回も行われなかった場合は空文字列が出力されてしまうので、`+a`で数値として評価しています。

```perl:Perl(46Byte)
<>=~$";map$x+=$'>>$i++&1&&$_,glob<>;print$x,$/
```

Perlゴルフで使われる主要な入力の読み込み方2つが両方とも出てきています。

まず入力の1行目ですが、`<>=~$"`を実行して読み込んでいます。これは`<>`に`$"`をマッチングさせていると読むことができます。
`$"`は初期値が` `（スペース文字）である組み込み変数なので、`<>=~$"`は`<>=~/ /`と等しく、$n$と$X$の間のスペースにマッチするはずです。
マッチングが行われると、`` $` ``に「マッチした位置より前方の文字列」、`$&`に「マッチした部分文字列」、`$'`に「マッチした位置より後方の文字列」が代入されます。したがって、`<>=~$"`を行うと`` $` ``が$n$と、`$'`が$X$とそれぞれ等しくなります。これで変数に明示的に代入することなく入力された値を保存できました。

次に`map`関数が実行されます。第1引数は`$x+=$'>>$i++&1&&$_`で、これは実行される無名関数のようなものです。第2引数は`glob<>`であり、ここで2行目を読み込んでいます。まずこれの説明をします。

`glob`関数は文字列を引数にとって、文字列中にワイルドカード文字が存在する場合、カレントディレクトリのファイル名として展開して列挙したリストを返します。しかしPerlゴルフではそういう使い方はされません。
そもそも与えた文字列、つまり`<>`で読み込んだ入力の2行目にはワイルドカード文字は存在しません。このような場合、`glob`は文字列を空白で区切ったものをリストとして返します。つまり、`split`関数の代用として用いることができます。（パフォーマンスは悪くなります。）

`map`関数は第2引数以降のリストの個々の要素を`$_`に代入しつつ第1引数のブロックや式を実行し、結果をリストにして返します。今回、返ってきたリストは使用されず、`map`はただ`for`文と等しくリストでループを回すために用いられています。必要な空白の関係で`map`を使ったほうが短くなるのです。

`$x+=$'>>$i++&1&&$_`を読みます。

上で述べたことより、`$'`は$X$でした。これを`$i`（ループごとにインクリメントされ、ちょうど今見ている要素がリストの何番目であるかを示します）だけ右にbitシフトすると、1bit目を見ることでリストのその位置の要素を足し合わせる必要があるか否かを判定できます。
`&1`で1bit目だけを取り出します。`&&`は左の項が`true`であれば右の項を、`false`であれば後を評価せず`false`になった左の項をそのまま返しますから、左の`$'>>$i++&1`が`1`である場合`$x+=$_`（`$_`はリスト$a$の`$i`番目です）、`0`であれば`$x+=0`と同じ意味になり、`$x`に出力すべき答えが保存されます。

最後に出力をしますが、末尾に改行が必要です。組み込み変数`$/`は初期値が改行文字なので、これを一緒に出力することで改行を付加することができ、`"\n"`などと改行を文字列として書くより短くすみます。

```perl:Perl6(46Byte)
get~~/\s.+/;say [+] map $/+>.++%2* *,get.words
```

Perl6でも、マッチングによって入力の読み込みをするテクニックが使われます。ただ、Perlでの`` $` ``や`$'`はPerl6においてそれぞれ`$/.prematch`、`$/.postmatch`というとんでもなく長い名前になってしまうので、ゴルフとしては実用的でありません。

[ABC097-A](https://qiita.com/kotatsugame/items/184bfd63d9b21f214475#abc097-colorful-transceivers)で用いたようなマッチングの時に設定されたキャプチャーは有用です。しかし、今回は1行目では$X$しか必要ではありません。このとき、もっと短く書く方法があります。
それがPerlでいう`$&`です。これはPerl6においては`$/`であらわされるので、長さは変わっておらず2文字そのままです。

$X$にマッチングさせるには、「空白1文字と任意の文字複数」というパターンが使えます。これは`/\s.+/`となります。（`+`は「1文字以上」です。）Perl6のパターンでは、空白は読みやすくするためのものであるとして自動で削除してしまうので、`/ .+/`と書いてもうまくいきません。スペースやタブなどの空白文字を表す`\s`を使う必要があります。

`$0`や`$1`、`$/`を使って入力を読み込む方法3つを並べてみます。
`get~~m:g/\d+/`
`$/=get.words`
`get~~/\s.+/`
このように、入力の必要な部分に応じて読み込む最短の方法が変化します。

とにかく、`$/`で$X$を表すことに成功しました。次の`say [+] map $/+>.++%2* *,get.words`を読みます。

ここでもまた`map`を使っています。構造を説明すると、まず`get.words`で2行目を空白区切りにしたリストを得て、それを`map`で変換し、`[+]`を使って`fold`し、出力しています。
`[+]`というのは`[]`と`+`の組み合わせであり、`[]`は中に置かれた演算子でリストを`fold`することができるメタ演算子です。

`map`でリストを変換するのには無名関数を使っています。それが`$/+>.++%2* *`です。

Perl6で無名関数を作るのには、ブロックを使うほかに、`*`を使う方法があります。これは、`*`に引数が1つづつ適用される関数になるというもので、例えば`*+5`と書くことで、引数を1つとって5と足し合わせたものを返す関数を作れます。

実際、`say (*+5).(4)`というコードは4を引数として関数を呼び出し、`4+5`、つまり9を出力します。

`$/+>.++%2* *`には`*`が2つ存在しますが、1つ目は乗算の演算子であり、`$/+>.++%2*(引数)`という関数であると解釈されます。

`$/+>.++%2`を読みます。$X$のbitに応じてこれが1 or 0の値をとれば、それとリストの要素が掛け算されることで$0$ or $a_i$となり、これでリストを変換することで、足し合わせて答えを得られます。実際にそうなっています。

まず、`+>`は右にbitシフトする演算子です。`.++`というのは、`++`（後置インクリメント）をメソッド呼び出しの形で書いていて、呼び出し元の値が存在しない場合は自動的に`$_`が補われるので、`$_++`と等しいです。`$_`はソースコード中のほかの場所では使われていないので初期値の`(Any)`であり、数値としては0です。上で紹介したPerlのコードにおける`$i`と同じ役割を果たしています。

`+>`と`%`の演算子の優先順位は等しいので、`$/+>.++%2`は`($/+>$_++)%2`と解釈され、bitシフトして1bit目を取り出していることになります。
結局$X$のbitに応じて1 or 0の値を取るという目的に合致していますから、先に述べたようにリストを$0$ or $a_i$に変換することができました。足し合わせて答えを得て出力します。


## [ABC015 高橋くんの集計](https://beta.atcoder.jp/contests/abc015/tasks/abc015_2)

> $N$
> $A_1 \quad A_2 \quad ... \quad A_N$

$A_{1..N}$のうち$0$でない数だけを抜き出し、その平均値を切り上げて出力します。

```perl:Perl(36Byte)
print!<>|.9+$a/grep{$a+=$_;$_}glob<>
```

まず`!<>`が実行され、1行読まれます。これは後で必要になります。
次に`glob<>`で入力の2行目を空白区切りにしたリストを得て、それを引数に関数`grep`を実行します。

関数`grep`は、第1引数で受け取った式やブロックに第2引数以降を次々と適用し、trueを返すもののみからなるリストを作ります。
今回実行するブロックは`{$a+=$_;$_}`です。引数が自動的に`$_`に代入されます。
このブロックでは、`$a`に`$_`を足し合わせ、`$_`を返しています。`$_!=0`のとき`true`になるので、結局`grep`は$A_{1..N}$のうち$0$でない数だけを抜き出したリストになります。また、`$a`はそのリストの総和になります。（$0$である要素は足しても和に影響しません。）

リストはスカラコンテキストで評価するとその長さになるので、`$a/grep...`で平均値を求めることができます。[ABC006-B](#abc006-トリボナッチ数列)で出てきた左辺値の性質によって、`$a`は左から順に見ていくと`grep`より先に出現しますが、計算時には`grep`を評価した後の値（リストの総和）になります。

あとは`$a/grep...`を切り上げるのですが、テストケースが微妙に弱いため`0.9`を足して切り下げることでACできます。bit演算を行うときは数値が整数型に切り下げられるという事実を利用して、`.9+$a/grep...`と`0`の`bitwise OR`を計算すればよいです。ここで`0`の代わりに`!<>`を使っています。`|`演算子は右項と左項のどちらかが数値であればもう片方も数値として評価するので、`!<>`は数値の`0`になるからです。

今回のジャッジでは出力の末尾に改行は必要ありません。

```octave:Octave(42Byte)
disp(ceil(mean((x=dlmread(0)(2,:))(!!x))))
```

括弧がネストしていてわかりづらいです。適当に空白を入れて構造を明らかにしてから、中から外に向かって読んでいきます。
`disp( ceil( mean( ( x=dlmread(0)(2,:) )(!!x) ) ) )`（入れてもわかりづらかった……）

まず、`x=dlmread(0)(2,:)`です。`dlmread`は入力全体を行列として読み込む関数で、第1引数にファイルハンドルを指定します。`0`はstdinを表します。
入力を読み込んだ結果、今回は1行1列目が$N$、2行目が数列$A$になります。これの数列$A$の部分だけを取り出すときには、添え字を2行目を表す`2`と列全体を表す`:`（これは1番目から最後まで、すなわち`1:end`の省略形です）にします。Octaveは1-indexedです。
こうして取り出した数列$A$を$N$要素の行ベクトルとして変数`x`に代入します。（Octaveは1-indexedです。）

次に`( x=dlmread(0)(2,:) )(!!x)`、`x`の値が分かったので括弧を外して`x(!!x)`です。
これは条件に沿ってベクトルを取り出す書き方です。例えば、`a`の3より大きな要素だけを取り出したい場合は、`a(a>3)`と書くことができます。
では`x(!!x)`はどのような条件を表すのか？まず、`!`は0を`true`に、それ以外を`false`にします。2回適用することで、0以外を`true`に、0を`false`にします。制約より`x`に負の値は存在しないため、結局これは`x(x>0)`と書いたのと変わりありません。

こうやって取り出したすべての要素が0より大である数列の、平均を求め、切り上げ、出力します。
順に`mean`、`ceil`、`disp`という関数があるので、適用します。

今回のジャッジは末尾に改行がなくても通ったりと柔軟なタイプなので、関数`disp`によって出力の先頭に空白文字が存在してもACできました。

```perl:Perl6(44Byte)
get;$_=@(get.words);say .sum/.grep(+*)+.9+|0
```

1行読み飛ばします。`$_`に`get.words`を代入することで、これに対するメソッド呼び出しが省略して書けることを利用します。

`@()`で囲っている理由は、`words`の返り値をリスト型に強制するためです。
`words`は`Seq`という型を返します。これは何かというと、遅延評価のリストであり、実は1回評価して値を取り出すとデータが消費されてしまい、もう二度と使えないのです。（2度目に使うとREになります。）
コードの後ろのほうで`.sum`と`.grep`によって2回使う予定なのでこれでは困るため、リストにしてからデータを保存しています。
[ABC066-A](https://qiita.com/kotatsugame/items/184bfd63d9b21f214475#abc066-ringring)で行ったように、`+<<`などを適用してもリストのデータが得られます。（あちらは、別の理由から`+<<`をつけたので、この問題が表面化しませんでした。）

そうして得られたリストを`$_`に持って`say .sum/.grep(+*)+.9+|0`を実行します。

まず、`.sum`（`$_.sum`の省略形、`.grep`もそう）は総和を求めます。次に、`.grep(+*)`というのは、リストのうち関数`(+*)`に値を渡したときの戻り値が`true`であるものだけ抜き出す関数です。`(+*)`では値が数値化され、0でない数であれば`true`に、0ならば`false`に評価されます。
よって`.grep(+*)`でリスト`$_`のうち0でない数だけが抜き出されたリストが得られます。実はリストは、数値として評価するとその長さになるため、`.sum/.grep(+*)`で「数列の総和」を「数列中の0でない数の個数」で割った値が得られます。

`0.9`を足し、`bitwise OR`で切り捨てをするのは上のPerlコードと同じです。`+|`は`bitwise OR`の演算子です。

```awk:Awk(44Byte)
t{for(;i++<NF;)c+=s<s+=$i}t++,$0=int(s/c+.9)
```

1行目の情報は、2行目では`NF`という「現在の行のフィールド数」を表す変数によって得られるので、必要ありません。読み飛ばします。
読み飛ばし方についてですが、カウント変数`t`を用意します。上のコードでは2度出現しており、2度目の出現で（後置で）インクリメントされています。
これによって、1行目の時点ではブロックは実行されず`$0`の出力も行われない、2行目ではブロックも実行されるし出力もされる、という風にできます。

ブロックの内部では、変数`i`を1から`NF`までインクリメントしてループを回しています。（後置デクリメントなので、`i<NF`という等号がついていない比較ですが、しっかり`NF`までループが回ります。）
`s<s+=$i`は`s<(s+=$i)`と評価され、両辺から`s`を引くと`0<$i`になるので、`s`に`$i`を足すのと`c`に`0<$i`を足すのを同時に行っています。これで`s`は数列の総和に、`c`は数列の$0$より大きな要素の個数になります。

最後に、`$0`に`int(s/c+.9)`を代入します。これも`0.9`を足して切り下げるとACできるという嘘解法に基づいています。
これは`t++`を左の式にした範囲パターン内なので、2行目を処理しているときだけ代入と出力が行われます。


## [ABC016 A±B Problem](https://beta.atcoder.jp/contests/abc016/tasks/abc016_2)

> $A \quad B \quad C$

$A+B=C \land A-B=C$ならば`?`、$A+B=C \land A-B \ne C$ならば`+`、$A+B \ne C \land A-B=C$ならば`-`、$A+B\ne C \land A-B \ne C$ならば`!`を出力します。

```awk:Awk(39Byte)
$0=$1+$2-$3?$1-$2-$3?"!":"-":$2?"+":"?"
```

$A+B-C \ne 0$であれば、$A-B-C$が0であるかそうでないかで`-`と`!`を分けることができます。
そうでなかったとき、$A+B=C \land A-B=C \Leftrightarrow A+B-C=0 \land B=0$なので、$B$が0であるかそうでないかで`?`と`+`を分けることができます。


## [ABC017 choku語](https://beta.atcoder.jp/contests/abc017/tasks/abc017_2)

> $X$

文字列$X$が`ch`と`o`と`k`と`u`だけに分解できるなら`YES`、できないなら`NO`を出力します。

```sed:Sed(24Byte)
s/ch//g
/[^oku]/cNO
cYES
```

まず、`s/ch//g`で`ch`という部分文字列を`g`フラグによってすべて空文字列に置換します。
こうして残った文字列に`oku`の3文字以外が存在すればそれはchoku語ではないため、`NO`を出力します。
この判定は、文字集合`[oku]`の補集合である`[^oku]`にマッチングするかどうかで行えます。


## [ABC018 文字列の反転](https://beta.atcoder.jp/contests/abc018/tasks/abc018_2)

> $S$
> $N$
> $l_1 \quad r_1$
> $l_2 \quad r_2$
> $:$
> $l_N \quad r_N$

文字列$S$の（1-indexedで）$l$文字目から$r$文字目までを反転する操作を$N$回行った後の文字列を出力します。

```perl:Perl(54Byte)
$\=<>;map$_=reverse,substr$\,$`-/ /,$'-$`+1for<>;print
```

`$\=<>`で$S$を読み込んでいます。変数`$\`を変更していけば、最後に`print`関数を呼び出すだけで`$\`は自動的に出力されます。`<>`は改行付きで読み込むので、その改行が変更されず残っていれば出力末尾の改行については問題ありません。

後置forで残りの入力をすべて読み込み、ループを実行します。
ループの中では`map`関数を実行しています。第2引数以降が1つ1つ`$_`に代入されて`$_=reverse`が実行されます。今回は``substr$\,$`-/ /,$'-$`+1``ただ1つです。

入力の3行目以降を処理しているならば、``$`-/ /``は$l-1$と等しく、``$'-$`+1``は$r-l+1$と等しいです。（これについては少し下のPerl 59Byteの元最短コードのほうに詳しく書いてあります。）
``substr$\,$`-/ /,$'-$`+1``は文字列`$\`の$l-1$文字目（0-indexed）から$r-l+1$文字の部分文字列を表します。これが反転するべき部分文字列です。

入力の2行目を処理しているならば、`/ /`のマッチングが失敗するため``$`,$'``はどちらも未定義値のままです。`/ /`が`0`となるので``$`-/ /``は$0$と等しく、また``$'-$`+1``は$1$と等しいため、``substr$\,$`-/ /,$'-$`+1``は`$\`の最初の1文字を表します。これを反転しても影響ありません。

各ループで`substr`で得られた部分文字列を反転すれば、求める答えが得られることがわかりました。`$_=reverse`を実行することで、それが実現できます。
関数`map`のブロックや式で使う`$_`は元の値のコピーではなくエイリアスなので、`$_`の値を変更すると元の値も変更されます。（代入不可能な値、つまり左辺値でない値だとエラーが出ます。）
関数`substr`には代入することが可能なので、`map`によって実行される式の内部で`$_`を書き換えることで元の文字列を変更できます。[substr](http://perldoc.jp/func/substr)
よって`$_=reverse`で`$_`に自身を反転した文字列（関数`reverse`は暗黙で`$_`を反転します）を代入することで、その部分文字列を反転することができます。[reverse](http://perldoc.jp/func/reverse)

最後に`print`で出力します。制約から、`$\`末尾の改行を変更してしまうような範囲は指定されないので、これで末尾に改行がついたまま出力されます。

```perl:Perl(59Byte)Perlの元最短コード
@S=<>=~/./sg;@S[@@]=@S[reverse@@=$`-/ /..$'-1]for<>;print@S
```

まず、`<>=~/./sg`によって文字列を文字のリストに分解します。`g`フラグはマッチするものすべてにマッチさせます。`s`フラグは、ここでは`.`を改行にマッチできるようにする役割を持っています。`<>=~/./sg`はリストに代入しようとすると、ただマッチングが成功したか否かを返すのではなく、マッチングする部分文字列すべてをリストにして返します。

こうして文字のリスト`@S`が得られました。リストの添え字として範囲などのリストを使うと、リストのスライスというものが作られ、これは変更可能なので、スライスを反転したものをスライスに代入することで部分文字列の反転ができます。

2行目以降を`for<>`で一気に読み込み、1行ずつ`$_`に代入して``@S[@@]=@S[reverse@@=$`-/ /..$'-1]``を実行します。

まず、``$`-/ /..$'-1``が評価されます。`$_`と`/ /`のマッチングが試みられ、2行目では失敗し、3行目以降では成功します。まず3行目以降のことを考えます。
マッチングに成功すると、``$` ``にマッチした位置より前方の、`$'`に後方の文字列が代入されますから、それぞれ$l$と$r$になるはずです。さらに、`/ /`は成功したので`1`（つまり`true`）となります。よって、``$`-/ /..$'-1``は`l..r`という範囲の両端から1引いて0-indexedにしたものだとわかります。
（ここで、最初の``$` ``を評価した時点では`/ /`が実行されていないから、値が入っていないのではないかと思う人もいるでしょう。しかし望んだとおりに動作します。理由は、最初に``$` ``を見るときは「``$` ``という変数を使う」ということが確定するのであって、実際に値が取り出されるのは式のかたまりを見終わってからだからです。今回は、取り出される前に`/ /`も見られ、こちらはその見られたタイミングでマッチングが行われるため、実際に``$` ``の値が取り出されるタイミングではちゃんと値が入っているようです。これは[ABC006-B](#abc006-トリボナッチ数列)に出てきた左辺値の効果です。）

ともかく、``$`-/ /..$'-1``で望む範囲を得られました。これは2回使うので`@@`というリスト（これはリストの名前が`@`であるだけの普通のリストです）に代入しておきます。

`@S`にリスト`@@`でアクセスします。得られる値はスカラではなくリストのスライスなので、`$S[@@]`ではなく`@S[@@]`です。`@S[@@]=reverse@S[@@]`とすると、望む範囲の`@S`のスライスが反転されて同じ範囲に代入されています。`reverse@S[@@]`というのは、`@S[reverse@@]`と等しく、上のコードではこちらを使っています。

少し戻って、「入力の2行目で`/ /`に失敗したらどうなるか」を考えておきます。このとき、``$` ``にも`$'`にも値は入っていませんから、``$`-/ /..$'-1``というのは`0-0..0-1`、つまり`0..-1`になります。これは範囲の始点が終点より大きいため有効な範囲ではありません。`@@`には空リストが代入され、`@S`は何ら変更されません。

最後に、`@S`を出力します。`print`関数に引数として与えると、リストは展開され、要素を1つ1つ引数に与えたのと同じ扱いになります。`print`関数はデフォルトでは引数と引数の間に余計なものは出力しないので、これで文字のリストが続けて出力されることになります。

末尾に改行をつける必要がありますが、1番最初に`<>=~/./sg`で文字列を分解した際、改行文字も`.`にマッチングさせたので、実は`@S`の末尾に改行文字が入っていました。これが出力されるのでACできます。

```perl:Perl6(60Byte)
$_=get;($/=get.words;.substr-rw($0-1..^$1).=flip)xx get;.say
```

まず`$_`に$S$を読み込みます。

次に`(~~~)xx get`ということをしています。`xx`はリスト繰り返しの演算子であり、これは`(~~~)`というリストを`get`回（2行目なので$N$です）繰り返すという意味で、このときリストの内容は繰り返すたびに評価されます。
今回は作られるリストには興味がなく、ただループの代わりとして使っています。

そのループの中では、`$/=get.words;.substr-rw($0-1..^$1).=flip`を実行しています。

まず`$/=get.words;`で入力を1行読み込み、[ABC097-A](https://qiita.com/kotatsugame/items/184bfd63d9b21f214475#abc097-colorful-transceivers)と同じテクニックで$l$と$r$をそれぞれ`$0`と`$1`でアクセスできるようにします。

`.substr-rw`は、メソッド呼び出しの省略形で`$_`に対して呼び出されているのですが、「変更可能な」部分文字列を返します。（普通の`substr`に代入しようとするとエラーが出ますが、これは代入できます。）
取り出す部分を指定する引数には、今回は範囲を渡すことにしました。0-indexedなので$l-1..r-1$という範囲を作っているのが`$0-1..^$1`です。
範囲の始点については`$0-1`と素直に1を引いていますが、範囲を作るのに`..`ではなく「範囲の終点を含まない」という意味の`..^`を使うことで、範囲の終点では1を引くのを省略しています。1Byteの短縮になります。

こうして得られた部分文字列を反転して取り出した部分に代入します。

反転するのには`flip`というメソッドを使いますが、この「メソッドを呼び出し、その返り値を呼び出し元に代入する」という操作について考えます。
`$invocant = $invocant.method`というのは、`.`を演算子としてみれば`$a = $a+5`と似た構造です。であれば、`$a+=5`のように`$invocant.=method`と書けてもおかしくなさそうです。実際書けます。

`$invocant`は`.substr-rw($0-1..^$1)`であり、`method`は`flip`です。くっつけて`.substr-rw($0-1..^$1).=flip`となります。

こうして、ループの中では部分文字列を反転して代入する操作が行われています。これが$N$回繰り返されて、最後に`$_`を出力します。これも、`say $_`ではなく`$_.say`と書くことで`$_`が省略できて、`.say`で済みます。

```ruby:Ruby(75Byte)
s=?1+gets;gets;$<.map{|i|s[x=eval(i.split*'..')]=s[x].reverse};$><<s[1..-1]
```

`s=?1+gets`で$S$を読み込み、`?1`は文字`1`を表すのでこれが先頭に追加され、`s`に代入されています。なぜ先頭に1文字追加しているかというと、文字列のほうを範囲指定に合わせて1-indexedにするためです。

`gets`で2行目を読み飛ばします。

`$<`に対して`map`を呼び出すことで、残りの入力がすべて読まれて行ごとにブロックが実行されます。入力の行は`i`に代入されます。
ブロックが返す値には興味はなく、ただ短くかけるループとしてのみ`map`を使っています。

ブロック内では`s[x=eval(i.split*'..')]=s[x].reverse`を実行しています。

まず`i.split*'..'`というのは、行を空白で分割して、`'..'`で`join`するという意味です。これによって、`"l r"`という入力が`"l..r"`という文字列になります。それを`eval`で評価すると範囲を表すオブジェクトになるので、インデックスにして`s`にアクセスすれば指定された範囲が得られるというわけです。

もう1回使うので`x`に代入しつつ、`s[l..r]`を得ます。Rubyでこうやって作った部分文字列は変更ができるので、ここに`s[l..r].reverse`を代入すれば部分文字列の反転ができました。

最後に出力をします。`s`の先頭1文字は必要ないので、`s[1..-1]`として求める箇所だけ取り出します。
`$>`というのは標準出力を表し、`<<`で文字列や数値を追加することで出力ができるので、`$><<s[1..-1]`となりました。空白の関係で`puts s[1..-1]`よりも1Byte短いです。
`$><<`を使うと改行が行われませんが、`gets`は改行付きで読み込むので、`s`の末尾には最初から改行がついており、問題ありません。


## [ABC019 高橋くんと文字列圧縮](https://beta.atcoder.jp/contests/abc019/tasks/abc019_2)

> $s$

文字列$s$中の1文字以上連続した同じ文字を、その文字+連続した文字数に置き換えて出力します。
`aabbbaad`は`a2b3a2d1`に変換されます。

```perl:Perl(33Byte)
print<>=~s/(.)\1*/$1.length$&/egr
```

置き換えるのですから、`s/pattern/replacement/`を使います。

まず、`/pattern/`は`/(.)\1*/`です。これは、まず1文字確定させて、それがさらに0文字以上続くというのにマッチングします。`sed`と違ってキャプチャにエスケープが必要ないので、`(`と`)`で囲むだけです。

`replacement`ですが、マッチングした箇所の長さを埋め込む必要があります。これをするために、`e`フラグを`s///`の後ろにつけています。
`e`フラグがあると何をするかというと、`replacement`でそのまま置き換えるのではなく、`replacement`をPerlコードとして評価した結果を埋め込むようになります。（`"e"val`するということです。）

`replacement`において、キャプチャした文字は`$1`、マッチした部分文字列は`$&`で参照できます。`$1`と`length$&`を`.`演算子を使って文字列として連結し、埋め込みます。
この置換を文字列のすべての部分に対して行うので、`g`フラグもつけます。

`<>=~`として入力を読み込んだ直後に置換しているのですが、この`<>`は書き換え不可能なので、`r`フラグをつけることによって、実際に書き換えるのではなく置換した文字列を返すようにします。

以上3つのフラグを付けて、`print<>=~s///egr`となります。`<>`で読み込んだ改行は`.`にマッチングせず、したがって変更されないので、末尾に改行がついたまま出力されます。

```bash:Bash(39Byte)
fold -1|uniq -c|awk '{printf$2$1}';echo
```

`fold`は行を折り返すコマンドです。`-1`とオプションを与えていますが、こうすると1文字ごとに折り返す、つまり、文字ごとに改行を挟むようにします。

`uniq`は「連続する」同じ行を1つにまとめます。（連続していない場合はまとめられません。）`-c`オプションを与えると、行の先頭に、まとめられた要素の個数を付けて出力します。

AWKから見ると、フィールド1に個数が、フィールド2にまとめられた行の内容があるので、これを逆にして連結し、出力します。余計なタブ文字や空白はフィールドの内容にはならないので、そういう余計なものを取り除く役割も持ちます。改行区切りにはなってほしくないので、AWKでは`printf`を使って改行せず出力しています。

ただ、こうしてしまうと末尾にも改行が入らないので、最後に`echo`を引数なしで呼び出すことで改行しています。


## [ABC020 足し算](https://beta.atcoder.jp/contests/abc020/tasks/abc020_b)

> $A \quad B$

$A$と$B$を文字列として連結し、数値として2倍して出力します。

```awk:Awk(11Byte)
$0=($1$2)*2
```

やるだけ。