trackler 2.0.3.4 → 2.0.3.5

data/tracks/crystal/config.json

@@ -131,6 +131,18 @@
       "topics": [
       ]
     },
+    {
+      "slug": "run-length-encoding",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
+    {
+      "slug": "pascals-triangle",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
     {
       "slug": "forth",
       "difficulty": 3,

data/tracks/crystal/exercises/pascals-triangle/spec/pascals_triangle_spec.cr

@@ -0,0 +1,30 @@
+require "spec"
+require "../src/*"
+
+describe "PascalsTriangle" do
+  it "will return the first 0 row(s)" do
+    PascalsTriangle.rows(0).should eq([] of Int32)
+  end
+
+  pending "will return the first 1 row(s)" do
+    PascalsTriangle.rows(1).should eq([[1]])
+  end
+
+  pending "will return the first 2 row(s)" do
+    PascalsTriangle.rows(2).should eq([[1], [1, 1]])
+  end
+
+  pending "will return the first 3 row(s)" do
+    PascalsTriangle.rows(3).should eq([[1], [1, 1], [1, 2, 1]])
+  end
+
+  pending "will return the first 4 row(s)" do
+    PascalsTriangle.rows(4).should eq([[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]])
+  end
+
+  pending "will raise an Argument error for negative rows" do
+    expect_raises do
+      PascalsTriangle.rows(-1)
+    end
+  end
+end

data/tracks/crystal/exercises/pascals-triangle/src/example.cr

@@ -0,0 +1,19 @@
+class PascalsTriangle
+  include Iterator(Array(Int32))
+
+  def self.rows(n)
+    raise ArgumentError.new("Number must not be less than zero") if n < 0
+    new.first(n).to_a
+  end
+
+  def initialize
+    @m = -1
+  end
+
+  def next
+    @m += 1
+    @m.times.reduce([1]) do |row, k|
+      row << (row[k] * (@m - k) / (k + 1))
+    end
+  end
+end

data/tracks/crystal/exercises/pascals-triangle/src/pascals_triangle.cr

@@ -0,0 +1 @@
+# Please implement your solution to pascals-triangle in this file

data/tracks/crystal/exercises/run-length-encoding/spec/run_length_encoding_spec.cr

@@ -0,0 +1,36 @@
+require "spec"
+require "../src/*"
+
+describe "RunLengthEncoding" do
+  it "encode empty string" do
+    RunLengthEncoding.encode("").should eq("")
+  end
+
+  pending "encode single characters only" do
+    RunLengthEncoding.encode("XYZ").should eq("XYZ")
+  end
+
+  pending "decode empty string" do
+    RunLengthEncoding.decode("").should eq("")
+  end
+
+  pending "decode single characters only" do
+    RunLengthEncoding.decode("XYZ").should eq("XYZ")
+  end
+
+  pending "encode simple" do
+    RunLengthEncoding.encode("AABBBCCCC").should eq("2A3B4C")
+  end
+
+  pending "decode simple" do
+    RunLengthEncoding.decode("2A3B4C").should eq("AABBBCCCC")
+  end
+
+  pending "encode with single values" do
+    RunLengthEncoding.encode("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB").should eq("12WB12W3B24WB")
+  end
+
+  pending "decode with single values" do
+    RunLengthEncoding.decode("12WB12W3B24WB").should eq("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB")
+  end
+end

data/tracks/crystal/exercises/run-length-encoding/src/example.cr

@@ -0,0 +1,40 @@
+module RunLengthEncoding
+  extend self
+
+  def encode(str)
+    reader = Char::Reader.new(str)
+    String.build do |io|
+      while reader.has_next?
+        count = 1
+
+        while reader.current_char == reader.peek_next_char
+          count += 1
+          reader.next_char
+        end
+
+        io << count if count > 1
+        io << reader.current_char
+        reader.next_char
+      end
+    end
+  end
+
+  def decode(str)
+    reader = Char::Reader.new(str)
+    String.build do |io|
+      while reader.has_next?
+        num = 0
+
+        while reader.current_char.number?
+          num *= 10
+          num += reader.current_char.to_i
+          reader.next_char
+        end
+
+        io << reader.current_char if num == 0
+        num.times { |i| io << reader.current_char }
+        reader.next_char
+      end
+    end
+  end
+end

data/tracks/crystal/src/generator/exercises/pascals-triangle.cr

@@ -0,0 +1,58 @@
+require "./exercise_generator"
+require "./exercise_test_case"
+
+class PascalsTriangleGenerator < ExerciseGenerator
+  def exercise_name
+    "pascals-triangle"
+  end
+
+  def test_cases
+    JSON.parse(data)["rows"]["cases"].map do |test_case|
+      PascalsTriangleTestCase.new(test_case) unless test_case["count"]?.nil?
+    end.compact
+  end
+end
+
+class PascalsTriangleTestCase < ExerciseTestCase
+  private getter description : JSON::Any
+  private getter count : JSON::Any
+  private getter expected : JSON::Any
+
+  def initialize(test_case)
+    @description = test_case["description"]
+    @count = test_case["count"]
+    @expected = fix_empty_array(test_case["expected"])
+  end
+
+  def workload
+    if !error?
+      "PascalsTriangle.rows(#{count}).should eq(#{expected})"
+    else
+      <<-WL
+      expect_raises do
+            PascalsTriangle.rows(#{count})
+          end
+      WL
+    end
+  end
+
+  def test_name
+    if !error?
+      "will return the first #{count} row(s)"
+    else
+      "will raise an Argument error for #{description}"
+    end
+  end
+
+  private def error?
+    expected == -1
+  end
+
+  private def fix_empty_array(json)
+    if json.to_s.match(/\[\]/)
+      JSON.parse("[] of Int32".to_json)
+    else
+      json
+    end
+  end
+end

data/tracks/crystal/src/generator/exercises/run_length_encoding.cr

@@ -0,0 +1,42 @@
+require "./exercise_generator"
+require "./exercise_test_case"
+
+class RunLengthEncodingGenerator < ExerciseGenerator
+  def exercise_name
+    "run-length-encoding"
+  end
+
+  def test_cases
+    JSON.parse(data)["cases"].map do |test_case|
+      RunLengthEncodingTestCase.new(test_case)
+    end
+  end
+end
+
+class RunLengthEncodingTestCase < ExerciseTestCase
+  private getter description : JSON::Any
+  private getter input : JSON::Any
+  private getter expected : JSON::Any
+
+  def initialize(test_case)
+    @description = test_case["description"]
+    @input = test_case["input"]
+    @expected = test_case["expected"]
+  end
+
+  def workload
+    "RunLengthEncoding.#{method}(\"#{input}\").should eq(\"#{expected}\")"
+  end
+
+  def test_name
+    description
+  end
+
+  private def method
+    if description.as_s.match(/encode/)
+      "encode"
+    else
+      "decode"
+    end
+  end
+end

data/tracks/javascript/config.json

@@ -70,7 +70,8 @@
     "bracket-push",
     "two-bucket",
     "bowling",
-    "diamond"
+    "diamond",
+    "all-your-base"
   ],
   "exercises": [
     {
@@ -468,6 +469,12 @@
       "difficulty": 1,
       "topics": [
       ]
+    },
+    {
+      "slug": "all-your-base",
+      "difficulty": 1,
+      "topics": [
+      ]
     }
   ],
   "deprecated": [

data/tracks/javascript/exercises/all-your-base/all-your-base.spec.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const Converter = require('./all-your-base');
+
+const converter = new Converter();
+
+describe('Converter', function () {
+
+  xit('single bit one to decimal', function () {
+    expect(converter.convert([1], 2, 10)).toEqual([1]);
+  });
+
+  xit('binary to single decimal', function () {
+    expect(converter.convert([1, 0, 1], 2, 10)).toEqual([5]);
+  });
+
+  xit('single decimal to binary', function () {
+    expect(converter.convert([5], 10, 2)).toEqual([1, 0, 1]);
+  });
+
+  xit('binary to multiple decimal', function () {
+    expect(converter.convert([1, 0, 1, 0, 1, 0], 2, 10)).toEqual([4, 2]);
+  });
+
+  xit('decimal to binary', function () {
+    expect(converter.convert([4, 2], 10, 2)).toEqual([1, 0, 1, 0, 1, 0]);
+  });
+
+  xit('trinary to hexadecimal', function () {
+    expect(converter.convert([1, 1, 2, 0], 3, 16)).toEqual([2, 10]);
+  });
+
+  xit('hexadecimal to trinary', function () {
+    expect(converter.convert([2, 10], 16, 3)).toEqual([1, 1, 2, 0]);
+  });
+
+  xit('15-bit integer', function () {
+    expect(converter.convert([3, 46, 60], 97, 73)).toEqual([6, 10, 45]);
+  });
+
+  xit('empty list', function () {
+    expect(function () {
+      converter.convert([], 2, 10);
+    }).toThrow(new Error('Input has wrong format'));
+  });
+
+  xit('single zero', function () {
+    expect(converter.convert([0], 10, 2)).toEqual([0]);
+  });
+
+  xit('multiple zeros', function () {
+    expect(function () {
+      converter.convert([0, 0, 0], 10, 2);
+    }).toThrow(new Error('Input has wrong format'));
+  });
+
+  xit('leading zeros', function () {
+    expect(function () {
+      converter.convert([0, 6, 0], 7, 10);
+    }).toThrow(new Error('Input has wrong format'));
+  });
+
+  xit('negative digit', function () {
+    expect(function () {
+      converter.convert([1, -1, 1, 0, 1, 0], 2, 10);
+    }).toThrow(new Error('Input has wrong format'));
+  });
+
+  xit('invalid positive digit', function () {
+    expect(function () {
+      converter.convert([1, 2, 1, 0, 1, 0], 2, 10);
+    }).toThrow(new Error('Input has wrong format'));
+  });
+
+  xit('first base is one', function () {
+    expect(function () {
+      converter.convert([], 1, 10);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  xit('second base is one', function () {
+    expect(function () {
+      converter.convert([1, 0, 1, 0, 1, 0], 2, 1);
+    }).toThrow(new Error('Wrong output base'));
+  });
+
+  xit('first base is zero', function () {
+    expect(function () {
+      converter.convert([], 0, 10);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  xit('second base is zero', function () {
+    expect(function () {
+      converter.convert([7], 10, 0);
+    }).toThrow(new Error('Wrong output base'));
+  });
+
+  xit('first base is negative', function () {
+    expect(function () {
+      converter.convert([1], -2, 10);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  xit('second base is negative', function () {
+    expect(function () {
+      converter.convert([1], 2, -7);
+    }).toThrow(new Error('Wrong output base'));
+  });
+
+  xit('both bases are negative', function () {
+    expect(function () {
+      converter.convert([1], -2, -7);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  it('missing input base throws an error', function () {
+    expect(function () {
+      converter.convert([0]);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  xit('wrong input_base base not integer', function () {
+    expect(function () {
+      converter.convert([0], 2.5);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  xit('missing output base throws an error', function () {
+    expect(function () {
+      converter.convert([0], 2);
+    }).toThrow(new Error('Wrong output base'));
+  });
+
+  xit('wrong output_base base not integer', function () {
+    expect(function () {
+      converter.convert([0], 3, 2.5);
+    }).toThrow(new Error('Wrong output base'));
+  });
+
+});

data/tracks/javascript/exercises/all-your-base/example.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const Converter = function () { };
+
+const isValidBase = function (base) {
+  return !base || base < 2 || Math.floor(base) !== base;
+};
+
+const isInputValid = function (array, base) {
+  if (!array || !array.length) {
+    return false;
+  }
+  const val = base - 1;
+  for (let i = 0, n = array.length; i < n; i++) {
+    const tmp = array[i];
+    if (tmp > val || tmp < 0) {
+      return false;
+    }
+  }
+  return true;
+};
+
+const convertFromDecimalToBase = function (num, outputBase) {
+  let tmp = num;
+  const result = [];
+  while (tmp) {
+    result.unshift(tmp % outputBase);
+    tmp = Math.floor(tmp / outputBase);
+  }
+  return result;
+};
+
+Converter.prototype.convert = function (array, inputBase, outputBase) {
+  if (isValidBase(inputBase)) {
+    throw new Error('Wrong input base');
+  }
+  if (isValidBase(outputBase)) {
+    throw new Error('Wrong output base');
+  }
+  const regexp = new RegExp('^0.', 'g');
+  const str = array.join('');
+  if (str.match(regexp)
+    || !isInputValid(array, inputBase)) {
+    throw new Error('Input has wrong format');
+  }
+  if (str === '0') {
+    return [0];
+  }
+  if (str === '1') {
+    return [1];
+  }
+  const decimalValue = array
+    .reduce((accumulator, value) => {
+      return accumulator * inputBase + value;
+    }, 0);
+  return convertFromDecimalToBase(decimalValue, outputBase);
+};
+
+module.exports = Converter;