trackler 2.2.1.135 → 2.2.1.136

data/tracks/swift/exercises/proverb/README.md

@@ -0,0 +1,25 @@
+# Proverb
+
+For want of a horseshoe nail, a kingdom was lost, or so the saying goes.
+
+Given a list of inputs, generate the relevant proverb. For example, given the list ["nail", "shoe", "horse", "rider", "message", "battle", "kingdom"], you will output the full text of this proverbial rhyme:
+
+For want of a nail the shoe was lost.
+For want of a shoe the horse was lost.
+For want of a horse the rider was lost.
+For want of a rider the message was lost.
+For want of a message the battle was lost.
+For want of a battle the kingdom was lost.
+And all for the want of a nail.
+
+Note that the list of inputs may vary; your solution should be able to handle lists of arbitrary length and content. No line of the output text should be a static, unchanging string; all should vary according to the input given.
+
+## Setup
+
+Go through the project setup instructions for Xcode using Swift:
+
+http://exercism.io/languages/swift
+
+
+## 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/proverb/Sources/Proverb.swift

@@ -0,0 +1 @@
+//Solution goes in Sources

data/tracks/swift/exercises/proverb/Sources/ProverbExample.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+extension Array where Element == String {
+
+    func recite() -> String {
+
+    var saying = ""
+
+    if let firstPiece = self.first {
+
+        for (position, piece) in self.enumerated() {
+
+            if position != self.count - 1 {
+
+                let nextPiece = self[position + 1]
+                saying.append("For want of a \(piece) the \(nextPiece) was lost.\n")
+            } else {
+
+                saying.append("And all for the want of a \(firstPiece).")
+            }
+
+        }
+    }
+
+    return saying
+}
+
+}

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

@@ -0,0 +1,6 @@
+import XCTest
+@testable import ProverbTests
+
+XCTMain([
+    testCase(ProverbTests.allTests),
+])

data/tracks/swift/exercises/proverb/Tests/ProverbTests/ProverbTests.swift

@@ -0,0 +1,61 @@
+import XCTest
+@testable import Proverb
+
+class ProverbTests: XCTestCase {
+
+    func testZeroPiecesOfProverb() {
+
+        let expectedResult = ""
+        let actualResult = [String]().recite()
+        XCTAssertEqual(expectedResult, actualResult)
+    }
+
+    func testOnePieceOfProverb() {
+
+        let expectedResult = "And all for the want of a nail."
+        let actualResult = ["nail"].recite()
+        XCTAssertEqual(expectedResult, actualResult)
+    }
+
+    func testTwoPiecesOfProverb() {
+
+        let expectedResult = "For want of a nail the shoe was lost.\nAnd all for the want of a nail."
+        let actualResult = ["nail", "shoe"].recite()
+        XCTAssertEqual(expectedResult, actualResult)
+    }
+
+    func testThreePiecesOfProverb() {
+
+        let expectedResult = "For want of a nail the shoe was lost.\nFor want of a shoe the horse was lost.\nAnd all for the want of a nail."
+        let actualResult = ["nail", "shoe", "horse"].recite()
+        XCTAssertEqual(expectedResult, actualResult)
+
+    }
+
+    func testFullProverb() {
+
+        let expectedResult = "For want of a nail the shoe was lost.\nFor want of a shoe the horse was lost.\nFor want of a horse the rider was lost.\nFor want of a rider the message was lost.\nFor want of a message the battle was lost.\nFor want of a battle the kingdom was lost.\nAnd all for the want of a nail."
+        let actualResult = ["nail", "shoe", "horse", "rider", "message", "battle", "kingdom"].recite()
+        XCTAssertEqual(expectedResult, actualResult)
+    }
+
+    func testFourPiecesOfProverbModernized() {
+
+        let expectedResult = "For want of a pin the gun was lost.\nFor want of a gun the soldier was lost.\nFor want of a soldier the battle was lost.\nAnd all for the want of a pin."
+        let actualResult = ["pin", "gun", "soldier", "battle"].recite()
+        XCTAssertEqual(expectedResult, actualResult)
+    }
+    
+    static var allTests: [(String, (ProverbTests) -> () throws -> Void)] {
+        return [
+            ("testZeroPiecesOfProverb", testZeroPiecesOfProverb),
+            ("testOnePieceOfProverb", testOnePieceOfProverb),
+            ("testTwoPiecesOfProverb", testTwoPiecesOfProverb),
+            ("testThreePiecesOfProverb", testThreePiecesOfProverb),
+            ("testFullProverb", testFullProverb),
+            ("testFourPiecesOfProverbModernized", testFourPiecesOfProverbModernized),
+            
+        ]
+    }
+
+}

data/tracks/typescript/config.json

@@ -674,6 +674,20 @@
       "unlocked_by": "grade-school",
       "uuid": "69cbdc2a-50f4-4e14-b9f4-c1ddee021018"
     },
