trackler 2.2.1.125 → 2.2.1.126

data/tracks/typescript/exercises/anagram/anagram.example.ts

@@ -8,11 +8,11 @@ class Anagram {
         this.value = input
     }
 
-   matches(...input: string[]): string[] {
+    matches(...input: string[]): string[] {
         const result: string[] = []
         for (const each of input) {
-            if ( sort(each) === sort(this.value) ) {
-                if (each.toLowerCase() === this.value.toLowerCase()) {continue}
+            if (sort(each) === sort(this.value)) {
+                if (each.toLowerCase() === this.value.toLowerCase()) { continue }
                 result.push(each)
             }
         }

data/tracks/typescript/exercises/anagram/anagram.test.ts

@@ -1,82 +1,80 @@
 import Anagram from './anagram'
 
 describe('Anagram', () => {
+    it("no matches", () => {
+        const subject = new Anagram("diaper")
+        const matches = subject.matches(...["hello", "world", "zombies", "pants"])
 
-  it("no matches", () => {
-    const subject = new Anagram("diaper")
-    const matches = subject.matches(...[ "hello", "world", "zombies", "pants"])
+        expect(matches).toEqual([])
+    })
 
-    expect(matches).toEqual([])
-  })
+    xit("detects simple anagram", () => {
+        const subject = new Anagram("ant")
+        const matches = subject.matches(...['tan', 'stand', 'at'])
 
-  xit("detects simple anagram", () => {
-    const subject = new Anagram("ant")
-    const matches = subject.matches(...['tan', 'stand', 'at'])
+        expect(matches).toEqual(['tan'])
+    })
 
-    expect(matches).toEqual(['tan'])
-  })
+    xit("does not detect false positives", () => {
+        const subject = new Anagram("galea")
+        const matches = subject.matches(...["eagle"])
 
-  xit("does not detect false positives", () => {
-    const subject = new Anagram("galea")
-    const matches = subject.matches(...["eagle"])
+        expect(matches).toEqual([])
+    })
 
-    expect(matches).toEqual([])
-  })
+    xit("detects multiple anagrams", () => {
+        const subject = new Anagram("master")
+        const matches = subject.matches(...['stream', 'pigeon', 'maters'])
 
-  xit("detects multiple anagrams", () => {
-    const subject = new Anagram("master")
-    const matches = subject.matches(...['stream', 'pigeon', 'maters'])
+        expect(matches).toEqual(['stream', 'maters'])
+    })
 
-    expect(matches).toEqual(['stream', 'maters'])
-  })
+    xit("does not detect anagram subsets", () => {
+        const subject = new Anagram("good")
+        const matches = subject.matches(...['dog', 'goody'])
 
-  xit("does not detect anagram subsets", () => {
-    const subject = new Anagram("good")
-    const matches = subject.matches(...['dog', 'goody'])
+        expect(matches).toEqual([])
+    })
 
-    expect(matches).toEqual([])
-  })
+    xit("detects anagram", () => {
+        const subject = new Anagram("listen")
+        const matches = subject.matches(...['enlists', 'google', 'inlets', 'banana'])
 
-  xit("detects anagram", () => {
-    const subject = new Anagram("listen")
-    const matches = subject.matches(...['enlists', 'google', 'inlets', 'banana'])
+        expect(matches).toEqual(['inlets'])
+    })
 
-    expect(matches).toEqual(['inlets'])
-  })
+    xit("detects multiple anagrams", () => {
+        const subject = new Anagram("allergy")
+        const matches = subject.matches(...['gallery', 'ballerina', 'regally', 'clergy', 'largely', 'leading'])
 
-  xit("detects multiple anagrams", () => {
-    const subject = new Anagram("allergy")
-    const matches = subject.matches(...['gallery', 'ballerina', 'regally', 'clergy', 'largely', 'leading'])
+        expect(matches).toEqual(['gallery', 'regally', 'largely'])
+    })
 
-    expect(matches).toEqual(['gallery', 'regally', 'largely'])
-  })
+    xit("detects anagrams case-insensitively", () => {
+        const subject = new Anagram("Orchestra")
+        const matches = subject.matches(...['cashregister', 'Carthorse', 'radishes'])
 
-  xit("detects anagrams case-insensitively", () => {
-    const subject = new Anagram("Orchestra")
-    const matches = subject.matches(...['cashregister', 'Carthorse', 'radishes'])
+        expect(matches).toEqual(['Carthorse'])
+    })
 
-    expect(matches).toEqual(['Carthorse'])
-  })
+    xit("does not detect a word as its own anagram", () => {
+        const subject = new Anagram("banana")
+        const matches = subject.matches(...['Banana'])
 
-  xit("does not detect a word as its own anagram", () => {
-    const subject = new Anagram("banana")
-    const matches = subject.matches(...['Banana'])
+        expect(matches).toEqual([])
+    })
 
-    expect(matches).toEqual([])
-  })
+    xit("matches() accepts string arguments", () => {
+        const subject = new Anagram("ant")
+        const matches = subject.matches("stand", "tan", "at")
 
-  xit("matches() accepts string arguments", () => {
-    const subject = new Anagram("ant")
-    const matches = subject.matches("stand", "tan", "at")
+        expect(matches).toEqual(["tan"])
+    })
 
-    expect(matches).toEqual(["tan"])
-  })
-
-  xit("matches() accepts single string argument", () => {
-    const subject = new Anagram("ant")
-    const matches = subject.matches("tan")
-
-    expect(matches).toEqual(["tan"])
-  })
+    xit("matches() accepts single string argument", () => {
+        const subject = new Anagram("ant")
+        const matches = subject.matches("tan")
 
+        expect(matches).toEqual(["tan"])
+    })
 })

data/tracks/typescript/exercises/anagram/anagram.ts

@@ -1,5 +0,0 @@
-export default class Anagram {
-	public matches(...input: string[]): string[]  {
-		return []
-	}
-}

data/tracks/typescript/exercises/crypto-square/README.md

@@ -0,0 +1,102 @@
+# Crypto Square
+
+Implement the classic method for composing secret messages called a square code.
+
+Given an English text, output the encoded version of that text.
+
+First, the input is normalized: the spaces and punctuation are removed
+from the English text and the message is downcased.
+
+Then, the normalized characters are broken into rows.  These rows can be
+regarded as forming a rectangle when printed with intervening newlines.
+
+For example, the sentence
+
+> If man was meant to stay on the ground, god would have given us roots.
+
+is normalized to:
+
+> ifmanwasmeanttostayonthegroundgodwouldhavegivenusroots
+
+The plaintext should be organized in to a rectangle.  The size of the
+rectangle (`r x c`) should be decided by the length of the message,
+such that `c >= r` and `c - r <= 1`, where `c` is the number of columns
+and `r` is the number of rows.
+
+Our normalized text is 54 characters long, dictating a rectangle with
+`c = 8` and `r = 7`:
+
+```text
+ifmanwas
+meanttos
+tayonthe
+groundgo
+dwouldha
+vegivenu
+sroots
+```
+
+The coded message is obtained by reading down the columns going left to
+right.
+
+The message above is coded as:
+
+```text
+imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau
+```
+
+Output the encoded text in chunks.  Phrases that fill perfect rectangles
+`(r X c)` should be output `c` chunks of `r` length, separated by spaces.
+Phrases that do not fill perfect rectangles will have `n` empty spaces.
+Those spaces should be distributed evenly, added to the end of the last
+`n` chunks.
+
+```text
+imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau 
+```
+
+Notice that were we to stack these, we could visually decode the
+cyphertext back in to the original message:
+
+```text
+imtgdvs
+fearwer
+mayoogo
+anouuio
+ntnnlvt
+wttddes
+aohghn
+sseoau
+```
+
+## 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
+
+J Dalbey's Programming Practice problems [http://users.csc.calpoly.edu/~jdalbey/103/Projects/ProgrammingPractice.html](http://users.csc.calpoly.edu/~jdalbey/103/Projects/ProgrammingPractice.html)
+
+## 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/crypto-square/crypto-square.example.ts

@@ -0,0 +1,59 @@
+export default class Square {
+    input: string
+
+    constructor(input: string) {
+        this.input = input
+    }
+
+    normalizePlaintext(): string {
+        return this.input.toLowerCase().replace(/[^a-zA-Z0-9]/g, '')
+    }
+
+    size() {
+        const realLength = Math.sqrt(this.normalizePlaintext().length)
+        return Math.ceil(realLength)
+    }
+
+    plaintextSegments() {
+        const plainText = this.normalizePlaintext()
+        const chunkSize = this.size()
+
+        const splitRegex = new RegExp(`.{1,${chunkSize}}`, 'g')
+        return plainText.match(splitRegex)
+    }
+
+    ciphertext() {
+        const textSegments = this.plaintextSegments()
+        let i
+        let j
+        // tslint:disable-next-line: no-any
+        const columns: any[] = []
+        let currentSegment
+        let currentLetter
+
+        for (i = 0; i < this.size(); i++) {
+            columns.push([])
+        }
+
+        for (i = 0; i < textSegments!.length; i++) {
+            currentSegment = textSegments![i]
+
+            for (j = 0; j < currentSegment.length; j++) {
+                currentLetter = currentSegment[j]
+                columns[j].push(currentLetter)
+            }
+        }
+
+        for (i = 0; i < columns.length; i++) {
+            columns[i] = columns[i].join('')
+        }
+
+        return columns.join('')
+    }
+
+    normalizeCiphertext() {
+        const chunkSize = this.size()
+        const splitRegex = new RegExp(`.{1,${chunkSize}}`, 'g')
+        return this.ciphertext().match(splitRegex)!.join(' ')
+    }
+}

data/tracks/typescript/exercises/crypto-square/crypto-square.test.ts

@@ -0,0 +1,53 @@
+import Crypto from './crypto-square'
+
+describe('Crypto', () => {
+    it('normalize strange characters', () => {
+        const crypto = new Crypto('s#$%^&plunk')
+        expect(crypto.normalizePlaintext()).toEqual('splunk')
+    })
+
+    xit('normalize numbers', () => {
+        const crypto = new Crypto('1, 2, 3 GO!')
+        expect(crypto.normalizePlaintext()).toEqual('123go')
+    })
+
+    xit('size of small square', () => {
+        const crypto = new Crypto('1234')
+        expect(crypto.size()).toEqual(2)
+    })
+
+    xit('size of small square with additional non-number chars', () => {
+        const crypto = new Crypto('1 2 3 4')
+        expect(crypto.size()).toEqual(2)
+    })
+
+    xit('size of slightly larger square', () => {
+        const crypto = new Crypto('123456789')
+        expect(crypto.size()).toEqual(3)
+    })
+
+    xit('size of non-perfect square', () => {
+        const crypto = new Crypto('123456789abc')
+        expect(crypto.size()).toEqual(4)
+    })
+
+    xit('plain text segments', () => {
+        const crypto = new Crypto('Never vex thine heart with idle woes')
+        expect(crypto.plaintextSegments()).toEqual(['neverv', 'exthin', 'eheart', 'withid', 'lewoes'])
+    })
+
+    xit('plain text segments', () => {
+        const crypto = new Crypto('ZOMG! ZOMBIES!!!')
+        expect(crypto.plaintextSegments()).toEqual(['zomg', 'zomb', 'ies'])
+    })
+
+    xit('cipher text', () => {
+        const crypto = new Crypto('Time is an illusion. Lunchtime doubly so.')
+        expect(crypto.ciphertext()).toEqual('tasneyinicdsmiohooelntuillibsuuml')
+    })
+
+    xit('cipher text', () => {
+        const crypto = new Crypto('We all know interspecies romance is weird.')
+        expect(crypto.ciphertext()).toEqual('wneiaweoreneawssciliprerlneoidktcms')
+    })
+})

data/tracks/typescript/exercises/crypto-square/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/crypto-square/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/crypto-square/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"]
+    }
+}