trackler 2.2.1.45 → 2.2.1.46

data/tracks/sml/exercises/accumulate/README.md

@@ -17,9 +17,13 @@ Your code should be able to produce the collection of squares:
 
 - 1, 4, 9, 16, 25
 
+Check out the test suite to see the expected function signature.
+
 ## Restrictions
 
-Avoid using any `map` or related functions supplied in the Standard Basis
+Keep your hands off `map` or related functions
+provided in the Standard Basis!
+Solve this one yourself using other basic tools instead.
 
 ## Loading your exercise implementation in PolyML
 
@@ -50,5 +54,9 @@ GitHub is the home for all of the Standard ML exercises.
 If you have feedback about an exercise, or want to help implementing a new
 one, head over there and create an issue. We'll do our best to help you!
 
+## Source
+
+Conversation with James Edward Gray II [https://twitter.com/jeg2](https://twitter.com/jeg2)
+
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/swift/exercises/luhn/Sources/LuhnExample.swift

@@ -3,32 +3,25 @@ import Foundation
 struct Luhn {
 
     var number: Int64 = 0
-    var addends: [Int] { return addendsFunc(number) }
+    var numberString: String = ""
+    var addends: [Int] { return addendsFunc(numberString) }
     var checksum: Int { return addends.reduce(0, +) }
-    var isValid: Bool { return checksum % 10 == 0 }
-
-    init(_ num: Int64) {
-        self.number = num
-    }
-
-    static func create (_ num: Int64) -> Double {
-
-        func createCheckDigit(_ value: Int) -> Int {
-            let nearestTen = Int(ceil((Double(value) / 10.00)) * 10)
-            return nearestTen - value
+    var isValid: Bool = false
+
+    init(_ num: String ) {
+        self.numberString = num.replacingOccurrences(of: " ", with: "")
+        let num = Int64(numberString)
+        if self.numberString.utf16.count <= 1 {
+            self.isValid = false
+        } else if num == nil {
+            isValid = false
+        } else {
+            self.number = num!
+            isValid = checksum % 10 == 0
         }
-
-        let zeroCheckDigitNumber = num * 10
-        let luhn = Luhn(zeroCheckDigitNumber)
-
-        if luhn.isValid {
-            return Double(zeroCheckDigitNumber)}
-
-        return Double((zeroCheckDigitNumber) + Int64(createCheckDigit(luhn.checksum)))
-
     }
 
-    func addendsFunc(_ num: Int64) -> [Int] {
+    func addendsFunc(_ num: String) -> [Int] {
         func oddIndexInt64Minus9( _ input: [Int]) -> [Int] {
             var input = input
             input = Array(input.reversed())
@@ -37,7 +30,7 @@ struct Luhn {
                 var tempEach: Int = each
                 if (inx+1) % 2 == 0 {
                     tempEach *= 2
-                    if tempEach > 10 {
+                    if tempEach >= 10 {
                         tempEach -= 9
                     }
                     tempArray.insert(tempEach, at: 0)
@@ -52,9 +45,7 @@ struct Luhn {
             return tempInt
         }
 
-        let tempString = "\(num)"
-
-        return oddIndexInt64Minus9(Array(tempString.characters).map { char2Int($0) })
+        return oddIndexInt64Minus9(Array(num.characters).map { char2Int($0) })
     }
 
 }

data/tracks/swift/exercises/luhn/Tests/LinuxMain.swift

@@ -2,5 +2,5 @@ import XCTest
 @testable import LuhnTests
 
 XCTMain([
-    testCase(LuhnTests.allTests),
+    testCase(LuhnTests.allTests)
     ])

data/tracks/swift/exercises/luhn/Tests/LuhnTests/LuhnTests.swift

@@ -3,62 +3,86 @@ import XCTest
 
 class LuhnTests: XCTestCase {
 
-    func testAddends() {
-        let luhn = Luhn(12_121)
-        XCTAssertEqual([1, 4, 1, 4, 1], luhn.addends)
+    func testSingleDigitInvalid() {
+        let luhn = Luhn("1")
+        XCTAssertEqual (false, luhn.isValid)
     }
 
-    func testTooLargeAddend() {
-        let luhn = Luhn(8631)
-        XCTAssertEqual([7, 6, 6, 1], luhn.addends)
+    func testSingleZeroInvalid() {
+        let luhn = Luhn("0")
+        XCTAssertEqual (false, luhn.isValid)
     }
 
-    func testChecksum() {
-        let luhn = Luhn(4913)
-        XCTAssertEqual(22, luhn.checksum)
+    func testSimpleReversableValid() {
+        let luhn = Luhn("059")
+        XCTAssertEqual (true, luhn.isValid)
     }
 
-    func testChecksumAgain() {
-        let luhn = Luhn(201_773)
-        XCTAssertEqual(21, luhn.checksum)
+    func testSimpleIrreversableValid() {
+        let luhn = Luhn("59")
+        XCTAssertEqual (true, luhn.isValid)
     }
 
-    func testInvalidNumber() {
-        let luhn = Luhn(738)
+    func testCanadianValid() {
+        let luhn = Luhn("055 444 285")
+        XCTAssertEqual (true, luhn.isValid)
+    }
+
+    func testCanadianInvalid() {
+        let luhn = Luhn("055 444 286")
         XCTAssertEqual (false, luhn.isValid)
     }
 
-    func testValidNumber() {
-        let luhn = Luhn(8_739_567)
-        XCTAssertEqual (true, luhn.isValid)
+    func testCreditCardInvalid() {
+        let luhn = Luhn("8273 1232 7352 0569")
+        XCTAssertEqual (false, luhn.isValid)
     }
 
-    func testCreateValidNumber() {
-        let number = Luhn.create(123)
-        XCTAssertEqual(1230, number)
+    func testNonDigitInvalid() {
+        let luhn = Luhn("055a 444 285")
+        XCTAssertEqual (false, luhn.isValid)
     }
 
-    func testCreateOtherValidNumber() {
-        let number = Luhn.create(873_956)
-        XCTAssertEqual(8_739_567, number)
+    func testPunctuationInvalid() {
+        let luhn = Luhn("055-444-285")
+        XCTAssertEqual (false, luhn.isValid)
     }
 
-    func testCreateYetAnotherValidNumber() {
-        let number = Luhn.create(837_263_756)
-        XCTAssertEqual(8_372_637_564, number)
+    func testSymbolsInvalid() {
+        let luhn = Luhn("055£ 444$ 285")
+        XCTAssertEqual (false, luhn.isValid)
+    }
+
+    func testZeroWithSpaceInvalid() {
+        let luhn = Luhn(" 0")
+        XCTAssertEqual (false, luhn.isValid)
+    }
+
+    func testMultipleZeroesValid() {
+        let luhn = Luhn("0000 0")
+        XCTAssertEqual (true, luhn.isValid)
+    }
+
+    func testInputNineOutputNine() {
+        let luhn = Luhn("091")
+        XCTAssertEqual (true, luhn.isValid)
     }
 
     static var allTests: [(String, (LuhnTests) -> () throws -> Void)] {
         return [
-            ("testAddends", testAddends),
-            ("testTooLargeAddend", testTooLargeAddend),
-            ("testChecksum", testChecksum),
-            ("testChecksumAgain", testChecksumAgain),
-            ("testInvalidNumber", testInvalidNumber),
-            ("testValidNumber", testValidNumber),
-            ("testCreateValidNumber", testCreateValidNumber),
-            ("testCreateOtherValidNumber", testCreateOtherValidNumber),
-            ("testCreateYetAnotherValidNumber", testCreateYetAnotherValidNumber),
+            ("testSingleDigitInvalid", testSingleDigitInvalid),
+            ("testSingleZeroInvalid", testSingleZeroInvalid),
+            ("testSimpleReversableValid", testSimpleReversableValid),
+            ("testSimpleIrreversableValid", testSimpleIrreversableValid),
+            ("testCanadianValid", testCanadianValid),
+            ("testCanadianInvalid", testCanadianInvalid),
+            ("testCreditCardInvalid", testCreditCardInvalid),
+            ("testNonDigitInvalid", testNonDigitInvalid),
+            ("testPunctuationInvalid", testPunctuationInvalid),
+            ("testSymbolsInvalid", testSymbolsInvalid),
+            ("testZeroWithSpaceInvalid", testZeroWithSpaceInvalid),
+            ("testMultipleZeroesValid", testMultipleZeroesValid),
+            ("testInputNineOutputNine", testInputNineOutputNine)
         ]
     }
 }

data/tracks/typescript/config.json

@@ -387,6 +387,40 @@
         "Integers",
         "Mathematics"
       ]
+    },
+    {
+      "uuid": "a4054ca4-0737-6e80-3ca5-372be502b1d8bb93b20",
+      "slug": "pascals-triangle",
+      "core": true,
+      "difficulty": 5,
+      "topics": [
+        "Control-flow (conditionals)",
+        "Control-flow (loops)",
+        "Mathematics"
+      ]
+    },
+    {
+      "uuid": "b2fcd8f0-03b2-7880-ec70-65ad5cedfdd8116012d",
+      "slug": "binary-search",
+      "core": false,
+      "difficulty": 5,
+      "topics": [
+        "Control-flow (conditionals)",
+        "Control-flow (loops)",
+        "Arrays",
+        "Algorithms"
+      ]
+    },
+    {
+      "uuid": "1447f7bc-0d30-b980-378b-ab8defd8ff148419dbd",
+      "slug": "rotational-cipher",
+      "core": false,
+      "difficulty": 4,
+      "topics": [
+        "ascii",
+        "Mathematics",
+        "Iterators"
+      ]
     }
   ],
   "foregone": []

data/tracks/typescript/exercises/binary-search/README.md

@@ -0,0 +1,67 @@
+# Binary Search
+
+Implement a binary search algorithm.
+
+Searching a sorted collection is a common task. A dictionary is a sorted
+list of word definitions. Given a word, one can find its definition. A
+telephone book is a sorted list of people's names, addresses, and
+telephone numbers. Knowing someone's name allows one to quickly find
+their telephone number and address.
+
+If the list to be searched contains more than a few items (a dozen, say)
+a binary search will require far fewer comparisons than a linear search,
+but it imposes the requirement that the list be sorted.
+
+In computer science, a binary search or half-interval search algorithm
+finds the position of a specified input value (the search "key") within
+an array sorted by key value.
+
+In each step, the algorithm compares the search key value with the key
+value of the middle element of the array.
+
+If the keys match, then a matching element has been found and its index,
+or position, is returned.
+
+Otherwise, if the search key is less than the middle element's key, then
+the algorithm repeats its action on the sub-array to the left of the
+middle element or, if the search key is greater, on the sub-array to the
+right.
+
+If the remaining array to be searched is empty, then the key cannot be
+found in the array and a special "not found" indication is returned.
+
+A binary search halves the number of items to check with each iteration,
+so locating an item (or determining its absence) takes logarithmic time.
+A binary search is a dichotomic divide and conquer search algorithm.
+
+## 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
+
+Wikipedia [http://en.wikipedia.org/wiki/Binary_search_algorithm](http://en.wikipedia.org/wiki/Binary_search_algorithm)
+
+## 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/binary-search/binary-search.example.ts

@@ -0,0 +1,42 @@
+export default class BinarySearch<T> {
+    array: T[]
+
+    constructor(array: T[]) {
+        if (this.isSorted(array)) {
+            this.array = array
+        }
+    }
+
+    indexOf(val: T) {
+        return this.search(val)
+    }
+
+    private isSorted(array: T[]) {
+        for (let i = 1; i < array.length; i++) {
+            if (array[i] < array[i - 1]) {
+                return false
+            }
+        }
+        return true
+    }
+
+    private search(val: T) {
+        const arr = this.array
+        let start = 0
+        let end = arr.length
+        while (start <= end) {
+            const mid = Math.floor((start + end) / 2)
+            if (arr[mid] === val) {
+                return mid
+            }
+            if (arr[mid] > val) {
+                end = mid - 1
+            } else {
+                start = mid + 1
+            }
+        }
+        // val not found
+        return -1
+    }
+
+}

data/tracks/typescript/exercises/binary-search/binary-search.test.ts

@@ -0,0 +1,27 @@
+import BinarySearch from "./binary-search"
+
+describe("BinarySearch", () => {
+  const sortedArray = [1, 2, 3, 4, 5, 6]
+  const sortedArrayOfOddLength = [0, 1, 2, 2, 3, 10, 12]
+  const unsortedArray = [10, 2, 5, 1]
+
+  it("should require a sorted array", () => {
+    const invalidBinarySearch = new BinarySearch(unsortedArray)
+    const validBinarySearch = new BinarySearch(sortedArray)
+
+    expect(typeof invalidBinarySearch.array).toEqual("undefined")
+    expect(Array.isArray(validBinarySearch.array)).toEqual(true)
+  })
+
+  xit("should find the correct index of an included value", () => {
+    expect(new BinarySearch(sortedArray).indexOf(3)).toEqual(2)
+  })
+
+  xit("should search the middle of the array", () => {
+    expect(new BinarySearch(sortedArrayOfOddLength).indexOf(2)).toEqual(3)
+  })
+
+  xit("should return -1 for a value not in the array", () => {
+    expect(new BinarySearch(sortedArray).indexOf(10)).toEqual(-1)
+  })
+})

data/tracks/typescript/exercises/binary-search/binary-search.ts

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

data/tracks/typescript/exercises/binary-search/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": "^20.0.0",
+    "@types/node": "^7.0.5",
+    "jest": "^20.0.4",
+    "ts-jest": "^20.0.6",
+    "tslint": "^5.4.3",
+    "typescript": "^2.2.1"
+  },
+  "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/binary-search/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"
+    ]
+}