Is this a pass by reference/value misunderstanding that's having this method fail output as intended?

I'm working on a solution to this problem (4hr50m in this vid):

• Write a function all_construct_tabular(target, word_array) to return a 2D array containing all of the ways in which the target string can be constructed by concatenating elements of the word_array.
• Each element of the 2D array should represent one combination that constructs target.
• Elements of word_array can be reused.

Here's my test:

    it "returns a 2d array with x4 sub array elements" do
      result = all_construct_tabular('abcdef', ['ab', 'abc', 'cd', 'def', 'abcd', 'ef', 'c'])
      expect(result).to eq([['ab', 'cd', 'ef'], ['ab', 'c', 'def'], ['abc', 'def'], ['abcd', 'ef']])
    end

Here's my method:

def all_construct_tabular(target, word_array)
  table = Array.new(target.length + 1).each.map { Array.new }
  table[0] = [[]]

  table.each_with_index do |e, i|
    word_array.each do |word|
      if target.slice(i, word.length) == word
          new_combos = table[i].map { |a| a << word }
          table[i + word.length].push(new_combos)      
      end
    end
  end
  return table[target.length]
end

And here's the failing output:

expected: [["ab", "cd", "ef"], ["ab", "c", "def"], ["abc", "def"], ["abcd", "ef"]]
            got: [[[["ab", "abc", "abcd"], "def"], [[["ab", "abc", "abcd"], "cd", "c"], "def"]], [[["ab", "abc", "abcd"], "ef"], [[["ab", "abc", "abcd"], "cd", "c"], "ef"]]]

I think that I may have a situation where line 8 is actually updating the table[i] value, when I'm intending to just store the updated values in the new_combos variable. And I clearly have an array nesting problem. I've been playing with this for so long that I can't see the wood for the trees any longer and would really appreciate any guidance on where I'm going and what I'm doing wrong. Thanks in advance.

– A working, but messy solution that I arrived at (Courtesy of many object_id and other puts statements):

def all_construct_tabular(target, word_array)
  table = Array.new(target.length + 1) { [] }
  table[0] = [[]]

  table.each_with_index do |e, i|
    word_array.each do |word|
      if target.slice(i, word.length) == word
        
        new_combos = table[i].each(&:dup)
        new_combos.map(&:flatten!)
        new_combos_with_word = new_combos.map(&:dup)
        new_combos_with_word.each {|e| e.push(word) }
        table[i + word.length] << new_combos_with_word
      end
    end
  end
  return table[target.length].flatten(1)
end

def all_construct_tabular(target, word_array)
  table = Array.new(target.length + 1).each.map { [] }
  table[0] = [[]]
  table.each_with_index do |_, i|
    word_array.each do |word|
      if target.slice(i, word.length) == word
        # `<<` modifies the original, but new combinations don't belong to that array
        new_combos = table[i].map { |a| a + [word] }
        # they belong where these combinations would end
        table[i + word.length].concat(new_combos) # or .push(*new_combos)
      end
    end
  end
  table[target.length]
end

Not sure if there is anything else I can do here, maybe massage some things around:

def all_construct_tabular(target, word_array)
  combinations = [[[]]]

  target.length.times.to_a.product(word_array) do |i, word|
    starting, ending = i, i + word.length
    next unless target[starting...ending] == word

    combinations[ending] ||= []
    combinations[ending].concat(combinations[starting].map { |ary| ary + [word] })
    # [["abc", "def"]]          [["abcd"]]                               ["ef"]
  end

  combinations.last
end

actual = all_construct_tabular("abcdef", ["c", "ab", "abc", "def", "cd", "abcd", "ef"]).sort
expected = [["ab", "cd", "ef"], ["ab", "c", "def"], ["abc", "def"], ["abcd", "ef"]].sort
p actual, expected
puts "Testing: #{actual == expected}"

[["ab", "c", "def"], ["ab", "cd", "ef"], ["abc", "def"], ["abcd", "ef"]]
[["ab", "c", "def"], ["ab", "cd", "ef"], ["abc", "def"], ["abcd", "ef"]]
Testing: true

In case this helps anyone else, the knowledge that I essentially needed in order to correct my code and answer this question is well illustrated in this article, the 2nd of a three part series of articles all of which would help anyone getting to grips with Ruby's object mutation and reference / value passing behaviours.