Ruby Array Maniplulation - Scanning and Counting - ruby

Question

I'm trying to read though each string in the array and count the number of times the letters occurs in each position (ie 1 , 2, 3, 4). How am I not using the multidimensional array and += operator correctly?
def scan_str(arr)
position = [[]]
x = 0
arr.select do |word|
word.length.times do |i|
if word.index('G') == x
position[x+1,0] += 1
x += 1
elsif word.index('A') == x
position[x+1,1] += 1
x += 1
elsif word.index('T') == x
position[x+1,2] += 1
x += 1
elsif word.index('C') == x
position[x+1,3] += 1
x += 1
else
x += 1
end
end
end
p position
end
input = ["CTAGATA","CCCGAT","AAATT","TTCAAATGA"]
scan_str(input)
Thanks this is helpful. But now how do I manipulate the array without the error message "`[]': no implicit conversion from nil to integer (TypeError)"... There must be something I'm not getting about the index or position [][] syntax.
def scan_str(arr)
position = [[]]
z=arr.count
x = 0
arr.select do |word|
if word.index('G') == x
position[y][0] += (countG =+ 1)/z
x += 1
y += 1
elsif word.index('A') == x
position[y][1] += (countA =+ 1)/z
x += 1
y += 1
elsif word.index('T') == x
position[y][2] += (countT =+ 1)/z
x += 1
y += 1
elsif word.index('C') == x
position[y][3] += (countC =+ 1)/z
x += 1
y += 1
else
x += 1
y += 1
end
end
p position
end
input = ["CTAGATA","CCCGAT","AAATT","TTCAAATGA"]
scan_str(input)

Answer 1

AS they almost answered it in comments:
position[1,3] is 3 elements from 2nd position, counting from 0.
Correct syntax is: position[1][3].
ps. Example:
arr=[[1,2,3], [4,5,6]]
arr[1][2]
# 6 # 3rd element from 2nd array, counting from 0!

Answer 2

It is no very beautiful and should probably be split into a few functions:
a = ["CTAGATA","CCCGAT","AAATT","TTCAAATGA"]
p Hash[
a.map{|sub| sub.chars.with_index(1).to_a}
.flatten(1).group_by(&:last)
.map{|pos, values|
[pos, Hash[values.group_by{|char,|char}.map{|char,s|[char, s.size.to_f/values.length]}]]
}
] #=> {1=>{"C"=>0.5, "A"=>0.25, "T"=>0.25}, 2=>{"T"=>0.5, "C"=>0.25, "A"=>0.25}, 3=>

Answer 3

