trackler 2.0.8.13 → 2.0.8.14

data/tracks/delphi/exercises/triangle/Triangle.dpr

@@ -0,0 +1,60 @@
+program Triangle; 
+ 
+{$IFNDEF TESTINSIGHT} 
+{$APPTYPE CONSOLE} 
+{$ENDIF}{$STRONGLINKTYPES ON} 
+uses 
+  System.SysUtils, 
+  {$IFDEF TESTINSIGHT} 
+  TestInsight.DUnitX, 
+  {$ENDIF } 
+  DUnitX.Loggers.Console, 
+  DUnitX.Loggers.Xml.NUnit, 
+  DUnitX.TestFramework, 
+  uTestTriangle in 'uTestTriangle.pas', 
+  uTriangle in 'uTriangle.pas'; 
+ 
+var 
+  runner : ITestRunner; 
+  results : IRunResults; 
+  logger : ITestLogger; 
+  nunitLogger : ITestLogger; 
+begin 
+{$IFDEF TESTINSIGHT} 
+  TestInsight.DUnitX.RunRegisteredTests; 
+  exit; 
+{$ENDIF} 
+  try 
+    //Check command line options, will exit if invalid 
+    TDUnitX.CheckCommandLine; 
+    //Create the test runner 
+    runner := TDUnitX.CreateRunner; 
+    //Tell the runner to use RTTI to find Fixtures 
+    runner.UseRTTI := True; 
+    //tell the runner how we will log things 
+    //Log to the console window 
+    logger := TDUnitXConsoleLogger.Create(true); 
+    runner.AddLogger(logger); 
+    //Generate an NUnit compatible XML File 
+    nunitLogger := TDUnitXXMLNUnitFileLogger.Create(TDUnitX.Options.XMLOutputFile); 
+    runner.AddLogger(nunitLogger); 
+    runner.FailsOnNoAsserts := False; //When true, Assertions must be made during tests; 
+ 
+    //Run tests 
+    results := runner.Execute; 
+    if not results.AllPassed then 
+      System.ExitCode := EXIT_ERRORS; 
+ 
+    {$IFNDEF CI} 
+    //We don't want this happening when running under CI. 
+    if TDUnitX.Options.ExitBehavior = TDUnitXExitBehavior.Pause then 
+    begin 
+      System.Write('Done.. press <Enter> key to quit.'); 
+      System.Readln; 
+    end; 
+    {$ENDIF} 
+  except 
+    on E: Exception do 
+      System.Writeln(E.ClassName, ': ', E.Message); 
+  end; 
+end. 

data/tracks/delphi/exercises/triangle/uTestTriangle.pas

