How to get sequence of array elements? - arrays

Question

I have the following array that is "separated" by "blocks". Each invisible block begins with a letter having number 5 next to it and finishes when another letter with 5 next to it appears.
a = [
"F5","a4","g4","F5","a4","d4","F5","a4","g4","e3",
"H5","a4",
"Y5","a4","d4","Y5","g4","c3"
]
In this array there are 3 "blocks" like below.
Block1 --> begins with first "F5" (index 0) and ends in "e3" (index
9), just before the "H5".
Block2 --> begins with first "H5" (index 10) and ends in "a4" (index
11), just before the "Y5".
Block3 --> begins with first "Y5" (index 12) and ends in "c3" (index
17), when it reaches the end of array.
What I'd like to get, is a sequence (from 1 to N) of each element within each block (Not within the array itself), where the output would be:
b = [
["F5",1],["a4",1],["g4",1],["F5",2],["a4",2],["d4",1],["F5",3],["a4",3],["g4",2],["e3",1],
["H5",1],["a4",1],
["Y5",1],["a4",1],["d4",1],["Y5",2],["g4",1],["c3",1]
]
With my current attempt I'm getting only the count of each element and not the sequence. How can this be done? Thanks
a = [
"F5","a4","g4","F5","a4","d4","F5","a4","g4","e3",
"H5","a4",
"Y5","a4","d4","Y5","g4","c3"
]
b = []
a.each{|v|
b.push([v,a.count(v)])
}
=> [
["F5", 3], ["a4", 5], ["g4", 3], ["F5", 3], ["a4", 5], ["d4", 2], ["F5", 3], ["a4", 5], ["g4", 3], ["e3", 1],
["H5", 1], ["a4", 5],
["Y5", 2], ["a4", 5], ["d4", 2], ["Y5", 2], ["g4", 3], ["c3", 1]
]

Answer 1

We are given the array
a = ["F5","a4","g4","F5","a4","d4","F5","a4","g4","e3",
"H5","a4","Y5","a4","d4","Y5","g4","c3"]
The problem can be viewed as having two steps, the first being to convert a to
arr = [["F5","a4","g4","F5","a4","d4","F5","a4","g4","e3"],
["H5","a4"], ["Y5","a4","d4","Y5","g4","c3"]]
The second step is to construct the desired array from arr.
Step 1
I understand the rule for converting a to arr is as follows.
the first element of each array of arr is a string of the form YZ that matches the regular expression /[A-Z]\d/ (but the digit does not necessarily equal 5).
it is assumed that the first element of a always has the above property.
the last element of each array b of arr is the last element of a or the element of a that precedes the first element of a following the element of a that corresponds to the first element of b that matches /[A-Z]\d/, but when compared with the first element of b the capital letters differ and the digits are equal.
We may write
frst = a.first
arr = a.slice_before do |s|
(s[0].match?(/[A-Z]/) && s[0] != frst[0] && s[1] == frst[1]) ?
(frst = s) : false
end.to_a
#=> [["F5", "a4", "g4", "F5", "a4", "d4", "F5", "a4", "g4", "e3"]],
# ["H5", "a4"], ["Y5", "a4", "d4", "Y5", "g4", "c3"]]
See Enumerable#slice_before.
Step 2
We may now convert arr to the desired array as follows.
arr.map do |e|
h = Hash.new(0)
e.map { |s| [s, h[s] += 1] }
end
#=> [[["F5", 1], ["a4", 1], ["g4", 1], ["F5", 2], ["a4", 2], ["d4", 1],
# ["F5", 3], ["a4", 3], ["g4", 2], ["e3", 1]],
# [["H5", 1], ["a4", 1]],
# [["Y5", 1], ["a4", 1], ["d4", 1], ["Y5", 2], ["g4", 1], ["c3", 1]]]
Here Hash::new is used to create an empty hash h with a default value of zero. All that means is that if h does not have a key k, h[k] returns zero. As h[k] += 1 can be seen as
h[k] = h[k] + 1
h[k] on the right returns 1 when h does not have a key k. Another way of writing that is
h[k] = h.fetch(k,0) + 1
See Hash#fetch.

