ルビ計数配列はそれらを返して合計します。出力コードを含める

Question

私のコードにいくつかの問題があり、私がしようとしていることがあります。私はこの日のほとんどをgoogledしました。これが簡単でソリューションがシンプルなら謝罪します。私は完全な説明を好む解決策を探しています。これまで

マイコード：ここで

a1 = [ 4, 6, 7, 8, 10, 13, 14, 15, 17, 21, 24, 45, 48, 61] 
a2 = [ 5, 10, 14, 18, 24, 25, 33, 34, 40, 45, 47, 50, 52, 54] 
a3 = [ 1, 5, 12, 17, 23, 24, 25, 29, 33, 39, 40, 44, 46, 48] 
a4 = [ 5, 16, 18, 20, 31, 39, 41, 42, 43, 55, 57, 60, 62, 63] 
a5 = [ 2, 7, 18, 26, 33, 36, 38, 43, 44, 45, 50, 51, 52, 55] 
a6 = [ 2, 12, 14, 15, 18, 24, 32, 35, 41, 43, 46, 47, 48, 51] 
a7 = [ 4, 12, 13, 15, 17, 18, 19, 23, 26, 32, 33, 35, 40, 47] 

all_arrays = [a1, a2, a3, a4, a5, a6, a7] 
total = Array.new 
fun = Array.new 
b = Array.new 
all_arrays.map do |arr3| 
    fun = [arr3.include?(41 & 43)] #.count(true) 
    total = [fun.count(true)] 

私は41と43は、彼らがA4とA6で行う配列、一緒に起こるかどうかを確認しようとしています。今度は一緒に起こる回数を数えたいと思っています。私がputs totalになった場合、出力は0001010になります。 私はputs funを出力すると、私はfalse、false、false、true、false、trueを得るでしょう。私は、真実または1を数えることができるようにしたいので、41と43が何回起こったのかを合計します。 出力を配列に変換する方法がわかりません。 total = [fun.count(true)]が正しくないと確信しています。しかし、それは動作しますか？並べ替え クラスを作成する必要がありますか？ここで

counts = Hash.new(0) 
    total.each do |color| 
     counts[color] += 1 
     #puts counts 
     #puts total.count 
     #total.uniq.each do |elem| 
     #puts "#{elem}\t#{total.count(elem)}" 
     #end 
    end 

stackoverflowのなど、Googleや他のサイトで を表示されるコードは、私の研究の間に、あります。私は医者とapiを見てきました。私はまだ言語の論理と構文を理解していないので、束を読んでいくつかのオンラインクラスを取ることはできませんでした。私はやって学ぶことを望んでいますが、現在、これは私には新しく、私は放課後のプロジェクトで息子を助けています。私はこれを学びたいので、私は彼に教えています。ご協力ありがとうございました。

Answer 1

あなたは1と0にしたい場合は、単に1に真の変更

all_arrays = [a1, a2, a3, a4, a5, a6, a7] 
fun = [] 
all_arrays.each do |arr3| 
    if arr3.include?(41) && arr3.include?(43) 
    fun << true 
    else 
    fun << false 
    end 
end 

puts fun 

とし、0にfalseが、これはあなたが探していたか、あなたは追加の何かが必要でした全体の出力ですか？

Answer 2

あなたは41と43の両方を含む配列のカウントを探しているなら、この使用：コードは両方を含む配列の数を保持する変数totalを設定することにより開始さ

total = 0 
for array in all_arrays do 
    if array.include?(41) && array.include?(43) 
    total += 1 
    end 
end 

を41と43の両方が存在するかどうかをチェックし、そうであれば1をtotalに追加します。

線

for array in all_arrays do 

はarrayで参照電流アレイと、all_arraysに各アレイのために一度実行されるループを定義します。最初のループでは、arrayはa1を参照します。 2回目のループでは、arrayはa2を参照します。ループを3回目にすると、arrayはa3などとなり、その後はすべてa7までとなります。

ループ内で、41と43の両方が現在の配列arrayに存在するかどうかを確認する必要があります。このコード行でこれを行います...

...これが該当する場合は、合計に1を加算します。

Answer 3

食品戦士は尋ねる：

なぜ&&だけでなく、&？

&&たちは論理と呼んでいます。式a && bは、aとbの両方が真である場合にのみ真です。 &&のバージョン「と」は、通常の生活で「と」という言葉を使用する方法に近いです。

&がビット単位と、そして現時点では有用ではないのです説明の多くを保存することで、私はただの数字のバイナリ表現に数学演算を実行するとき、それはのみ意味だとしましょう。 ではないaとbの両方が真であるかどうかを知りたいときは「と」と思っています。

食品戦士も求められます。

は

