trackler 2.1.0.36 → 2.1.0.37

data/tracks/elisp/config.json

@@ -5,10 +5,6 @@
   "active": true,
   "deprecated": [
 
-  ],
-  "ignored": [
-    "docs",
-    "bin"
   ],
   "foregone": [
 
@@ -17,102 +13,142 @@
     {
       "difficulty": 1,
       "slug": "hello-world",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "bob",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "difference-of-squares",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "gigasecond",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "hamming",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "anagram",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "binary",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "leap",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "allergies",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "robot-name",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "rna-transcription",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "atbash-cipher",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "raindrops",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "roman-numerals",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "perfect-numbers",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "etl",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "word-count",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "nucleotide-count",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "difficulty": 1,
       "slug": "phone-number",
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "grains",
       "difficulty": 1,
-      "topics": []
+      "topics": [
+
+      ]
     }
   ]
 }

data/tracks/elixir/exercises/poker/poker_test.exs

@@ -142,7 +142,7 @@ defmodule PokerTest do
   end
 
   @tag :pending
-  test "straight beats a flush" do
+  test "flush beats a straight" do
     straight_to_8 = ~w(4C 6H 7D 8D 5H)
     flush_to_7 = ~w(2S 4S 5S 6S 7S)
     assert Poker.best_hand([straight_to_8, flush_to_7]) == [flush_to_7]

data/tracks/fortran/config.json

@@ -41,6 +41,12 @@
       "difficulty": 1,
       "topics": [
       ]
+  },
+  {
+      "slug": "pangram",
+      "difficulty": 1,
+      "topics": [
+      ]
   }
   ],
   "deprecated": [

data/tracks/fortran/exercises/pangram/example.f90

@@ -0,0 +1,33 @@
+module pangram
+contains
+  logical function is_pangram(sentance)
+    implicit none
+    character(*) :: sentance
+    logical :: seen(26)
+    integer :: i,val
+
+    seen = .false.
+
+    do i = 1,len(sentance)
+      val = to_index(sentance(i:i))
+      if ( val .ne. 0 ) then
+        seen(val:val) = .true.
+      end if
+    end do
+
+    is_pangram = all(seen)
+   end function is_pangram
+
+   integer function to_index(chr)
+       implicit none
+       character :: chr
+
+       if ((chr .ge. 'a' ) .and. (chr .le. 'z')) then
+         to_index = ichar('z') - ichar(chr) + 1
+       else if ((chr .ge. 'A' ) .and. (chr .le. 'Z')) then
+         to_index = ichar('Z') - ichar(chr) + 1
+       else
+         to_index = 0
+       end if
+   end function to_index
+end module pangram

data/tracks/fortran/exercises/pangram/pangram.fun

@@ -0,0 +1,42 @@
+test_suite pangram
+
+setup
+end setup
+
+test sentance_empty
+  assert_false( is_pangram('') )
+end test
+
+Xtest pangram_with_only_lower_case
+  assert_true( is_pangram('the quick brown fox jumps over the lazy dog') )
+end test
+
+Xtest missing_character_x
+  assert_false( is_pangram('a quick movement of the enemy will jeopordize five gunboats') )
+end test
+
+Xtest missing_another_character_x
+  assert_false( is_pangram('the quick brown fish jumps over the lazy dog') )
+end test
+
+Xtest panagram_with_underscores
+  assert_true( is_pangram('the_quick_brown_fox_jumps_over_the_lazy_dog') )
+end test
+
+Xtest panagram_with_numbers
+  assert_true( is_pangram('the 1 quick brown fox jumps over the 2 lazy dogs') )
+end test
+
+Xtest pangram_missing_letters_replaced_by_numbers
+  assert_false( is_pangram('7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog') )
+end test
+
+Xtest pangram_with_mixed_case_and_punctuation
+  assert_true( is_pangram('""Five quacking Zephyrs jolt my wax bed.""') )
+end test
+
+Xtest upper_and_lower_case_versions_of_the_same_character
+  assert_false( is_pangram('the quick brown fox jumped over the lazy FOX') )
+end test
+
+end test_suite

data/tracks/go/config.json

@@ -229,14 +229,20 @@
       ]
     },
     {
-      "difficulty": 1,
+      "difficulty": 5,
       "slug": "pythagorean-triplet",
-      "topics": []
+      "topics": [
+	"Algorithms",
+	"Mathematics"
+      ]
     },
     {
-      "difficulty": 1,
+      "difficulty": 3,
       "slug": "isogram",
-      "topics": []
+      "topics": [
+	"Strings",
+	"Sequences"
+      ]
     },
     {
       "difficulty": 1,

data/tracks/go/exercises/acronym/acronym.go

@@ -1,5 +1,5 @@
 package acronym
 
-const testVersion = 2
+const testVersion = 3
 
 func Abbreviate(string) string

data/tracks/haskell/config.json

@@ -289,7 +289,7 @@
       "slug": "bracket-push",
       "difficulty": 5,
       "topics": [
-          "Stack"
+        "Stack"
       ]
     },
     {

data/tracks/java/bin/journey-test.sh

@@ -236,6 +236,9 @@ solve_all_exercises() {
     "$EXECPATH"/gradlew compileTestJava
     # Ensure we run all the tests (as delivered, all but the first is @Ignore'd)
     for testfile in `find . -name "*Test.${TRACK_SRC_EXT}"`; do
+      # Strip @Ignore annotations to ensure we run the tests (as delivered, all but the first is @Ignore'd).
+      # Note that unit-test.sh also strips @Ignore annotations via the Gradle task copyTestsFilteringIgnores.
+      # The stripping implementations here and in copyTestsFilteringIgnores should be kept consistent.
       sed 's/@Ignore\(\(.*\)\)\{0,1\}//' ${testfile} > "${tempfile}" && mv "${tempfile}" "${testfile}"
     done
     "$EXECPATH"/gradlew test

data/tracks/java/config.json

@@ -137,6 +137,13 @@
 
       ]
     },