As the problem with your code has been explained, I would like to suggest a more "Ruby-like" approach:
TEST = ['G', 'A', 'T', 'C']
def scan_str(arr)
TEST.each_with_object({}) {|c,h| h[c] = arr.each_with_object(Hash.new(0)) {|line, hh| \
line.chars.each_with_index {|s,i| hh[i] += 1 if s==c}}}
end
arr = ["CTAGATA","CCCGAT","AAATT","TTCAAATGA"]
scan_str(arr)
# => {"G"=>{3=>2, 7=>1}, \
# => "A"=>{2=>2, 4=>3, 6=>1, 0=>1, 1=>1, 3=>1, 5=>1, 8=>1}, \
# => "T"=>{1=>2, 5=>2, 3=>1, 4=>1, 0=>1, 6=>1}, \
# => "C"=>{0=>2, 1=>1, 2=>2}}
A few points:
It is probably most convenient to put the results in a hash. Here I have scan_str returning a hash whose keys are the elements of TEST. The value of each key is itself a hash, with each key being a line offset position and the associated value being the number of times the letter given by the outer key is located at that position.
I first iterate over the elements of TEST using Enumerable#each_with_object with the default object being an empty hash {}. Inside the block the hash is referenced by h. The alternative would be to define an empty has (h = {}) in the line above and then use TEST.each {|c|... instead. Had I done that it would have also been necessary to add the line h at the end of the method, so that the hash would be returned.
For each element c of TEST, I iterate over the lines of the array, again using each_with_object. This time, however, the default value of the object is Hash.new(0) which creates a hash with default values of zero. By doing that, when hh[i] += 1 is executed in the inner loop, we don't have to check if hh has a key i; if it does not, Ruby first executes hh[i] = 0 (zero being the default value), then hh[i] += 1 => 1.
For each line, line.chars converts the line to an array of characters. I then iterate with Enumerable#each_with_index. Inside the block, the character (string of length one) and line offset are referenced by s and i respectively.
There are a couple of ways to obtain the result you want. The first, and probably easiest, would be just to change the code I've already offered. I'll do that later today.
The second is to use the code above as a "helper method".
Use helper" method
To use the code we already have, rename the scan_str method above to scan_str_helper and add this:
def scan_str(arr)
h = scan_str_helper(arr)
posh = Hash[h.values.map(&:keys).flatten.uniq.map {|e| \
[e,Hash[TEST.zip([0]*TEST.size)]]}]
h.each {|k,v| v.each {|kk,vv| posh[kk][k] += vv}}
posh.each_with_object({}) {|(k,v),hp| tot = 1.0 * v.values.reduce(&:+); \
hp[k] = Hash[v.keys.zip(v.values.map {|e| e/tot})]}
end
scan_str(arr)
# {3=>{"G"=>0.5, "A"=>0.25, "T"=>0.25, "C"=>0.0}, 7=>{"G"=>1.0, "A"=>0.0, "T"=>0.0, "C"=>0.0},
# 2=>{"G"=>0.0, "A"=>0.5, "T"=>0.0, "C"=>0.5}, 4=>{"G"=>0.0, "A"=>0.75, "T"=>0.25, "C"=>0.0},
# 6=>{"G"=>0.0, "A"=>0.5, "T"=>0.5, "C"=>0.0}, 0=>{"G"=>0.0, "A"=>0.25, "T"=>0.25, "C"=>0.5},
# 1=>{"G"=>0.0, "A"=>0.25, "T"=>0.5, "C"=>0.25},
# 5=>{"G"=>0.0, "A"=>0.3333333333333333, "T"=>0.6666666666666666, "C"=>0.0},
# 8=>{"G"=>0.0, "A"=>1.0, "T"=>0.0, "C"=>0.0}}
A few more notes:
h.values.map(&:keys).flatten.uniq => [3, 7, 2, 4, 6, 0, 1, 5, 8]` merely constructs an array of the position offsets that contain one or more TEST elements.
h.keys.zip([0]*TEST.size) => h.keys.zip([0, 0, 0, 0]) => Hash[["G",0], ["A",0], ["T",0], ["C",0]]] => {"G"=>0, "A"=>0, "T"=>0, "C"=>0}, so for e = 3 (say), Hash[3, {"G"=>0, "A"=>0, "T"=>0, "C"=>0}] => {3=>{"G"=>0, "A"=>0, "T"=>0, "C"=>0}}.
Instead of h.keys.zip([0]*TEST.size), you may be tempted to write a = [0]*TEST.size; TEST.zip(a). That doesn't work. I'll leave it to you to figure out why.
h.each {|k,v| v.each {|kk,vv| posh[kk][k] += vv}} fills the hash posh =>
# {3=>{"G"=>2, "A"=>1, "T"=>1, "C"=>0}, 7=>{"G"=>1, "A"=>0, "T"=>0, "C"=>0},
# 2=>{"G"=>0, "A"=>2, "T"=>0, "C"=>2}, 4=>{"G"=>0, "A"=>3, "T"=>1, "C"=>0},
# 6=>{"G"=>0, "A"=>1, "T"=>1, "C"=>0}, 0=>{"G"=>0, "A"=>1, "T"=>1, "C"=>2},
# 1=>{"G"=>0, "A"=>1, "T"=>2, "C"=>1}, 5=>{"G"=>0, "A"=>1, "T"=>2, "C"=>0},
# 8=>{"G"=>0, "A"=>1, "T"=>0, "C"=>0}}.
The last line merely converts the numbers of occurrences to fractions. For example, 3=>{"G"=>2, "A"=>1, "T"=>1, "C"=>0} is converted to 3=>{"G"=>0.5, "A"=>0.25, "T"=>0.25, "C"=>0.0}
Modification of Initial Code
def scan_str(arr)
a = Array.new(arr.map(&:size).max).map {|e| \
Hash[TEST.zip(Array.new(TEST.size,0))]}
arr.each {|s| s.chars.each_with_index {|c,i| TEST.each \
{|ss| a[i][ss] += 1 if c == ss}}}
Hash[a.map.with_index {|h,i| tot = 1.0 * h.values.reduce(&:+); tot > 0.0 ? \
[i, Hash[h.keys.zip(h.values.map {|e| e/tot})]] : nil}.compact]
end
The first statement creates an array a, the ith element corresponding to character offset i in each line. The value of the ith element is the hash referred to in the next note, with all values equal to zero.
The second statement fills the array a:
# => [{"G"=>0, "A"=>1, "T"=>1, "C"=>2}, {"G"=>0, "A"=>1, "T"=>2, "C"=>1},
# => {"G"=>0, "A"=>2, "T"=>0, "C"=>2}, {"G"=>2, "A"=>1, "T"=>1, "C"=>0},
# => {"G"=>0, "A"=>3, "T"=>1, "C"=>0}, {"G"=>0, "A"=>1, "T"=>2, "C"=>0},
# => {"G"=>0, "A"=>1, "T"=>1, "C"=>0}, {"G"=>1, "A"=>0, "T"=>0, "C"=>0},
# => {"G"=>0, "A"=>1, "T"=>0, "C"=>0}].
The last statement converts each element of a to a hash if the sum of the values is positive; else to nil. compact removes all elements that are nil. Putting Hash[ and the beginning and ] at the end converts the array to a hash, which is returned by scan_str.
Note this approach gives the same result as the method that the used the "helper" method, though the order of the elements of the hash is different.