Commit f220e3a

@@ -0,0 +1,108 @@
+<<-DOC
+You're given 2 huge integers represented by linked lists.
+Each linked list element is a number from 0 to 9999 that
+represents a number with exactly 4 digits.
+The represented number might have leading zeros.
+Your task is to add up these huge integers and
+return the result in the same format.
+
+Example
+
+For a = [9876, 5432, 1999] and b = [1, 8001], the output should be
+addTwoHugeNumbers(a, b) = [9876, 5434, 0].
+
+Explanation: 987654321999 + 18001 = 987654340000.
+
+For a = [123, 4, 5] and b = [100, 100, 100], the output should be
+addTwoHugeNumbers(a, b) = [223, 104, 105].
+
+Explanation: 12300040005 + 10001000100 = 22301040105.
+
+Input/Output
+
+[time limit] 4000ms (rb)
+[input] linkedlist.integer a
+
+The first number, without its leading zeros.
+
+Guaranteed constraints:
+0 ≤ a size ≤ 104,
+0 ≤ element value ≤ 9999.
+
+[input] linkedlist.integer b
+
+The second number, without its leading zeros.
+
+Guaranteed constraints:
+0 ≤ b size ≤ 104,
+0 ≤ element value ≤ 9999.
+
+[output] linkedlist.integer
+
+The result of adding a and b together, returned without leading zeros in the same format.
+DOC
+
+describe "#add_two_huge_numbers" do
+  def to_number(head)
+    number, x = [head.value.to_s.rjust(4, '0')], head
+    number.push(x.value.to_s.rjust(4, '0')) while x = x.next
+    number.join.to_i
+  end
+
+  def add_two_huge_numbers(a, b)
+    x, y = to_number(a), to_number(b)
+    sum = x + y
+    chunks = sum.to_s.chars.reverse.each_slice(4).to_a.reverse.map(&:reverse)
+    chunks.map(&:join).map(&:to_i).to_a
+  end
+
+  [
+    { a: [9876, 5432, 1999], b: [1, 8001], x: [9876, 5434, 0] },
+    { a: [123, 4, 5], b: [100, 100, 100], x: [223, 104, 105] },
+    { a: [0], b: [0], x: [0] },
+    { a: [1234, 1234, 0], b: [0], x: [1234, 1234, 0] },
+    { a: [0], b: [1234, 123, 0], x: [1234, 123, 0] },
+    { a: [1], b: [9998, 9999, 9999, 9999, 9999, 9999], x: [9999, 0, 0, 0, 0, 0] },
+    { a: [1], b: [9999, 9999, 9999, 9999, 9999, 9999], x: [1, 0, 0, 0, 0, 0, 0] },
+    { a: [8339, 4510], b: [2309], x: [8339, 6819] },
+  ].each do |x|
+    it do
+      expect(add_two_huge_numbers(
+        ListNode.to_list(x[:a]), ListNode.to_list(x[:b])
+      )).to eql(x[:x].to_a)
+    end
+  end
+
+  class ListNode
+    attr_accessor :value, :next
+
+    def initialize(value, next_node: nil)
+      @value = value
+      @next = next_node
+    end
+
+    def to_a
+      result = []
+      current = self
+      until current.nil?
+        result.push(current.value)
+        current = current.next
+      end
+      result
+    end
+
+    def self.to_list(items)
+      x = nil
+      items.inject(nil) do |memo, item|
+        node = new(item)
+        if memo.nil?
+          x = node
+        else
+          memo.next = node
+        end
+        node
+      end
+      x
+    end
+  end
+end