Qiita 7 - キータぞ、来たぞ、キータだぞー

**デフォルトの名無しさん** · 2025/09/13(土) 12:24:07.83

Hello hackers !
Qiitaは、エンジニアリングに関する知識を記録・共有するためのサービスです。
コードを書いていて気づいたことや、自分がハマったあの仕様について、
他のエンジニアと知見を共有しましょう ;)

https://qiita.com/

Qiita（キータ）は、Incrementsが運営するプログラミング情報のナレッジコミュニティ。
2016年現在で日本最大のプログラマーコミュニティとされている[1]。

https://internet.watch.impress.co.jp/docs/news/1025972.html

前スレ Qiita
https://mevius.5ch.net/test/read.cgi/tech/1542357242/
Qiita 2 - キータぞ、来たぞ、キータだぞー
https://mevius.5ch.net/test/read.cgi/tech/1658762410/
Qiita 3 - キータぞ、来たぞ、キータだぞー
https://mevius.5ch.net/test/read.cgi/tech/1685235361/
Qiita 4 - キータぞ、来たぞ、キータだぞー
https://mevius.5ch.net/test/read.cgi/tech/1705486836/
Qiita 5 - キータぞ、来たぞ、キータだぞー
https://mevius.5ch.net/test/read.cgi/tech/1717651046/
Qiita 6 - キータぞ、来たぞ、キータだぞー
https://mevius.5ch.net/test/read.cgi/tech/1739527246/

**デフォルトの名無しさん** · 2025/09/14(日) 01:56:40.69

『【Go】配列を再帰的に逆順にするサンプルコードを書いてみた』
> 再帰を使うことで、ループを使わずにエレガントに実装できる。
　
根本的なところで誤解してる人な模様。

**デフォルトの名無しさん** · 2025/09/14(日) 02:53:44.41

>>2
一般論として
再帰で表現した方が抽象度が高く理解しやすく定義そのまま表現できることが多い
特に末尾再帰をコンパイラがループへ変換してくれて実行効率が同等ならば全ての点で再帰による表記が勝る

**デフォルトの名無しさん** · 2025/09/14(日) 12:10:16.28

入力配列と出力配列渡してループで処理するわ

**デフォルトの名無しさん** · 2025/09/14(日) 12:59:52.05

記事の再帰版のコードは

> func ReverseArray(arr []int, start, end int) []int {
> 　　// ベースケース: 配列の中央に到達したら終了
> 　　if start >= end {
> 　　　　return arr
> 　　}
>
> 　　// 要素を交換
> 　　arr[start], arr[end] = arr[end], arr[start]
>
> 　　// 再帰呼び出し: 範囲を狭めて継続
> 　　return ReverseArray(arr, start+1, end-1)
> }

引数で渡した配列の内容書き換えるんでreturn要らないんだよなあ。

再帰で書くよか繰り返しで書いた方が余程シンプルとも思う。

func ReverseArrayWithFor(arr []int, start, end int) {
　　for start < end {
　　　　arr[start], arr[end] = arr[end], arr[start]
　　　　start += 1
　　　　end　 -= 1
　　}
}

**デフォルトの名無しさん** · 2025/09/14(日) 13:06:57.84

記事のスライス操作版のコードは

> // ReverseArrayWithSlice はスライス操作で配列を逆順にする（再帰）
> func ReverseArrayWithSlice(arr []int) []int {
> 　　// ベースケース: 要素が1つ以下なら逆順にする必要なし
> 　　if len(arr) <= 1 {
> 　　　　return arr
> 　　}
>
> 　　// 最初の要素を取り出し、残りを再帰的に逆順にしてから結合
> 　　return append(ReverseArrayWithSlice(arr[1:]), arr[0])
> }

引数の配列内容を書き換えないし再帰を説明する上では面白い例だと思うが、パフォーマンスは最低だ罠。

**デフォルトの名無しさん** · 2025/09/14(日) 13:28:33.58

そもそもの話として、ひとつの記事の中で複数の関数が引数だとか配列の内容を書き換えるのかどうかとか仕様が合ってないから比較になってないのよね。

**デフォルトの名無しさん** · 2025/09/14(日) 13:42:25.65

>>7
問題はそこだね
ループでも書けるよとかの筋違いな批判は要らんて