@@ -0,0 +1,186 @@
+unit uTestTriangle; 
+ 
+interface 
+uses 
+  DUnitX.TestFramework; 
+ 
+type 
+  [TestFixture('Equilateral')] 
+  EquilateralTests = class(TObject) 
+  public 
+    [Test] 
+//  [Ignore('Comment the "[Ignore]" statement to run the test')]
+    procedure True_if_all_sides_are_equal; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure False_if_any_side_is_unequal; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure False_if_no_sides_are_equal; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure All_zero_sides_are_illegal_so_the_triangle_is_not_equilateral; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure Sides_may_be_floats; 
+  end; 
+ 
+  [TestFixture('Isosceles')] 
+  IsoscelesTests = class(TObject) 
+  public 
+    [Test] 
+    [Ignore] 
+    procedure True_if_last_two_sides_are_equal; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure True_if_first_two_sides_are_equal; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure True_if_first_and_last_sides_are_equal; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure Equilateral_triangles_are_also_isosceles; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure False_if_no_sides_are_equal; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure Sides_that_violate_triangle_inequality_are_not_isosceles_even_if_two_are_equal; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure Sides_may_be_floats; 
+  end; 
+ 
+  [TestFixture('Scalene')] 
+  ScaleneTests = class(TObject) 
+  public 
+    [Test] 
+    [Ignore] 
+    procedure True_if_no_sides_are_equal; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure False_if_all_sides_are_equal; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure False_if_two_sides_are_equal; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure Sides_that_violate_triangle_inequality_are_not_scalene_even_if_they_are_all_different; 
+ 
+    [Test] 
+    [Ignore] 
+    procedure Sides_may_be_floats; 
+  end; 
+ 
+implementation 
+uses uTriangle; 
+ 
+{$region 'EquilateralTests'} 
+procedure EquilateralTests.True_if_all_sides_are_equal; 
+begin 
+  Assert.AreEqual(true, Triangle.Sides(Equilateral, 2, 2, 2)); 
+end; 
+ 
+procedure EquilateralTests.False_if_any_side_is_unequal; 
+begin 
+  Assert.AreEqual(false, Triangle.Sides(Equilateral, 2, 3, 2)); 
+end; 
+ 
+procedure EquilateralTests.False_if_no_sides_are_equal; 
+begin 
+  Assert.AreEqual(false, Triangle.Sides(Equilateral, 5, 4, 6)); 
+end; 
+ 
+procedure EquilateralTests.All_zero_sides_are_illegal_so_the_triangle_is_not_equilateral; 
+begin 
+  Assert.AreEqual(false, Triangle.Sides(Equilateral, 0, 0, 0)); 
+end; 
+ 
+procedure EquilateralTests.Sides_may_be_floats; 
+begin 
+  Assert.AreEqual(true, Triangle.Sides(Equilateral, 0.5, 0.5, 0.5)); 
+end; 
+{$endregion} 
+ 
+{$region'IsoscelesTests'} 
+procedure IsoscelesTests.True_if_last_two_sides_are_equal; 
+begin 
+  Assert.AreEqual(true, Triangle.Sides(Isosceles, 3, 4, 4)); 
+end; 
+ 
+procedure IsoscelesTests.True_if_first_two_sides_are_equal; 
+begin 
+  Assert.AreEqual(true, Triangle.Sides(Isosceles, 4, 4, 3)); 
+end; 
+ 
+procedure IsoscelesTests.True_if_first_and_last_sides_are_equal; 
+begin 
+  Assert.AreEqual(true, Triangle.Sides(Isosceles, 4, 3, 4)); 
+end; 
+ 
+procedure IsoscelesTests.Equilateral_triangles_are_also_isosceles; 
+begin 
+  Assert.AreEqual(true, Triangle.Sides(Isosceles, 4, 4, 4)); 
+end; 
+ 
+procedure IsoscelesTests.False_if_no_sides_are_equal; 
+begin 
+  Assert.AreEqual(false, Triangle.Sides(Isosceles, 2, 3, 4)); 
+end; 
+ 
+procedure IsoscelesTests.Sides_that_violate_triangle_inequality_are_not_isosceles_even_if_two_are_equal; 
+begin 
+  Assert.AreEqual(false, Triangle.Sides(Isosceles, 1, 1, 3)); 
+end; 
+ 
+procedure IsoscelesTests.Sides_may_be_floats; 
+begin 
+  Assert.AreEqual(true, Triangle.Sides(Isosceles, 0.5, 0.4, 0.5)); 
+end; 
+{$endregion} 
+ 
+{$region 'ScaleneTests'} 
+procedure ScaleneTests.True_if_no_sides_are_equal; 
+begin 
+  Assert.AreEqual(true, Triangle.Sides(Scalene, 5, 4, 6)); 
+end; 
+ 
+procedure ScaleneTests.False_if_all_sides_are_equal; 
+begin 
+  Assert.AreEqual(false, Triangle.Sides(Scalene, 4, 4, 4)); 
+end; 
+ 
+procedure ScaleneTests.False_if_two_sides_are_equal; 
+begin 
+  Assert.AreEqual(false, Triangle.Sides(Scalene, 4, 4, 3)); 
+end; 
+ 
+procedure ScaleneTests.Sides_that_violate_triangle_inequality_are_not_scalene_even_if_they_are_all_different; 
+begin 
+  Assert.AreEqual(false, Triangle.Sides(Scalene, 7, 3, 2)); 
+end; 
+ 
+procedure ScaleneTests.Sides_may_be_floats; 
+begin 
+  Assert.AreEqual(true, Triangle.Sides(Scalene, 0.5, 0.4, 0.6)); 
+end; 
+{$endregion} 
+ 
+initialization 
+  TDUnitX.RegisterTestFixture(EquilateralTests); 
+  TDUnitX.RegisterTestFixture(IsoscelesTests); 
+  TDUnitX.RegisterTestFixture(ScaleneTests); 
+end. 

