trackler 2.2.1.125 → 2.2.1.126

data/tracks/typescript/config.json

@@ -495,6 +495,21 @@
       "unlocked_by": null,
       "uuid": "32953258-d488-4761-9669-895a359a8b9a"
     },
+    {
+      "core": false,
+      "difficulty": 5,
+      "slug": "all-your-base",
+      "topics": [
+        "control_flow_conditionals",
+        "control_flow_loops",
+        "exception_handling",
+        "integers",
+        "mathematics",
+        "parsing"
+      ],
+      "unlocked_by": null,
+      "uuid": "0f4f98fe-245a-4842-b3cf-6581b89afd44"
+    },
     {
       "core": true,
       "difficulty": 6,
@@ -589,6 +604,23 @@
       "unlocked_by": "linked-list",
       "uuid": "3cc210e8-b3bb-11e7-abc4-cec278b6b50a"
     },
+    {
+      "core": false,
+      "difficulty": 9,
+      "slug": "crypto-square",
+      "topics": [
+        "algorithms",
+        "arrays",
+        "control_flow_conditionals",
+        "control_flow_loops",
+        "regular_expressions",
+        "sorting",
+        "text_formatting",
+        "transforming"
+      ],
+      "unlocked_by": "simple-cipher",
+      "uuid": "e92b7444-a5c3-4452-82fd-8c70cf14085a"
+    },
     {
       "core": false,
       "difficulty": 3,
@@ -713,7 +745,7 @@
         "strings"
       ],
       "unlocked_by": "pangram",
-      "uuid": "2ceec21e-fb9d-4145-8788-826c3941eb01"
+      "uuid": "d3c93056-07b9-4d06-a681-1bb25db68c01"
     },
     {
       "core": false,
@@ -879,7 +911,7 @@
         "Text formatting"
       ],
       "unlocked_by": "wordy",
