trackler 2.0.6.6 → 2.0.6.7

data/tracks/haskell/exercises/grade-school/HINTS.md

@@ -8,6 +8,6 @@ and implement the following functions:
 - `grade`
 - `sorted`
 
-You will find a dummy data declaration already in place, but it is up to you to
-define the functions and create a meaningful data type, newtype or type
-synonym.
+You will find a dummy data declaration and type signatures already in
+place, but it is up to you to define the functions and create a meaningful
+data type, newtype or type synonym.

data/tracks/haskell/exercises/grade-school/src/School.hs

@@ -2,10 +2,14 @@ module School (School, add, empty, grade, sorted) where
 
 data School = Dummy
 
-add = undefined
+add :: Int -> String -> School -> School
+add gradeNum student school = undefined
 
+empty :: School
 empty = undefined
 
-grade = undefined
+grade :: Int -> School -> [String]
+grade gradeNum school = undefined
 
-sorted = undefined
+sorted :: School -> [(Int, [String])]
+sorted school = undefined

data/tracks/haskell/exercises/meetup/HINTS.md

@@ -1,8 +1,6 @@
 ## Hints
 
-To complete this exercise, you need to create the data types `Weekday`
-and `Schedule`, and implement the function `meetupDay`.
+To complete this exercise, you need to implement the `meetupDay` function.
 
-You will find the type signature for `meetupDay` and dummy data declarations
-already in place, but it is up to you to define the function and create
-meaningful data types, newtypes or type synonyms.
+You will find the type signature for `meetupDay` already in place,
+but it is up to you to define the function.

data/tracks/haskell/exercises/meetup/src/Meetup.hs

@@ -2,8 +2,20 @@ module Meetup (Weekday(..), Schedule(..), meetupDay) where
 
 import Data.Time.Calendar (Day)
 
-data Schedule = Dummy
-data Weekday = Dummy2
+data Weekday = Monday
+             | Tuesday
+             | Wednesday
+             | Thursday
+             | Friday
+             | Saturday
+             | Sunday
+
+data Schedule = First
+              | Second
+              | Third
+              | Fourth
+              | Last
+              | Teenth
 
 meetupDay :: Schedule -> Weekday -> Integer -> Int -> Day
 meetupDay schedule weekday year month = undefined

data/tracks/haskell/exercises/space-age/HINTS.md

@@ -1,8 +1,9 @@
 ## Hints
 
