trackler 2.2.1.49 → 2.2.1.50

data/tracks/purescript/exercises/rna-transcription/bower.json

@@ -0,0 +1,26 @@
+{
+  "name": "rna-transcription",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "output"
+  ],
+  "dependencies": {
+    "purescript-console": "^3.0.0",
+    "purescript-datetime": "^3.4.0",
+    "purescript-either": "^3.1.0",
+    "purescript-enums": "^3.2.1",
+    "purescript-integers": "^3.1.0",
+    "purescript-lists": "^4.10.0",
+    "purescript-maps": "^3.5.2",
+    "purescript-prelude": "^3.1.0",
+    "purescript-sets": "^3.0.0",
+    "purescript-strings": "^3.3.1",
+    "purescript-unicode": "^3.0.1"
+  },
+  "devDependencies": {
+    "purescript-psci-support": "^3.0.0",
+    "purescript-test-unit": "^13.0.0"
+  }
+}

data/tracks/purescript/exercises/rna-transcription/examples/src/RNATranscription.purs

@@ -0,0 +1,18 @@
+module RNATranscription
+  ( toRNA
+  ) where
+
+import Prelude
+import Data.Maybe (Maybe(..))
+import Data.String (fromCharArray, toCharArray)
+import Data.Traversable (traverse)
+
+toRNA :: String -> Maybe String
+toRNA dna = fromCharArray <$> traverse complement (toCharArray dna)
+
+complement :: Char -> Maybe Char
+complement 'C' = Just 'G'
+complement 'G' = Just 'C'
+complement 'A' = Just 'U'
+complement 'T' = Just 'A'
+complement _ = Nothing

data/tracks/purescript/exercises/rna-transcription/src/RNATranscription.purs

@@ -0,0 +1,3 @@
+module RNATranscription
+  ( toRNA
+  ) where

data/tracks/purescript/exercises/rna-transcription/test/Main.purs

@@ -0,0 +1,48 @@
+module Test.Main where
+
+import Prelude
+import Control.Monad.Eff (Eff)
+import Control.Monad.Eff.AVar (AVAR)
+import Control.Monad.Eff.Console (CONSOLE)
+import Data.Maybe (Maybe(..))
+import Test.Unit (TestSuite, suite, test)
+import Test.Unit.Assert as Assert
+import Test.Unit.Console (TESTOUTPUT)
+import Test.Unit.Main (runTest)
+import RNATranscription (toRNA)
+
+main :: forall eff
+  . Eff ( avar :: AVAR
+        , console :: CONSOLE
+        , testOutput :: TESTOUTPUT
+        | eff
+        )
+        Unit
+main = runTest suites
+
+suites :: forall e. TestSuite e
+suites =
+  suite "RNATranscription.toRNA" do
+    test "RNA complement of cytosine is guanine" $
+      Assert.equal (Just "G") (toRNA "C")
+
+    test "RNA complement of guanine is cytosine" $
+      Assert.equal (Just "C") (toRNA "G")
+
+    test "RNA complement of thymine is adenine" $
+      Assert.equal (Just "A") (toRNA "T")
+
+    test "RNA complement of adenine is uracil" $
+      Assert.equal (Just "U") (toRNA "A")
+
+    test "RNA complement" $
+      Assert.equal (Just "UGCACCAGAAUU") (toRNA "ACGTGGTCTTAA")
+
+    test "correctly handles invalid input (RNA instead of DNA)" $
+      Assert.equal Nothing (toRNA "U")
+
+    test "correctly handles completely invalid DNA input" $
+      Assert.equal Nothing (toRNA "XXX")
+
+    test "correctly handles partially invalid DNA input" $
+      Assert.equal Nothing (toRNA "ACGTXXXCTTAA")

data/tracks/python/exercises/variable-length-quantity/example.py

@@ -3,32 +3,32 @@ SEVENBITSMASK = 0x7f
 
 
 def encode_single(n):
-    bytes = [n & SEVENBITSMASK]
+    bytes_ = [n & SEVENBITSMASK]
     n >>= 7
 
     while n > 0:
-        bytes.append(n & SEVENBITSMASK | EIGHTBITMASK)
+        bytes_.append(n & SEVENBITSMASK | EIGHTBITMASK)
         n >>= 7
 
-    return bytes[::-1]
+    return bytes_[::-1]
 
 
 def encode(numbers):
     return sum((encode_single(n) for n in numbers), [])
 
 
-def decode(bytes):
+def decode(bytes_):
     values = []
     n = 0
 
