Ruby- counting array returns and totalling them. include output code

Firstly, since you want to create an array (fun) with one element (true or false) for each element of all_arrays, you want to invoke Enumerable#map on all_arrays.

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

Since we were only checking to see if each element of all_arrays contain both of two values (41 and 43), this would be reasonably efficient. Let's generalize this.

targets = [41, 43]

then

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

Let's count the number of operations required for each element row of all_arrays. For each element t of targets, row.include?(t) must be executed. For simplicity, suppose row contains no duplicates and row.include?(t) returns true one-half the time. When it returns true we may assume that the average number of elements of row that are examined is rows.size/2. As all elements of row must be examined when false is returned, the average number of elements of row that are examined is 0.75 * row.size. Therefore the average number of operations required per element of all_arrays is

target.size * 0.75 * row_size

This is obscenely inefficient. What we want to do is make a single pass through each element of all_arrays, looking to see if it is an elements of target, bringing the expected number of operations to something less than row_size. Each operation may take slightly longer, but it will still be vastly more efficient than the sledge hammer approach above. Here are two more efficient approaches.

#1 Convert targets to a set

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] 

If elements of all_arrays contain at most a small number of duplicate values, the time required to compute row.uniq may not be justified, in which case .uniq should be omitted.

Under the covers, sets are implemented with hashes. As a result, the time required to determine if a set contains an element, and then delete that element (see Set#delete) if it is found, is equivalent to determining whether the underlying hash has a given key and then deleting it if it does. The time required for the latter does not vary greatly with the size of the hash. As a result, set lookups are much more efficient than array lookups.

Note that require 'set' installs an instance method 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 Use set operations on arrays

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

See Array#&. Note from the doc that the order of the elements of targets & row is consistent with the order of the elements of target.

Alternatively,

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

This uses Array#-.

Both of these set-like operations are quite fast, in part because they are coded in C. (Moreover, the array difference calculation may terminate when the conclusion is foregone; that is, when (and if) targets - row becomes empty in the course of the calculations. Anybody know if Array#- does such short-circuiting? )

If you’re looking for a count of arrays that contain both 41 and 43, use this:

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

The code starts by setting the variable total, which will hold a count of arrays that contain both 41 and 43, to 0. The plan is to go through all the arrays one by one, checking each array for the presence of both 41 and 43, and if so, add 1 to total.

The line

for array in all_arrays do

defines a loop that will be executed once for each array in all_arrays, with the current array referenced by array. The first time through the loop, array will refer to a1. The second time through the loop, array will refer to a2. The third time through the loop, array will refer to a3, and so on, all the way up to a7.

Inside the loop, we need to see if 41 and 43 are both present in the current array, array. We do this with this line of code...

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

...and if this is the case, we add 1 to the total.

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

If you want 1s and 0s, just change true to 1 and and false to 0. Is this the whole output you were looking for or did you need something additional?

Food Warrior asks:

why && and not just &?

&& is what we call a logical and. The expression a && b is true if and only if both a and b are true. The && version of “and” is closer to the way we use the word “and” in regular life.

& is a bitwise and, and to save a lot of explanation that’s not useful at the moment, let me just say that it’s only meaningful when performing math operations on the binary representations of numbers. It’s not the “and” you think of when you want to know if both a and b are true.

Food Warrior also asks:

Why use if array.include?(41) && array.include?(43) instead of if array.include?(41 && 43)?

Computers are “dumb”, which means that the language when use when programming has to be more precise than natural (human) language. When we want to know if a given array contains both 41 and 43, we’re actually asking three questions:

1. Does the array contain the number 41?
2. Does the array contain the number 43?
3. Are the answers to questions 1 and 2 both “yes”?

These three questions are contained in this line of code:

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

Of course, if we were talking to a human rather than a computer, we might say “If the current array contains 41 and 43”, which we might be tempted to write as:

if array.include?(41 && 43)

This makes sense to humans, but to Ruby, it interprets this statement as “first, calculate the value of 41 && 43, then see if the array contains that value”. For reasons that are a bit lengthy to get into here, the value of 41 && 43 is 43. This means that if array.include?(41 && 43) is equivalent to if array.include?(43), which isn’t what you want.