+    {
+      "core": false,
+      "difficulty": 7,
+      "slug": "palindrome-products",
+      "topics": [
+        "algorithms",
+        "control_flow_conditionals",
+        "control_flow_loops",
+        "integers",
+        "mathematics"
+      ],
+      "unlocked_by": "prime-factors",
+      "uuid": "ffb0ad36-2cf5-46d4-9a5f-5bbdfb9691a7"
+    },
     {
       "core": false,
       "difficulty": 8,

data/tracks/typescript/exercises/palindrome-products/README.md

@@ -0,0 +1,65 @@
+# Palindrome Products
+
+Detect palindrome products in a given range.
+
+A palindromic number is a number that remains the same when its digits are
+reversed. For example, `121` is a palindromic number but `112` is not.
+
+Given a range of numbers, find the largest and smallest palindromes which
+are products of numbers within that range.
+
+Your solution should return the largest and smallest palindromes, along with the
+factors of each within the range. If the largest or smallest palindrome has more
+than one pair of factors within the range, then return all the pairs.
+
+## Example 1
+
+Given the range `[1, 9]` (both inclusive)...
+
+And given the list of all possible products within this range:
+`[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 15, 21, 24, 27, 20, 28, 32, 36, 25, 30, 35, 40, 45, 42, 48, 54, 49, 56, 63, 64, 72, 81]`
+
+The palindrome products are all single digit numbers (in this case):
+`[1, 2, 3, 4, 5, 6, 7, 8, 9]`
+
+The smallest palindrome product is `1`. Its factors are `(1, 1)`.
+The largest palindrome product is `9`. Its factors are `(1, 9)` and `(3, 3)`.
+
+## Example 2
+
+Given the range `[10, 99]` (both inclusive)...
+
+The smallest palindrome product is `121`. Its factors are `(11, 11)`.
+The largest palindrome product is `9009`. Its factors are `(91, 99)`.
+
+## 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
+
+Problem 4 at Project Euler [http://projecteuler.net/problem=4](http://projecteuler.net/problem=4)
+
+## 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/palindrome-products/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/palindrome-products/palindrome-products.example.ts

@@ -0,0 +1,38 @@
+const isPalindrome = (num: number) => num.toString().split('').reverse().join('') === num.toString()
+
+const Palindromes = (params: {maxFactor: number, minFactor?: number}) => {
+    let maxFactor,
+        minFactor,
+        maxProduct,
+        minProduct,
+        data
+    maxFactor = params.maxFactor
+    minFactor = params.minFactor || 1
+    maxProduct = 1
+    minProduct = Infinity
+    data = []
+
+    for (let ii = minFactor; ii < maxFactor; ii++) {
+        for (let jj = ii; jj <= maxFactor; jj++) {
+            const product = ii * jj
+            if (isPalindrome(product)) {
+                data[product] = [ii, jj]
+                maxProduct = Math.max(maxProduct, product)
+                minProduct = Math.min(minProduct, product)
+            }
+        }
+    }
+
+    return {
+        largest: {
+            value: maxProduct,
+            factors: data[maxProduct],
+        },
+        smallest: {
+            value: minProduct,
+            factors: data[minProduct],
+        },
+    }
+}
+
+export default Palindromes

data/tracks/typescript/exercises/palindrome-products/palindrome-products.test.ts

@@ -0,0 +1,69 @@
+import generate from './palindrome-products'
+
+describe('Palindrome', () => {
+    it('largest palindrome from single digit factors', () => {
+        const palindromes = generate({ maxFactor: 9 })
+        const largest = palindromes.largest
+
+        expect(largest.value).toEqual(9)
+        const containsMatch = [[3, 3], [1, 9]].filter((el) => numericalArraysMatch(el, [3, 3])).length > 0
+        expect(containsMatch).toBe(true)
+    })
+
+    xit('largest palindrome from double digit factors', () => {
+        const palindromes = generate({ maxFactor: 99, minFactor: 10 })
+        const largest = palindromes.largest
+
+        expect(largest.value).toEqual(9009)
+        expect(largest.factors).toEqual([91, 99])
+    })
+
+    xit('smallest palindrome from double digit factors', () => {
+        const palindromes = generate({ maxFactor: 99, minFactor: 10 })
+        const smallest = palindromes.smallest
+
+        expect(smallest.value).toEqual(121)
+        expect(smallest.factors).toEqual([11, 11])
+    })
+
+    xit('largest palindrome from triple digit factors', () => {
+        const palindromes = generate({ maxFactor: 999, minFactor: 100 })
+        const largest = palindromes.largest
+
+        expect(largest.value).toEqual(906609)
+        expect(largest.factors).toEqual([913, 993])
+    })
+
+    xit('smallest palindrome from triple digit factors', () => {
+        const palindromes = generate({ maxFactor: 999, minFactor: 100 })
+        const smallest = palindromes.smallest
+
+        expect(smallest.value).toEqual(10201)
+        expect(smallest.factors).toEqual([101, 101])
+    })
+})
+
+function numericalArraysMatch(a: number[], b: number[]) {
+    if (a.length !== b.length) {
+        return false
+    }
+    const one = [...a].sort(numericalSort)
+    const two = [...b].sort(numericalSort)
+    let result = true
+    let index = 0
+    while (index < one.length) {
+        result = result && one[index] === two[index]
+        index++
+    }
+    return result
+}
+
+function numericalSort(x: number, y: number) {
+    if (x < y) {
+        return -1
+    }
+    if (x > y) {
+        return 1
+    }
+    return 0
+}

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