trackler 2.2.1.74 → 2.2.1.75

data/tracks/clojure/config.json

@@ -33,6 +33,14 @@
       "unlocked_by": null,
       "uuid": "04a6c1d6-6cce-4c87-a34b-23fdd9baf70d"
     },
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "isbn-verifier",
+      "topics": null,
+      "unlocked_by": null,
+      "uuid": "e6411d18-d9b9-48fa-8ee6-0df8c13d3dee"
+    },
     {
       "core": false,
       "difficulty": 1,
@@ -541,8 +549,16 @@
         "pattern matching"
       ],
       "uuid": "c4b7120c-a7c5-4a39-a08e-8d4fb9861a27"
+    },
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "proverb",
+      "topics": null,
+      "unlocked_by": null,
+      "uuid": "c8ba6ce5-9a7e-4c1c-8044-bb18a0d6ad39"
     }
   ],
   "foregone": [],
   "language": "Clojure"
-}
+} 

data/tracks/clojure/exercises/isbn-verifier/README.md

@@ -0,0 +1,43 @@
+Check if a given ISBN-10 is valid.
+
+## Functionality
+
+Given an unknown string the program should check if the provided string is a valid ISBN-10.
+Putting this into place requires some thinking about preprocessing/parsing of the string prior to calculating the check digit for the ISBN.
+
+The program should allow for ISBN-10 without the separating dashes to be verified as well.
+
+## ISBN
+
+Let's take a random ISBN-10 number, say `3-598-21508-8` for this.
+The first digit block indicates the group where the ISBN belongs. Groups can consist of shared languages, geographic regions or countries. The leading '3' signals this ISBN is from a german speaking country.
+The following number block is to identify the publisher. Since this is a three digit publisher number there is a 5 digit title number for this book.
+The last digit in the ISBN is the check digit which is used to detect read errors.
+
+The first 9 digits in the ISBN have to be between 0 and 9.
+The check digit can additionally be an 'X' to allow 10 to be a valid check digit as well.
+
+A valid ISBN-10 is calculated with this formula `(x1 * 10 + x2 * 9 + x3 * 8 + x4 * 7 + x5 * 6 + x6 * 5 + x7 * 4 + x8 * 3 + x9 * 2 + x10 * 1) mod 11 == 0`
+So for our example ISBN this means:
+(3 * 10 + 5 * 9 + 9 * 8 + 8 * 7 + 2 * 6 + 1 * 5 + 5 * 4 + 0 * 3 + 8 * 2 + 8 * 1) mod 11 = 0
+
+Which proves that the ISBN is valid.
+
+## Caveats
+
+Converting from string to number can be tricky in certain languages.
+It's getting even trickier since the check-digit of an ISBN-10 can be 'X'.
+
+## Bonus tasks
+
+* Generate a valid ISBN-13 from the input ISBN-10 (and maybe verify it again with a derived verifier)
+
+* Generate valid ISBN, maybe even from a given starting ISBN
+
+## Source
+
+Converting a string into a number and some basic processing utilizing a relatable real world example.
+[https://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digit_calculation](https://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digit_calculation)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/clojure/exercises/isbn-verifier/project.clj

@@ -0,0 +1,4 @@
+(defproject isbn-verifier "0.1.0-SNAPSHOT"
+  :description "isbn-verifier xercise."
+  :url "https://github.com/exercism/clojure/tree/master/exercises/isbn-verifier"
+  :dependencies [[org.clojure/clojure "1.8.0"]])

data/tracks/clojure/exercises/isbn-verifier/src/example.clj

@@ -0,0 +1,17 @@
+(ns isbn-verifier)
+
+(defn is-in? [xs x] (some #(= x %) xs))
+
+(defn isbn-chars [isbn]
+  (filter #(is-in? [\0 \1 \2 \3 \4 \5 \6 \7 \8 \9 \X] %) isbn))
+
+(defn isbn? [isbn]
+  (let [chars (isbn-chars isbn)
+        nums  (map #(if (= \X %) 10 (Character/digit % 10)) chars)]
+    (and (-> chars butlast (is-in? \X) not)
+         (= 10 (count chars))
+         (as-> nums x
+               (map #(* %1 %2) (range 10 0 -1) x)
+               (reduce + x)
+               (mod x 11)
+               (zero? x)))))

data/tracks/clojure/exercises/isbn-verifier/src/isbn_verifier.clj

@@ -0,0 +1,3 @@
+(ns isbn-verifier)
+
+(defn isbn? [isbn])

data/tracks/clojure/exercises/isbn-verifier/test/isbn_verifier_test.clj

@@ -0,0 +1,42 @@
+(ns isbn-verifier-test
+  (:require [clojure.test :refer [deftest is]]
+            [isbn-verifier :refer [isbn?]]))
+
+(deftest valid-isbn-number
+  (is (= true (isbn? "3-598-21508-8"))))
+
+(deftest invalid-isbn-check-digit
+  (is (= false (isbn? "3-598-21508-9"))))
+
+(deftest valid-isbn-number-with-a-check-digit-of-10
+  (is (= true (isbn? "3-598-21507-X"))))
+
+(deftest check-digit-is-a-character-other-than-X
+  (is (= false (isbn? "3-598-21507-A"))))
+
+(deftest invalid-character-in-isbn
+  (is (= false (isbn? "3-598-2K507-0"))))
+
+(deftest X-is-only-valid-as-a-check-digit
+  (is (= false (isbn? "3-598-2X507-9"))))
+
+(deftest valid-isbn-without-separating-dashes
+  (is (= true (isbn? "3598215088"))))
+
+(deftest isbn-without-separating-dashes-and-X-as-check-digit
+  (is (= true (isbn? "359821507X"))))
+
+(deftest isbn-without-check-digit-and-dashes
+  (is (= false (isbn? "359821507"))))
+
+(deftest too-long-isbn-and-no-dashes
+  (is (= false (isbn? "3598215078X"))))
+
+(deftest isbn-without-check-digit
+  (is (= false (isbn? "3-598-21507"))))
+
+(deftest too-long-isbn
+  (is (= false (isbn? "3-598-21507-XX"))))
+
+(deftest check-digit-of-X-should-not-be-used-for-0
+  (is (= false (isbn? "3-598-21515-X"))))

data/tracks/clojure/exercises/proverb/README.md

@@ -0,0 +1,15 @@
+For want of a horseshoe nail, a kingdom was lost, or so the saying goes.
+
+Given a list of inputs, generate the relevant proverb. For example, given the list `["nail", "shoe", "horse", "rider", "message", "battle", "kingdom"]`, you will output the full text of this proverbial rhyme:
+
+```text
+For want of a nail the shoe was lost.
+For want of a shoe the horse was lost.
+For want of a horse the rider was lost.
+For want of a rider the message was lost.
+For want of a message the battle was lost.
+For want of a battle the kingdom was lost.
+And all for the want of a nail.
+```
+
+Note that the list of inputs may vary; your solution should be able to handle lists of arbitrary length and content. No line of the output text should be a static, unchanging string; all should vary according to the input given.

data/tracks/clojure/exercises/proverb/project.clj

@@ -0,0 +1,4 @@
+(defproject proverb "0.1.0-SNAPSHOT"
+  :description "proverb exercise."
+  :url "https://github.com/exercism/xclojure/tree/master/exercises/proverb"
+  :dependencies [[org.clojure/clojure "1.8.0"]])

data/tracks/clojure/exercises/proverb/src/example.clj

@@ -0,0 +1,15 @@
+(ns proverb
+  (:require [clojure.string :as str]))
+
+(def subjects ["nail" "shoe" "horse" "rider" "message" "battle" "kingdom"])
+
+(def last-line "And all for the want of a horseshoe nail.")
+
+(defn- line [[cause-subject effect-subject]]
+  (format "For want of a %s the %s was lost." cause-subject effect-subject))
+
+(def proverb (->> subjects
+                  (partition 2 1)
+                  (map line)
+                  (#(conj (vec %) last-line))
+                  (str/join "\n")))

data/tracks/clojure/exercises/proverb/src/proverb.clj

@@ -0,0 +1,3 @@
+(ns proverb)
+
+(def proverb "")

data/tracks/clojure/exercises/proverb/test/proverb_test.clj

@@ -0,0 +1,14 @@
+(ns proverb-test
+  (:require [clojure.test :refer [deftest is]]
+            [proverb :refer [proverb]]
+            [clojure.string :as str]))
+
+(deftest full-text-is-correct
+  (is (= proverb
+         (str/join "\n" ["For want of a nail the shoe was lost."
+                         "For want of a shoe the horse was lost."
+                         "For want of a horse the rider was lost."
+                         "For want of a rider the message was lost."
+                         "For want of a message the battle was lost."
+                         "For want of a battle the kingdom was lost."
+                         "And all for the want of a horseshoe nail."]))))

data/tracks/common-lisp/docs/LEARNING.md

@@ -2,6 +2,7 @@ Exercism provides exercises and feedback but can be difficult to jump
 into for those learning Common Lisp for the first time. These
 resources can help you get started:
 
+* [Practical Common Lisp](http://www.gigamonkeys.com/book/), a complete book for learning Common Lisp, available free online (as well as in print)
 * [Cliki.net Getting Start Started Page](http://cliki.net/Getting%20Started),
   by various contributors
 * [Wikibooks book of Common Lisp, First steps](http://en.wikibooks.org/wiki/Common_Lisp/First_steps),
@@ -10,6 +11,6 @@ resources can help you get started:
   Paul Nathan
 * [Northwestern University EECS 325 Readings](http://www.cs.northwestern.edu/academics/courses/325/readings/readings.php),
   by Chris Riesbeck
-* [The Common Lisp Cookbook](http://lispcookbook.github.io/cl-cookbook/),
-  by various contributors
-  ([legacy SF site](http://cl-cookbook.sourceforge.net/))
+
+See also, within this Exercism Common Lisp track: [Important Resources](http://exercism.io/languages/common-lisp/resources)
+

data/tracks/common-lisp/docs/RESOURCES.md

@@ -37,3 +37,14 @@ be afraid of them, they're quite accessible and "classics".
 The last is actually on a related Lisp dialect, Scheme, but it's very
 helpful book, generally. If you find you prefer Scheme, it's an
 excellent start.
+
+
+### Quick reference
+
+Quick-guides / cheat sheets for Common Lisp:
+
+* [The Common Lisp Cookbook](http://lispcookbook.github.io/cl-cookbook/)
+  by various contributors, includes quick help on often used commands or features. 
+  ([legacy SF site](http://cl-cookbook.sourceforge.net/))
+* [Common Lisp Quick Reference](http://clqr.boundp.org/) is a print-it-yourself booklet for having a quick reference handy.
+* [Simplified Common Lisp Reference](http://jtra.cz/stuff/lisp/sclr/index.html) gives a quick glance at often used commands, ideal for newcomers.

data/tracks/delphi/.gitignore

@@ -1,6 +1,7 @@
 # Exercism project
 bin/configlet
 bin/configlet.exe
+*.skip
 
 # Delphi Language
 *.a

data/tracks/delphi/config.json

@@ -52,6 +52,19 @@
       ],
       "uuid": "9e54a998-450c-4020-834e-eaa77f909744"
     },
+    {
+      "core": false,
+      "difficulty": 4,
+      "slug": "isbn-verifier",
+      "topics": [
+        "conditionals",
+        "loops",
+        "pattern_matching",
+        "strings"
+      ],
+      "unlocked_by": "bob",
+      "uuid": "4cdb8216-4526-49ac-8ab5-68d70060a54e"
+    },
     {
       "core": false,
       "difficulty": 1,
@@ -172,6 +185,17 @@
       "unlocked_by": "collatz-conjecture",
       "uuid": "cba5cf99-8001-4113-af80-cf9c041f1b21"
     },
+    {
+      "core": false,
+      "difficulty": 3,
+      "slug": "secret-handshake",
+      "topics": [
+        "arrays",
+        "bitwise_operations"
+      ],
+      "unlocked_by": "collatz-conjecture",
+      "uuid": "2032ba03-845a-460b-ad93-0958e97eb7cc"
+    },
     {
       "core": false,
       "difficulty": 3,

data/tracks/delphi/docs/INSTALLATION.md

@@ -17,7 +17,7 @@ With Delphi successfully installed, and working correctly, please follow these s
 - Step-by-step instructions on how to install DUnitX into Delphi have been posted by Vincent Parrett in a blog post located [here](https://www.finalbuilder.com/resources/blogs/postid/702/dunitx-has-a-wizard).
 - The Starter Edition of Delphi doesn't allow the use of project experts.  DUnitX comes with an expert which will aid the student in creating a new DUnitX based project.  The expert creates the project's .DPR file.  The exercises in this track all include the .DPR file making the expert not necessary.  DUnitX otherwise has no issues with projects created in Delphi versions starting with XE all the way up to and including the Starter Edition of Berlin.
 
-### Delphi Configuration for DunitX ###
+### Delphi Configuration for DUnitX ###
 
 If you had to install DUnitX because your installation didn't already come with it then please follow the following illustrated steps to make the necessary configuration changes to Delphi in order for it to locate your installation of DUnitX.
 

data/tracks/delphi/exercises/isbn-verifier/ISBNVerifier.dpr

@@ -0,0 +1,60 @@
+program ISBNVerifier;
+
+{$IFNDEF TESTINSIGHT}
+{$APPTYPE CONSOLE}
+{$ENDIF}{$STRONGLINKTYPES ON}
+uses
+  System.SysUtils,
+  {$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX,
+  {$ENDIF }
+  DUnitX.Loggers.Console,
+  DUnitX.Loggers.Xml.NUnit,
+  DUnitX.TestFramework,
+  uTestISBNVerifier in 'uTestISBNVerifier.pas',
+  uISBNVerifier in 'uISBNVerifier.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/isbn-verifier/README.md

@@ -0,0 +1,68 @@
+# Isbn Verifier
+
+The [ISBN-10 verification process](https://en.wikipedia.org/wiki/International_Standard_Book_Number) is used to validate book identification
+numbers. These normally contain dashes and look like: `3-598-21508-8`
+
+## ISBN
+
+The ISBN-10 format is 9 digits (0 to 9) plus one check character (either a digit or an X only). In the case the check character is an X, this represents the value '10'. These may be communicated with or without hyphens, and can be checked for their validity by the following formula:
+
+```
+(x1 * 10 + x2 * 9 + x3 * 8 + x4 * 7 + x5 * 6 + x6 * 5 + x7 * 4 + x8 * 3 + x9 * 2 + x10 * 1) mod 11 == 0
+```
+
+If the result is 0, then it is a valid ISBN-10, otherwise it is invalid.
+
+## Example
+
+Let's take the ISBN-10 `3-598-21508-8`. We plug it in to the formula, and get:
+```
+(3 * 10 + 5 * 9 + 9 * 8 + 8 * 7 + 2 * 6 + 1 * 5 + 5 * 4 + 0 * 3 + 8 * 2 + 8 * 1) mod 11 == 0
+```
+
+Since the result is 0, this proves that our ISBN is valid.
+
+## Task
+
+Given a string the program should check if the provided string is a valid ISBN-10.
+Putting this into place requires some thinking about preprocessing/parsing of the string prior to calculating the check digit for the ISBN.
+
+The program should be able to verify ISBN-10 both with and without separating dashes.
+
+
+## Caveats
+
+Converting from strings to numbers can be tricky in certain languages.
+Now, it's even trickier since the check digit of an ISBN-10 may be 'X' (representing '10'). For instance `3-598-21507-X` is a valid ISBN-10.
+
+## Bonus tasks
+
+* Generate a valid ISBN-13 from the input ISBN-10 (and maybe verify it again with a derived verifier).
+
+* Generate valid ISBN, maybe even from a given starting ISBN.
+## Testing
+
+In order to run the tests for this track, you will need to install
+DUnitX. Please see the [installation](http://www.exercism.io/languages/delphi/installation) instructions for more information.
+
+### Loading Exercises into Delphi
+
+If Delphi is properly installed, and `*.dpr` file types have been associated with Delphi, then double clicking the supplied `*.dpr` file will start Delphi and load the exercise/project.  `control + F9` is the keyboard shortcut to compile the project or pressing `F9` will compile and run the project.
+
+Alternatively you may opt to start Delphi and load your project via. the `File` drop down menu.
+
+### When Questions Come Up
+We monitor the [Pascal-Delphi](https://gitter.im/exercism/Pascal-Delphi) support room on [gitter.im](https://gitter.im) to help you with any questions that might arise.
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the exercise file you're submitting is in the `exercism/delphi/<exerciseName>` directory.
+
+For example, if you're submitting `ubob.pas` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/delphi/bob/ubob.pas`.
+
+## Source
+
+Converting a string into a number and some basic processing utilizing a relatable real world example. [https://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digit_calculation](https://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digit_calculation)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/delphi/exercises/isbn-verifier/uISBNVerifierExample.pas

@@ -0,0 +1,46 @@
+unit uISBNVerifier;
+
+interface
+
+type
+  TIsbn = class
+  public
+    class function isValid(aInput: string): Boolean;
+  end;
+
+implementation
+uses sysutils, RegularExpressions;
+
+{ TIsbn }
+
+class function TIsbn.isValid(aInput: string): Boolean;
+var
+  wrkStr: string;
+  sum,
+  weight,
+  digit,
+  i: integer;
+begin
+  result := false;
+  wrkStr := aInput.replace('-','');
+
+  if TRegex.IsMatch(wrkStr, '^(\d{9}[\dX])$') then
+  begin
+    sum := 0;
+    weight := 10;
+    digit := 0;
+    for i := low(wrkStr) to high(wrkStr) do
+    begin
+      if (wrkStr[i] = 'X') and (i = 10) then
+        digit := 10
+      else
+        digit := string.ToInteger(wrkStr[i]);
+      sum := sum + (digit * weight);
+      dec(weight);
+    end;
+    result := sum mod 11 = 0;
+  end;
+
+end;
+
+end.