trackler 2.2.1.51 → 2.2.1.52

data/tracks/common-lisp/config.json

@@ -1,6 +1,17 @@
 {
   "active": true,
   "exercises": [
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "acronym",
+      "topics": [
+        "strings",
+        "transforming"
+      ],
+      "unlocked_by": null,
+      "uuid": "6efa02be-0f9e-1d80-7efb-536d383535c98b1d883"
+    },
     {
       "core": true,
       "difficulty": 1,
@@ -26,20 +37,16 @@
       "uuid": "c029678b-9b9f-4fb2-958f-3a118efa16a9"
     },
     {
-      "uuid": "428e5b28-31b6-4c84-8eae-d7753d45efc1",
-      "slug": "sublist",
       "core": false,
-      "unlocked_by": null,
       "difficulty": 1,
+      "slug": "sublist",
       "topics": [
-        "Lists"
-      ]
+        "lists"
+      ],
+      "unlocked_by": null,
+      "uuid": "428e5b28-31b6-4c84-8eae-d7753d45efc1"
     },
     {
-      "uuid": "eb3a92bf-0748-4406-ba67-9e27e367ae45",
-      "slug": "grains",
-      "core": false,
-      "unlocked_by": null,
       "core": true,
       "difficulty": 1,
       "slug": "leap",
@@ -249,6 +256,16 @@
       "unlocked_by": null,
       "uuid": "b3ad38c2-2962-4b47-9b15-15ca262ebff6"
     },
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "isogram",
+      "topics": [
+        "strings"
+      ],
+      "unlocked_by": null,
+      "uuid": "89ea51d0-3f7e-4e07-8e2b-4dde4c76608b"
+    },
     {
       "core": false,
       "difficulty": 1,

data/tracks/common-lisp/exercises/acronym/README.md

@@ -0,0 +1,61 @@
+# Acronym
+
+Convert a phrase to its acronym.
+
+Techies love their TLA (Three Letter Acronyms)!
+
+Help generate some jargon by writing a program that converts a long name
+like Portable Network Graphics to its acronym (PNG).
+
+## Setup
+
+Check out [Exercism Help](http://exercism.io/languages/lisp) for instructions to
+get started writing Common Lisp. That page will explain how to install and setup
+a Lisp implementation and how to run the tests.
+
+## Formatting
+
+While Common Lisp doesn't care about indentation and layout of code,
+nor whether you use spaces or tabs, this is an important consideration
+for submissions to exercism.io. Excercism.io's code widget cannot
+handle mixing of tab and space characters well so using only spaces is recommended to make
+the code more readable to the human reviewers. Please review your
+editors settings on how to accomplish this. Below are instructions for
+popular editors for Common Lisp.
+
+### VIM
+
+Use the following commands to ensure VIM uses only spaces for
+indentation:
+
+```vimscript
+:set tabstop=2
+:set shiftwidth=2
+:set expandtab
+```
+
+(or as a oneliner `:set tabstop=2 shiftwidth=2 expandtab`). This can
+be added to your `~/.vimrc` file to use it all the time.
+
+### Emacs
+
+Emacs is very well suited for editing Common Lisp and has many
+powerful add-on packages available. The only thing that one needs to
+do with a stock emacs to make it work well with exercism.io is to
+evaluate the following code:
+
+`(setq indent-tab-mode nil)`
+
+This can be placed in your `~/.emacs` (or `~/.emacs.d/init.el`) in
+order to have it set whenever Emacs is launched.
+
+One suggested add-on for Emacs and Common Lisp is
+[SLIME](https://github.com/slime/slime) which offers tight integration
+with the REPL; making iterative coding and testing very easy.
+
+## Source
+
+Julien Vanier [https://github.com/monkbroc](https://github.com/monkbroc)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/common-lisp/exercises/acronym/acronym-test.lisp

@@ -0,0 +1,48 @@
+(ql:quickload "lisp-unit")
+#-xlisp-test (load "acronym")
+
+(defpackage #:acronym-test
+  (:use #:common-lisp #:lisp-unit))
+
+(in-package #:acronym-test)
+
+
+(define-test empty-gives-empty
+  (assert-equal
+    ""
+    (acronym:acronym "")))
+
+(define-test png-test
+  (assert-equal
+    "PNG"
+    (acronym:acronym "Portable Network Graphics")))
+
+(define-test ror-test
+  (assert-equal
+    "ROR"
+    (acronym:acronym "Ruby on Rails")))
+
+(define-test html-test
+  (assert-equal
+    "HTML"
+    (acronym:acronym "HyperText Markup Language")))
+
+(define-test fifo-test
+  (assert-equal
+    "FIFO"
+    (acronym:acronym "First In, First Out")))
+
+(define-test php-test
+  (assert-equal
+    "PHP"
+    (acronym:acronym "PHP: Hypertext Preprocessor")))
+
+(define-test cmos-test
+  (assert-equal
+    "CMOS"
+    (acronym:acronym "Complementary metal-oxide semiconductor")))
+
+#-xlisp-test
+(let ((*print-errors* t)
+      (*print-failures* t))
+  (run-tests :all :acronym-test))

data/tracks/common-lisp/exercises/acronym/acronym.lisp

@@ -0,0 +1,6 @@
+(in-package #:cl-user)
+(defpackage #:acronym
+  (:use #:common-lisp)
+  (:export #:acronym))
+
+(in-package #:acronym)

data/tracks/common-lisp/exercises/acronym/example.lisp

@@ -0,0 +1,24 @@
+(in-package #:cl-user)
+(defpackage #:acronym
+  (:use #:cl)
+  (:export #:acronym))
+
+(in-package #:acronym)
+
+(defun acronym (str)
+  (labels ((recur (st ls)
+    (cond
+      ((equal "" st)
+        ls)
+      ((both-case-p (elt st 0))
+       (recur (string-left-trim
+              "abcdefghijklmnopqrstuvwxyz"
+              (string-left-trim
+                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                st))
+             (cons (elt st 0)
+                   ls)))
+      (t (recur (subseq st 1) ls)))))
+    (map 'string
+         #'char-upcase
+         (nreverse (recur str nil)))))

data/tracks/common-lisp/exercises/isogram/README.md

@@ -0,0 +1,65 @@
+Determine if a word or phrase is an isogram.
+
+An isogram (also known as a "nonpattern word") is a word or phrase without a repeating letter, however spaces and hyphens are allowed to appear multiple times.
+
+Examples of isograms:
+
+- lumberjacks
+- background
+- downstream
+- six-year-old
+
+The word *isograms*, however, is not an isogram, because the s repeats.
+
+## Setup
+
+Check out [Exercism Help](http://exercism.io/languages/lisp) for instructions to
+get started writing Common Lisp. That page will explain how to install and setup
+a Lisp implementation and how to run the tests.
+
+## Formatting
+
+While Common Lisp doesn't care about indentation and layout of code,
+nor whether you use spaces or tabs, this is an important consideration
+for submissions to exercism.io. Excercism.io's code widget cannot
+handle mixing of tab and space characters well so using only spaces is recommended to make
+the code more readable to the human reviewers. Please review your
+editors settings on how to accomplish this. Below are instructions for
+popular editors for Common Lisp.
+
+### VIM
+
+Use the following commands to ensure VIM uses only spaces for
+indentation:
+
+```vimscript
+:set tabstop=2
+:set shiftwidth=2
+:set expandtab
+```
+
+(or as a oneliner `:set tabstop=2 shiftwidth=2 expandtab`). This can
+be added to your `~/.vimrc` file to use it all the time.
+
+### Emacs
+
+Emacs is very well suited for editing Common Lisp and has many
+powerful add-on packages available. The only thing that one needs to
+do with a stock emacs to make it work well with exercism.io is to
+evaluate the following code:
+
+`(setq indent-tab-mode nil)`
+
+This can be placed in your `~/.emacs` (or `~/.emacs.d/init.el`) in
+order to have it set whenever Emacs is launched.
+
+One suggested add-on for Emacs and Common Lisp is
+[SLIME](https://github.com/slime/slime) which offers tight integration
+with the REPL; making iterative coding and testing very easy.
+
+## Source
+
+Learn more about Isograms at [wikipedia](https://en.wikipedia.org/wiki/Isogram")
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/common-lisp/exercises/isogram/example.lisp

@@ -0,0 +1,18 @@
+(defpackage #:isogram
+  (:use #:common-lisp)
+  (:export #:is-isogram))
+
+(in-package #:isogram)
+
+(defun str-list (s)
+  (assert (stringp s) (s))
+  (coerce (string-upcase s) 'list))
+
+(defun is-isogram-helper (xs)
+  (if (null xs) T
+    (and (not (and (find (car xs) "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+                   (find (car xs) (cdr xs))))
+         (is-isogram-helper (cdr xs)))))
+
+(defun is-isogram (xs)
+  (is-isogram-helper (str-list xs)))

data/tracks/common-lisp/exercises/isogram/isogram-test.lisp

@@ -0,0 +1,39 @@
+(ql:quickload "lisp-unit")
+#-xlisp-test (load "isogram")
+
+(defpackage #:isogram-test
+  (:use #:common-lisp #:lisp-unit))
+
+(in-package #:isogram-test)
+
+(define-test empty-string
+  (assert-true (isogram:is-isogram "")))
+
+(define-test isogram-with-only-lower-case-characters
+  (assert-true (isogram:is-isogram "isogram")))
+
+(define-test word-with-one-duplicated-character
+  (assert-false (isogram:is-isogram "eleven")))
+
+(define-test longest-reported-english-isogram
+  (assert-true (isogram:is-isogram "subdermatoglyphic")))
+
+(define-test word-with-duplicated-character-in-mixed-case
+  (assert-false (isogram:is-isogram "Alphabet")))
+
+(define-test hypothetical-isogrammic-word-with-hyphen
+  (assert-true (isogram:is-isogram "thumbscrew-japingly")))
+
+(define-test isogram-with-duplicated-hyphen
+  (assert-true (isogram:is-isogram "six-year-old")))
+
+(define-test made-up-name-that-is-an-isogam
+  (assert-true (isogram:is-isogram "Emily Jung Schwartzkopf")))
+
+(define-test duplicated-character-in-the-middle
+  (assert-false (isogram:is-isogram "accentor")))
+
+#-xlisp-test
+(let ((*print-errors* t)
+      (*print-failures* t))
+  (run-tests :all :isogram-test))

data/tracks/common-lisp/exercises/isogram/isogram.lisp

@@ -0,0 +1,8 @@
+(defpackage #:isogram
+  (:use #:cl)
+  (:export #:is-isogram))
+
+(in-package #:isogram)
+
+(defun is-isogram (string)
+  "Is string an Isogram?")

data/tracks/delphi/exercises/etl/README.md

@@ -1,4 +1,4 @@
-# Etl
+# ETL
 
 We are going to do the `Transform` step of an Extract-Transform-Load.
 

data/tracks/delphi/exercises/rna-transcription/README.md

@@ -1,4 +1,4 @@
-# Rna Transcription
+# RNA Transcription
 
 Given a DNA strand, return its RNA complement (per RNA transcription).
 

data/tracks/delphi/exercises/saddle-points/README.md

@@ -15,7 +15,7 @@ So say you have a matrix like so:
 It has a saddle point at (1, 0).
 
 It's called a "saddle point" because it is greater than or equal to
-every element in its row and the less than or equal to every element in
+every element in its row and less than or equal to every element in
 its column.
 
 A matrix may have zero or more saddle points.

data/tracks/fsharp/exercises/all-your-base/AllYourBaseTest.fs

@@ -9,169 +9,169 @@ open AllYourBase
 
 [<Fact>]
 let ``Single bit one to decimal`` () =
-    let expected = Some [1]
     let inputBase = 2
     let inputDigits = [1]
     let outputBase = 10
+    let expected = Some [1]
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Binary to single decimal`` () =
-    let expected = Some [5]
     let inputBase = 2
     let inputDigits = [1; 0; 1]
     let outputBase = 10
+    let expected = Some [5]
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Single decimal to binary`` () =
-    let expected = Some [1; 0; 1]
     let inputBase = 10
     let inputDigits = [5]
     let outputBase = 2
+    let expected = Some [1; 0; 1]
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Binary to multiple decimal`` () =
-    let expected = Some [4; 2]
     let inputBase = 2
     let inputDigits = [1; 0; 1; 0; 1; 0]
     let outputBase = 10
+    let expected = Some [4; 2]
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Decimal to binary`` () =
-    let expected = Some [1; 0; 1; 0; 1; 0]
     let inputBase = 10
     let inputDigits = [4; 2]
     let outputBase = 2
+    let expected = Some [1; 0; 1; 0; 1; 0]
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Trinary to hexadecimal`` () =
-    let expected = Some [2; 10]
     let inputBase = 3
     let inputDigits = [1; 1; 2; 0]
     let outputBase = 16
+    let expected = Some [2; 10]
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Hexadecimal to trinary`` () =
-    let expected = Some [1; 1; 2; 0]
     let inputBase = 16
     let inputDigits = [2; 10]
     let outputBase = 3
+    let expected = Some [1; 1; 2; 0]
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``15-bit integer`` () =
-    let expected = Some [6; 10; 45]
     let inputBase = 97
     let inputDigits = [3; 46; 60]
     let outputBase = 73
+    let expected = Some [6; 10; 45]
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Empty list`` () =
-    let expected = None
     let inputBase = 2
     let inputDigits = []
     let outputBase = 10
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Single zero`` () =
-    let expected = None
     let inputBase = 10
     let inputDigits = [0]
     let outputBase = 2
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Multiple zeros`` () =
-    let expected = None
     let inputBase = 10
     let inputDigits = [0; 0; 0]
     let outputBase = 2
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Leading zeros`` () =
-    let expected = None
     let inputBase = 7
     let inputDigits = [0; 6; 0]
     let outputBase = 10
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First base is one`` () =
-    let expected = None
     let inputBase = 1
     let inputDigits = []
     let outputBase = 10
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First base is zero`` () =
-    let expected = None
     let inputBase = 0
     let inputDigits = []
     let outputBase = 10
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First base is negative`` () =
-    let expected = None
     let inputBase = -2
     let inputDigits = [1]
     let outputBase = 10
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Negative digit`` () =
-    let expected = None
     let inputBase = 2
     let inputDigits = [1; -1; 1; 0; 1; 0]
     let outputBase = 10
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Invalid positive digit`` () =
-    let expected = None
     let inputBase = 2
     let inputDigits = [1; 2; 1; 0; 1; 0]
     let outputBase = 10
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second base is one`` () =
-    let expected = None
     let inputBase = 2
     let inputDigits = [1; 0; 1; 0; 1; 0]
     let outputBase = 1
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second base is zero`` () =
-    let expected = None
     let inputBase = 10
     let inputDigits = [7]
     let outputBase = 0
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second base is negative`` () =
-    let expected = None
     let inputBase = 2
     let inputDigits = [1]
     let outputBase = -7
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Both bases are negative`` () =
-    let expected = None
     let inputBase = -2
     let inputDigits = [1]
     let outputBase = -7
+    let expected = None
     rebase inputBase inputDigits outputBase |> should equal expected