なぜif array.include?(41) && array.include?(43)の代わりif array.include?(41 && 43)でしょうか？

コンピュータプログラミングは、天然（ヒト）言語よりも正確でなければならない場合、その言語の使用時を意味し、「ダム」です。私たちは、指定された配列が41と43の両方が含まれているかどうかを知りたい場合は、私たちが実際に質問求めている：

1. を配列番号41を含んでいますか？
2. 配列には43が含まれていますか？
3. 質問1と2の回答はどちらも「はい」ですか？

は、これらの3つの質問は、このコード行に含まれています。もちろん

if array.include?(41) && array.include?(43) 

、我々は人間ではなくコンピュータに話していた場合、現在の配列は41が含まれている場合は、私たちは「言うかもしれないし、 43” 我々が書くように誘惑されるかもしれない、：

if array.include?(41 && 43) 

これは人間に理にかなっているが、ルビーに、それは、この文を解釈する「41 && 43の値を計算し、まず、アレイはトンが含まれている場合は、次に見ます帽子の価値 "。ここに入るのに少し時間がかかる理由のために、41 && 43の値は43です。つまり、if array.include?(41 && 43)はif array.include?(43)に相当します。これはあなたが望むものではありません。あなたがall_arraysの各要素に対して1つの要素（trueまたはfalse）の配列（fun）を作成したいので、

Answer 4

まず、あなたはall_arraysにEnumerable#mapを呼び出したいです。

我々だけ all_arraysの各要素は、2つの値（ 41と 43）の両方を含むかどうかをチェックしたので

fun = all_arrays.map { |row| row.include?(41) && row.include?(43) } 
    #=> [false, false, false, true, false, true, false] 

、これは合理的に効率的であろう。これを一般化しましょう。

targets = [41, 43] 

その後、

fun = all_arrays.map { |row| targets.all? { |t| row.include?(t) } } 
    #=> [false, false, false, true, false, true, false] 

のはall_arraysの各要素rowに必要な操作の数を数えてみましょう。要素tがtargetsの場合、row.include?(t)を実行する必要があります。簡略化のため、rowに重複が含まれていないとし、row.include?(t)が2分の1の時間でtrueを返したとします。 trueが返された場合、調べられるrowの要素の平均数はrows.size/2であると想定されることがあります。 falseが返されたときにrowのすべての要素を調べる必要があるため、調べられるrowの平均要素数は0.75 * row.sizeです。従ってall_arraysの要素ごとに必要な操作の平均数は

target.size * 0.75 * row_size 

これはわいせつ非効率的です。我々がしたいことは、all_arraysの各要素を1回通過させて、要素がtargetであるかどうかを調べ、予想される操作回数をrow_size未満にすることです。各操作は少し時間がかかるかもしれませんが、上記のスレッジハンマーアプローチよりもずっと効率的です。ここには2つのより効率的なアプローチがあります。セットへ

＃1変換targets

require 'set' 

def check_row(row, set_targets) 
    row.uniq.each { |x| return true if set_targets.delete(x).empty? } 
    false 
end 

set_targets = targets.to_set 
fun = all_arrays.map { |row| check_row(row, set_targets.dup) } 
    #=> [false, false, false, true, false, true, false] 

all_arraysの要素は重複値の最も小さい数に含まれている場合.uniqがすべき場合には、row.uniqを計算するのに必要な時間は、正当化されないことが省略される。

カバーの下では、セットはハッシュで実装されています。その結果、セットに要素が含まれているかどうかを判断し、その要素を削除するのに必要な時間（Set#delete参照）は、基になるハッシュに所定のキーがあるかどうかを判断し、それがあれば削除します。後者に必要な時間はdoes not vary greatly with the size of the hashです。その結果、セットルックアップは配列ルックアップよりもはるかに効率的です。

require 'set'がインスタンスメソッドEnumerable#to_setをインストールすることに注意してください。

Array.instance_methods.include?(:to_set) 
    #=> false 

require 'set' 

Array.instance_methods.include?(:to_set) 
    #=> true 
Array.instance_method(:to_set).owner 
    #=> Enumerable 

＃2を使用し、配列

fun = all_arrays.map { |row| targets == targets & row } 
    #=> [false, false, false, true, false, true, false] 

の操作を設定Array#&を参照してください。文書から、targets & rowという要素の順序は、targetの要素の順序と一致することに注意してください。あるいは

、

fun = all_arrays.map { |row| (targets - row).empty? } 
    #=> [false, false, false, true, false, true, false] 

これはArray#-を使用します。

C言語でコード化されているため、これらのセットのような操作はどちらも非常に高速です（また、結論が間違っている場合、つまり（そして、その場合）targets - rowが空になるArray#-は、ない場合は、計算の過程で。誰でも知っている短絡を？ ）