索引

Array クラス

　　配列を扱うクラスです．配列は，複合データ型の一種であり，複数のデータを処理する場合に利用されます．Ruby においては Array クラスのインスタンスとして定義され，例えば，

x = Array[1, 2.3, "abc"];   # x = [1, 2.3, "abc"]; でも可

のように宣言すれば，3 つのデータを記憶できる領域が確保され，各要素に記憶される値が 1，2.3，"abc" で初期設定されます．また，変数名と添え字を利用して，x[0]，x[1]，x[2] のようにして参照できます．この例に示すように，各要素は，必ずしも，同じデータ型である必要はありません．しかし，間違いの元になる可能性がありますので，配列は，同じデータ型だけで構成するようにした方が良いと思います．また，プログラムの実行時に，要素の追加，削除等を行うことが可能です．このような点から，Array クラスは，C++ 標準ライブラリ内の vector クラスに似ています．

　　例えば，

u1 = Array[1, "abc", 2];
u2 = Array[1, "abc", 2];
u3 = u1;

の最初の 2 行では，同じ値で初期設定された 2 つの配列 u1，u2 を定義し，次の行において u1 を u3 に代入しています．しかし，この代入は，整数型の場合のような代入ではありません．つまり，u1 の領域及びそこに記憶されている要素をすべてコピーし，u3 に代入しているわけではありません．ここでは，u1，u2，u3 をポインタとしてとらえた方が理解しやすいと思います．つまり，2 行目の代入によって，u1 に記憶されているアドレスが u3 に記憶され，u1 と u3 が同じ領域を指しているという意味です．実際，u1 の値を変更すれば，u3 の値も変化します（逆も同様）．配列を関数の引数として渡す場合も，ポインタを引数とすることに相当しますので，関数内で配列の要素の値を変更すれば，関数を呼んだ側における対応する要素の値も変化します．このことを概念的に示せば以下のようになります．

　　多次元の配列を扱うことも可能です．例えば，

v1 = Array[[10, 20, 30], [40, 50, 60]];
v2 = Array[[10, 20, 30], [40, 50, 60]];
v3 = v1;

のように，配列の要素を，さらに配列として定義すれば，2 次元の配列を定義できます．この例では，2 行 3 列の配列になります．3 行目の記述によって，v3 も，v1 と同じ 2 行 3 列の配列になります．そのイメージは，new 演算子を使用した C++ の場合と同じく，以下のようになります．

　　また，

v4 = v1[0];   // v1，v3 の 1 行目

のように，各行を 1 次元配列として扱うことも可能です．勿論，v4 と v1[0] は同じ場所を指していますので，例えば，v4[1] の値を変更すれば，v1[0][1] の値も変化します（逆も同様）．しかし，すべてのデータが連続した領域に確保されるとは限らないため，異なる行のデータを，連続した 1 次元配列とみなして参照することはできません．

　　以下，多くのメソッドが挙げられていますが，同じ機能を持つものであれば，「記述しやすい」ではなく，「理解しやすい」ものを使用するようにしてください．

［インクルードモジュール］ Enumerable モジュール
［クラスメソッド］ Array　配列の生成 new　配列の生成
［メソッド］ [nth]　nth 番目の要素 [start..end]　（ start 番目～ end 番目）の要素からなる部分配列 slice(start..end)　（ start 番目～ end 番目）の要素からなる部分配列 [start,length]　start 番目から length 個の要素を含む部分配列 slice(start,length)　start 番目から length 個の要素を含む部分配列 [nth]=val　nth 番目の要素を val に設定 [start..end]=val　start から end 番目の要素を配列 val に置換 [start,length]=val　start から length 個の要素を配列 val で置換 +　内容を繋げた新しい配列 *　配列の内容を繰り返した新しい配列 -　配列に含まれる要素を除いた配列 &　両方の配列に含まれる要素からなる配列 |　いずれかの配列に含まれる要素からなる配列 <<　配列の末尾に追加 <=>　各要素を順に <=> で比較 ==　等しいか否か assoc　配列の配列を検索（ 0 番目） at　nth 番目の要素 bsearch　二分探索 clear　要素をすべて削除 clone　コピー（複製） dup　コピー（複製） collect!　要素の評価 map!　要素の評価 compact　nil 要素の除去 compact!　nil 要素の除去 concat　配列を末尾に追加 delete　指定された要素の削除 delete_at　指定された位置にある要素の削除 delete_if　真となる要素を削除 reject!　真となる要素を削除 each　要素の評価 each_index　要素の添え字の評価 empty?　要素を持たないとき真 eql?　各要素のオブジェクトが等しければ真 fetch　nth 番目の要素 fill　要素の値の設定 first　最初の要素 flatten　平滑化 flatten!　平滑化 include?　指定された要素を含んでいるか? index　指定された要素の位置（最初） insert　要素の挿入 join　要素を連結した文字列 last　末尾の要素 length　配列のサイズ size　配列のサイズ pop　末尾の要素を取り除く push　末尾に要素を追加 rassoc　配列の配列を検索（ 1 番目） replace　配列の置き換え reverse　逆順に並べ替え reverse!　逆順に並べ替え reverse_each　逆順に評価 rindex　指定された要素の位置（最後） shift　先頭の要素を取り除く slice!(start..end)　部分配列の削除 slice!(start,length)　部分配列の削除 sort　ソート sort!　ソート transpose　転置 uniq　重複要素の削除 uniq!　重複要素の削除 unshift　先頭に要素を追加 values_at　指定された添え字に対応する要素

