ゴンを使えば６文字出せなくてもクリア可能。 ただ6文字を狙いやすい盤面なので、基本的には6文字を狙う。
き〇い〇ん〇〇
かん〇ん〇〇〇
〇い〇ん〇〇い
〇い〇ん〇ん〇
〇しん〇い〇〇
＊しんさいこん(震災婚)
〇ん〇ん〇〇ん
ruby では require でライブラリを読む。 (ファイルは .rb (rubyファイル)でも .so 等でもよいようだ)
参照するパスは $: (or $LOAD_PATH) が使われる。
gem でインストールすると ~/.gem/ にインストールされる。 gem install rufo で rufo をインストールしたあとパスを確認すると以下の通り。
$ gem which rufo /home/XXXX/.gem/ruby/2.6.0/gems/rufo-0.12.0/lib/rufo.rb
この状態で require "rufo" をするとエラーが出ないから、ライブラリ読み込みは成功している。しかし、 $: に ~/.gem は入ってない。なぜ require できるのか。
$ ruby -e 'require "rufo"' $ ruby -e 'puts $:' /usr/share/gems/gems/did_you_mean-1.2.2/lib /usr/local/share/ruby/site_ruby /usr/local/lib/ruby/site_ruby/2.6 /usr/share/ruby/vendor_ruby /usr/lib/ruby/vendor_ruby/2.6 /usr/share/rubygems /usr/share/ruby/2.6 /usr/lib/ruby/2.6
rubygem が require を書き換えているらしい。
確かに require した後に $: を見ると ~/.gem が追加されている。
$ ruby -e 'require "rufo"; puts $:' /usr/share/gems/gems/did_you_mean-1.2.2/lib /home/XXX/.gem/ruby/2.6.0/gems/rufo-0.12.0/lib /usr/local/share/ruby/site_ruby /usr/local/lib/ruby/site_ruby/2.6 /usr/share/ruby/vendor_ruby /usr/lib/ruby/vendor_ruby/2.6 /usr/share/rubygems /usr/share/ruby/2.6 /usr/lib/ruby/2.6
探索パートでは会話し、情報を集める。情報を集めたあと、メニューのキーワードで推理する。推理することでストーリーが進む。
ゲームボーイカラーを生かして配色がきれい。特に船や背景などの無機物はイベント絵もマップチップも光と影が絶妙で美しく仕上がっている。
maxは配列の最大値を返す。maxの引数で数値を指定して上位複数を返すこともできる。
a=[3,1,4,1,5,9]
a.max
=> 9
a.max(3)
=> [9, 5, 4]
maxはブロックで比較方法を指定できる。ブロックは、-1,0,1を返す必要がある。
a=%w(lemon apple pineapple orange)
=> ["lemon", "apple", "pineapple", "orange"]
a.max{|i,j|i.size <=> j.size}
=> "pineapple"
a.max(2){|i,j|i.size <=> j.size}
=> ["pineapple", "orange"]
may_byは <=> で比較できる数値を返せばよい。
a.max_by{|i| i.size}
=> "pineapple"
a.max_by(2){|i| i.size}
=> ["pineapple", "orange"]
例えば、配列の特定の値が最大の要素を取り出すようなことが容易にできる。
> a=[["md", 1988], ["sfc", 1990], ["fc", 1986], ["pce",1988]]
a.max_by{|w|w.last}
=> ["sfc", 1990]
sort, sort_by も同様
Arrayで使えるメソッド
------------------------------------------------------------
# push n
配列の末尾に n を追加する(破壊的)
a=[1,2,3]
a.push(4,5)
a
=> [1, 2, 3, 4, 5]
------------------------------------------------------------
# pop
# pop(n)
配列から１つ取り除いて返す
または nで指定した数だけ配列から取り除き、その要素を配列で返す
返り値と残った値を使って、配列を分割するのにも使える
a = [1, 2, 3, 4, 5]
a.pop(3)
=> [3, 4, 5]
a
=> [1, 2]
------------------------------------------------------------
# shift
配列の先頭から要素を捨てて、配列を返す。
a=[1,2,3,4,5]
a.shift(3)
=> [1, 2, 3]
a
=> [4, 5]
------------------------------------------------------------
# unshift
配列の先頭に要素を追加する
a=[1,2,3,4,5]
a.unshift 6
=> [6, 1, 2, 3, 4, 5]
------------------------------------------------------------
# drop(n)
先頭のn要素を捨てた配列を返す
配列は書き換えない
a = [1,2,3,4,5]
a.drop(2) #=> [3,4,5]
------------------------------------------------------------
# drop_while{|e| ....}
最初に偽になった要素までを捨てる
(最初に偽になった要素以降を取り出す)
a = [1,2,3,4,5]
a.drop_while{|i|i%3!=0}
=> [3, 4, 5]
see also take_while
------------------------------------------------------------
# each {|i| ... }
配列の要素に対し繰り返す
------------------------------------------------------------
# each_index {|i| ... }
配列のindexに対して繰り返す
for(i=0; i<N; i++) a[i]... 的な使い方ができる。
a=[3,1,4,1,5,9]
a.each_index.map{|i| "#{i}:#{a[i]},"}
=> ["0:3,", "1:1,", "2:4,", "3:1,", "4:5,", "5:9,"]
メモ:
a.map.with_index{|v,i| "#{i}:#{v},"}
=> ["0:3,", "1:1,", "2:4,", "3:1,", "4:5,", "5:9,"]
------------------------------------------------------------
# count(n)
nに一致する要素の数を返す
# count{|e| ... }
ブロックが真になった要素の数を返す
a = [3, 1, 4, 1, 5, 9]
a.count{|i| i%3 == 0}
=> 2
------------------------------------------------------------
# delete
配列から一致する要素を削除する
a = [3, 1, 4, 1, 5, 9]
a.delete(1)
a
=> [3, 4, 5, 9]
------------------------------------------------------------
# delete_at(n)
位置 n の要素を削除する
a=[3,1,4,1,5,9]
a.delete_at(-1)
a
=> [3, 1, 4, 1, 5]
------------------------------------------------------------
# delete_if{|i| ...}
条件に一致する要素を削除する
------------------------------------------------------------
# fill(val)
すべての要素を val にする
# fill(val, start, length)
# fill(val, range)
指定した範囲を val にする
a=[3,1,4,1,5,9]
a.fill(-1, 3..nil)
=> [3, 1, 4, -1, -1, -1]
------------------------------------------------------------
# filter{i| ... }
# select{|i|... }
各要素に対しブロックを評価し、真だった要素の配列を返す
------------------------------------------------------------
# index(n)
# find_index(n)
# index{|i| ... }
# find_index{|i| ... }
n に一致するまたは、ブロックが真を返す最初の位置を返す
a=[3,1,4,1,5,9]
a.index(1)
=> 1
a.index{|v|v>3}
=> 2
# rindex(n)
# rindex{|i) ...}
nに一致する最後の要素の位置を返す
a=[3,1,4,1,5,9]
a.rindex(1)
=> 3
------------------------------------------------------------
# first
配列の先頭の要素を返す。
Lisp でいえば car
(cdr は drop(1))
first(n) として複数要素を返すことができる
------------------------------------------------------------
# flatten
配列を平たん化する
a="this is a pen".split.map(&:chars)
=> [["t", "h", "i", "s"], ["i", "s"], ["a"], ["p", "e", "n"]]
a.flatten
=> ["t", "h", "i", "s", "i", "s", "a", "p", "e", "n"]
------------------------------------------------------------
# include?(n)
配列が要素nを含むとき true, そうでないとき false を返す
------------------------------------------------------------
# insert(n, *val)
位置n の直前に val を追加する
a=[3,1,4,1,5,9]
a.insert(2, 11,12,13)
=> [3, 1, 11, 12, 13, 4, 1, 5, 9]
------------------------------------------------------------
# last
# last(n)
配列の最後の要素を返す
------------------------------------------------------------
# all? {|e| ... }
すべての要素が真のとき、真を返す
# any? {|e| ... }
1個以上の要素が真のとき、真を返す
# one? {|e| ... }
1個の要素が真のとき、真を返す
"XXXXOXXXX".chars.one?{|v|v=="O"}
=> true
"XXXXOXXXO".chars.one?{|v|v=="O"}
=> false
------------------------------------------------------------
# permutation(n)
順列を返す
a=[?a, ?b, ?c]
=> ["a", "b", "c"]
a.permutation(2).to_a
=> [["a", "b"], ["a", "c"], ["b", "a"], ["b", "c"], ["c", "a"], ["c", "b"]]
------------------------------------------------------------
# combination(n)
組み合わせを返す
a=[?a, ?b, ?c]
=> ["a", "b", "c"]
a.combination(2).to_a
=> [["a", "b"], ["a", "c"], ["b", "c"]]
------------------------------------------------------------
# rotate
指定した位置(省略時は1)の要素が先頭になる配列を生成し返す。
a
=> [3, 1, 4, 1, 5, 9]
a.rotate
=> [1, 4, 1, 5, 9, 3]
a
=> [3, 1, 4, 1, 5, 9]
a.rotate(-1)
=> [9, 3, 1, 4, 1, 5]
------------------------------------------------------------
# sample
配列からランダムに１つ(引数を指定すれば複数）選んで返す
a=(1..6).to_a
a.sample
=> 4
a.sample
=> 2
------------------------------------------------------------
# slice(n)
# slice(n, length)
# slice(range)
Array#[] と同じ。
配列から指定した範囲の部分配列を返す
------------------------------------------------------------
# sort
ソートする。要素は <=> で比較する。
# sort_by
要素をそのまま <=> で比較するのではなくブロックの出力で比較する
"pencil".chars.sort_by{|c|c.ord}
=> ["c", "e", "i", "l", "n", "p"]
------------------------------------------------------------
# sum
# sum{|e| ... }
"abc".chars.sum{|c|c.ord}
=> 294
97+98+99
=> 294
------------------------------------------------------------
# take(n)
配列の先頭n要素を返す
n は省略できない。
n が2以上なら firstと同じ
------------------------------------------------------------
# take_while{|e| ... }
要素が偽になるまでの要素を配列で返す。
（先頭から数えて要素が真である範囲を返す）
a=[1,2,3,4,5,6]
a.take_while{|n|n<4}
=> [1, 2, 3]
a.take_while{|n|n>3}
=> []
------------------------------------------------------------
# to_h
配列をハッシュにする
[[:foo, :bar], [1, 2]].to_h
=> {:foo=>:bar, 1=>2}
> %w(uma shika inu neko).each_with_index.to_h
=> {"uma"=>0, "shika"=>1, "inu"=>2, "neko"=>3}
ブロックを指定するとそのブロックが返した [key, value]でハッシュを作る
%w(uma shika inu neko).to_h{|w| [w, w.size]}
=> {"uma"=>3, "shika"=>5, "inu"=>3, "neko"=>4}
------------------------------------------------------------
# zip
> [1,2,3].zip(["a", "b", "c"])
=> [[1, "a"], [2, "b"], [3, "c"]]
w=%w(uma shika inu kaba)
=> ["uma", "shika", "inu", "kaba"]
(0...w.size).zip(w)
=> [[0, "uma"], [1, "shika"], [2, "inu"], [3, "kaba"]]
------------------------------------------------------------
# join
# *
%w(uma shika inu kaba).join("//")
=> "uma//shika//inu//kaba"
%w(uma shika inu kaba)*"//"
=> "uma//shika//inu//kaba"
------------------------------------------------------------
# |
和演算
[1, 1, 4, 2, 3] | [5, 4, 5]
#=> [1, 4, 2, 3, 5]
------------------------------------------------------------
# &
積演算
[3,1,4,1,5,9] & [1,7,3,2,0,5.0,8]
=> [3, 1]
------------------------------------------------------------
# +
連結
[1,2,3] + [2,3,4,5]
=> [1, 2, 3, 2, 3, 4, 5]
------------------------------------------------------------
# -
減算。
減算される側の配列中の、減算する配列に含まれる要素はすべて削除される。
[1,2,3]-[2,3,4,5]
=> [1]
[1,2,2,3,3]-[2,3,4,5]
=> [1]
はっきりとは覚えてないが、今回、Windows Update をうながすダイアログに時間がかかるような記述があった気がする。実際、WindowsUpdateをすると、結構な時間（数十分？）待たされた。
44%ぐらいの時点で画面が表示されたが、それまでディスプレイは真っ暗となる。ディスクアクセスがたまに発生するものの、キーボードもマウスも反応しない。これは焦る。強制電源オフしちゃう人いるんじゃないかな…
立ち上がったら、どうもおかしい。 まずタスクバーやシステムメニューの背景が白い。デスクトップ右メニューから、色の設定を「カスタマイズ」にして、「システム：黒、アプリ：白」にするとなんとなくもとの感じになった。なんか違う気がしないでもないが…
またこれをやられた。
Windowsアップデートしたら音がこもるようになった - 日々のメモ＠はてな
文字入力がおかしい…と思ったら以前、変換キーをIME on/offにする設定をしたのが戻ってしまっている。またこれ↓をするのかと思ったら、
win10のimeで「変換」でIMEをon/offする - 日々のメモ＠はてな
そもそもIME自体が変わってしまったみたい。 新しい方は詳細設定が無く、キーカスタマイズができない、なんだこれ。
「以前のIMEを使う」を選択すると、変換キーの設定も残っており、そのまま元通りになった。
ひどいアップデートだ。 他にもまだ気づいてないだけで、なんかやっていそう
str = "122333455" str.scan(/((.)\2*)/).map(&:first) #=> ["1", "22", "333", "4", "55"]
括弧が２つあるのは、内側の括弧のドットで１文字にマッチし、外側の括弧でその繰り返しをキャプチャするため。ドットにマッチした文字は \2 で参照する。scanの結果は、外側括弧の連続文字全体と、内側括弧の単文字の配列となる。
p str.scan(/((.)\2*)/ #=> [["1", "1"], ["22", "2"], ["333", "3"], ["4", "4"], ["55", "5"]]
How to split a string of repeated characters with uneven amounts? Ruby
chunk_whileを使い、前の文字と等しい場合を条件にすることで同じ文字が続く単位をグループ化することもできる。
str.chars.chunk_while{|a,b|a==b}.to_a
=> [["1"], ["2", "2"], ["3", "3", "3"], ["4"], ["5", "5"]]
母音(aeiou)と子音で分ける。
v="aeiou"
str="throughout"
str.chars.chunk_while{|i,j| v.include?(i) == v.include?(j)}.to_a
=> [["t", "h", "r"], ["o", "u"], ["g", "h"], ["o", "u"], ["t"]]
chunkは要素を順にブロックで評価しその結果でグループ分けする。
[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5].chunk {|n|n.even?}.to_a
=> [[false, [3, 1]], [true, [4]], [false, [1, 5, 9]], [true, [2, 6]], [false, [5, 3, 5]]]
[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5].chunk {|n|n%3}.to_a
=> [[0, [3]], [1, [1, 4, 1]], [2, [5]], [0, [9]], [2, [2]], [0, [6]], [2, [5]], [0, [3]], [2, [5]]]
同じ文字の連続でグループ分けする場合は itself が使える。
str = "122333455"
str.chars.chunk(&:itself).to_a
=> [["1", ["1"]], ["2", ["2", "2"]], ["3", ["3", "3", "3"]], ["4", ["4"]], ["5", ["5", "5"]]]
str.chars.chunk(&:itself).map{|x|x.last.join}
=> ["1", "22", "333", "4", "55"]
group_byを使う場合
str="ABBCCCAAECBB"
str.chars.group_by{|a|a}.to_a
=> [["A", ["A", "A", "A"]], ["B", ["B", "B", "B", "B"]], ["C", ["C", "C", "C", "C"]], ["E", ["E"]]]
> str.chars.group_by{|a|a}.map{|k,v| "#{k}=#{v.size}"}
=> ["A=3", "B=4", "C=4", "E=1"]
countを使う方がシンプル
> str.chars.uniq.map{|c| "#{c}=#{str.count(c)}"}
=> ["A=3", "B=4", "C=4", "E=1"]
each_consを使う。
> a=[3,1,4,1,5,9] > a.each_cons(2).to_a => [[3, 1], [1, 4], [4, 1], [1, 5], [5, 9]]
map を使いたい場合、each_cons(2).map とすることができる。 パラメタで指定した数だけ入力が無い場合は空配列が返る。
> a=[1,2,3] > a.each_cons(4).to_a => []
重複無しの場合は each_slice
> a=[3,1,4,1,5,9,2,6] > a.each_slice(3).to_a => [[3, 1, 4], [1, 5, 9], [2, 6]]
入力が不足する場合、返り値の最後の値の要素が少なくなる。
f = 3.14159 f.round(2) #=> 3.14 f.round(3) #=> 3.142
範囲オブジェクトは each や map に渡せばその範囲での繰り返しになるが、そのままでは配列にならない。そのため、to_a を使うなどをする。
(1..10).map{|c| print c} #=>12345678910
p (1..10) # 1..10
p [1..10] # [1..10]
p (1..10).to_a # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
p [*1..10] # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a = *1..10
p a # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
代入式において複数の値を受け取ることができる。
a,*b = 1,2,3,4,5 # a => 1 # b => [2,3,4,5]
メソッドで複数の引数を受け取る場合に使う。(splat演算子と呼ばれる) メソッドの引数の配列の前に * をつけると、配列をここの引数に展開する。
def abc(a,b,c)
puts "a:#{a} b:#{b} c:#{c}"
end
def my_printf(fmt, *args)
puts "#{fmt} #{args]"
end
a=[1,2,3]
abc(*a) # => abcを1,2,3 で呼び出す。(引数不足エラーにならない)
my_printf("%s", *a) # => my_printf("%d", 1,2,3) と同じ。
# この結果、fmt="%d", args=[1,2,3] となる
関数の中間の引数に * を使うこともできる。
def abc(a,*b,c)
puts "a:#{a} b:#{b} c:#{c}"
end
abc(1,2)
abc(1,2,3)
abc(1,2,3,4)
#--output--
a:1 b:[] c:2
a:1 b:[2] c:3
a:1 b:[2, 3] c:4
標準入力の各行を返す。複数行で数値が渡されるような場合、
a = gets.to_i b = gets.to_i c = gets.to_i
とするが、これを
a,b,c = $<.map &:to_i
とすることができる
memo
memo
memo
メモ