+    {
+      "slug": "kindergarten-garden",
+      "difficulty": 4,
+      "topics": [
+
+      ]
+    },
     {
       "slug": "collatz-conjecture",
       "difficulty": 4,
@@ -207,6 +214,13 @@
 
       ]
     },
+    {
+      "slug": "run-length-encoding",
+      "difficulty": 5,
+      "topics": [
+
+      ]
+    },
     {
       "slug": "robot-name",
       "difficulty": 5,
@@ -457,20 +471,6 @@
       "difficulty": 1,
       "topics": [
 
-      ]
-    },
-    {
-      "slug": "run-length-encoding",
-      "difficulty": 1,
-      "topics": [
-
-      ]
-    },
-    {
-      "slug": "kindergarten-garden",
-      "difficulty": 1,
-      "topics": [
-
       ]
     }
   ],

data/tracks/java/exercises/binary-search/src/test/java/BinarySearchTest.java

@@ -15,9 +15,9 @@ public class BinarySearchTest {
     public void findsAValueInAnArrayWithOneElement() {
         List<Integer> listOfUnitLength = Collections.singletonList(6);
 
-        BinarySearch<Integer> sut = new BinarySearch<>(listOfUnitLength);
+        BinarySearch<Integer> search = new BinarySearch<>(listOfUnitLength);
 
-        assertEquals(0, sut.indexOf(6));
+        assertEquals(0, search.indexOf(6));
     }
 
     @Ignore("Remove to run test")
@@ -27,9 +27,9 @@ public class BinarySearchTest {
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(3, sut.indexOf(6));
+        assertEquals(3, search.indexOf(6));
     }
 
     @Ignore("Remove to run test")
@@ -39,9 +39,9 @@ public class BinarySearchTest {
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(0, sut.indexOf(1));
+        assertEquals(0, search.indexOf(1));
     }
 
     @Ignore("Remove to run test")
@@ -51,9 +51,9 @@ public class BinarySearchTest {
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(6, sut.indexOf(11));
+        assertEquals(6, search.indexOf(11));
     }
 
     @Ignore("Remove to run test")
@@ -63,9 +63,9 @@ public class BinarySearchTest {
                 Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedListOfOddLength);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedListOfOddLength);
 
-        assertEquals(9, sut.indexOf(144));
+        assertEquals(9, search.indexOf(144));
     }
 
     @Ignore("Remove to run test")
@@ -75,9 +75,9 @@ public class BinarySearchTest {
                 Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedListOfEvenLength);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedListOfEvenLength);
 
-        assertEquals(5, sut.indexOf(21));
+        assertEquals(5, search.indexOf(21));
     }
 
     @Ignore("Remove to run test")