［クラスメソッド］

Array [ item, ･･･ ]

　　引数を要素として持つ配列を生成します．
```
a = [1, 2, 3]; p a   # => [1, 2, 3]
b = Array[1, 2, 3]; p b   # => [1, 2, 3]		
```
Array.new ( [ size [ , val ] ] )
Array.new ( ary )
Array.new ( size ) { |index| ･･･ }

　　配列を生成します．size を指定したときには，その大きさの配列を生成し nil で初期化します．第二引数 val も指定したときには，nil の代わりに，そのオブジェクトを全要素にセットします．val をコピーしてすべての要素に設定するわけではないことに注意してください．すべての要素は，同じオブジェクトを指します（つまり，同じオブジェクトに対するアドレスが設定される）．

　　二番目の形式では，引数に指定した配列を複製して返します．また，三番目の形式では，ブロックの評価結果で値を設定します．ブロックは要素毎に実行されるので，全要素をあるオブジェクトの複製にすることができます．
```
a = Array.new(3, 10); p a   # => [10, 10, 10]
b = Array.new(["a", "b", "c"]); p b   # => ["a", "b", "c"]
k = -1; c = Array.new(3) { |m| k += 1 }; p c   # => [0, 1, 2]		
```

［メソッド］

self [ nth ]

　　nth 番目の要素を返します．先頭の要素が 0 番目になります．nth の値が負の時には，末尾からのインデックスと見倣します（末尾の要素が -1 番目）．
```
a = [1, 2, 3]; p a   # => [1, 2, 3]
p a[1]   # => 2
b = [["a", "b"], ["c", "d"], ["e", "f"]]; p b   # => [["a", "b"], ["c", "d"], ["e", "f"]]
p b[1]   # => ["c", "d"]
p b[1][0]   # => "c"		
```
self [ start .. end ]
slice ( start .. end )

　　start 番目の要素から，end 番目の要素からなる部分配列を返します．start の値が負の時には，末尾からのインデックスと見倣します（末尾の要素が -1 番目）．
```
a = [1, 2, 3]; p a[0..1]   # => [1, 2]		
```
self [ start, length ]
slice ( start, length )

　　start 番目から length 個の要素を含む部分配列を返します．start の値が負の時には，末尾からのインデックスと見倣します（末尾の要素が -1 番目）．
```
a = [1, 2, 3]; p a[0, 2]   # => [1, 2]		
```
self [ nth ] = val

　　nth 番目の要素を val に設定します．nth が配列の範囲を越える時には，配列の長さを自動的に拡張し，拡張した領域を nil で初期化します．val を返します．
```
a = [1, 2, 3]; a[1] = 10; p a   # => [1, 10, 3]
a = [[1, 2], [3, 4], [5, 6]]; a[1][0] = 10; p a   # => [[1, 2], [10, 4], [5, 6]]		
```
self [ start .. end ] = val