data/tracks/delphi/exercises/triangle/uTriangleExample.pas

@@ -0,0 +1,64 @@
+unit uTriangle; 
+ 
+interface 
+ 
+type 
+  TriangleKind = (Equilateral, Isosceles, Scalene); 
+ 
+  Triangle = class 
+  private 
+    class function AllSidesAreZero(aSide1, aSide2, aSide3: double): boolean; static; 
+    class function HasImpossibleSides(aSide1, aSide2, aSide3: double): boolean; static; 
+    class function ViolatesTriangleInequality(aSide1, aSide2, aSide3: double): boolean; static; 
+    class function UniqueSides(aSide1, aSide2, aSide3: double): integer; static; 
+  public 
+    class function Sides(aIsKind: TriangleKind; aSide1, aSide2, aSide3: double): boolean; static; 
+  end; 
+ 
+implementation 
+uses System.SysUtils; 
+ 
+class function Triangle.AllSidesAreZero(aSide1, aSide2, aSide3: double): boolean; 
+begin 
+  result := (aSide1 = 0) and (aSide2 = 0) and (aSide3 = 0); 
+end; 
+ 
+class function Triangle.HasImpossibleSides(aSide1, aSide2, aSide3: double): boolean; 
+begin 
+  result := (aSide1 < 0) or (aSide2 < 0) or (aSide3 < 0); 
+end; 
+ 
+class function Triangle.ViolatesTriangleInequality(aSide1, aSide2, aSide3: double): boolean; 
+begin 
+  result := (aSide1 + aSide2 <= aSide3) or (aSide1 + aSide3 <= aSide2) or (aSide2 + aSide3 <= aSide1); 
+end; 
+ 
+class function Triangle.UniqueSides(aSide1, aSide2, aSide3: double): integer; 
+begin 
+  result := 1; 
+  if (aSide1 <> aSide2) and (aSide1 <> aSide3) then 
+    inc(result); 
+  if (aSide2 <> aSide1) and (aSide2 <> aSide3) then 
+    inc(result); 
+  if (aSide3 <> aSide2) and (aSide3 <> aSide1) then 
+    inc(result); 
+  if result > 3 then 
+    result := 3; 
+end; 
+ 
+class function Triangle.Sides(aIsKind: TriangleKind; aSide1, aSide2, aSide3: double): boolean; 
+var luniqueSides: integer; 
+begin 
+  result := false; 
+  if not (AllSidesAreZero(aSide1, aSide2, aSide3) or 
+          ViolatesTriangleInequality(aSide1, aSide2, aSide3) or 
+          HasImpossibleSides(aSide1, aSide2, aSide3)) then 
+  begin 
+    luniqueSides := UniqueSides(aSide1, aSide2, aSide3); 
+    result := ((luniqueSides = 1) and (aIsKind in [Equilateral, Isosceles])) or 
+              ((luniqueSides = 2) and (aIsKind = Isosceles)) or 
+              ((aIsKind = Scalene) and (luniqueSides = 3)); 
+  end; 
+end; 
+ 
+end. 

data/tracks/go/exercises/poker/poker_test.go

