From 075f147d0a919da79d39d80440058e6f9d2dd17e Mon Sep 17 00:00:00 2001
From: RHOPRHH <rhoprhh@gmail.com>
Date: Fri, 13 May 2016 10:54:07 -0400
Subject: [PATCH 1/2] [WIP] add list-ops


From 28d7e8b70bc6785c1944bf5ba38d5d1aed3c44ac Mon Sep 17 00:00:00 2001
From: RHOPRHH <rhoprhh@gmail.com>
Date: Fri, 13 May 2016 14:55:30 -0400
Subject: [PATCH 2/2] list-ops ready for review

---
 config.json                         |   1 +
 exercises/list-ops/example.rb       |  67 +++++++++++++++++
 exercises/list-ops/list_ops_test.rb | 107 ++++++++++++++++++++++++++++
 3 files changed, 175 insertions(+)
 create mode 100644 exercises/list-ops/example.rb
 create mode 100755 exercises/list-ops/list_ops_test.rb

diff --git a/config.json b/config.json
index f9cb865357..a1fec204f8 100644
--- a/config.json
+++ b/config.json
@@ -32,6 +32,7 @@
     "etl",
     "trinary",
     "beer-song",
+    "list-ops",
     "bowling",
     "space-age",
     "anagram",
diff --git a/exercises/list-ops/example.rb b/exercises/list-ops/example.rb
new file mode 100644
index 0000000000..0b7b5db94e
--- /dev/null
+++ b/exercises/list-ops/example.rb
@@ -0,0 +1,67 @@
+class ListOps
+  VERSION = 1
+  ## Do not use the functions map, concat, count, length, etc.
+  ## and other built in ruby methods to solve  these
+  ##
+  def self.arrays(arr)
+    counter = 0
+    arr.each do
+      counter += 1
+    end
+    counter
+  end
+
+  def self.reverser(arr)
+    answer = []
+    until arr.empty?
+      answer << arr.pop
+    end
+    answer
+  end
+
+  def self.concatter(arr1, arr2)
+    answer = []
+    arr1.each do |element|
+      answer << element
+    end
+    arr2.each do |element|
+      answer << element
+    end
+    answer
+  end
+
+  def self.mapper(arr)
+    answer = []
+    arr.each do |element|
+      answer << (element + 1)
+    end
+    answer
+  end
+
+  def self.filterer(arr)
+    answer = []
+    arr.each do |element|
+      if element % 2 == 1
+        answer << element
+      end
+    end
+    answer
+  end
+
+  def self.sum_reducer(arr)
+    total = 0
+    arr.each do |element|
+      total += element
+    end
+    total
+  end
+
+  def self.factorial_reducer(arr)
+    total = 1
+    arr.each do |element|
+        total = total * element
+    end
+    total
+  end
+
+end
diff --git a/exercises/list-ops/list_ops_test.rb b/exercises/list-ops/list_ops_test.rb
new file mode 100755
index 0000000000..7c91a97a69
--- /dev/null
+++ b/exercises/list-ops/list_ops_test.rb
@@ -0,0 +1,107 @@
+gem 'minitest', '>= 5.0.0'
+require 'minitest/autorun'
+require_relative 'list_ops'
+
+class ListOpsTest < Minitest::Test
+  def test_count_empty
+    assert_equal 0, ListOps.arrays([])
+  end
+
+  def test_count_normal
+    skip
+    assert_equal 5, ListOps.arrays(Array.new(5))
+  end
+
+  def test_count_gigantic
+    skip
+    assert_equal 1_000_000, ListOps.arrays(Array.new(1_000_000))
+  end
+
+  def test_reverse_empty
+    skip
+    assert_equal [], ListOps.reverser([])
+  end
+
+  def test_reverse_normal
+    skip
+    assert_equal [5, 4, 3, 2, 1], ListOps.reverser([1, 2, 3, 4, 5])
+  end
+
+  def test_reverse_gigantic
+    skip
+    assert (1_000_000..1).to_a, ListOps.reverser((1..1_000_000).to_a)
+  end
+
+  def test_concat_empty
+    skip
+    assert [], ListOps.concatter([], [])
+  end
+
+  def test_concat_normal
+    skip
+    assert [12, 34, 56, 78], ListOps.concatter([12, 34], [56, 78])
+  end
+
+  def test_concat_gigantic
+    skip
+    input1 = (1..1_000_000).to_a
+    input2 = (1_000_001..2_000_000).to_a
+    assert (1..2_000_000).to_a, ListOps.concatter(input1, input2)
+  end
+
+  def test_mapper_empty
+    skip
+    assert [], ListOps.mapper([])
+  end
+
+  def test_mapper_normal
+    skip
+    assert [2, 3, 4, 5, 6], ListOps.mapper([1, 2, 3, 4, 5])
+  end
+
+  def test_mapper_gigantic
+    skip
+    assert (2..1_000_001).to_a, ListOps.mapper((1..1_000_000).to_a)
+  end
+
+  def test_filterer_empty
+    skip
+    assert [], ListOps.filterer([])
+  end
+
+  def test_filterer_normal
+    skip
+    assert [1, 3, 5, 7, 9], ListOps.filterer([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+  end
+
+  def test_filterer_gigantic
+    skip
+    assert (1..10_000).to_a.select(&:even?), ListOps.filterer((1..10_000).to_a)
+  end
+
+  def test_sum_reducer_empty
+    skip
+    assert_equal 0, ListOps.sum_reducer([])
+  end
+
+  def test_sum_reducer_normal
+    skip
+    assert_equal 55, ListOps.sum_reducer([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+  end
+
+  def test_factorial_reducer_empty
+    skip
+    assert_equal 1, ListOps.factorial_reducer([])
+  end
+
+  def test_factorial_reducer_normal
+    skip
+    input = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    assert_equal 3_628_800, ListOps.factorial_reducer(input)
+  end
+
+  def test_bookkeeping
+    skip
+    assert_equal 1, ListOps::VERSION
+  end
+end