　　start 番目の要素から end 番目の要素までを，配列 val の内容に置換します．val の値が配列でないときには，val で置換します．val が，nil か空の配列 [] なら，start から end までの要素が削除されます．val を返します．
```
a = [1, 2, 3]; a[0..1] = [10, 10, 10]; p a   # => [10, 10, 10, 3]
a = [1, 2, 3]; a[0..1] = 10; p a   # => [10, 3]		
```
self[start, length]=val

　　start から length 個の要素を配列 val の内容で置換します．val が配列でないときには，val で置換します．val を返します．
```
a = [1, 2, 3]; a[0, 2] = [10, 10, 10]; p a   # => [10, 10, 10, 3]
a = [1, 2, 3]; a[0, 2] = 10; p a   # => [10, 3]		
```
self + other

　　self と other の内容を繋げた新しい配列を返します．
```
p [1, 2] + [3, 4]   # => [1, 2, 3, 4]		
```
self * times

　　配列の内容を繰り返した新しい配列を作成し返します．new と同様，元の内容をコピーして設定されるわけではなく，同じオブジェクトに対するアドレスが設定されます．
```
p [1, 2] * 3   # => [1, 2, 1, 2, 1, 2]		
```
self - other

　　self から配列 other に含まれるの要素を取り除いた新しい配列を返します（集合の差演算）．
```
p [1, 2, 3, 2, 2, 4, 5, 4] - [2, 4]   # => [1, 3, 5]		
```
self & other

　　両方の配列に含まれる要素からなる新しい配列を返します（集合の積演算）
```
p [1, 2, 2, 3] & [3, 2, 3, 4, 4]   # => [2, 3]		
```
self | other

　　いずれかの配列に含まれる要素を全て含む新しい配列を返します（集合の和演算）．
```
p [1, 2, 2] | [3, 2, 2, 3]   # => [1, 2, 3]		
```
self << obj

　　obj を配列の末尾に追加します．push と同じ効果です．self を返します．
```
a = [1]; p a << 2   # => [1, 2]
b = [1]; p b << 2 << 3 << 4   # => [1, 2, 3, 4]		
```
self <=> other

　　self と other の各要素を順に <=> で比較していき，self が大きい時に正，小さい時に負の整数を返します．等しいときは，次の要素を調べ，同じ処理を行います．そして，すべての要素が等しいときは，0 を返します．各要素が等しいまま，一方だけ，配列の末尾に達した時は，より短い配列の方が小さいとみなします．
```
p [1, 2, 3] <=> [-1, 1, 5]   # => 1
p [1, 2, 3] <=> [1, 1, 5]   # => 1
p [1, 2, 3] <=> [1, 2, 5]   # => -1
p [1, 2, 3] <=> [1, 2, 3]   # => 0
p [1, 2, 3] <=> [1, 2, 2]   # => 1
p [1, 2, 3] <=> [1, 3, 5]   # => -1
p [1, 2, 3] <=> [2, 1, 5]   # => -1
p [1, 2, 3] <=> [1, 2]   # => 1
```
self == other

　　self と other の各要素をそれぞれ順に == で比較して，全要素が等しければ真を返します．
```
p [1, 2, 3] == [1, 2, 3]   # => true		
```
assoc ( key )

　　配列の配列を検索して，その 0 番目の要素が key に等しい最初の要素を返します（ rassoc 参照）．比較は == 演算子を使って行われます．
```
p [[1, 15], [2, 25], [3, 35]].assoc(2)   # => [2, 25]		
```
at ( nth )

　　nth 番目の要素を返します．先頭の要素が 0 番目になります．nth の値が負の時には，末尾からのインデックスと見倣します（末尾の要素が -1 番目）．[nth] と同じです．
```
a = [1, 2, 3]; p a   # => [1, 2, 3]
p a.at(1)   # => 2
b = [["a", "b"], ["c", "d"], ["e", "f"]]; p b   # => [["a", "b"], ["c", "d"], ["e", "f"]]
p b.at(1)   # => ["c", "d"]
p b.at(1).at(0)   # => "c"		
```
bsearch { |item| ･･･ }

　　ソートされた配列を対象として，各要素を順番にブロックに渡して評価し，条件を最初に満たした要素を返します．要素が存在しない場合は，nil を返します．以下の例に見るように，同じ要素が含まれている場合は注意してください．
```
data1 = [10, 30, 34, 35, 37, 44, 50, 70]
p data1.bsearch { |v| v == 37 }   # => 37
p data1.bsearch { |v| v <=> 37 }   # => 37
data2 = [10, 30, 34, 37, 37, 38, 50, 70, 80, 100]
p data2.bsearch { |v| v == 37 }   # => nil
p data2.bsearch { |v| v >= 37 }   # => 37		
```
clear