-In this exercise, you need to complete the definition of the
+In this exercise, we provided the definition of the
 [algebric data data](http://learnyouahaskell.com/making-our-own-types-and-typeclasses)
-named `Planet`, and implement the `ageOn` function, that calculates how many
+named `Planet`.
+You need to implement the `ageOn` function, that calculates how many
 years old someone would be on a `Planet`, given an age in seconds.
 
 Your can use the provided signature if you are unsure about the types, but
@@ -11,6 +12,3 @@ don't let it restrict your creativity:
 ```haskell
 ageOn :: Planet -> Float -> Float
 ```
-
-Keep in mind that the test suite will not compile until you correctly
-implement the data type `Planet`.

data/tracks/haskell/exercises/space-age/src/SpaceAge.hs

@@ -1,6 +1,13 @@
 module SpaceAge (Planet(..), ageOn) where
 
-data Planet
+data Planet = Mercury
+            | Venus
+            | Earth
+            | Mars
+            | Jupiter
+            | Saturn
+            | Uranus
+            | Neptune
 
 ageOn :: Planet -> Float -> Float
 ageOn planet seconds = undefined

data/tracks/java/config.json

@@ -53,7 +53,8 @@
     "all-your-base",
     "custom-set",
     "wordy",
-    "palindrome-products"
+    "palindrome-products",
+    "sublist"
   ],
   "exercises": [
     {
@@ -305,6 +306,11 @@
       "slug": "palindrome-products",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "sublist",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

data/tracks/java/exercises/settings.gradle

@@ -44,6 +44,7 @@ include 'series'
 include 'sieve'
 include 'simple-cipher'
 include 'simple-linked-list'
+include 'sublist'
 include 'sum-of-multiples'
 include 'space-age'
 include 'strain'

data/tracks/java/exercises/sublist/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

data/tracks/java/exercises/sublist/src/example/java/Relationship.java

@@ -0,0 +1 @@
+tracks/java/exercises/sublist/src/example/java/../../main/java/Relationship.java

data/tracks/java/exercises/sublist/src/example/java/RelationshipComputer.java

@@ -0,0 +1,29 @@
+import java.util.List;
+
+final class RelationshipComputer<T extends Comparable> {
+
+    Relationship computeRelationship(final List<T> firstList, final List<T> secondList) {
+        if (firstList.equals(secondList))          return Relationship.EQUAL;
+        if (checkIfSublist(firstList, secondList)) return Relationship.SUBLIST;
+        if (checkIfSublist(secondList, firstList)) return Relationship.SUPERLIST;
+        return Relationship.UNEQUAL;
+    }
+
+    private boolean checkIfSublist(final List<T> firstList, final List<T> secondList) {
+        final int firstListSize = firstList.size();
+        final int secondListSize = secondList.size();
+
+        if (firstListSize > secondListSize) return false;
+
+        final int numberOfSublistCandidates = secondListSize - firstListSize + 1;
+
+        for (int startIndex = 0; startIndex < numberOfSublistCandidates; startIndex++) {
+            if (secondList.subList(startIndex, startIndex + firstListSize).equals(firstList)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+}

data/tracks/java/exercises/sublist/src/main/java/Relationship.java

@@ -0,0 +1,5 @@
+enum Relationship {
+
+    EQUAL, SUBLIST, SUPERLIST, UNEQUAL
+
+}

data/tracks/java/exercises/sublist/src/main/java/RelationshipComputer.java

@@ -0,0 +1,5 @@
+final class RelationshipComputer<T extends Comparable> {
+
+
+
+}

data/tracks/java/exercises/sublist/src/test/java/RelationshipComputerTest.java

@@ -0,0 +1,183 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static org.junit.Assert.assertEquals;
+
+public class RelationshipComputerTest {
+
+    @Test
+    public void testThatTwoEmptyListsAreConsideredEqual() {
+        Relationship computedRelationship = new RelationshipComputer<>().computeRelationship(
+                emptyList(),
+                emptyList());
+
+        assertEquals(Relationship.EQUAL, computedRelationship);
+    }
+
+    @Ignore
+    @Test
+    public void testEmptyListIsSublistOfNonEmptyList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                emptyList(),
+                asList(1, 2, 3));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testNonEmptyListIsSuperlistOfEmptyList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('1', '2', '3'),
+                emptyList());
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testListIsEqualToItself() {
+        List<String> anyList = asList("1", "2", "3");
+
+        Relationship relationship = new RelationshipComputer<String>().computeRelationship(
+                anyList,
+                anyList);
+
+        assertEquals(Relationship.EQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testDifferentListsOfTheSameLengthAreUnequal() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(1, 2, 3),
+                asList(2, 3, 4));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistCheckDoesNotAbortAfterFalseStart() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('1', '2', '5'),
+                asList('0', '1', '2', '3', '1', '2', '5', '6'));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistCheckHandlesExtraneousRepeatsOfFirstEntry() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("1", "1", "2"),
+                asList("0", "1", "1", "1", "2", "1", "2"));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistAtStart() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(0, 1, 2),
+                asList(0, 1, 2, 3, 4, 5));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistInMiddle() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('2', '3', '4'),
+                asList('0', '1', '2', '3', '4', '5'));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistAtEnd() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("3", "4", "5"),
+                asList("0", "1", "2", "3", "4", "5"));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testAtStartOfSuperlist() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(0, 1, 2, 3, 4, 5),
+                asList(0, 1, 2));
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testInMiddleOfSuperlist() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('0', '1', '2', '3', '4', '5'),
+                asList('2', '3'));
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testAtEndOfSuperlist() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("0", "1", "2", "3", "4", "5"),
+                asList("3", "4", "5"));
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testFirstListMissingElementFromSecondList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(1, 3),
+                asList(1, 2, 3));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSecondListMissingElementFromFirstList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('1', '2', '3'),
+                asList('1', '3'));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testThatListOrderingIsAccountedFor() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("1", "2", "3"),
+                asList("3", "2", "1"));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testThatListsWithSameDigitsButDifferentNumbersAreUnequal() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(1, 0, 1),
+                asList(10, 1));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+}

data/tracks/lua/exercises/run-length-encoding/example.lua

