trackler 2.2.1.57 → 2.2.1.58

data/tracks/sml/exercises/pig-latin/testlib.sml

@@ -0,0 +1,159 @@
+structure Expect =
+struct
+  datatype expectation = Pass | Fail of string * string
+
+  local
+    fun failEq b a =
+      Fail ("Expected: " ^ b, "Got: " ^ a)
+    
+    fun failExn b a =
+      Fail ("Expected: " ^ b, "Raised: " ^ a)
+
+    fun exnName (e: exn): string = General.exnName e
+  in
+    fun truthy a =
+      if a
+      then Pass
+      else failEq "true" "false"
+
+    fun falsy a =
+      if a
+      then failEq "false" "true"
+      else Pass
+
+    fun equalTo b a = 
+      if a = b
+      then Pass
+      else failEq (PolyML.makestring b) (PolyML.makestring a)
+
+    fun nearTo b a =
+      if Real.== (a, b)
+      then Pass
+      else failEq (Real.toString b) (Real.toString a)
+
+    fun anyError f =
+      (
+        f ();
+        failExn "an exception" "Nothing"
+      ) handle _ => Pass
+
+    fun error e f =
+      (
+        f ();
+        failExn (exnName e) "Nothing"
+      ) handle e' => if exnMessage e' = exnMessage e
+                     then Pass
+                     else failExn (exnMessage e) (exnMessage e')
+  end
+end
+
+structure TermColor =
+struct
+  datatype color = Red | Green | Yellow | Normal
+
+  fun f Red    = "\027[31m"
+    | f Green  = "\027[32m"
+    | f Yellow = "\027[33m"
+    | f Normal = "\027[0m"
+
+  fun colorize color s = (f color) ^ s ^ (f Normal)
+
+  val redit = colorize Red
+
+  val greenit = colorize Green
+
+  val yellowit = colorize Yellow
+end
+
+structure Test =
+struct
+  datatype testnode = TestGroup of string * testnode list
+                    | Test of string * (unit -> Expect.expectation)
+
+  local
+    datatype evaluation = Success of string
+                        | Failure of string * string * string
+                        | Error of string * string
+
+    fun indent n s = (implode (List.tabulate (n, fn _ => #" "))) ^ s
+
+    fun fmt indentlvl ev =
+      let
+        val check = TermColor.greenit "\226\156\148 " (* ✔ *)
+        val cross = TermColor.redit "\226\156\150 "   (* ✖ *)
+        val indentlvl = indentlvl * 2
+      in
+      case ev of
+        Success descr => indent indentlvl (check ^ descr)
+      | Failure (descr, exp, got) =>
+          String.concatWith "\n" [indent indentlvl (cross ^ descr),
+                                  indent (indentlvl + 2) exp,
+                                  indent (indentlvl + 2) got]
+      | Error (descr, reason) =>
+          String.concatWith "\n" [indent indentlvl (cross ^ descr),
+                                  indent (indentlvl + 2) (TermColor.redit reason)]
+      end
+
+    fun eval (TestGroup _) = raise Fail "Only a 'Test' can be evaluated"
+      | eval (Test (descr, thunk)) =
+          (
+            case thunk () of
+              Expect.Pass   => ((1, 0, 0), Success descr)
+            | Expect.Fail (s, s') => ((0, 1, 0), Failure (descr, s, s'))
+          )
+          handle e => ((0, 0, 1), Error (descr, "Unexpected error: " ^ exnMessage e))
+
+    fun flatten depth testnode =
+      let
+        fun sum (x, y, z) (a, b, c) = (x + a, y + b, z + c)
+
+        fun aux (t, (counter, acc)) =
+          let
+            val (counter', texts) = flatten (depth + 1) t
+          in
+            (sum counter' counter, texts :: acc)
+          end
+      in
+        case testnode of
+          TestGroup (descr, ts) =>
+            let
+              val (counter, texts) = foldr aux ((0, 0, 0), []) ts
+            in
+              (counter, (indent (depth * 2) descr) :: List.concat texts)
+            end
+        | Test _ =>
+            let
+              val (counter, evaluation) = eval testnode
+            in
+              (counter, [fmt depth evaluation])
+            end
+      end
+    
+    fun println s = print (s ^ "\n")
+  in
+    fun run suite =
+      let
+        val ((succeeded, failed, errored), texts) = flatten 0 suite
+
+        val summary = String.concatWith ", " [
+          TermColor.greenit ((Int.toString succeeded) ^ " passed"),
+          TermColor.redit ((Int.toString failed) ^ " failed"),
+          TermColor.redit ((Int.toString errored) ^ " errored"),
+          (Int.toString (succeeded + failed + errored)) ^ " total"
+        ]
+        
+        val status = if failed = 0 andalso errored = 0
+                     then OS.Process.success
+                     else OS.Process.failure
+
+      in
+        List.app println texts;
+        println "";
+        println ("Tests: " ^ summary);
+        OS.Process.exit status
+      end
+  end
+end
+
+fun describe description tests = Test.TestGroup (description, tests)
+fun test description thunk = Test.Test (description, thunk)

data/tracks/typescript/config.json

@@ -479,6 +479,22 @@
       ],
       "unlocked_by": "wordy",
       "uuid": "abe907d0-7ca0-4fe5-83fd-72a4d2acab66"
+    },
+    {
+      "core": false,
+      "difficulty": 5,
+      "slug": "ocr-numbers",
+      "topics": [
+        "control_flow_conditionals",
+        "control_flow_loops",
+        "exception_handling",
+        "equality",
+        "parsing",
+        "integers",
+        "text_formatting"
+      ],
+      "unlocked_by": "matrix",
+      "uuid": "61f0964f-0779-446d-bd6b-6bb988414302"
     }
   ],
   "foregone": [],

data/tracks/typescript/exercises/ocr-numbers/README.md

@@ -0,0 +1,110 @@
+# Ocr Numbers
+
+Given a 3 x 4 grid of pipes, underscores, and spaces, determine which number is
+represented, or whether it is garbled.
+
+# Step One
+
+To begin with, convert a simple binary font to a string containing 0 or 1.
+
+The binary font uses pipes and underscores, four rows high and three columns wide.
+
+```
+     _   #
+    | |  # zero.
+    |_|  #
+         # the fourth row is always blank
+```
+
+Is converted to "0"
+
+```
+         #
+      |  # one.
+      |  #
+         # (blank fourth row)
+```
+
+Is converted to "1"
+
+If the input is the correct size, but not recognizable, your program should return '?'
+
+If the input is the incorrect size, your program should return an error.
+
+# Step Two
+
+Update your program to recognize multi-character binary strings, replacing garbled numbers with ?
+
+# Step Three
+
+Update your program to recognize all numbers 0 through 9, both individually and as part of a larger string.
+
+```
+ _ 
+ _|
+|_ 
+   
+```
+
+Is converted to "2"
+
+```
+      _  _     _  _  _  _  _  _  #
+    | _| _||_||_ |_   ||_||_|| | # decimal numbers.
+    ||_  _|  | _||_|  ||_| _||_| #
+                                 # fourth line is always blank
+```
+
+Is converted to "1234567890"
+
+# Step Four
+
+Update your program to handle multiple numbers, one per line. When converting several lines, join the lines with commas.
+
+```
+    _  _ 
+  | _| _|
+  ||_  _|
+         
+    _  _ 
+|_||_ |_ 
+  | _||_|
+         
+ _  _  _ 
+  ||_||_|
+  ||_| _|
+         
+```
+
+Is converted to "123,456,789"
+
+## 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
+
+Inspired by the Bank OCR kata [http://codingdojo.org/cgi-bin/wiki.pl?KataBankOCR](http://codingdojo.org/cgi-bin/wiki.pl?KataBankOCR)
+
+## 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/ocr-numbers/ocr-numbers.example.ts

@@ -0,0 +1,92 @@
+interface Patterns {
+    [key: number]: string[]
+}
+
+const PATTERNS: Patterns = {
+    0: [' _ ',
+        '| |',
+        '|_|',
+        '   '],
+    1: ['   ',
+        '  |',
+        '  |',
+        '   '],
+    2: [' _ ',
+        ' _|',
+        '|_ ',
+        '   '],
+    3: [' _ ',
+        ' _|',
+        ' _|',
+        '   '],
+    4: ['   ',
+        '|_|',
+        '  |',
+        '   '],
+    5: [' _ ',
+        '|_ ',
+        ' _|',
+        '   '],
+    6: [' _ ',
+        '|_ ',
+        '|_|',
+        '   '],
+    7: [' _ ',
+        '  |',
+        '  |',
+        '   '],
+    8: [' _ ',
+        '|_|',
+        '|_|',
+        '   '],
+    9: [' _ ',
+        '|_|',
+        ' _|',
+        '   '],
+}
+
+export default class OcrParser {
+    static convert(text: string) {
+        return OcrParser.splitIntoRows(text).map(OcrParser.valuesInRow).join(',')
+    }
+
+    static valuesInRow(row: string) {
+        return OcrParser.splitIntoDigits(row).map(OcrParser.getDigit).join('')
+    }
+
+    static splitIntoRows(text: string) {
+        const rows = []
+        const lines = text.split('\n')
+        for (let rowNumber = 0; rowNumber < lines.length; rowNumber += 4) {
+            let row = ''
+            for (let rowLine = 0; rowLine < 4; rowLine++) {
+                row += `${lines[rowNumber + rowLine]}\n`
+            }
+            rows.push(row.slice(0, -1))
+        }
+        return rows
+    }
+
+    static splitIntoDigits(row: string) {
+        const digits = [],
+            rows = row.split('\n')
+        for (let digitNumber = 0; digitNumber < rows[0].length; digitNumber += 3) {
+            let digit = ''
+            for (const row of rows) {
+                digit += row.substr(digitNumber, 3)
+            }
+            digits.push(digit)
+        }
+        return digits
+    }
+
+    static getDigit(text: string) {
+        for (const digit in PATTERNS) {
+            if (PATTERNS[digit].join('') === text) {
+                return digit
+            }
+        }
+        return '?'
+    }
+
+}

data/tracks/typescript/exercises/ocr-numbers/ocr-numbers.test.ts

@@ -0,0 +1,155 @@
+import OcrParser from "./ocr-numbers"
+
+describe('ocr', () => {
+    it('recognizes zero', () => {
+        expect(OcrParser.convert(
+            ' _ \n' +
+            '| |\n' +
+            '|_|\n' +
+            '   ',
+        )).toBe('0')
+    })
+
+    xit('recognizes one', () => {
+        expect(OcrParser.convert(
+            '   \n' +
+            '  |\n' +
+            '  |\n' +
+            '   ',
+        )).toBe('1')
+    })
+
+    xit('recognizes two', () => {
+        expect(OcrParser.convert(
+            ' _ \n' +
+            ' _|\n' +
+            '|_ \n' +
+            '   ',
+        )).toBe('2')
+    })
+
+    xit('recognizes three', () => {
+        expect(OcrParser.convert(
+            ' _ \n' +
+            ' _|\n' +
+            ' _|\n' +
+            '   ',
+        )).toBe('3')
+    })
+
+    xit('recognizes four', () => {
+        expect(OcrParser.convert(
+            '   \n' +
+            '|_|\n' +
+            '  |\n' +
+            '   ',
+        )).toBe('4')
+    })
+
+    xit('recognizes five', () => {
+        expect(OcrParser.convert(
+            ' _ \n' +
+            '|_ \n' +
+            ' _|\n' +
+            '   ',
+        )).toBe('5')
+    })
+
+    xit('recognizes six', () => {
+        expect(OcrParser.convert(
+            ' _ \n' +
+            '|_ \n' +
+            '|_|\n' +
+            '   ',
+        )).toBe('6')
+    })
+
+    xit('recognizes seven', () => {
+        expect(OcrParser.convert(
+            ' _ \n' +
+            '  |\n' +
+            '  |\n' +
+            '   ',
+        )).toBe('7')
+    })
+
+    xit('recognizes eight', () => {
+        expect(OcrParser.convert(
+            ' _ \n' +
+            '|_|\n' +
+            '|_|\n' +
+            '   ',
+        )).toBe('8')
+    })
+
+    xit('recognizes nine', () => {
+        expect(OcrParser.convert(
+            ' _ \n' +
+            '|_|\n' +
+            ' _|\n' +
+            '   ',
+        )).toBe('9')
+    })
+
+    xit('recognizes ten', () => {
+        expect(OcrParser.convert(
+            '    _ \n' +
+            '  || |\n' +
+            '  ||_|\n' +
+            '      ',
+        )).toBe('10')
+    })
+
+    xit('identifies garble', () => {
+        expect(OcrParser.convert(
+            '   \n' +
+            '| |\n' +
+            '| |\n' +
+            '   ',
+        )).toBe('?')
+    })
+
+    xit('converts 110101100', () => {
+        expect(OcrParser.convert(
+            '       _     _        _  _ \n' +
+            '  |  || |  || |  |  || || |\n' +
+            '  |  ||_|  ||_|  |  ||_||_|\n' +
+            '                           ',
+        )).toBe('110101100')
+    })
+
+    xit('identifies garble mixed in', () => {
+        expect(OcrParser.convert(
+            '       _     _           _ \n' +
+            '  |  || |  || |     || || |\n' +
+            '  |  | _|  ||_|  |  ||_||_|\n' +
+            '                           ',
+        )).toBe('11?10?1?0')
+    })
+
+    xit('converts 1234567890', () => {
+        expect(OcrParser.convert(
+            '    _  _     _  _  _  _  _  _ \n' +
+            '  | _| _||_||_ |_   ||_||_|| |\n' +
+            '  ||_  _|  | _||_|  ||_| _||_|\n' +
+            '                              ',
+        )).toBe('1234567890')
+    })
+
+    xit('converts 123 456 789', () => {
+        expect(OcrParser.convert(
+            '    _  _ \n' +
+            '  | _| _|\n' +
+            '  ||_  _|\n' +
+            '         \n' +
+            '    _  _ \n' +
+            '|_||_ |_ \n' +
+            '  | _||_|\n' +
+            '         \n' +
+            ' _  _  _ \n' +
+            '  ||_||_|\n' +
+            '  ||_| _|\n' +
+            '         ',
+        )).toBe('123,456,789')
+    })
+})

data/tracks/typescript/exercises/ocr-numbers/ocr-numbers.ts

@@ -0,0 +1,3 @@
+export default class OcrParser {
+
+}

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