　　配列の要素をすべて削除して空にします．self を返します．
```
a = [1, 2, 3]; p a   # => [1, 2, 3]
a.clear; p a   # => []		
```
clone
dup
　　同じ内容を持つ新しい配列を返します．clone は，frozen （内容の変更の可否）などの情報も含めてコピーしますが，dup は，内容だけをコピーします．また，どちらのメソッドも，要素それ自体のコピーはしません．

collect! { |item| ･･･ }
map! { |item| ･･･ }

　　各要素を順番にブロックに渡して評価し，その結果で要素を置き換えます．self を返します．
p [-1, 2, -3].collect! { |v| v > 0 } # => [false, true, false]
compact
compact!

　　compact は，self から nil である要素を取り除いた新しい配列を返します．compact! は，変更が行われた場合は self を，そうでなければ nil を返します．
p [1, nil, 2, 3, nil].compact # => [1, 2, 3]
concat ( other )

　　配列 other を末尾に（破壊的に）連結します．self を返します．
p [1, 2].concat([3, 4]) # => [1, 2, 3, 4]
delete ( val )
delete ( val ) { ･･･ }

　　val と == で等しい要素をすべて取り除きます．val と等しい要素が見つかった場合は，val を返します．val と等しい要素がなければ nil を返しますが，ブロックが指定されていれば，ブロックを評価してその結果を返します．
a = [1, 2, 2, 3]; a.delete(2); p a # => [1, 3] p [1, 2, 2, 3].delete(2) # => 2 p [1, 2, 2, 3].delete(4) # => nil p [1, 2, 2, 3].delete(4) { "Not Exist" } # => "Not Exist"
delete_at ( pos )

　　pos で指定された位置にある要素を取り除き，その要素を返します．pos の値が負の時には，末尾からのインデックスと見倣します（末尾の要素が -1 番目）．
a = [1, 2, 3]; a.delete_at(1); p a # => [1, 3]
delete_if { |x| ･･･ }
reject! { |x| ･･･ }

　　要素を順番にブロックに渡して評価し，その結果が真になった要素をすべて削除します．delete_if は常に self を返しますが，reject! は，要素が 1 つ以上削除されれば self を，1 つも削除されなければ nil を返します．
p [1, 2, 3, 4, 5].delete_if { |m| m % 2 == 0 } # => [1, 3, 5]
each { |item| ･･･ }

　　各要素に対して，ブロックを評価します．self を返します．
[10, 20, 30].each { |m| print m, " " }; print "\n" # => 10 20 30 [10, 20, 30].each_index { |m| print m, " " } # => 0 1 2
each_index { |item| ･･･ }

　　各要素のインデックス（添え字）に対して，ブロックを評価します．self を返します．
[10, 20, 30].each { |m| print m, " " }; print "\n" # => 10 20 30 [10, 20, 30].each_index { |m| print m, " " } # => 0 1 2
empty?

　　配列の要素数が 0 の時，真を返します．
p [].empty? # => true
eql? ( other )

　　self と other の各要素を，それぞれ順に eql?（オブジェクトが等しければ真）で比較して，全要素が等しければ真を返します．
p [1, 2.0, 3] == [1, 2, 3] # => true p [1, 2.0, 3].eql?([1, 2, 3]) # => false
fetch ( nth )
fetch ( nth, ifnone )
fetch ( nth ) { |nth| ･･･ }

　　[nth] と同様，nth 番目の要素を返しますが，nth 番目の要素が存在しない場合の振舞いが異なります．最初の形式では，例外 IndexError が発生します．二番目の形式では，引数 ifnone を返します．三番目の形式では，ブロックを評価した結果を返します．
p [1, 2, 3][4] # => nil p [1, 2, 3].fetch(4, nil) # => nil p [1, 2, 3].fetch(4, "Not Exist") # => "Not Exist" [1, 2, 3].fetch(4) { |m| p m } # => 4 p [1, 2, 3].fetch(4) # => test.rb:5:in `fetch': index 4 out of array ・・・
fill ( va l)
fill ( val, start [ , length ] )
fill ( val, start .. end )
fill { |index| ･･･ }
fill ( start [ , length ] ) { |index| ･･･ }
fill ( start .. end ) { |index| ･･･ }