@@ -87,9 +87,9 @@ public class BinarySearchTest {
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(-1, sut.indexOf(7));
+        assertEquals(-1, search.indexOf(7));
     }
 
     @Ignore("Remove to run test")
@@ -99,9 +99,9 @@ public class BinarySearchTest {
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(-1, sut.indexOf(0));
+        assertEquals(-1, search.indexOf(0));
     }
 
     @Ignore("Remove to run test")
@@ -111,9 +111,9 @@ public class BinarySearchTest {
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(-1, sut.indexOf(13));
+        assertEquals(-1, search.indexOf(13));
     }
 
     @Ignore("Remove to run test")
@@ -121,8 +121,8 @@ public class BinarySearchTest {
     public void nothingIsIncludedInAnEmptyArray() {
         List<Integer> emptyList = Collections.emptyList();
 
-        BinarySearch<Integer> sut = new BinarySearch<>(emptyList);
+        BinarySearch<Integer> search = new BinarySearch<>(emptyList);
 
-        assertEquals(-1, sut.indexOf(1));
+        assertEquals(-1, search.indexOf(1));
     }
 }

data/tracks/java/exercises/binary-search-tree/src/test/java/BSTTest.java

@@ -11,10 +11,10 @@ public class BSTTest {
 
     @Test
     public void dataIsRetained() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int actual = 4;
-        sut.insert(actual);
-        final BST.Node<Integer> root = sut.getRoot();
+        bst.insert(actual);
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final int expected = root.getData();
         assertEquals(expected, actual);
@@ -23,14 +23,14 @@ public class BSTTest {
     @Test
     @Ignore("Remove to run test")
     public void insertsLess() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         final int expectedLeft = 2;
 
-        sut.insert(expectedRoot);
-        sut.insert(expectedLeft);
+        bst.insert(expectedRoot);
+        bst.insert(expectedLeft);
 
-        final BST.Node<Integer> root = sut.getRoot();
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final BST.Node<Integer> left = root.getLeft();
         assertNotNull(left);
@@ -44,14 +44,14 @@ public class BSTTest {
     @Test
     @Ignore("Remove to run test")
     public void insertsSame() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         final int expectedLeft = 4;
 
-        sut.insert(expectedRoot);
-        sut.insert(expectedLeft);
+        bst.insert(expectedRoot);
+        bst.insert(expectedLeft);
 
-        final BST.Node<Integer> root = sut.getRoot();
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final BST.Node<Integer> left = root.getLeft();
         assertNotNull(left);
@@ -65,14 +65,14 @@ public class BSTTest {
     @Test
     @Ignore("Remove to run test")
     public void insertsRight() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         final int expectedRight = 5;
 
-        sut.insert(expectedRoot);
-        sut.insert(expectedRight);
+        bst.insert(expectedRoot);
+        bst.insert(expectedRight);
 
-        final BST.Node<Integer> root = sut.getRoot();
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final BST.Node<Integer> right = root.getRight();
         assertNotNull(right);
@@ -86,7 +86,7 @@ public class BSTTest {
     @Test
     @Ignore("Remove to run test")
     public void createsComplexTree() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 6, 1, 3, 5, 7)
         );
@@ -94,60 +94,60 @@ public class BSTTest {
         List<Integer> treeData = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 6, 1, 3, 7, 5)
         );
-        treeData.forEach(sut::insert);
+        treeData.forEach(bst::insert);
 
-        List<Integer> actual = sut.getAsLevelOrderList();
+        List<Integer> actual = bst.getAsLevelOrderList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void sortsSingleElement() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Collections.singletonList(4)
         );
 
-        sut.insert(4);
+        bst.insert(4);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(2, 4)
         );
 
-        sut.insert(4);
-        sut.insert(2);
+        bst.insert(4);
+        bst.insert(2);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(4, 5)
         );
 
-        sut.insert(4);
-        sut.insert(5);
+        bst.insert(4);
+        bst.insert(5);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void iteratesOverComplexTree() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(1, 2, 3, 4, 5, 6, 7)
         );
@@ -155,9 +155,9 @@ public class BSTTest {
         List<Integer> treeData = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 1, 3, 6, 7, 5)
         );
-        treeData.forEach(sut::insert);
+        treeData.forEach(bst::insert);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 }