trackler 2.2.1.111 → 2.2.1.113

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

@@ -1,7 +1,7 @@
 import java.io.File
 
 import PrimeFactorsTestGenerator.toString
-import testgen.TestSuiteBuilder.{sutArgs, _}
+import testgen.TestSuiteBuilder.{sutArgs, toString, _}
 import testgen._
 
 object SayTestGenerator {
@@ -16,8 +16,8 @@ object SayTestGenerator {
       }
     }
 
-    def sutArgs(parseResult: CanonicalDataParser.ParseResult, argNames: String*): String =
-      argNames map (name => toArgString(parseResult(name))) mkString ", "
+    def sutArgsFromInput(parseResult: CanonicalDataParser.ParseResult, argNames: String*): String =
+      argNames map (name => toArgString(parseResult("input").asInstanceOf[Map[String, Any]](name))) mkString ", "
 
     def toArgString(any: Any): String = {
       any match {
@@ -31,10 +31,10 @@ object SayTestGenerator {
       }
     }
 
-    def fromLabeledTest(argNames: String*): ToTestCaseData =
+    def fromLabeledTestFromInput(argNames: String*): ToTestCaseData =
       withLabeledTest { sut =>
         labeledTest =>
-          val args = sutArgs(labeledTest.result, argNames: _*)
+          val args = sutArgsFromInput(labeledTest.result, argNames: _*)
           val property = labeledTest.property
           val sutCall =
             s"""$sut.inEnglish($args)"""
@@ -42,7 +42,7 @@ object SayTestGenerator {
           TestCaseData(labeledTest.description, sutCall, expected)
       }
 
-    val code = TestSuiteBuilder.build(file, fromLabeledTest("input"))
+    val code = TestSuiteBuilder.build(file, fromLabeledTestFromInput("number"))
     println(s"-------------")
     println(code)
     println(s"-------------")

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

@@ -1,13 +1,13 @@
 import java.io.File
 
 import testgen.TestSuiteBuilder
-import testgen.TestSuiteBuilder.fromLabeledTest
+import testgen.TestSuiteBuilder.fromLabeledTestFromInput
 
 object ScrabbleScoreTestGenerator {
   def main(args: Array[String]): Unit = {
     val file = new File("src/main/resources/scrabble-score.json")
 
-    val code = TestSuiteBuilder.build(file, fromLabeledTest("input"))
+    val code = TestSuiteBuilder.build(file, fromLabeledTestFromInput("word"))
     println(s"-------------")
     println(code)
     println(s"-------------")

data/tracks/typescript/config.json

@@ -36,6 +36,22 @@
       ],
       "uuid": "fb80f76c-42da-4f62-9f0f-8c85d984908b"
     },
+    {
+      "core": true,
+      "difficulty": 1,
+      "slug": "simple-cipher",
+      "topics": [
+        "algorithms",
+        "control_flow_conditionals",
+        "control_flow_loops",
+        "mathematics",
+        "randomness",
+        "strings",
+        "text_formatting",
+        "transforming"
+      ],
+      "uuid": "3ea9d03e-6d06-48e5-a4d3-6e1bb9367c2f"
+    },
     {
       "core": false,
       "difficulty": 2,

data/tracks/typescript/exercises/simple-cipher/README.md

@@ -0,0 +1,114 @@
+# Simple Cipher
+
+Implement a simple shift cipher like Caesar and a more secure substitution cipher.
+
+## Step 1
+
+"If he had anything confidential to say, he wrote it in cipher, that is,
+by so changing the order of the letters of the alphabet, that not a word
+could be made out. If anyone wishes to decipher these, and get at their
+meaning, he must substitute the fourth letter of the alphabet, namely D,
+for A, and so with the others."
+—Suetonius, Life of Julius Caesar
+
+Ciphers are very straight-forward algorithms that allow us to render
+text less readable while still allowing easy deciphering. They are
+vulnerable to many forms of cryptoanalysis, but we are lucky that
+generally our little sisters are not cryptoanalysts.
+
+The Caesar Cipher was used for some messages from Julius Caesar that
+were sent afield. Now Caesar knew that the cipher wasn't very good, but
+he had one ally in that respect: almost nobody could read well. So even
+being a couple letters off was sufficient so that people couldn't
+recognize the few words that they did know.
+
+Your task is to create a simple shift cipher like the Caesar Cipher.
+This image is a great example of the Caesar Cipher:
+
+![Caesar Cipher][1]
+
+For example:
+
+Giving "iamapandabear" as input to the encode function returns the cipher "ldpdsdqgdehdu". Obscure enough to keep our message secret in transit.
+
+When "ldpdsdqgdehdu" is put into the decode function it would return
+the original "iamapandabear" letting your friend read your original
+message.
+
+## Step 2
+
+Shift ciphers are no fun though when your kid sister figures it out. Try
+amending the code to allow us to specify a key and use that for the
+shift distance. This is called a substitution cipher.
+
+Here's an example:
+
+Given the key "aaaaaaaaaaaaaaaaaa", encoding the string "iamapandabear"
+would return the original "iamapandabear".
+
+Given the key "ddddddddddddddddd", encoding our string "iamapandabear"
+would return the obscured "ldpdsdqgdehdu"
+
+In the example above, we've set a = 0 for the key value. So when the
+plaintext is added to the key, we end up with the same message coming
+out. So "aaaa" is not an ideal key. But if we set the key to "dddd", we
+would get the same thing as the Caesar Cipher.
+
+## Step 3
+
+The weakest link in any cipher is the human being. Let's make your
+substitution cipher a little more fault tolerant by providing a source
+of randomness and ensuring that the key contains only lowercase letters.
+
+If someone doesn't submit a key at all, generate a truly random key of
+at least 100 characters in length.
+
+If the key submitted is not composed only of lowercase letters, your
+solution should handle the error in a language-appropriate way.
+
+## Extensions
+
+Shift ciphers work by making the text slightly odd, but are vulnerable
+to frequency analysis. Substitution ciphers help that, but are still
+very vulnerable when the key is short or if spaces are preserved. Later
+on you'll see one solution to this problem in the exercise
+"crypto-square".
+
+If you want to go farther in this field, the questions begin to be about
+how we can exchange keys in a secure way. Take a look at [Diffie-Hellman
+on Wikipedia][dh] for one of the first implementations of this scheme.
+
+[1]: https://upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Caesar_cipher_left_shift_of_3.svg/320px-Caesar_cipher_left_shift_of_3.svg.png
+[dh]: http://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange
+
+## Setup
+
+Go through the setup instructions for TypeScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/typescript
+
+## Requirements
+
+Install assignment dependencies:
+
+```bash
+$ yarn install
+```
+
+## Making the test suite pass
+
+Execute the tests with:
+
+```bash
+$ yarn test
+```
+
+
+
+## Source
+
+Substitution Cipher at Wikipedia [http://en.wikipedia.org/wiki/Substitution_cipher](http://en.wikipedia.org/wiki/Substitution_cipher)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/typescript/exercises/simple-cipher/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "xtypescript",
+  "version": "1.0.0",
+  "description": "Exercism exercises in Typescript.",
+  "author": "",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/xtypescript"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "tsc --noEmit -p . && jest --no-cache",
+    "lint": "tsc --noEmit -p . && tslint \"*.ts?(x)\"",
+    "lintci": "tslint \"*.ts?(x)\" --force"
+  },
+  "dependencies": {
+    "@types/jest": "^21.1.5",
+    "@types/node": "^8.0.47",
+    "jest": "^21.2.1",
+    "ts-jest": "^21.1.3",
+    "tslint": "^5.8.0",
+    "typescript": "^2.5.3"
+  },
+  "jest": {
+    "transform": {
+      ".(ts|tsx)": "<rootDir>/node_modules/ts-jest/preprocessor.js"
+    },
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js"
+    ]
+  }
+}

data/tracks/typescript/exercises/simple-cipher/simple-cipher.example.ts

@@ -0,0 +1,42 @@
+class SimpleCipher {
+    key: string
+
+    constructor(key?: string) {
+        if (key === undefined) {
+            for (let i = 0; i < 100; i++) {
+                this.key += String.fromCharCode(Math.random() * 26 + 97)
+            }
+        } else {
+            this.key = key!
+        }
+        if (!/[a-z]/.test(key!)) {
+            throw new Error('Bad key')
+        }
+    }
+
+    encode(decodedMessage: string): string {
+        let encodedMessage = ''
+        for (let i = 0; i < decodedMessage.length; i++) {
+            let encodedChar = String.fromCharCode(decodedMessage.charCodeAt(i) + (this.key.charCodeAt(i % this.key.length) - 97))
+            if (encodedChar.charCodeAt(0) > 122) {
+                encodedChar = String.fromCharCode(encodedChar.charCodeAt(0) - 26)
+            }
+            encodedMessage += encodedChar
+        }
+        return encodedMessage
+    }
+
+    decode(encodedMessage: string): string {
+        let decodedMessage = ''
+        for (let i = 0; i < encodedMessage.length; i++) {
+            let decodedChar = String.fromCharCode(encodedMessage.charCodeAt(i) - (this.key.charCodeAt(i % this.key.length) - 97))
+            if (decodedChar.charCodeAt(0) < 97) {
+                decodedChar = String.fromCharCode(decodedChar.charCodeAt(0) + 26)
+            }
+            decodedMessage += decodedChar
+        }
+        return decodedMessage
+    }
+}
+
+export default SimpleCipher

data/tracks/typescript/exercises/simple-cipher/simple-cipher.test.ts

@@ -0,0 +1,84 @@
+import SimpleCipher from './simple-cipher'
+
+describe('Random key cipher', () => {
+    const simpleCipher = new SimpleCipher()
+
+    it('has a key made of letters', () => {
+        expect(simpleCipher.key).toMatch(/^[a-z]+$/)
+    })
+
+    // Here we take advantage of the fact that plaintext of "aaa..."
+    // outputs the key. This is a critical problem with shift ciphers, some
+    // characters will always output the key verbatim.
+    xit('can encode', () => {
+        expect(simpleCipher.encode('aaaaaaaaaa')).toEqual(simpleCipher.key.substr(0, 10))
+    })
+
+    xit('can decode', () => {
+        expect(simpleCipher.decode(simpleCipher.key.substr(0, 10))).toEqual('aaaaaaaaaa')
+    })
+
+    xit('is reversible', () => {
+        const plaintext = 'abcdefghij'
+        expect(simpleCipher.decode(simpleCipher.encode(plaintext))).toEqual(plaintext)
+    })
+})
+
+describe('Incorrect key cipher', () => {
+    xit('throws an error with an all caps key', () => {
+        expect(() => {
+            new SimpleCipher('ABCDEF')
+        }).toThrowError('Bad key')
+    })
+
+    xit('throws an error with a numeric key', () => {
+        expect(() => {
+            new SimpleCipher('12345')
+        }).toThrow('Bad key')
+    })
+
+    xit('throws an error with an empty key', () => {
+        expect(() => {
+            new SimpleCipher('')
+        }).toThrow('Bad key')
+    })
+})
+
+describe('Substitution cipher', () => {
+    const key = 'abcdefghij'
+    const simpleCipher = new SimpleCipher(key)
+
+    xit('keeps the submitted key', () => {
+        expect(simpleCipher.key).toEqual(key)
+    })
+
+    xit('can encode', () => {
+        expect(simpleCipher.encode('aaaaaaaaaa')).toEqual('abcdefghij')
+    })
+
+    xit('can decode', () => {
+        expect(simpleCipher.decode('abcdefghij')).toEqual('aaaaaaaaaa')
+    })
+
+    xit('is reversible', () => {
+        expect(simpleCipher.decode(simpleCipher.encode('abcdefghij'))).toEqual('abcdefghij')
+    })
+
+    xit(': double shift encode', () => {
+        expect(new SimpleCipher('iamapandabear').encode('iamapandabear'))
+            .toEqual('qayaeaagaciai')
+    })
+
+    xit('can wrap on encode', () => {
+        expect(simpleCipher.encode('zzzzzzzzzz')).toEqual('zabcdefghi')
+    })
+
+    xit('can wrap on decode', () => {
+        expect(simpleCipher.decode('zabcdefghi')).toEqual('zzzzzzzzzz')
+    })
+
+    xit('can handle messages longer than the key', () => {
+        expect(new SimpleCipher('abc').encode('iamapandabear'))
+            .toEqual('iboaqcnecbfcr')
+    })
+})

data/tracks/typescript/exercises/simple-cipher/simple-cipher.ts

@@ -0,0 +1,11 @@
+class SimpleCipher {
+    encode( /* Parameters go here */ ) {
+        // Your code here
+    }
+
+    decode( /* Parameters go here */ ) {
+        // Your code here
+    }
+}
+
+export default SimpleCipher

data/tracks/typescript/exercises/simple-cipher/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": { 
+        "target": "es2017",
+        "module": "commonjs",
+        "alwaysStrict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "preserveConstEnums": true,
+        "noFallthroughCasesInSwitch":true,
+        "noImplicitThis":true,
+        "noImplicitReturns":true,
+        "sourceMap": true,
+        "noEmitOnError": true,
+        "outDir": "./build"
+    },
+    "compileOnSave": true, 
+    "exclude": [
+        "node_modules"
+    ]
+}