　　配列の，指定された範囲すべてに，val をセットします．二番目の形式で length が省略された時は，配列の終りまでの長さを意味します．指定された部分配列が，元の配列の範囲を越える時は，長さを自動的に拡張し，拡張した部分を val で初期化します．val をコピーしてすべての要素に設定するわけではないことに注意してください．すべての要素は，同じオブジェクトを指します（つまり，同じオブジェクトに対するアドレスが設定される）．

　　val の代わりにブロックを指定すると，ブロックの評価結果を値とします．ブロックは要素毎に実行されるので，セットする値のそれぞれをあるオブジェクトの複製にすることができます．ブロックのパラメータには start からのインデックスが渡されます．
a = Array.new(3); p a.fill(1) # => [1, 1, 1] a = Array.new(3); p a.fill(1, 0, 2) # => [1, 1, nil] a = Array.new(3); p a.fill(1, 0..1) # => [1, 1, nil] a = Array.new(3); p a.fill { |k| k } # => [0, 1, 2] a = Array.new(3); p a.fill(0, 2) { |k| k } # => [0, 1, nil] a = Array.new(3); p a.fill(0..1) { |k| k } # => [0, 1, nil]
first ( [ n ] )

　　配列の先頭の要素を返します（ last 参照）．引数 n を指定した場合，先頭の n 要素を配列で返します．
p [1, 2, 3, 4, 5].first # => 1 p [1, 2, 3, 4, 5].first(2) # => [1, 2]
flatten
flatten!

　　ネストした配列を，平滑化してそれを返します．flatten! は，配列それ自体を破壊的に平滑化し，配列がネストしていないときには nil を返します．
p [1, [2, 3], [4, 5], 6].flatten # => [1, 2, 3, 4, 5, 6]
include? ( val )

　　配列が val と == において等しい要素を持つ時に，真を返します
p [1, 2, 3].include?(2) # => true
index ( val )
index { |item| ･･･ }

　　最初の形式では，val と == で等しい最初の要素の位置を返します．二番目の形式では，ブロックが真を返した最初の要素の位置を返します．ブロック引数には，要素が順に渡されます．rindex も参照して下さい．
p [1, 4, 3, 4, 5].index(4) # => 1 p [1, 4, 3, 4, 5].index { |m| m > 3 } # => 1
insert ( nth, [ val [ , val2 ･･･ ] ] )

　　インデックス nth の要素の直前に，第 2 引数以降の値を挿入します．self を返します．引数 val を一つも指定しなければ，何もしません．
p [1, 2, 3].insert(1, 3, 2) # => [1, 3, 2, 2, 3]
join ( [ sep ] )

　　配列の要素を，区切り文字列 sep を間に挟んで，連結した文字列を返します．引数 sep が省略された場合には，組み込み変数 $, の値が使われます．$, のデフォルト値は nil です．
p [1, 2, 3].join("|") # => "1|2|3"
last ( [ n ] )

　　配列の末尾の要素を返します（ first 参照）．引数 n を指定した場合，末尾の n 要素を配列で返します．
p [1, 2, 3, 4, 5].last # => 5 p [1, 2, 3, 4, 5].last(2) # => [4, 5]
length
size

　　配列の長さを返します．配列が空のときは 0 を返します．
p [1, 2, 3, 4, 5].length # => 5
pop

　　末尾の要素を取り除き，その要素を返します（ shift，unshift，push 参照）．空配列の時は nil を返します．
a = [1, 2, 3, 4, 5]; a.pop; p a # => [1, 2, 3, 4]
push ( [ obj1 [ , obj2 ･･･ ] ] )

　　配列の末尾に，obj1，obj2，･･･を順番に追加します（ shift，unshift，pop 参照）．引数を指定しなければ何もしません．
p [1, 2, 3].push(4, 5) # => [1, 2, 3, 4, 5]
rassoc ( key )

　　配列の配列を検索して，その 1 番目の要素が key に等しい最初の要素を返します（ assoc 参照）．比較は == 演算子を使って行われます．
p [[1, 15], [2, 25], [3, 35]].rassoc(25) # => [2, 25]
replace ( another )

