trackler 2.0.8.18 → 2.0.8.19

data/tracks/elixir/config.json

@@ -20,6 +20,13 @@
         "enumerables"
       ]
     },
+    {
+      "slug": "rotational-cipher",
+      "difficulty": 2,
+      "topics": [
+        "string processing"
+      ]
+    },
     {
       "slug": "space-age",
       "difficulty": 2,

data/tracks/elixir/exercises/rotational-cipher/example.exs

@@ -0,0 +1,35 @@
+defmodule RotationalCipher do
+  @alphabet "abcdefghijklmnopqrstuvwxyz"
+  @alphabet_size String.length(@alphabet)
+
+  for shift <- 0..25 do
+    plain = String.split(@alphabet, "", trim: true)
+    cipher = @alphabet
+             |> Kernel.<>(@alphabet)
+             |> String.split("", trim: true)
+             |> Enum.drop(shift)
+             |> Enum.take(@alphabet_size)
+    for {p, c} <- Enum.zip(plain, cipher) do
+      def translate(unquote(p), unquote(shift)), do: unquote(c)
+      def translate(unquote(p |> String.upcase), unquote(shift)), do: unquote(c |> String.upcase)
+    end
+  end
+
+  # Non a-zA-Z just returns the original character
+  def translate(plaintext, _), do: plaintext
+
+  @doc """
+  Given a plaintext and amount to shift by, return a rotated string.
+
+  Example:
+  iex> RotationalCipher.rotate("Attack at dawn", 13)
+  "Nggnpx ng qnja"
+  """
+  @spec rotate(text :: String.t(), shift :: integer) :: String.t()
+  def rotate(text, shift) do
+    text
+    |> String.split("", trim: true)
+    |> Enum.map_join(&(translate(&1, shift)))
+  end
+end
+

data/tracks/elixir/exercises/rotational-cipher/rotational_cipher.exs

@@ -0,0 +1,13 @@
+defmodule RotationalCipher do
+  @doc """
+  Given a plaintext and amount to shift by, return a rotated string.
+
+  Example:
+  iex> RotationalCipher.rotate("Attack at dawn", 13)
+  "Nggnpx ng qnja"
+  """
+  @spec rotate(text :: String.t(), shift :: integer) :: String.t()
+  def rotate(text, shift) do
+  end
+end
+

data/tracks/elixir/exercises/rotational-cipher/rotational_cipher_test.exs

@@ -0,0 +1,80 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("rotational_cipher.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule RotationalCipherTest do
+  use ExUnit.Case
+
+  #@tag :pending
+  test "rotate a by 1" do
+    plaintext = "a"
+    shift = 1
+    assert RotationalCipher.rotate(plaintext, shift) == "b"
+  end
+
+  @tag :pending
+  test "rotate a by 26, same output as input" do
+    plaintext = "a"
+    shift = 26
+    assert RotationalCipher.rotate(plaintext, shift) == "a"
+  end
+
+  @tag :pending
+  test "rotate a by 0, same output as input" do
+    plaintext = "a"
+    shift = 0
+    assert RotationalCipher.rotate(plaintext, shift) == "a"
+  end
+
+  @tag :pending
+  test "rotate m by 13" do
+    plaintext = "m"
+    shift = 13
+    assert RotationalCipher.rotate(plaintext, shift) == "z"
+  end
+
+  @tag :pending
+  test "rotate n by 13 with wrap around alphabet" do
+    plaintext = "n"
+    shift = 13
+    assert RotationalCipher.rotate(plaintext, shift) == "a"
+  end
+
+  @tag :pending
+  test "rotate capital letters" do
+    plaintext = "OMG"
+    shift = 5
+    assert RotationalCipher.rotate(plaintext, shift) == "TRL"
+  end
+
+  @tag :pending
+  test "rotate spaces" do
+    plaintext = "O M G"
+    shift = 5
+    assert RotationalCipher.rotate(plaintext, shift) == "T R L"
+  end
+
+  @tag :pending
+  test "rotate numbers" do
+    plaintext = "Testing 1 2 3 testing"
+    shift = 4
+    assert RotationalCipher.rotate(plaintext, shift) == "Xiwxmrk 1 2 3 xiwxmrk"
+  end
+
+  @tag :pending
+  test "rotate punctuation" do
+    plaintext = "Let's eat, Grandma!"
+    shift = 21
+    assert RotationalCipher.rotate(plaintext, shift) == "Gzo'n zvo, Bmviyhv!"
+  end
+
+  @tag :pending
+  test "rotate all letters" do
+    plaintext = "The quick brown fox jumps over the lazy dog."
+    shift = 13
+    assert RotationalCipher.rotate(plaintext, shift) == "Gur dhvpx oebja sbk whzcf bire gur ynml qbt."
+  end
+end

data/tracks/go/exercises/raindrops/raindrops_test.go

@@ -4,10 +4,13 @@ import "testing"
 
 const targetTestVersion = 2
 
-func TestConvert(t *testing.T) {
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
 		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestConvert(t *testing.T) {
 	for _, test := range tests {
 		if actual := Convert(test.input); actual != test.expected {
 			t.Errorf("Convert(%d) = %q, expected %q.",

data/tracks/go/exercises/react/react_test.go

@@ -16,14 +16,6 @@ const targetTestVersion = 5
 // This is a compile time check to see if you've properly implemented New().
 var _ Reactor = New()
 
-// If this test fails and you've proprly defined testVersion the requirements
-// of the tests have changed since you wrote your submission.
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
-	}
-}
-
 func assertCellValue(t *testing.T, c Cell, expected int, explanation string) {
 	observed := c.Value()
 	_, _, line, _ := runtime.Caller(1)
@@ -32,6 +24,12 @@ func assertCellValue(t *testing.T, c Cell, expected int, explanation string) {
 	}
 }
 
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
 // Setting the value of an input cell changes the observable Value()
 func TestSetInput(t *testing.T) {
 	r := New()

data/tracks/go/exercises/rna-transcription/rna_transcription_test.go

@@ -4,10 +4,13 @@ import "testing"
 
 const targetTestVersion = 3
 
-func TestRNATranscription(t *testing.T) {
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
 		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestRNATranscription(t *testing.T) {
 	for _, test := range rnaTests {
 		if actual := ToRNA(test.input); actual != test.expected {
 			t.Errorf("ToRNA(%s): %s, expected %s",

data/tracks/go/exercises/robot-simulator/robot_simulator_test.go

@@ -27,11 +27,14 @@ import (
 
 const targetTestVersion = 3
 
-func TestStep1(t *testing.T) {
-
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
 		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestStep1(t *testing.T) {
+
 	want := func(x, y int, dir Dir) {
 		_, _, line, _ := runtime.Caller(1)
 		if Step1Robot.X != x || Step1Robot.Y != y {

data/tracks/haskell/exercises/allergies/src/Allergies.hs

@@ -11,7 +11,7 @@ data Allergen = Eggs
               deriving (Eq)
 
 allergies :: Int -> [Allergen]
-allergies = error "You need to implement this function."
+allergies score = error "You need to implement this function."
 
 isAllergicTo :: Allergen -> Int -> Bool
-isAllergicTo = error "You need to implement this function."
+isAllergicTo allergen score = error "You need to implement this function."

data/tracks/haskell/exercises/atbash-cipher/src/Atbash.hs

@@ -1,7 +1,7 @@
 module Atbash (decode, encode) where
 
 decode :: String -> String
-decode = error "You need to implement this function."
+decode phrase = error "You need to implement this function."
 
 encode :: String -> String
-encode = error "You need to implement this function."
+encode phrase = error "You need to implement this function."

data/tracks/haskell/exercises/bank-account/src/BankAccount.hs

@@ -9,13 +9,13 @@ module BankAccount
 data BankAccount = Dummy
 
 closeAccount :: BankAccount -> IO ()
-closeAccount = error "You need to implement this function."
+closeAccount account = error "You need to implement this function."
 
 getBalance :: BankAccount -> IO (Maybe Integer)
-getBalance = error "You need to implement this function."
+getBalance account = error "You need to implement this function."
 
 incrementBalance :: BankAccount -> Integer -> IO (Maybe Integer)
-incrementBalance = error "You need to implement this function."
+incrementBalance account amount = error "You need to implement this function."
 
 openAccount :: IO BankAccount
 openAccount = error "You need to implement this function."

data/tracks/haskell/exercises/binary-search-tree/src/BST.hs

@@ -13,25 +13,25 @@ module BST
 data BST a = Dummy deriving (Eq, Show)
 
 bstLeft :: BST a -> Maybe (BST a)
-bstLeft = error "You need to implement this function."
+bstLeft tree = error "You need to implement this function."
 
 bstRight :: BST a -> Maybe (BST a)
-bstRight = error "You need to implement this function."
+bstRight tree = error "You need to implement this function."
 
 bstValue :: BST a -> Maybe a
-bstValue = error "You need to implement this function."
+bstValue tree = error "You need to implement this function."
 
 empty :: BST a
 empty = error "You need to implement this function."
 
 fromList :: Ord a => [a] -> BST a
-fromList = error "You need to implement this function."
+fromList xs = error "You need to implement this function."
 
 insert :: Ord a => a -> BST a -> BST a
-insert = error "You need to implement this function."
+insert x tree = error "You need to implement this function."
 
 singleton :: a -> BST a
-singleton = error "You need to implement this function."
+singleton x = error "You need to implement this function."
 
 toList :: BST a -> [a]
-toList = error "You need to implement this function."
+toList tree = error "You need to implement this function."

data/tracks/haskell/exercises/bowling/src/Bowling.hs

@@ -5,5 +5,5 @@ data BowlingError = IncompleteGame
   deriving (Eq, Show)
 
 score :: [Int] -> Either BowlingError Int
-score = error "You need to implement this function."
+score rolls = error "You need to implement this function."
 

data/tracks/haskell/exercises/clock/src/Clock.hs

@@ -3,13 +3,13 @@ module Clock (clockHour, clockMin, fromHourMin, toString) where
 data Clock = Dummy
 
 clockHour :: Clock -> Int
-clockHour = error "You need to implement this function."
+clockHour clock = error "You need to implement this function."
 
 clockMin :: Clock -> Int
-clockMin = error "You need to implement this function."
+clockMin clock = error "You need to implement this function."
 
 fromHourMin :: Int -> Int -> Clock
-fromHourMin = error "You need to implement this function."
+fromHourMin hour min = error "You need to implement this function."
 
 toString :: Clock -> String
-toString = error "You need to implement this function."
+toString clock = error "You need to implement this function."

data/tracks/haskell/exercises/connect/src/Connect.hs

@@ -3,4 +3,4 @@ module Connect (Mark(..), winner) where
 data Mark = Cross | Nought deriving (Eq, Show)
 
 winner :: [String] -> Maybe Mark
-winner = error "You need to implement this function."
+winner board = error "You need to implement this function."

data/tracks/haskell/exercises/crypto-square/src/CryptoSquare.hs

@@ -1,4 +1,4 @@
 module CryptoSquare (encode) where
 
 encode :: String -> String
-encode = error "You need to implement this function."
+encode xs = error "You need to implement this function."

data/tracks/haskell/exercises/custom-set/src/CustomSet.hs

@@ -19,40 +19,40 @@ import Prelude hiding (null)
 data CustomSet a = Dummy deriving (Eq, Show)
 
 delete :: a -> CustomSet a -> CustomSet a
-delete = error "You need to implement this function."
+delete x set = error "You need to implement this function."
 
 difference :: CustomSet a -> CustomSet a -> CustomSet a
-difference = error "You need to implement this function."
+difference setA setB = error "You need to implement this function."
 
 empty :: CustomSet a
 empty = error "You need to implement this function."
 
 fromList :: [a] -> CustomSet a
-fromList = error "You need to implement this function."
+fromList xs = error "You need to implement this function."
 
 insert :: a -> CustomSet a -> CustomSet a
-insert = error "You need to implement this function."
+insert x set = error "You need to implement this function."
 
 intersection :: CustomSet a -> CustomSet a -> CustomSet a
-intersection = error "You need to implement this function."
+intersection setA setB = error "You need to implement this function."
 
 isDisjointFrom :: CustomSet a -> CustomSet a -> Bool
-isDisjointFrom = error "You need to implement this function."
+isDisjointFrom setA setB = error "You need to implement this function."
 
 isSubsetOf :: CustomSet a -> CustomSet a -> Bool
-isSubsetOf = error "You need to implement this function."
+isSubsetOf setA setB = error "You need to implement this function."
 
 member :: a -> CustomSet a -> Bool
-member = error "You need to implement this function."
+member x set = error "You need to implement this function."
 
 null :: CustomSet a -> Bool
-null = error "You need to implement this function."
+null set = error "You need to implement this function."
 
 size :: CustomSet a -> Int
-size = error "You need to implement this function."
+size set = error "You need to implement this function."
 
 toList :: CustomSet a -> [a]
-toList = error "You need to implement this function."
+toList set = error "You need to implement this function."
 
 union :: CustomSet a -> CustomSet a -> CustomSet a
-union = error "You need to implement this function."
+union setA setB = error "You need to implement this function."

data/tracks/haskell/exercises/difference-of-squares/src/Squares.hs

@@ -1,10 +1,10 @@
 module Squares (difference, squareOfSums, sumOfSquares) where
 
 difference :: Integral a => a -> a
-difference = error "You need to implement this function."
+difference n = error "You need to implement this function."
 
 squareOfSums :: Integral a => a -> a
-squareOfSums = error "You need to implement this function."
+squareOfSums n = error "You need to implement this function."
 
 sumOfSquares :: Integral a => a -> a
-sumOfSquares = error "You need to implement this function."
+sumOfSquares n = error "You need to implement this function."

data/tracks/haskell/exercises/etl/src/ETL.hs

@@ -3,4 +3,4 @@ module ETL (transform) where
 import Data.Map (Map)
 
 transform :: Map a String -> Map Char a
-transform = error "You need to implement this function."
+transform legacyData = error "You need to implement this function."

data/tracks/haskell/exercises/forth/src/Forth.hs

@@ -23,7 +23,7 @@ empty :: ForthState
 empty = error "You need to implement this function."
 
 evalText :: Text -> ForthState -> Either ForthError ForthState
-evalText = error "You need to implement this function."
+evalText text stack = error "You need to implement this function."
 
 toList :: ForthState -> [Int]
-toList = error "You need to implement this function."
+toList stack = error "You need to implement this function."

data/tracks/haskell/exercises/go-counting/src/Counting.hs

@@ -10,7 +10,7 @@ data Color = Black | White deriving (Eq, Ord, Show)
 type Coord = (Int, Int)
 
 territories :: [String] -> [(Set Coord, Maybe Color)]
-territories = error "You need to implement this function."
+territories board = error "You need to implement this function."
 
 territoryFor :: [String] -> Coord -> Maybe (Set Coord, Maybe Color)
-territoryFor = error "You need to implement this function."
+territoryFor board coord = error "You need to implement this function."

data/tracks/haskell/exercises/kindergarten-garden/src/Garden.hs

@@ -14,10 +14,10 @@ data Plant = Clover
            deriving (Eq, Show)
 
 defaultGarden :: String -> Map String [Plant]
-defaultGarden = error "You need to implement this function."
+defaultGarden plants = error "You need to implement this function."
 
 garden :: [String] -> String -> Map String [Plant]
-garden = error "You need to implement this function."
+garden students plants = error "You need to implement this function."
 
 lookupPlants :: String -> Map String [Plant] -> [Plant]
-lookupPlants = error "You need to implement this function."
+lookupPlants student garden = error "You need to implement this function."