-    for i, byte in enumerate(bytes):
+    for i, byte in enumerate(bytes_):
         n <<= 7
         n += (byte & SEVENBITSMASK)
 
         if byte & EIGHTBITMASK == 0:
             values.append(n)
             n = 0
-        elif i == len(bytes) - 1:
+        elif i == len(bytes_) - 1:
             raise ValueError('incomplete byte sequence')
 
     return values

data/tracks/python/exercises/variable-length-quantity/variable_length_quantity.py

@@ -1,6 +1,6 @@
-def encode():
+def encode(numbers):
     pass
 
 
-def decode():
+def decode(bytes_):
     pass

data/tracks/ruby/config.json

@@ -895,6 +895,12 @@
       "uuid": "89bd3d71-000f-4cd9-9a84-ad1b22ddbd33",
       "slug": "point-mutations",
       "deprecated": true
+    },
+    {
+      "uuid": "4ca1322e-0c39-1e80-91e9-6b3f9ccf894f9058490",
+      "slug": "complex-numbers",
+      "difficulty": 3,
+      "topics": [ "Mathematics" ]
     }
   ],
   "foregone": [

data/tracks/ruby/exercises/complex-numbers/.meta/.version

@@ -0,0 +1 @@
+1

data/tracks/ruby/exercises/complex-numbers/.meta/generator/complex_numbers_case.rb

@@ -0,0 +1,44 @@
+require 'generator/exercise_case'
+
+class ComplexNumbersCase < Generator::ExerciseCase
+
+  def workload
+    indent_text(4, testcase)
+  end
+
+  def number
+    (respond_to? :input) ? input : z1
+  end
+
+  def operation
+    case property
+    when "add" then " + #{construct_complex(z2)}"
+    when "sub" then " - #{construct_complex(z2)}" 
+    when "mul" then " * #{construct_complex(z2)}" 
+    when "div" then " / #{construct_complex(z2)}" 
+    else ".#{property}"
+    end
+  end
+
+  def testcase
+    "expected = #{expected_value}\n" +
+    "assert_equal expected, #{construct_complex(number)}#{operation}"
+  end
+
+  def construct_complex(value)
+    "ComplexNumber.new(#{parse_number(value)})"
+  end
+
+  def expected_value
+    (expected.is_a? Numeric) ? expected : construct_complex(expected)
+  end
+
+  def parse_number(number)
+    return number if number.is_a? Numeric
+    Array(number).map do |elem|
+      (elem.is_a? Numeric) ? elem.to_s : "Math::#{elem.upcase}"
+    end.join(", ")
+  end
+
+end
+

data/tracks/ruby/exercises/complex-numbers/.meta/solutions/complex_numbers.rb

@@ -0,0 +1,49 @@
+class ComplexNumber
+  attr_reader :real, :imaginary
+
+  def initialize(real, imaginary = 0)
+    @real = real
+    @imaginary = imaginary
+  end
+
+  def ==(other)
+     (self - other).abs < 1e-15
+  end
+
+  def +(other)
+    self.class.new(@real + other.real, @imaginary + other.imaginary)
+  end
+
+  def -(other)
+    self.class.new(@real - other.real, @imaginary - other.imaginary)
+  end
+
+  def *(other)
+    self.class.new(@real * other.real - @imaginary * other.imaginary,
+         @real * other.imaginary + @imaginary * other.real)
+  end
+
+  def /(other)
+    self*other.inv
+  end
+
+  def abs
+    Math.sqrt((self*self.conjugate).real)
+  end
+
+  def conjugate
+    self.class.new(@real, -@imaginary)
+  end
+
+  def inv
+   self.class.new(@real / abs**2, -@imaginary / abs**2)
+  end
+
+  def exp
+   self.class.new(Math.exp(@real)) * self.class.new(Math.cos(@imaginary), Math.sin(@imaginary))
+  end
+end
+
+module BookKeeping
+  VERSION = 1
+end

data/tracks/ruby/exercises/complex-numbers/README.md

@@ -0,0 +1,64 @@
+# Complex Numbers
+
+A complex number is a number in the form `z = a + b * i` where `a` and `b` are real and `i` satisfies `i^2 = -1`.
+
+`a` is called the real part and `b` is called the imaginary part of `z`.
+The conjugate of the number `a + b * i` is the number `a - b * i`.
+The absolute value of a complex number `z = a + b * i` is a real number `|z| = sqrt(a^2 + b^2)`. The square of the absolute value `|z|^2` is the result of multiplication of `z` by its complex conjugate.
+
+The sum / difference of two complex numbers involves adding / subtracting their real and imaginary parts separately:
+`(a + i * b) + (c + i * d) = (a + c) + (b + d) * i`,
+`(a + i * b) - (c + i * d) = (a - c) + (b - d) * i`.
+
+Multiplication result is by definition
+`(a + i * b) * (c + i * d) = (a * c - b * d) + (b * c + a * d) * i`.
+
+The reciprocal of a non-zero complex number is
+`1 / (a + i * b) = a/(a^2 + b^2) - b/(a^2 + b^2) * i`.
+
+Dividing a complex number `a + i * b` by another `c + i * d` gives:
+`(a + i * b) / (c + i * d) = (a * c + b * d)/(c^2 + d^2) + (b * c - a * d)/(c^2 + d^2) * i`.
+
+Exponent of a complex number can be expressed as
+`exp(a + i * b) = exp(a) * exp(i * b)`,
+and the last term is given by Euler's formula `exp(i * b) = cos(b) + i * sin(b)`.
+
+
+Implement the following operations:
+ - addition, subtraction, multiplication and division of two complex numbers,
+ - conjugate, absolute value, exponent of a given complex number.
+
+
+Assume the programming language you are using does not have an implementation of complex numbers.
+
+* * * *
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/ruby).
+
+For running the tests provided, you will need the Minitest gem. Open a
+terminal window and run the following command to install minitest:
+
+    gem install minitest
+
+If you would like color output, you can `require 'minitest/pride'` in
+the test file, or note the alternative instruction, below, for running
+the test file.
+
+In order to run the test, you can run the test file from the exercise
+directory. For example, if the test suite is called
+`hello_world_test.rb`, you can run the following command:
+
+    ruby hello_world_test.rb
+
+To include color from the command line:
+
+    ruby -r minitest/pride hello_world_test.rb
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Complex_number](https://en.wikipedia.org/wiki/Complex_number)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+

data/tracks/ruby/exercises/complex-numbers/complex_numbers_test.rb

@@ -0,0 +1,207 @@
+require 'minitest/autorun'
+require_relative 'complex_numbers'
+
+# Common test data version: 1.0.0 '117d062'
+class ComplexNumbersTest < Minitest::Test
+  def test_imaginary_unit
+    # skip
+    expected = ComplexNumber.new(-1, 0)
+    assert_equal expected, ComplexNumber.new(0, 1) * ComplexNumber.new(0, 1)
+  end
+
+  def test_add_purely_real_numbers
+    skip
+    expected = ComplexNumber.new(3, 0)
+    assert_equal expected, ComplexNumber.new(1, 0) + ComplexNumber.new(2, 0)
+  end
+
+  def test_add_purely_imaginary_numbers
+    skip
+    expected = ComplexNumber.new(0, 3)
+    assert_equal expected, ComplexNumber.new(0, 1) + ComplexNumber.new(0, 2)
+  end
+
+  def test_add_numbers_with_real_and_imaginary_part
+    skip
+    expected = ComplexNumber.new(4, 6)
+    assert_equal expected, ComplexNumber.new(1, 2) + ComplexNumber.new(3, 4)
+  end
+
+  def test_subtract_purely_real_numbers
+    skip
+    expected = ComplexNumber.new(-1, 0)
+    assert_equal expected, ComplexNumber.new(1, 0) - ComplexNumber.new(2, 0)
+  end
+
+  def test_subtract_purely_imaginary_numbers
+    skip
+    expected = ComplexNumber.new(0, -1)
+    assert_equal expected, ComplexNumber.new(0, 1) - ComplexNumber.new(0, 2)
+  end
+
+  def test_subtract_numbers_with_real_and_imaginary_part
+    skip
+    expected = ComplexNumber.new(-2, -2)
+    assert_equal expected, ComplexNumber.new(1, 2) - ComplexNumber.new(3, 4)
+  end
+
+  def test_multiply_purely_real_numbers
+    skip
+    expected = ComplexNumber.new(2, 0)
+    assert_equal expected, ComplexNumber.new(1, 0) * ComplexNumber.new(2, 0)
+  end
+
+  def test_multiply_purely_imaginary_numbers
+    skip
+    expected = ComplexNumber.new(-2, 0)
+    assert_equal expected, ComplexNumber.new(0, 1) * ComplexNumber.new(0, 2)
+  end
+
+  def test_multiply_numbers_with_real_and_imaginary_part
+    skip
+    expected = ComplexNumber.new(-5, 10)
+    assert_equal expected, ComplexNumber.new(1, 2) * ComplexNumber.new(3, 4)
+  end
+
+  def test_divide_purely_real_numbers
+    skip
+    expected = ComplexNumber.new(0.5, 0)
+    assert_equal expected, ComplexNumber.new(1, 0) / ComplexNumber.new(2, 0)
+  end
+
+  def test_divide_purely_imaginary_numbers
+    skip
+    expected = ComplexNumber.new(0.5, 0)
+    assert_equal expected, ComplexNumber.new(0, 1) / ComplexNumber.new(0, 2)
+  end
+
+  def test_divide_numbers_with_real_and_imaginary_part
+    skip
+    expected = ComplexNumber.new(0.44, 0.08)
+    assert_equal expected, ComplexNumber.new(1, 2) / ComplexNumber.new(3, 4)
+  end
+
+  def test_absolute_value_of_a_positive_purely_real_number
+    skip
+    expected = 5
+    assert_equal expected, ComplexNumber.new(5, 0).abs
+  end
+
+  def test_absolute_value_of_a_negative_purely_real_number
+    skip
+    expected = 5
+    assert_equal expected, ComplexNumber.new(-5, 0).abs
+  end
+
+  def test_absolute_value_of_a_purely_imaginary_number_with_positive_imaginary_part
+    skip
+    expected = 5
+    assert_equal expected, ComplexNumber.new(0, 5).abs
+  end
+
+  def test_absolute_value_of_a_purely_imaginary_number_with_negative_imaginary_part
+    skip
+    expected = 5
+    assert_equal expected, ComplexNumber.new(0, -5).abs
+  end
+
+  def test_absolute_value_of_a_number_with_real_and_imaginary_part
+    skip
+    expected = 5
+    assert_equal expected, ComplexNumber.new(3, 4).abs
+  end
+
+  def test_conjugate_a_purely_real_number
+    skip
+    expected = ComplexNumber.new(5, 0)
+    assert_equal expected, ComplexNumber.new(5, 0).conjugate
+  end
+
+  def test_conjugate_a_purely_imaginary_number
+    skip
+    expected = ComplexNumber.new(0, -5)
+    assert_equal expected, ComplexNumber.new(0, 5).conjugate
+  end
+
+  def test_conjugate_a_number_with_real_and_imaginary_part
+    skip
+    expected = ComplexNumber.new(1, -1)
+    assert_equal expected, ComplexNumber.new(1, 1).conjugate
+  end
+
+  def test_real_part_of_a_purely_real_number
+    skip
+    expected = 1
+    assert_equal expected, ComplexNumber.new(1, 0).real
+  end
+
+  def test_real_part_of_a_purely_imaginary_number
+    skip
+    expected = 0
+    assert_equal expected, ComplexNumber.new(0, 1).real
+  end
+
+  def test_real_part_of_a_number_with_real_and_imaginary_part
+    skip
+    expected = 1
+    assert_equal expected, ComplexNumber.new(1, 2).real
+  end
+
+  def test_imaginary_part_of_a_purely_real_number
+    skip
+    expected = 0
+    assert_equal expected, ComplexNumber.new(1, 0).imaginary
+  end
+
+  def test_imaginary_part_of_a_purely_imaginary_number
+    skip
+    expected = 1
+    assert_equal expected, ComplexNumber.new(0, 1).imaginary
+  end
+
+  def test_imaginary_part_of_a_number_with_real_and_imaginary_part
+    skip
+    expected = 2
+    assert_equal expected, ComplexNumber.new(1, 2).imaginary
+  end
+
+  def test_eulers_identityformula
+    skip
+    expected = ComplexNumber.new(-1, 0)
+    assert_equal expected, ComplexNumber.new(0, Math::PI).exp
+  end
+
+  def test_exponential_of_0
+    skip
+    expected = ComplexNumber.new(1, 0)
+    assert_equal expected, ComplexNumber.new(0, 0).exp
+  end
+
+  def test_exponential_of_a_purely_real_number
+    skip
+    expected = ComplexNumber.new(Math::E, 0)
+    assert_equal expected, ComplexNumber.new(1, 0).exp
+  end
+
+  # Problems in exercism evolve over time, as we find better ways to ask
+  # questions.
+  # The version number refers to the version of the problem you solved,
+  # not your solution.
+  #
+  # Define a constant named VERSION inside of the top level BookKeeping
+  # module, which may be placed near the end of your file.
+  #
+  # In your file, it will look like this:
+  #
+  # module BookKeeping
+  #   VERSION = 1 # Where the version number matches the one in the test.
+  # end
+  #
+  # If you are curious, read more about constants on RubyDoc:
+  # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
+
+  def test_bookkeeping
+    skip
+    assert_equal 1, BookKeeping::VERSION
+  end
+end