-      "uuid": "b1ab1795-3f8e-43f6-86b4-88be4967e934"
+      "uuid": "d70d3579-999c-452c-9243-98908e24b47e"
     },
     {
       "core": false,

data/tracks/typescript/exercises/all-your-base/README.md

@@ -0,0 +1,60 @@
+# All Your Base
+
+Convert a number, represented as a sequence of digits in one base, to any other base.
+
+Implement general base conversion. Given a number in base **a**,
+represented as a sequence of digits, convert it to base **b**.
+
+## Note
+
+- Try to implement the conversion yourself.
+  Do not use something else to perform the conversion for you.
+
+## About [Positional Notation](https://en.wikipedia.org/wiki/Positional_notation)
+
+In positional notation, a number in base **b** can be understood as a linear
+combination of powers of **b**.
+
+The number 42, *in base 10*, means:
+
+(4 * 10^1) + (2 * 10^0)
+
+The number 101010, *in base 2*, means:
+
+(1 * 2^5) + (0 * 2^4) + (1 * 2^3) + (0 * 2^2) + (1 * 2^1) + (0 * 2^0)
+
+The number 1120, *in base 3*, means:
+
+(1 * 3^3) + (1 * 3^2) + (2 * 3^1) + (0 * 3^0)
+
+I think you got the idea!
+
+*Yes. Those three numbers above are exactly the same. Congratulations!*
+
+## 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
+```
+
+
+
+## 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/all-your-base/all-your-base.example.ts

@@ -0,0 +1,53 @@
+const isValidBase = (base: number) => {
+    return !base || base < 2 || Math.floor(base) !== base
+}
+
+const isInputValid = (array: number[], base: number) => {
+    if (!array || !array.length) {
+        return false
+    }
+    const val = base - 1
+    for (let i = 0, n = array.length; i < n; i++) {
+        const tmp = array[i]
+        if (tmp > val || tmp < 0) {
+            return false
+        }
+    }
+    return true
+}
+
+const convertFromDecimalToBase = (num: number, outputBase: number) => {
+    let tmp = num
+    const result = []
+    while (tmp) {
+        result.unshift(tmp % outputBase)
+        tmp = Math.floor(tmp / outputBase)
+    }
+    return result
+}
+
+export default class Converter {
+    convert(array: number[], inputBase: number, outputBase: number) {
+        if (isValidBase(inputBase)) {
+            throw new Error('Wrong input base')
+        }
+        if (isValidBase(outputBase)) {
+            throw new Error('Wrong output base')
+        }
+        const regexp = new RegExp('^0.', 'g')
+        const str = array.join('')
+        if (str.match(regexp)
+            || !isInputValid(array, inputBase)) {
+            throw new Error('Input has wrong format')
+        }
+        if (str === '0') {
+            return [0]
+        }
+        if (str === '1') {
+            return [1]
+        }
+        const decimalValue = array
+            .reduce((accumulator, value) => accumulator * inputBase + value, 0)
+        return convertFromDecimalToBase(decimalValue, outputBase)
+    }
+}

data/tracks/typescript/exercises/all-your-base/all-your-base.test.ts

@@ -0,0 +1,119 @@
+import Converter from './all-your-base'
+
+const converter = new Converter()
+
+describe('Converter', () => {
+    it('single bit one to decimal', () => {
+        expect(converter.convert([1], 2, 10)).toEqual([1])
+    })
+
+    xit('binary to single decimal', () => {
+        expect(converter.convert([1, 0, 1], 2, 10)).toEqual([5])
+    })
+
+    xit('single decimal to binary', () => {
+        expect(converter.convert([5], 10, 2)).toEqual([1, 0, 1])
+    })
+
+    xit('binary to multiple decimal', () => {
+        expect(converter.convert([1, 0, 1, 0, 1, 0], 2, 10)).toEqual([4, 2])
+    })
+
+    xit('decimal to binary', () => {
+        expect(converter.convert([4, 2], 10, 2)).toEqual([1, 0, 1, 0, 1, 0])
+    })
+
+    xit('trinary to hexadecimal', () => {
+        expect(converter.convert([1, 1, 2, 0], 3, 16)).toEqual([2, 10])
+    })
+
+    xit('hexadecimal to trinary', () => {
+        expect(converter.convert([2, 10], 16, 3)).toEqual([1, 1, 2, 0])
+    })
+
+    xit('15-bit integer', () => {
+        expect(converter.convert([3, 46, 60], 97, 73)).toEqual([6, 10, 45])
+    })
+
+    xit('empty list', () => {
+        expect(() => {
+            converter.convert([], 2, 10)
+        }).toThrowError('Input has wrong format')
+    })
+
+    xit('single zero', () => {
+        expect(converter.convert([0], 10, 2)).toEqual([0])
+    })
+
+    xit('multiple zeros', () => {
+        expect(() => {
+            converter.convert([0, 0, 0], 10, 2)
+        }).toThrowError('Input has wrong format')
+    })
+
+    xit('leading zeros', () => {
+        expect(() => {
+            converter.convert([0, 6, 0], 7, 10)
+        }).toThrowError('Input has wrong format')
+    })
+
+    xit('negative digit', () => {
+        expect(() => {
+            converter.convert([1, -1, 1, 0, 1, 0], 2, 10)
+        }).toThrowError('Input has wrong format')
+    })
+
+    xit('invalid positive digit', () => {
+        expect(() => {
+            converter.convert([1, 2, 1, 0, 1, 0], 2, 10)
+        }).toThrowError('Input has wrong format')
+    })
+
+    xit('first base is one', () => {
+        expect(() => {
+            converter.convert([], 1, 10)
+        }).toThrowError('Wrong input base')
+    })
+
+    xit('second base is one', () => {
+        expect(() => {
+            converter.convert([1, 0, 1, 0, 1, 0], 2, 1)
+        }).toThrowError('Wrong output base')
+    })
+
+    xit('first base is zero', () => {
+        expect(() => {
+            converter.convert([], 0, 10)
+        }).toThrowError('Wrong input base')
+    })
+
+    xit('second base is zero', () => {
+        expect(() => {
+            converter.convert([7], 10, 0)
+        }).toThrowError('Wrong output base')
+    })
+
+    xit('first base is negative', () => {
+        expect(() => {
+            converter.convert([1], -2, 10)
+        }).toThrowError('Wrong input base')
+    })
+
+    xit('second base is negative', () => {
+        expect(() => {
+            converter.convert([1], 2, -7)
+        }).toThrowError('Wrong output base')
+    })
+
+    xit('both bases are negative', () => {
+        expect(() => {
+            converter.convert([1], -2, -7)
+        }).toThrowError('Wrong input base')
+    })
+
+    xit('wrong output_base base not integer', () => {
+        expect(() => {
+            converter.convert([0], 3, 2.5)
+        }).toThrowError('Wrong output base')
+    })
+})

data/tracks/typescript/exercises/all-your-base/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/all-your-base/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/all-your-base/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"]
+    }
+}