trackler 2.2.1.155 → 2.2.1.156

data/tracks/reasonml/README.md

@@ -0,0 +1,67 @@
+# Exercism ReasonML Track
+
+![build status](https://travis-ci.org/exercism/reasonml.svg?branch=master)
+
+Exercism exercises in ReasonML.
+
+## Setup
+
+The simplest way to install ReasonML is ...
+
+## Contributing
+
+Thank you so much for contributing! :tada:
+
+Please read about how to [get involved in a track](https://github.com/exercism/docs/tree/master/contributing-to-language-tracks). Be sure to read the Exercism [Code of Conduct](https://github.com/exercism/exercism.io/blob/master/CODE_OF_CONDUCT.md).
+
+We welcome pull requests of all kinds. No contribution is too small.
+
+We encourage contributions that provide fixes and improvements to existing exercises. Please note that this track's exercises must conform to the Exercism-wide standards described in the [documentation](https://github.com/exercism/docs/tree/master/language-tracks/exercises). If you're unsure about how to make a change, then go ahead and open a GitHub issue, and we'll discuss it.
+
+## Exercise Tests
+
+At the most basic level, Exercism is all about the tests. You can read more about how we think about test suites in [the Exercism documentation](https://github.com/exercism/docs/blob/master/language-tracks/exercises/anatomy/test-suites.md).
+
+Test files should use the following format:
+
+```
+# include the body of an example test
+```
+
+## Opening an Issue
+
+If you plan to make significant or breaking changes, please open an issue so we can discuss it first. If this is a discussion that is relevant to more than just the ReasonML track, please open an issue in [exercism/discussions](https://github.com/exercism/discussions/issues).
+
+## Submitting a Pull Request
+
+Pull requests should be focused on a single exercise, issue, or conceptually cohesive change. Please refer to Exercism's [pull request guidelines](https://github.com/exercism/docs/blob/master/contributing/pull-request-guidelines.md).
+
+Please follow the coding standards for ReasonML. (If there is a formatter for the track's language, add instructions for using it here.)
+
+### Verifying Your Change
+
+Before submitting your pull request, you'll want to verify the changes in two ways:
+
+* Run all the tests for the ReasonML exercises
+* Run an Exercism-specific linter to verify the track
+
+All the tests for ReasonML exercises can be run from the top level of the repo with
+
+```
+# add this command
+```
+
+For the Exercism-specific linting, please see [the documentation](https://github.com/exercism/docs/blob/master/language-tracks/configuration/linting.md).
+
+## Contributing a New Exercise
+
+Please see the documentation about [adding new exercises](https://github.com/exercism/docs/blob/master/you-can-help/make-up-new-exercises.md).
+
+Note that:
+
+- Each exercise must stand on its own. Do not reference files outside the exercise directory. They will not be included when the user fetches the exercise.
+- Exercises should use only the ReasonML core libraries.
+- Exercises must conform to the Exercism-wide standards described in [the documentation](https://github.com/exercism/docs/tree/master/language-tracks/exercises).
+- Each exercise should have a test suite, an example solution, a template file for the real implementation and ... (anything else that needs to go with each exercise for this track). The CI build expects files to be named using the following convention: (describe the ReasonML convention for naming the various files that make up an exercise).
+- Please do not commit any configuration files or directories inside the exercise other than ...
+- Be sure to add it to the appropriate place in the `config.json` file.

data/tracks/reasonml/bin/fetch-configlet

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+LATEST=https://github.com/exercism/configlet/releases/latest
+
+OS=$(
+case $(uname) in
+    (Darwin*)
+        echo "mac";;
+    (Linux*)
+        echo "linux";;
+    (Windows*)
+        echo "windows";;
+    (*)
+        echo "linux";;
+esac)
+
+ARCH=$(
+case $(uname -m) in
+    (*64*)
+        echo 64bit;;
+    (*686*)
+        echo 32bit;;
+    (*386*)
+        echo 32bit;;
+    (*)
+        echo 64bit;;
+esac)
+
+VERSION="$(curl --head --silent $LATEST | awk -v FS=/ '/Location:/{print $NF}' | tr -d '\r')"
+URL=https://github.com/exercism/configlet/releases/download/$VERSION/configlet-$OS-${ARCH}.tgz
+
+curl -s --location $URL | tar xz -C bin/

data/tracks/reasonml/config.json

@@ -0,0 +1,11 @@
+{
+  "track_id": "reasonml",
+  "language": "ReasonML",
+  "active": false,
+  "ignore_pattern": "[Ee]xample",
+  "solution_pattern": "[Ee]xample",
+  "test_pattern": "[Tt]est",
+  "foregone": [],
+  "exercises": null,
+  "deprecated": []
+}

data/tracks/reasonml/config/exercise_readme.go.tmpl

@@ -0,0 +1,16 @@
+# {{ .Spec.Name }}
+
+{{ .Spec.Description -}}
+{{- with .Hints }}
+{{ . }}
+{{ end }}
+{{- with .TrackInsert }}
+{{ . }}
+{{ end }}
+{{- with .Spec.Credits -}}
+## Source
+
+{{ . }}
+{{ end }}
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/reasonml/config/maintainers.json

@@ -0,0 +1,4 @@
+{
+  "docs_url": "https://github.com/exercism/docs/blob/master/maintaining-a-track/maintainer-configuration.md",
+  "maintainers": []
+}

data/tracks/scala/config.json

@@ -105,6 +105,17 @@
         "Mathematics"
       ]
     },
+    {
+      "uuid": "2bd9ab9e-ecc4-4331-984d-8e5f15f775b4",
+      "slug": "armstrong-numbers",
+      "core": false,
+      "unlocked_by": "leap",
+      "difficulty": 2,
+      "topics": [
+        "Integers",
+        "Mathematics"
+      ]
+    },
     {
       "uuid": "5a31217f-02fd-4be4-b64f-7a93f36f5140",
       "slug": "hamming",

data/tracks/scala/exercises/armstrong-numbers/README.md

@@ -0,0 +1,29 @@
+# Armstrong Numbers
+
+An [Armstrong number](https://en.wikipedia.org/wiki/Narcissistic_number) is a number that is the sum of its own digits each raised to the power of the number of digits.
+
+For example:
+
+- 9 is an Armstrong number, because `9 = 9^1 = 9`
+- 10 is *not* an Armstrong number, because `10 != 1^2 + 0^2 = 1`
+- 153 is an Armstrong number, because: `153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153`
+- 154 is *not* an Armstrong number, because: `154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`
+
+Write some code to determine whether a number is an Armstrong number.
+
+The Scala exercises assume an SBT project scheme. The exercise solution source
+should be placed within the exercise directory/src/main/scala. The exercise
+unit tests can be found within the exercise directory/src/test/scala.
+
+To run the tests simply run the command `sbt test` in the exercise directory.
+
+For more detailed info about the Scala track see the [help
+page](http://exercism.io/languages/scala).
+
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Narcissistic_number](https://en.wikipedia.org/wiki/Narcissistic_number)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/scala/exercises/armstrong-numbers/build.sbt

@@ -0,0 +1,3 @@
+scalaVersion := "2.12.1"
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/armstrong-numbers/example.scala

@@ -0,0 +1,7 @@
+object ArmstrongNumbers {
+  def isArmstrongNumber(i: Int): Boolean = {
+    val s = i.toString
+    val power = s.length
+    i == s.toStream.foldLeft(0.0)((acc, c) => acc + math.pow(c.asDigit, power))
+  }
+}

data/tracks/scala/exercises/armstrong-numbers/src/test/scala/ArmstrongNumbersTest.scala

@@ -0,0 +1,44 @@
+import org.scalatest.{Matchers, FunSuite}
+
+/** @version 1.0.0 */
+class ArmstrongNumbersTest extends FunSuite with Matchers {
+
+  test("Single digit numbers are Armstrong numbers") {
+    ArmstrongNumbers.isArmstrongNumber(5) should be (true)
+  }
+
+  test("There are no 2 digit Armstrong numbers") {
+    pending
+    ArmstrongNumbers.isArmstrongNumber(10) should be (false)
+  }
+
+  test("Three digit number that is an Armstrong number") {
+    pending
+    ArmstrongNumbers.isArmstrongNumber(153) should be (true)
+  }
+
+  test("Three digit number that is not an Armstrong number") {
+    pending
+    ArmstrongNumbers.isArmstrongNumber(100) should be (false)
+  }
+
+  test("Four digit number that is an Armstrong number") {
+    pending
+    ArmstrongNumbers.isArmstrongNumber(9474) should be (true)
+  }
+
+  test("Four digit number that is not an Armstrong number") {
+    pending
+    ArmstrongNumbers.isArmstrongNumber(9475) should be (false)
+  }
+
+  test("Seven digit number that is an Armstrong number") {
+    pending
+    ArmstrongNumbers.isArmstrongNumber(9926315) should be (true)
+  }
+
+  test("Seven digit number that is not an Armstrong number") {
+    pending
+    ArmstrongNumbers.isArmstrongNumber(9926314) should be (false)
+  }
+}

data/tracks/scala/testgen/src/main/scala/ArmstrongNumbersTestGenerator.scala

@@ -0,0 +1,33 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder._
+import testgen._
+
+object ArmstrongNumbersTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/armstrong-numbers.json")
+
+    def toString(expected: CanonicalDataParser.Expected): String = {
+      expected match {
+        case Right(b: Boolean) => b.toString
+        case _ => throw new IllegalStateException()
+      }
+    }
+
+    def fromLabeledTestFromInput(argNames: String*): ToTestCaseData =
+      withLabeledTest { sut =>
+        labeledTest =>
+          val args = sutArgsFromInput(labeledTest.result, argNames: _*)
+          val property = labeledTest.property
+          val sutCall =
+            s"""$sut.$property($args)"""
+          val expected = toString(labeledTest.expected)
+          TestCaseData(labeledTest.description, sutCall, expected)
+      }
+
+    val code = TestSuiteBuilder.build(file, fromLabeledTestFromInput("number"))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

data/tracks/scheme/config.json

@@ -128,6 +128,14 @@
       "topics": null,
       "unlocked_by": null,
       "uuid": "3ecc2d1c-55e0-45c9-ba35-57d7d8cfd51e"
+    },
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "atbash-cipher",
+      "topics": null,
+      "unlocked_by": null,
+      "uuid": "82169e85-3938-48da-ada9-7394adadc57a"
     }
   ],
   "foregone": [],

data/tracks/scheme/exercises/atbash-cipher/README.md

@@ -0,0 +1,36 @@
+# Atbash Cipher
+
+Create an implementation of the atbash cipher, an ancient encryption system created in the Middle East.
+
+The Atbash cipher is a simple substitution cipher that relies on
+transposing all the letters in the alphabet such that the resulting
+alphabet is backwards. The first letter is replaced with the last
+letter, the second with the second-last, and so on.
+
+An Atbash cipher for the Latin alphabet would be as follows:
+
+```text
+Plain:  abcdefghijklmnopqrstuvwxyz
+Cipher: zyxwvutsrqponmlkjihgfedcba
+```
+
+It is a very weak cipher because it only has one possible key, and it is
+a simple monoalphabetic substitution cipher. However, this may not have
+been an issue in the cipher's time.
+
+Ciphertext is written out in groups of fixed length, the traditional group size
+being 5 letters, and punctuation is excluded. This is to make it harder to guess
+things based on word boundaries.
+
+## Examples
+
+- Encoding `test` gives `gvhg`
+- Decoding `gvhg` gives `test`
+- Decoding `gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt` gives `thequickbrownfoxjumpsoverthelazydog`
+
+## Source
+
+Wikipedia [http://en.wikipedia.org/wiki/Atbash](http://en.wikipedia.org/wiki/Atbash)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/scheme/exercises/atbash-cipher/atbash-cipher-test.scm

@@ -0,0 +1,67 @@
+;; Load SRFI-64 lightweight testing specification
+(use-modules (srfi srfi-64))
+
+;; Suppress log file output. To write logs, comment out the following line:
+(module-define! (resolve-module '(srfi srfi-64)) 'test-log-to-file #f)
+
+;; Require module
+(add-to-load-path (dirname (current-filename)))
+(use-modules (atbash-cipher))
+
+(test-begin "atbash-cipher")
+
+;; Tests go here
+
+(test-equal "'yes' encoded is 'bvh'."
+  "bvh"
+  (encode "yes"))
+
+(test-equal "'no' encoded is 'ml'."
+  "ml"
+  (encode "no"))
+
+(test-equal "Encoding always returns lower-case letters."
+  "lnt"
+  (encode "OMG"))
+
+(test-equal "Encoding removes spaces from input."
+  "lnt"
+  (encode "O M G"))
+
+(test-equal "Encoded output includes a space every five characters."
+  "nrmwy oldrm tob"
+  (encode "mindblowingly"))
+
+(test-equal "Symbols are ignored, and numbers are passed-through unmodified"
+  "gvhgr mt123 gvhgr mt"
+  (encode "Testing,1 2 3, Testing."))
+
+(test-equal "Deep thoughts can be encoded"
+  "gifgs rhurx grlm"
+  (encode "Truth is fiction."))
+
+(test-equal "Every lowercase less has an encoding"
+  "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
+  (encode "The quick brown fox jumps over the lazy dog."))
+
+(test-equal "Unicode-range symbols are ignored"
+  "mlmzh xrrrt mlivw"
+  (encode "non ascii éignored"))
+
+(test-equal "Exercism can be decoded"
+  "exercism"
+  (decode "vcvix rhn"))
+
+(test-equal "Decodes a sentence"
+  "anobstacleisoftenasteppingstone"
+  (decode "zmlyh gzxov rhlug vmzhg vkkrm thglm v"))
+
+(test-equal "Decoding ignores symbols and passes-through numbers just like encoding"
+  "testing123testing"
+  (decode "gvhgr mt123 gvhgr mt"))
+
+(test-equal "Every lowercase letter can be decoded"
+  "thequickbrownfoxjumpsoverthelazydog"
+  (decode "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"))
+
+(test-end "atbash-cipher")

data/tracks/scheme/exercises/atbash-cipher/atbash-cipher.scm

@@ -0,0 +1,8 @@
+(define-module (atbash-cipher)
+  #:export (encode decode))
+
+(define (encode phrase)
+  "")
+
+(define (decode ciphertext)
+  "")

data/tracks/scheme/exercises/atbash-cipher/example.scm

@@ -0,0 +1,40 @@
+(define-module (atbash-cipher)
+  #:autoload (srfi srfi-26) (cut)
+  #:autoload (srfi srfi-1) (iota)
+  #:autoload (ice-9 regex) (regexp-substitute/global
+                            list-matches)
+  #:export (encode decode))
+
+;; "zip" a...z and z...a together to create an alist of mappings.
+(define alphamap
+  (let* ((alpha (map integer->char (iota 26 (char->integer #\a)))))
+    (map cons alpha (reverse alpha))))
+
+;; Look up the given character in the alphamap and return its complement.
+(define (convert-char chr)
+  (or (assoc-ref alphamap chr) chr))
+
+;; Encode the given "val" string using the Atbash cipher.
+(define (encode val)
+  (format-atbash (string-map convert-char (prepare-input val))))
+
+;; Decode the given Atbash cipher.
+(define (decode val)
+  (string-map convert-char (prepare-input val)))
+
+;; Filter any unprocessable characters out of the plain text.
+;; Only lowercase a-z and 0-9 are allowed.
+(define (prepare-input val)
+  (regexp-substitute/global #f "[^a-z0-9]" (string-downcase val) 'pre "" 'post))
+
+;; Format atbash ciphertext for output.
+;; Add a space every 5 characters
+;; Currently generates a preceeding space, which must be trimmed :(
+(define (format-atbash val)
+  (string-trim
+   (string-concatenate
+    (map (compose (cut string-append " " <>)
+                  match:substring)
+         (list-matches "[a-z0-9]{1,5}" val)))))
+
+