**デフォルトの名無しさん** · 2025/09/14(日) 14:21:09.67

・引数は配列を渡すのみ
・内容を逆にした配列を返し、引数で渡した配列の内容は書き換えない
という条件にしたとして、繰り返しで書くより再帰のほうが良い書き方ができるだろうか?

func ReverseArrayWithFor(arr []int) []int {
　　n := len(arr)
　　result := make([]int, n)

　　for i := 0; i < n; i++ {
　　　　result[i] = arr[n - i - 1]
　　}

　　return result
}

「全ての点で再帰による表記が勝る」という人には再帰の素晴らしさをぜひ証明してほしいところだが口だけ番長だろうなあ。

**デフォルトの名無しさん** · 2025/09/14(日) 15:20:41.57

>>9
大昔からの古典すら知らない無知
LISPも知らないんだろうな

**デフォルトの名無しさん** · 2025/09/14(日) 15:24:57.73

GoとLISPの区別もつかない人とはなあｗ

**デフォルトの名無しさん** · 2025/09/14(日) 15:30:37.23

記事のスライス操作版のコードは

> // ReverseArrayWithSlice はスライス操作で配列を逆順にする（再帰）
> func ReverseArrayWithSlice(arr []int) []int {
> 　　// ベースケース: 要素が1つ以下なら逆順にする必要なし
> 　　if len(arr) <= 1 {
> 　　　　return arr
> 　　}
>
> 　　// 最初の要素を取り出し、残りを再帰的に逆順にしてから結合
> 　　return append(ReverseArrayWithSlice(arr[1:]), arr[0])
> }

要素数1の配列を渡した場合は引数の配列をそのまま返してしまうので