　　配列の内容を配列 another の内容で置き換えます．self を返します．
c = Array.new(3, "a"); c[1].replace("b"); p c # => ["b", "b", "b"] b = ["a", "a", "a"]; b[1].replace("b"); p b # => ["a", "b", "a"] a = [1, 1, 1]; a.replace([1, 2, 1]); p a # => [1, 2, 1] b = [1, 1, 1]; b[1].replace(2); p b # Error
reverse
reverse!

　　reverse は，全ての要素を逆順に並べた新しい配列を返します．reverse! は，配列の要素を逆順に（破壊的に）並べ替え，self を返します．
p [1, 2, 3].reverse # => [3, 2, 1]
reverse_each { |item| ･･･ }

　　各要素に対して，逆順にブロックを評価します．self を返します．
[1, 2, 3].reverse_each { |m| print m, " " } # => 3 2 1
rindex ( val )
rindex { |item| ･･･ }

　　最初の形式では，val と == で等しい最後の要素の位置を返します．二番目の形式では，ブロックが真を返した最後の要素の位置を返します．ブロック引数には，要素が順に渡されます．index も参照して下さい．
p [1, 4, 3, 4, 5].rindex(4) # => 3 p [1, 4, 3, 4, 5].rindex { |m| m > 3 } # => 3
shift

　　配列の先頭の要素を取り除き，その要素を返します（ unshift，pop，push 参照）．残りの要素は，ひとつずつ前に詰められます．
a = [1, 2, 3, 4, 5]; a.shift; p a # => [2, 3, 4, 5]
slice! ( start .. end )

　　start 番目の要素から，end 番目の要素からなる部分配列を取り除き，取り除いた部分配列を返します．start の値が負の時には，末尾からのインデックスと見倣します（末尾の要素が -1 番目）．
a = [1, 2, 3, 4, 5]; a.slice!(0..1); p a # => [3, 4, 5]
slice! ( start, length )

　　start 番目から length 個の要素を含む部分配列を取り除き，取り除いた部分配列を返します．start の値が負の時には，末尾からのインデックスと見倣します（末尾の要素が -1 番目）．
a = [1, 2, 3, 4, 5]; a.slice!(0, 2); p a # => [3, 4, 5]
sort
sort!
sort { |a, b| ･･･ }
sort! { |a, b| ･･･ }

　　全ての要素を昇順にソートした配列を生成して返します．ブロックなしのときは，<=> メソッドを要素に対して呼び，その結果をもとにソートします．

　　<=> 以外でソートしたい場合は，ブロックを指定します．この場合，ブロックの評価結果を元にソートします．ブロックの値に対しては，a > b のとき正，a == b のとき 0，a < b のとき負の整数を期待しています．
p [2, 1, 5, 3, 4].sort # => [1, 2, 3, 4, 5] p [2, 1, 5, 3, 4].sort { |a, b| a <=> b } # => [1, 2, 3, 4, 5] p [2, 1, 5, 3, 4].sort { |a, b| -a <=> -b } # => [5, 4, 3, 2, 1] p [2, 1, 5, 3, 4].sort { |a, b| (a > b) ? 1 : -1 } # => [1, 2, 3, 4, 5] p [2, 1, 5, 3, 4].sort { |a, b| (a < b) ? 1 : -1 } # => [5, 4, 3, 2, 1]
transpose

　　self を行列と見立てて，行列の転置を行います．転置した配列を生成して返します．
p [[1, 2], [3, 4], [5, 6]].transpose # => [[1, 3, 5], [2, 4, 6]]
uniq
uniq!

　　重複した要素を取り除いた新しい配列を返します．取り除かれた要素の部分は，前に詰められます．uniq! は，削除を破壊的に行い，削除が行われた場合は self を，そうでなければ nil を返します．
p [1, 2, 2, 3, 3, 3].uniq # => [1, 2, 3]
unshift

　　obj1，obj2，･･･を，順番に配列の先頭に挿入します（ shift，pop，push 参照）．self を返します．
p [3, 4, 5].unshift(1, 2) # => [1, 2, 3, 4, 5]
values_at ( index_1, ･･･, index_n )

　　引数で指定されたインデックスに対応する要素を配列で返します．
p [1, 2, 3, 4, 5].values_at(0, 2, 4) # => [1, 3, 5]

情報学部

菅沼ホーム

索引