Answer 2

This is what I'd do:
Starting with:
a_ary = [
'F5', 'a4', 'g4', 'F5', 'a4', 'd4', 'F5', 'a4', 'g4', 'e3',
'H5', 'a4',
'Y5', 'a4', 'd4', 'Y5', 'g4', 'c3'
]
BREAK_REGEX = /^.5/
I'd group the array by matching blocks, then grab the resulting chunks and flatten them back to the collected arrays.
grouped_ary = a_ary.slice_before(BREAK_REGEX)
.group_by { |a| a.first } # => {"F5"=>[["F5", "a4", "g4"], ["F5", "a4", "d4"], ["F5", "a4", "g4", "e3"]], "H5"=>[["H5", "a4"]], "Y5"=>[["Y5", "a4", "d4"], ["Y5", "g4", "c3"]]}
.values # => [[["F5", "a4", "g4"], ["F5", "a4", "d4"], ["F5", "a4", "g4", "e3"]], [["H5", "a4"]], [["Y5", "a4", "d4"], ["Y5", "g4", "c3"]]]
.map(&:flatten) # => [["F5", "a4", "g4", "F5", "a4", "d4", "F5", "a4", "g4", "e3"], ["H5", "a4"], ["Y5", "a4", "d4", "Y5", "g4", "c3"]]
Then process those, counting the occurrences in each array, looping over them and output the element and the count, resetting the counter for each block:
b_ary = grouped_ary.flat_map{ |e|
element_count = Hash.new { |h, k| h[k] = 0 }
e.map { |i|
element_count[i] += 1
[
i,
element_count[i]
]
}
}
Which results in:
b_ary
# => [["F5", 1],
# ["a4", 1],
# ["g4", 1],
# ["F5", 2],
# ["a4", 2],
# ["d4", 1],
# ["F5", 3],
# ["a4", 3],
# ["g4", 2],
# ["e3", 1],
# ["H5", 1],
# ["a4", 1],
# ["Y5", 1],
# ["a4", 1],
# ["d4", 1],
# ["Y5", 2],
# ["g4", 1],
# ["c3", 1]]
# ]
Here's what the very first step using slice_before creates:
a_ary.slice_before(BREAK_REGEX).to_a
# => [["F5", "a4", "g4"],
# ["F5", "a4", "d4"],
# ["F5", "a4", "g4", "e3"],
# ["H5", "a4"],
# ["Y5", "a4", "d4"],
# ["Y5", "g4", "c3"]]
Enumerable is where the magic lies.

Answer 3

I'd break this into a few functions.
require 'minitest/autorun'
# Split array where the given block returns true
def group_by_sequence(x)
i = 0
x.each_with_object([]) { |e, a|
i += 1 if yield e
a[i] = [] if a[i].nil?
a[i] << e
}
end
# Split array at each new "five", eg. going from "A5" to "B5"
def group_by_fives(x)
li = nil
group_by_sequence(x) { |e|
l, n = e.chars
li = l if li.nil?
if n == '5' && li != l
li = l
true
else
false
end
}
end
# Given [A,B,C,B], returns [[A,1], [B,1], [C,1], [B,2]]
def add_counts_by_group(x)
group_by_fives(x).flat_map { |group|
count = {}
group.map { |e|
count[e] = count[e].to_i + 1
[e, count[e]]
}
}
end
class Test < Minitest::Test
def test_add_counts_by_group
assert_equal(
[
["F5",1],["a4",1],["g4",1],["F5",2],["a4",2],["d4",1],["F5",3],["a4",3],["g4",2],["e3",1],
["H5",1],["a4",1],
["Y5",1],["a4",1],["d4",1],["Y5",2],["g4",1],["c3",1]
],
add_counts_by_group([
"F5","a4","g4","F5","a4","d4","F5","a4","g4","e3",
"H5","a4",
"Y5","a4","d4","Y5","g4","c3"
])
)
end
end