@@ -13,7 +13,7 @@ return {
 
   decode = function(s)
     local result = ''
-    for length, c in s:gmatch('(%d?)(.)') do
+    for length, c in s:gmatch('(%d*)(.)') do
       if length == '' then length = 1 end
       result = result .. c:rep(length)
     end

data/tracks/lua/exercises/run-length-encoding/run-length-encoding_spec.lua

@@ -5,10 +5,18 @@ describe('run-length-encoding', function()
     assert.equal('2A3B4C', rle.encode('AABBBCCCC'))
   end)
 
+  it('should encode strings with multi-digit run lengths', function()
+    assert.equal('2A10B4C', rle.encode('AABBBBBBBBBBCCCC'))
+  end)
+
   it('should decode simple strings', function()
     assert.equal('AABBBCCCC', rle.decode('2A3B4C'))
   end)
 
+  it('should decode strings with multi-digit run lengths', function()
+    assert.equal('AABBBBBBBBBBCCCC', rle.decode('2A10B4C'))
+  end)
+
   it('should not encode characters with a run length of 1', function()
     assert.equal('2AB4CD', rle.encode('AABCCCCD'))
   end)

data/tracks/lua/exercises/sublist/sublist_spec.lua

@@ -13,6 +13,10 @@ describe('sublist', function()
     assert.equal(true, is_sublist({ 1, 2, 3 }, { 1, 2, 3 }))
   end)
 
+  it('should not consider a subset to be a sublist', function()
+    assert.equal(false, is_sublist({ 1, 2, 3 }, { 2, 1, 3 }))
+  end)
+
   it('should find a sublist at the beginning of a list', function()
     assert.equal(true, is_sublist({ 11, 22, 33 }, { 11, 22, 33, 44, 55 }))
   end)

data/tracks/rust/problem_ordering.md

@@ -0,0 +1,41 @@
+# Rust Track Problem Order
+
+The actual source of truth of problem order and topics is [config.json](config.json), but this file documents our reasoning behind the problem order in that file.
+
+## Background
+
+- https://github.com/exercism/xrust/issues/126
+- https://github.com/exercism/xrust/issues/127
+- http://designisrefactoring.com/2016/07/09/exercism-shouldnt-make-you-cry/
+
+## Our Approach
+
+We order our problems for students who are learning Rust. With that audience in mind, we follow two rules when adding new problems.
+
+- A exercise should introduce one new concept
+- Exercises should progress from Rust basics to advanced Rust concepts
+
+### One New Concept
+
+If a problem solution requires students to use both `Result` and `HashMap`, then at least one of these concepts should be introduced by an earlier problem.
+
+If the track has several problems that rely on a concept, group them together to reinforce learning.
+
+### Progress Through Rust
+
+#### Early Problems
+
+Early problems should focus on Rust syntax and concepts that are present in many programming languages: conditionals, looping, higher-order-functions.
+
+#### Middle Problems
+
+Problems in the middle of the of the track should introduce concepts that are less common. `Result` and `Option` and Traits, for example. Or syntax such as `while let`.
+
+Through the middle section of the track students should gain familiarity with a wide range of Rust concepts.
+
+#### Later Problems
+
+Problems late in the track should do one of two things:
+
+1. Introduce advanced concepts -- Lifetimes, Concurrency, Unsafety
+2. Require a complex solution that synthesizes all the knowledge students have gained to date

data/tracks/scala/config.json

@@ -367,12 +367,20 @@
       "slug": "saddle-points",
       "difficulty": 1,
       "topics": [
+        "Matrices",
+        "Lists",
+        "Sets",
+        "Tuples"
       ]
 		},
     {
       "slug": "say",
       "difficulty": 1,
       "topics": [
+        "Strings",
+        "Transforming",
+        "Text formatting",
+        "Optional values"
       ]
 		},
     {
@@ -385,12 +393,18 @@
       "slug": "secret-handshake",
       "difficulty": 1,
       "topics": [
+         "Lists",
+         "Strings",
+         "Bitwise operations"
       ]
 		},
     {
       "slug": "series",
       "difficulty": 1,
       "topics": [
+        "Strings",
+        "Sequences",
+        "Transforming"
       ]
 		},
     {

data/tracks/scala/exercises/saddle-points/build.sbt

@@ -1,3 +1,3 @@
-scalaVersion := "2.11.7"
+scalaVersion := "2.12.1"
 
-libraryDependencies += "org.scalatest" % "scalatest_2.11" % "2.2.5" % "test"
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/say/build.sbt

@@ -1,3 +1,3 @@
-scalaVersion := "2.11.7"
+scalaVersion := "2.12.1"
 
-libraryDependencies += "org.scalatest" % "scalatest_2.11" % "2.2.5" % "test"
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/secret-handshake/build.sbt

@@ -1,3 +1,3 @@
-scalaVersion := "2.11.7"
+scalaVersion := "2.12.1"
 
-libraryDependencies += "org.scalatest" % "scalatest_2.11" % "2.2.5" % "test"
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/series/build.sbt

@@ -1,3 +1,4 @@
-scalaVersion := "2.11.7"
+scalaVersion := "2.12.1"
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"
 
-libraryDependencies += "org.scalatest" % "scalatest_2.11" % "2.2.5" % "test"

data/tracks/scheme/config.json

@@ -3,20 +3,73 @@
   "language": "Scheme",
   "repository": "https://github.com/exercism/xscheme",
   "active": true,
-  "problems": [
-      "hello-world",
-      "hamming",
-      "leap",
-      "grains",
-      "bob",
-      "raindrops",
-      "rna-transcription",
-      "robot-name",
-      "phone-number",
-      "anagram",
-      "nucleotide-count",
-      "difference-of-squares",
-      "list-ops"
+  "exercises" : [
+    {
+      "slug": "hello-world",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "hamming",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "leap",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "grains",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "bob",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "raindrops",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "rna-transcription",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "robot-name",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "phone-number",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "anagram",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "nucleotide-count",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "difference-of-squares",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "list-ops",
+      "difficulty": 1,
+      "topics": []
+    }
+
   ],
   "deprecated": [