data/tracks/typescript/exercises/simple-cipher/tslint.json

@@ -0,0 +1,127 @@
+{
+    "jsRules": {
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "indent": [
+            true,
+            "spaces"
+        ],
+        "no-duplicate-variable": true,
+        "no-eval": true,
+        "no-trailing-whitespace": true,
+        "no-unsafe-finally": true,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "quotemark": [
+            false,
+            "double"
+        ],
+        "semicolon": [
+            true,
+            "never"
+        ],
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "variable-name": [
+            true,
+            "ban-keywords"
+        ],
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type"
+        ]
+    },
+    "rules": {
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "indent": [
+            true,
+            "spaces"
+        ],
+        "no-eval": true,
+        "no-internal-module": true,
+        "no-trailing-whitespace": true,
+        "no-unsafe-finally": true,
+        "no-var-keyword": true,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "semicolon": [
+            true,
+            "never"
+        ],
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "typedef-whitespace": [
+            true,
+            {
+                "call-signature": "nospace",
+                "index-signature": "nospace",
+                "parameter": "nospace",
+                "property-declaration": "nospace",
+                "variable-declaration": "nospace"
+            }
+        ],
+        "variable-name": [
+            true,
+            "ban-keywords"
+        ],
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type"
+        ],
+        "no-namespace": true, 
+        "prefer-for-of": true,
+        "only-arrow-functions": [true, "allow-declarations"],
+        "no-var-requires": true,
+        "no-any": true,
+        "curly": true,
+        "forin": true,
+        "no-arg": true,
+        "label-position": true,
+        "no-conditional-assignment": true,
+        "no-console": [true, "log", "error"],
+        "no-construct": true,
+        "no-duplicate-variable": true,
+        "no-empty": true,
+        "no-invalid-this": [true, "check-function-in-method"],
+        "no-misused-new": true,
+        "no-null-keyword": true,
+        "no-string-literal": true,
+        "radix": true,
+        "typeof-compare": true,
+        "use-isnan": true,
+        "prefer-const": true,
+        "array-type": [true, "array-simple"],
+        "arrow-parens": true,
+        "new-parens": true,
+        "no-consecutive-blank-lines": [true,1],
+        "no-parameter-properties": true,
+        "no-unnecessary-initializer": true,
+        "object-literal-shorthand": true,
+        "object-literal-key-quotes": [true, "as-needed"]
+    }
+}