　　// ベースケース: 要素が0以下なら逆順にする必要なし
　　if len(arr) <= 0 {

とした方が良いな。

**デフォルトの名無しさん** · 2025/09/14(日) 15:35:06.93

試しに
・引数は配列を渡すのみ
・内容を逆にした配列を返し、引数で渡した配列の内容は書き換えない
再帰で書いてみたが

func ReverseArray(arr []int) []int {
　　n := len(arr)
　　result := make([]int, n)
　　copy(result, arr)
　　var reverseArray func(int, int)
　　reverseArray = func(start int, end int) {
　　　　if start < end {
　　　　　　result[start], result[end] = result[end], result[start]
　　　　　　reverseArray(start + 1, end - 1)
　　　　}
　　}
　　reverseArray(0, n - 1)
　　return result
}

エレガントとは程遠いな。
ぜひLISP仕込みのエレガントな例をGoで書いて披露してほしいものだ。

**デフォルトの名無しさん** · 2025/09/14(日) 17:50:25.98

ChatGPTに下記の質問投げたらそこそこ納得できる回答くれたわ。

「Go言語は末尾再帰はサポートされてるの?」
「末尾再帰最適化されないところでの再帰呼び出しは引数の範囲が不定だとスタックがどれくらい使われるかの予測はしづらいので要はGoでは引数の範囲が不定なところでの再帰呼び出しは使わない方が無難てことですね。」
「関数型言語で育った人とかで「再帰は繰り返し処理より常に正義」とかって人いるじゃない。ああいう人にはGoは辛いかもですね。」
「Lispにloopがサポートされても意地でも使わないとかの人いましたね。」

**デフォルトの名無しさん** · 2025/09/14(日) 18:13:30.88

>>6
何言ってんの爆速ですわ

**デフォルトの名無しさん** · 2025/09/14(日) 18:45:10.81

＞何言ってんの爆速ですわ
　
コードと実行結果のひとつでも挙げりゃ良いのだけど、それができない人がなんか言ってる感じｗ

**デフォルトの名無しさん** · 2025/09/14(日) 19:42:15.05

>>13
下手すぎ
最初に丸ごとcopyする時点でプログラミングのセンスがない

**デフォルトの名無しさん** · 2025/09/14(日) 19:59:01.07

丸ごとcopyしない>>17のセンスある実装に期待ｗ

**デフォルトの名無しさん** · 2025/09/14(日) 21:05:23.33

いつも的外れな記事批判を繰り返している連投クンは本気でわからないようだな
元データを改変せずに新たに逆順を返す再帰関数を書きたいのならば例えばこうする

func ReverseArray(input []int) []int {
if len(input) == 0 {
return nil
} else {
return append(ReverseArray(input[1:]), input[0])
}
}

**デフォルトの名無しさん** · 2025/09/15(月) 00:35:19.13

>>19と他のコードでベンチマークしてみた。要素数は10から10000。

https://ideone.com/DZJosr
> 10:
> ReverseArray9: 0.000001
> ReverseArray13: 0.000000
> ReverseArray19: 0.000002
> 100:
> ReverseArray9: 0.000000
> ReverseArray13: 0.000000
> ReverseArray19: 0.000016
> 1000:
> ReverseArray9: 0.000002
> ReverseArray13: 0.000040
> ReverseArray19: 0.000104
> 10000:
> ReverseArray9: 0.000011
> ReverseArray13: 0.000293
> ReverseArray19: 0.000958

**デフォルトの名無しさん** · 2025/09/15(月) 00:39:24.47

エンジニアならベンチ結果で語るべきだよな！

**デフォルトの名無しさん** · 2025/09/15(月) 00:41:02.81

末尾再帰を自動的にループ化しないシステムもあれば
appendするだけで毎回ムダに新たに別メモリを確保してしまうシステムもある
Goは最悪だと実証された

**デフォルトの名無しさん** · 2025/09/15(月) 00:50:27.97

このクソ仕様がGoの敗因っぽいね

＞appendは毎回新たなスライスを生成します

**デフォルトの名無しさん** · 2025/09/15(月) 08:10:37.10

>>17が丸ごとcopyしないセンスある実装を晒してくれなかったので書いてみた。

func ReverseArray(arr []int) []int {
　　n := len(arr)
　　result := make([]int, n)
　　var reverseArray func(int)
　　reverseArray = func(i int) {
　　　　if i < n {
　　　　　　result[i] = arr[n - 1 - i]
　　　　　　reverseArray(i + 1)
　　　　}
　　}
　　reverseArray(0)
　　return result
}

やはりセンスある感じではないな。素直に for で繰り返した方が素直な感じ。

**デフォルトの名無しさん** · 2025/09/15(月) 08:16:11.29

ベンチマーク結果

https://ideone.com/mBV6Jr
> 10:
> ReverseArray9: 0.000001
> ReverseArray13: 0.000001
> ReverseArray19: 0.000003
> ReverseArray24: 0.000000
> 100:
> ReverseArray9: 0.000000
> ReverseArray13: 0.000001
> ReverseArray19: 0.000024
> ReverseArray24: 0.000001
> 1000:
> ReverseArray9: 0.000003
> ReverseArray13: 0.000061
> ReverseArray19: 0.000143
> ReverseArray24: 0.000006
> 10000:
> ReverseArray9: 0.000013
> ReverseArray13: 0.000446
> ReverseArray19: 0.001487
> ReverseArray24: 0.000060

ReverseArray24が案外良いのは恐らくは再帰呼び出しをループにする最適化が行われている感じ。

**デフォルトの名無しさん** · 2025/09/15(月) 08:27:46.98

ideone では Go のコンパイラが 1.12.1 と旧く、もっと新しい版(1.24.2)だと ReverseArray9 と ReverseArray24 の差は小さくなる模様。

https://godbolt.org/z/KW87qMWsf

出力コードも見ようとしたけどちょっと見る気起きないな。
main_ReverseArray19_pc0 の中で再帰呼び出ししてることは
> CALL main.ReverseArray19(SB)
確認したが。

**デフォルトの名無しさん** · 2025/09/15(月) 08:41:05.40

一番シンプルにわかりやすい>>19を再帰呼び出しのままは厳しいな
appendするたびに作り直すらしいGoの仕様が足を引っ張ってるのだろうか

**デフォルトの名無しさん** · 2025/09/15(月) 09:31:01.39

今のQiitaはこの程度の話すらコメ欄ではできないのがクソなんだよなあ。

**デフォルトの名無しさん** · 2025/09/15(月) 12:47:17.00

なんか同じパラメータでの呼び出しを2回繰り返すと ReverseArray13 と ReverseArray19 だけ 2回目の速度が向上するな?

https://ideone.com/zLdldJ
> 1000:
> ReverseArray9: 0.000003
> ReverseArray13: 0.000089
> ReverseArray19: 0.000174
> ReverseArray24: 0.000007
> 1000:
> ReverseArray9: 0.000004
> ReverseArray13: 0.000005
> ReverseArray19: 0.000016
> ReverseArray24: 0.000007
> 10000:
> ReverseArray9: 0.000018
> ReverseArray13: 0.000574
> ReverseArray19: 0.001747
> ReverseArray24: 0.000059
> 10000:
> ReverseArray9: 0.000024
> ReverseArray13: 0.000035
> ReverseArray19: 0.000207
> ReverseArray24: 0.000055

キャッシュの影響ではなさそうだがなんぞコレ? こういうのは楽しい。

**デフォルトの名無しさん** · 2025/09/15(月) 13:03:08.76

要素数を1000から1000刻みで増やしていくと6000でガクッとパフォーマンス落ちてるな。
https://ideone.com/2yAyfW

再帰呼び出しを深く行うことでスタックが足りなくなりスタック領域の拡張が行われそれでパフォーマンスが落ちてる気がする。
予めスタック領域が十分拡張されてれば ReverseArray13 と ReverseArray19 のパフォーマンスも 1回目から比較的マシになりそうな気がする。

**デフォルトの名無しさん** · 2025/09/15(月) 13:16:02.23

試しにmain()の先頭にスタック領域を拡張してくれそうな処理を入れてみた。

　　var enlarge func(int)
　　enlarge = func(n int) {
　　　　if n > 0 {
　　　　　　enlarge(n - 1)
　　　　}
　　}
　　enlarge(100000)

実行結果
https://ideone.com/cJl9AC
> 1000:
> ReverseArray9: 0.000005
> ReverseArray13: 0.000011
> ReverseArray19: 0.000028
> ReverseArray24: 0.000009
> 10000:
> ReverseArray9: 0.000032
> ReverseArray13: 0.000048
> ReverseArray19: 0.000273
> ReverseArray24: 0.000110

こうかは　ばつぐんだ！

**デフォルトの名無しさん** · 2025/09/15(月) 13:23:08.72

>>25で
> ReverseArray24が案外良いのは恐らくは再帰呼び出しをループにする最適化が行われている感じ。

というのは多分間違いで、ReverseArray24 の前に実行している ReverseArray13 や ReverseArray19 のお陰でスタック領域が予め拡張されていたため ReverseArray24 の実行でスタック領域拡張処理が発生しなかったことがパフォーマンスが案外良かったことの原因と思われる。

**デフォルトの名無しさん** · 2025/09/15(月) 19:24:06.27

IDコロコロ切り替えてる人は自分の投稿に自信がないのかな

**デフォルトの名無しさん** · 2025/09/15(月) 22:14:31.00

>>33
いや自信ないのはお前
いまはIDコロコロを言う流れでない
直前の投稿は同一IDで8件投稿してIDコロコロでない
安価なくIDコロコロと言われても何を言ってるのかわからない
お前が自分の投稿に自信ないのは空気を読めず日本語が不自由だから

**デフォルトの名無しさん** · 2025/09/16(火) 01:27:30.19

IDコロコロに反応する人がいるのは面白いねえｗ

**デフォルトの名無しさん** · 2025/09/16(火) 02:12:35.47

図っ星

**デフォルトの名無しさん** · 2025/09/16(火) 09:08:34.57

Qiitaのコメ欄で有意義な議論ができない問題、バカなこと言ってる側が複垢使うとかで相手を攻撃的と通報する可能性までありそうだなｗ

**デフォルトの名無しさん** · 2025/09/16(火) 19:41:50.97

>>9や>>24のコードがダサくて>>19がシンプルなのは再帰の有無ではなくコードの抽象的な度合いが原因だと思う

**デフォルトの名無しさん** · 2025/09/17(水) 08:59:29.24

数学的に言うと Σ(Sigma) は
再帰の方が抽象的なんか？
ループでも等価だと思うんだが

**デフォルトの名無しさん** · 2025/09/17(水) 09:21:49.27

>>38
再帰を使わないシンプルな版を書いて主張すれば良い

**デフォルトの名無しさん** · 2025/09/17(水) 09:26:43.33

>>9
arr[n - i - 1]が不格好ではあるな

**デフォルトの名無しさん** · 2025/09/17(水) 10:55:53.14

>>41
func ReverseArray(arr []int) []int {
　　n := len(arr)
　　result := make([]int, n)

　　for i, j := 0, n - 1; i < n; i, j = i + 1, j - 1 {
　　　　result[i] = arr[j]
　　}

　　return result
}

**デフォルトの名無しさん** · 2025/09/17(水) 21:20:35.77

しまったー！
ElixirChip初お目見え会今日だったじゃーん
忘れてたわー！ざーんねーん！
とか言ったりして。

**デフォルトの名無しさん** · 2025/09/17(水) 22:01:15.40

配列などの各要素を巡る抽象化はイテレータだよ
抽象化の役割分担がわかりやすいRustで説明すると
今回の各要素の順番を逆順にしたベクタを作る関数はこうなる

fn reverse_value<T: Clone>(input: &[T]) -> Vec<T> {
input
.iter() // 各要素への参照を巡るイテレータ
.rev() // それを逆順に巡る
.cloned() // 各要素への参照から値を複製して値を得る
.collect() // それらの値を今回は返り型で指定のVecへ収集
}

このイテレータは各要素への参照(ポインタ)を動かしていくので
今回のように値を複製したい場合は.cloned()が必要となる
それを無しにすると以下のように各要素への参照のベクタが得られる

fn reverse_reference<T>(input: &[T]) -> Vec<&T> {
input
.iter() // 各要素への参照を巡るイテレータ
.rev() // それを逆順に巡る
.collect() // それらの参照を今回は返り型で指定のVecへ収集
}

このように抽象化された各パーツを組み合わせることで
可読性と安全性と高速実行を両立させている

**デフォルトの名無しさん** · 2025/09/17(水) 22:14:21.95

改行CRとLFの真実：MS-DOS・BIOS・WIN10での挙動比較
https://qiita.com/earthen94/items/9c1a1fb8e1c7a2f32432
> Windows10
> '\r'で行頭に戻ることは確認できましたが、'\n'では下の行に下がるだけでなく行頭に自動的に戻されてしまうようです。

'\n'で行頭に移動するのはC言語の仕様で「\n 改行（new line）現表示位置を次の行の最初の位置に移動する。」となってるからで、WindowsではユニバーサルCランタイム (UCRT)が標準出力をテキストモードでオープンしてるため '\n' が '\r' + '\n' に変換されるからで、さらに最近の Windows Terminal は '\n' の動作が行頭に移動するようなってるので、とか説明せんといかんのかな、メンドい。

**デフォルトの名無しさん** · 2025/09/17(水) 22:54:27.39

せっかくなので>>44の関数のベンチマークをしてみた。
https://godbolt.org/z/KxYEdofWd

reverse_value() のほうがちょっと速いのかな。
Rustって知らんけどblack_boxなんてあんのは面白いな。

**デフォルトの名無しさん** · 2025/09/17(水) 23:13:57.67

>>46
参照型つまりアドレスたぶん64bitを収容と
i32型つまり32bitを収容のサイズの異なる比較になってしまってないかね？

**デフォルトの名無しさん** · 2025/09/18(木) 00:40:20.60

for でぐるぐる回すとこんな感じかな。

fn reverse_array<T: Clone>(input: &[T]) -> Vec<T> {
　　let mut result = Vec::with_capacity(input.len());

　　for i in (0..input.len()).rev() {
　　　　result.push(input[i].clone());
　　}

　　result
}

https://godbolt.org/z/5dc1KaWsd

**デフォルトの名無しさん** · 2025/09/18(木) 01:41:40.32

出力の関数名間違ってたので訂正
https://godbolt.org/z/Kb7b3hc6P

**デフォルトの名無しさん** · 2025/09/18(木) 16:56:30.82

>>44
元のGoのコードがintの配列扱ってるのにジェネリック化してCloneで効率下げてるのなんで??

**デフォルトの名無しさん** · 2025/09/18(木) 17:45:09.89

>>50
Rustのジェネリックは効率を下げなくて従来の型指定した時と全く同じように動作することが特徴です
RustのCloneとは参照先から値を複製することです
例えば32bit数値の場合ならばCPUによるメモリ/レジスタ⇔メモリ/レジスタ間のロードやセーブが複製であって必ず行われることなので効率が下がることはありません

**デフォルトの名無しさん** · 2025/09/18(木) 23:44:30.13

Rustが広まってる理由はC並みの高速実行をゼロコスト抽象化によるコードの可読性・保守性・開発効率の高さで実現したことにあるからね
安全性などはついでのオマケ

**デフォルトの名無しさん** · 2025/09/21(日) 18:14:05.85

再帰派、息してる?

**デフォルトの名無しさん** · 2025/09/21(日) 19:59:36.62

もれちんは再吃不能

**デフォルトの名無しさん** · 2025/09/21(日) 19:59:57.80

天才すぎて再起不能

**デフォルトの名無しさん** · 2025/09/21(日) 23:24:29.32

>>52
Rustは冗長なくせに変な略語や記号を多用するから可読性は低いよ。JavaとPerlの悪い所取り。

**デフォルトの名無しさん** · 2025/09/21(日) 23:46:21.39

>>56
変な記号？
記号は他の言語と同じ
Rustはコードの抽象化に成功していて可読性も保守性も高い

**デフォルトの名無しさん** · 2025/09/22(月) 07:39:29.97

Rustの..と..=の違いはセンスないなあと思った。Rubyの..と...も同様。

**デフォルトの名無しさん** · 2025/09/22(月) 08:00:31.81

>>58
長さlenの連続体(スライス)のインデックスは0からlen-1になるのだから
0..lenが0以上len未満つまり0からlen-1を示すRustの仕様はセンスが良い

これを一般的には半開区間と言い数学では[start, end)と表記しstartは含むがendは含まず利点が多い

プログラミングでn個を処理するときにインデックスなどを i = 0 から i < n と書くがこれも半開区間でRustなら0..nの表記になる
ごく稀にn+1個の処理をする i = 0 から i <= n を扱いたい時には対応する0..=nの表記ができる
したがってRustの表記法がベストであることがよくわかる

**デフォルトの名無しさん** · 2025/09/22(月) 09:09:30.72

『Rust で書いたプログラムがなんか遅い』
　
Rustで..=を気軽にホイホイ使ってしまって「なんか遅い」と言ってる例。
抽象化の高い言語を使って何が起きてるか分かってないのも考えものだな。

**デフォルトの名無しさん** · 2025/09/22(月) 09:16:25.38

Rubyの .. はPascal と記法を合わせたもので、 ... は番兵を1つ外側に立たせておくくらいのイメージかな。
Rustの .. は、Pascac と記法を合わせることには拘らず、多用される番兵方式を少ない記号数で記述できる方が合理的という判断なんだろう。..= という記法のセンスの良し悪しは何とも言えないが。
どちらも内在的にはそれなりに合理的なんじゃないかな。

**デフォルトの名無しさん** · 2025/09/22(月) 09:59:26.76

Pascal方式は1発進と相性がよく1..nがn個になる
Rust方式は0発進と相性がよく0..nがn個になる
indexが0発進になる言語はRust方式が便利

**デフォルトの名無しさん** · 2025/09/22(月) 10:11:48.70

Pascalは..もforも閉区間[a, b]で統一されてるし配列の添字の範囲も自由なので思想的にはシンプルだと思う。

**デフォルトの名無しさん** · 2025/09/22(月) 11:19:37.59

記述や可読性の差が大きい

start..endの個数
【Rust】 end-start個
【Pascal】 end-start+1個

startからn個
【Rust】 start..(start+n)
【Pascal】 start..(start+n-1)

このように間違えやすく見にくい+1や-1が
半開区間を採用のRustでは不要となる

**デフォルトの名無しさん** · 2025/09/22(月) 11:35:27.21

Ruby の .. と ... はスッキリしているけど、老眼には辛いのよ。麻雀牌のニ萬と三萬よりさらに見分けづらいから。

**デフォルトの名無しさん** · 2025/09/22(月) 23:00:01.38

>>59
..は左右対称なので閉区間にしか見えず、それで右半開区間を表すのはバグの元となりやすい。
右半開区間は左右非対称の..<で表すのが妥当で、Swiftはそうしている。Swiftは閉区間が...で
.が1個余分なのは良くないが。

閉区間を..で、右半開区間を..<で表せば、左半開区間を<..で、開区間を<..<で整合的に表せるし、
互いの見分けも容易だから合理的。もしC++が範囲演算子を導入するならこうしてもらいたい。

**デフォルトの名無しさん** · 2025/09/22(月) 23:50:00.52

前例に倣ったままにしとけめんどくせえ

**デフォルトの名無しさん** · 2025/09/23(火) 00:57:25.80

>>64
Rustの方式が優れてるね

**デフォルトの名無しさん** · 2025/09/23(火) 08:21:07.31

半開区間と閉区間の両方をサポートするならどちらも間違いようがない書き方にするべきだろう。Rustは閉区間を..=で表すなら半開区間は..<とでもすれば良かったな。
..では「あれ? どっちだっけ?」と思ってしまう可能性がある。

**デフォルトの名無しさん** · 2025/09/23(火) 09:39:04.17

コード内に使われる記号列として許容できるのは .. と ... までかなぁ（ただし、両方を採用すると、ぱっと見では見分けがつきにくいという問題がある）。..= とか ..< は、もちろんそれなりに合理的な考慮の上で採用されたんだろうけど、もう見た目で受け付けないわ。
Rustも基本的には .. を使えってことなんじゃない？　一応、..= も用意してあるけど、どうしても必要なケースがあるなら使ってねくらいの位置付けに過ぎないと思う。

**デフォルトの名無しさん** · 2025/09/23(火) 10:03:23.14

範囲を表すのは .. だけにして、含まれない端点にはマーカー文字をつけるという方法もありそうだけど、目立つ採用例がないってことはたぶん問題があるんだろうね。

1 .. 5 → 1から5まで
1 .. 5^ → 1から4まで

**デフォルトの名無しさん** · 2025/09/23(火) 15:33:33.09

>>64
一見すると素人には閉区間が便利に見えてしまうけどそのような複雑化する害が多すぎるんだよな
プログラミング言語としては半開区間が最適だ

**デフォルトの名無しさん** · 2025/09/23(火) 17:38:31.18

IDコロコロ君の投稿を容易に見分けられるようになってしまい残念な気持ち。

**デフォルトの名無しさん** · 2025/09/23(火) 19:08:43.70

>>60
半開区間イテレータはゼロコスト抽象化が可能だけど、
閉区間イテレータはその仕様上どうしても枯渇フラグが別途必要となるため、
データサイズの増大とコード実行が遅くなってしまうからね。
閉区間イテレータは効率を求める場面ではタブーと教えるしかないよ。

**デフォルトの名無しさん** · 2025/09/23(火) 19:13:50.59

>>69
Rustはもともと効率のいい半開区間イテレータ「..」しかなくて、「..」以外の仕様でも半開区間が採用されているため、間違えることがないようにできているよ。
動作が遅くてもいいから欲しいとの要望により、閉区間イテレータ「..=」を後から追加したんだよ。
速度を気にする場所でこの変な記号「..=」を使うのは要注意と覚えれば大丈夫。

**デフォルトの名無しさん** · 2025/09/24(水) 04:44:51.44

歴史的な事情で対称性の悪い表記が存在するのって（その歴史を知らないと納得できないから）負の遺産だよね。

**デフォルトの名無しさん** · 2025/09/24(水) 09:37:45.93

古い言語は仕方ないね
新たな言語を作るならば歴史的な知見で誰もが半開区間ベースの言語仕様にするでしょう
①プログラムを書く上で便利　理由>>64
②実行効率も良い　理由>>74

**デフォルトの名無しさん** · 2025/09/25(木) 07:39:21.36

Pythonのrange(1,5)も1,2,3,4を意味する半開区間だよ

**デフォルトの名無しさん** · 2025/09/25(木) 08:04:45.13

半開区間と閉区間の両方をサポートしてて紛らわしい表記になってるのが残念という話が理解できない人かな

**デフォルトの名無しさん** · 2025/09/25(木) 10:55:22.03

Rustみたいに標準ライブラリ全体の仕様を半開区間で統一すれば間違えることもなく悩まずに済むのに

**デフォルトの名無しさん** · 2025/09/25(木) 11:16:52.45

要らない..=をサポートしてしまった為に糞化してしまったRust哀れ

**デフォルトの名無しさん** · 2025/09/25(木) 11:29:57.30

>>81
糞化って何？
意味がわからない

**デフォルトの名無しさん** · 2025/09/26(金) 10:22:57.69

確かに元から糞なものが糞化とは腹が痛い

**デフォルトの名無しさん** · 2025/09/26(金) 12:42:08.13

>>82
「糞化って何？」って何？
意味がわからない
元から糞なものが糞になって糞化したと言っても意味が通る

**デフォルトの名無しさん** · 2025/09/26(金) 16:46:57.32

>>82
ウンコになったってことだよ

**デフォルトの名無しさん** · 2025/09/26(金) 20:33:46.74

>>64
それよりもっと重要なことが抜けてるぞ
Pascal方式で避けられないそれら+1や-1がRust方式では不要となるだけでなく
Rust方式では長さ0を特別扱いせずに自然に扱えることが最大の特徴

Rust方式は長さnがstart..(start + n)であるため
長さ0はstart..startになって特別扱いすることなく自然にそのまま扱える

Pascal方式は長さnがstart..(start + n -1)であるため
長さ0はstart..(start -1)になり左右逆転してしまう
そのためこの不格好な逆転状態を長さ0とみなして扱うか
場合分けして長さ0を扱わないようにするか
場合分けして長さ0の時にnullとかnilとか空リストなど特別扱いする形になる

**デフォルトの名無しさん** · 2025/09/27(土) 00:25:32.78

＞長さ0はstart..startになって特別扱いすることなく自然にそのまま扱える
　
長さ0を表現するのにstartが具体的な値持ってて自然てどういう理屈?

**デフォルトの名無しさん** · 2025/09/27(土) 00:31:44.56

>>87
長さ1や長さ2がstart違ってあちこちにあるように
長さ0もstart違ってあちこちに存在する

**デフォルトの名無しさん** · 2025/09/27(土) 00:43:10.07

>>88
Pascalでstartの違う長さ0表して便利な例挙げてみて

**デフォルトの名無しさん** · 2025/09/27(土) 00:55:46.18

>>87
Rustの..は性質の良い半開区間なので、
例えばstart..endを途中のmiddleの位置で分割すると、start..middleとmiddle..endの二つに綺麗に分かれる性質も持っているよ。
そしてそのmiddleの決定算出結果が処理内容や処理状況によっては、たまたまstartと一致することも出てくる。
その時、start..middleとmiddle..endの二つは、start..startとstart..endの二つに分かれて前者は長さ0になるね。
Rustでのプログラミングでも実際にこれはよく起きるよ。

**デフォルトの名無しさん** · 2025/09/27(土) 01:43:57.58

>>90
区間の長さが0だった話じゃなくて、長さ0を表現するのにstartが具体的な値持ってるのはどうなのと聞いています。

**デフォルトの名無しさん** · 2025/09/27(土) 01:48:32.95

閉区間と半開区間のどちらにメリットがある場合もあり、Rustも閉区間をサポートしてるのに半開区間のみを持ち上げてるのは見識が狭いな。

**デフォルトの名無しさん** · 2025/09/27(土) 02:17:11.42

>>91
区間には必ずスタート位置を伴いますね。
そこから長さが2だったり長さが1だったり長さが0だったりするわけです。
長さ0の時だけスタート位置が無いのは不自然でしょう。

>>92
良い性質を備えていてメリットがあるのは半開区間でしょう。
Rustの標準APIは区間分割split_atなどでも半開区間を前提として処理されます。

**デフォルトの名無しさん** · 2025/09/27(土) 02:20:12.82

『fast inverse square root (高速逆平方根) のようなトリックまとめ』
　
未定義動作コードの見本市みたいな記事。
C言語知りませんアピールか。

**デフォルトの名無しさん** · 2025/09/27(土) 07:25:01.25

C言語なんて動きゃいいんだよ動きゃ

**デフォルトの名無しさん** · 2025/09/27(土) 08:53:18.36

動きゃいいんだよ動きゃなんて言語でカーネルを作ってほしくない

**デフォルトの名無しさん** · 2025/09/27(土) 12:15:10.22

古いのから新しいのまであらゆるCPUで動きゃいいんだよ動きゃ

**デフォルトの名無しさん** · 2025/09/27(土) 13:57:37.59

＞動きゃいいんだよ動きゃ
　
動くかわからん未定義動作のコードにこういうこと言う奴は馬鹿