@@ -281,6 +281,12 @@ var invalidTestCases = []struct {
 	},
 }
 
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
 func TestBestHandValid(t *testing.T) {
 	for _, tt := range validTestCases {
 		actual, err := BestHand(tt.hands)
@@ -304,12 +310,6 @@ func TestBestHandInvalid(t *testing.T) {
 	}
 }
 
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
-	}
-}
-
 func BenchmarkBestHand(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		for _, tt := range validTestCases {

data/tracks/java/exercises/atbash-cipher/src/test/java/AtbashTest.java

@@ -53,7 +53,8 @@ public class AtbashTest {
             return Arrays.asList(new Object[][] {
                     { "vcvix rhn", "exercism" },
                     { "zmlyh gzxov rhlug vmzhg vkkrm thglm v", "anobstacleisoftenasteppingstone" },
-                    { "gvhgr mt123 gvhgr mt", "testing123testing" }
+                    { "gvhgr mt123 gvhgr mt", "testing123testing" },
+                    { "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt", "thequickbrownfoxjumpsoverthelazydog" }
             });
         }
 

data/tracks/scala/config.json

@@ -700,6 +700,16 @@
             "Control-flow (if-else statements)",
             "Lists"
          ]
+      },
+      {
+         "slug":"variable-length-quantity",
+         "difficulty":1,
+         "topics":[
+            "Discriminated unions",
+            "Lists",
+            "Algorithms",
+            "Bitwise operations"
+         ]
       }
    ],
    "deprecated":[

data/tracks/scala/exercises/variable-length-quantity/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+Remember that in Scala there are two forms of the right shift operator. The `>>` operator preserves the sign, while `>>>` zeroes the leftmost bits.

data/tracks/scala/exercises/variable-length-quantity/build.sbt

@@ -0,0 +1,3 @@
+scalaVersion := "2.12.1"
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/variable-length-quantity/example.scala

@@ -0,0 +1,56 @@
+import scala.annotation.tailrec
+
+object VariableLengthQuantity {
+  private val sevenBitsMask = 0x7f
+  private val eightBitMask = 0x80
+
+  def encode(n: Int): List[Int] = {
+    @tailrec
+    def encode_internal(n: Int, acc: List[Int]): List[Int] = {
+      if (n == 0) {
+        acc
+      } else {
+        var tmp = n & sevenBitsMask
+        if (acc.nonEmpty) {
+          tmp = tmp | eightBitMask
+        }
+
+        encode_internal(n >>> 7, tmp :: acc)
+      }
+    }
+
+    if (n == 0)
+      List(0)
+    else
+      encode_internal(n, List())
+  }
+
+  def encode(nums: List[Int]): List[Int] = {
+    nums.foldRight(List[Int]())((n, acc) => encode(n) ::: acc)
+  }
+
+  def decode(encoded: List[Int]): Either[String, List[Int]] = {
+    @tailrec
+    def decode_internal(encoded: List[Int], tmp: Int, acc: List[Int]): Either[String, List[Int]] = {
+      encoded match {
+        case Nil => if (tmp == 0 && acc.nonEmpty)
+          Right(acc.reverse)
+        else
+          Left("Incomplete sequence")
+        case x::xs =>
+          if ((tmp & 0xfe000000) > 0) {
+            Left("Overflow")
+          } else {
+            val newTmp = (tmp << 7) | (x & sevenBitsMask)
+            if ((x & eightBitMask) == 0) {
+              decode_internal(xs, 0, newTmp :: acc)
+            } else {
+              decode_internal(xs, newTmp, acc)
+            }
+          }
+      }
+    }
+
+    decode_internal(encoded, 0, List())
+  }
+}

data/tracks/scala/exercises/variable-length-quantity/src/test/scala/VariableLengthQuantityTest.scala

@@ -0,0 +1,162 @@
+import org.scalatest.{FunSuite, Matchers}
+
+class VariableLengthQuantityTest extends FunSuite with Matchers {
+
+  // Encode a series of integers, producing a series of bytes.
+  test("encode: zero") {
+    val encoded = VariableLengthQuantity.encode(List(0x0))
+    encoded should be (List(0x0))
+  }
+
+  test("encode: arbitrary single byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x40))
+    encoded should be (List(0x40))
+  }
+
+  test("encode: largest single byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x7f))
+    encoded should be (List(0x7f))
+  }
+
+  test("encode: smallest double byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x80))
+    encoded should be (List(0x81, 0x0))
+  }
+
+  test("encode: arbitrary double byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x2000))
+    encoded should be (List(0xc0, 0x0))
+  }
+
+  test("encode: largest double byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x3fff))
+    encoded should be (List(0xff, 0x7f))
+  }
+
+  test("encode: smallest triple byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x4000))
+    encoded should be (List(0x81, 0x80, 0x0))
+  }
+
+  test("encode: arbitrary triple byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x100000))
+    encoded should be (List(0xc0, 0x80, 0x0))
+  }
+
+  test("encode: largest triple byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x1fffff))
+    encoded should be (List(0xff, 0xff, 0x7f))
+  }
+
+  test("encode: smallest quadruple byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x200000))
+    encoded should be (List(0x81, 0x80, 0x80, 0x0))
+  }
+
+  test("encode: arbitrary quadruple byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x8000000))
+    encoded should be (List(0xc0, 0x80, 0x80, 0x0))
+  }
+
+  test("encode: largest quadruple byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0xfffffff))
+    encoded should be (List(0xff, 0xff, 0xff, 0x7f))
+  }
+
+  test("encode: smallest quintuple byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x10000000))
+    encoded should be (List(0x81, 0x80, 0x80, 0x80, 0x0))
+  }
+
+  test("encode: arbitrary quintuple byte") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0xff000000))
+    encoded should be (List(0x8f, 0xf8, 0x80, 0x80, 0x0))
+  }
+
+  test("encode: maximum 32-bit integer input") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0xffffffff))
+    encoded should be (List(0x8f, 0xff, 0xff, 0xff, 0x7f))
+  }
+
+  test("encode: two single-byte values") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x40, 0x7f))
+    encoded should be (List(0x40, 0x7f))
+  }
+
+  test("encode: two multi-byte values") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x4000, 0x123456))
+    encoded should be (List(0x81, 0x80, 0x0, 0xc8, 0xe8, 0x56))
+  }
+
+  test("encode: many multi-byte values") {
+    pending
+    val encoded = VariableLengthQuantity.encode(List(0x2000, 0x123456, 0xfffffff, 0x0, 0x3fff, 0x4000))
+    encoded should be (List(0xc0, 0x0, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f, 0x0, 0xff, 0x7f, 0x81, 0x80, 0x0))
+  }
+
+  // Decode a series of bytes, producing a series of integers.
+  test("decode: one byte") {
+    pending
+    val decoded = VariableLengthQuantity.decode(List(0x7f))
+    decoded should be (Right(List(0x7f)))
+  }
+
+  test("decode: two bytes") {
+    pending
+    val decoded = VariableLengthQuantity.decode(List(0xc0, 0x0))
+    decoded should be (Right(List(0x2000)))
+  }
+
+  test("decode: three bytes") {
+    pending
+    val decoded = VariableLengthQuantity.decode(List(0xff, 0xff, 0x7f))
+    decoded should be (Right(List(0x1fffff)))
+  }
+
+  test("decode: four bytes") {
+    pending
+    val decoded = VariableLengthQuantity.decode(List(0x81, 0x80, 0x80, 0x0))
+    decoded should be (Right(List(0x200000)))
+  }
+
+  test("decode: maximum 32-bit integer") {
+    pending
+    val decoded = VariableLengthQuantity.decode(List(0x8f, 0xff, 0xff, 0xff, 0x7f))
+    decoded should be (Right(List(0xffffffff)))
+  }
+
+  test("decode: incomplete sequence causes error") {
+    pending
+    val decoded = VariableLengthQuantity.decode(List(0xff))
+    decoded.isLeft should be (true)
+  }
+
+  test("decode: incomplete sequence causes error, even if value is zero") {
+    pending
+    val decoded = VariableLengthQuantity.decode(List(0x80))
+    decoded.isLeft should be (true)
+  }
+
+  test("decode: multiple values") {
+    pending
+    val decoded = VariableLengthQuantity.decode(List(0xc0, 0x0, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f, 0x0, 0xff, 0x7f, 0x81, 0x80, 0x0))
+    decoded should be (Right(List(0x2000, 0x123456, 0xfffffff, 0x0, 0x3fff, 0x4000)))
+  }
+
+}