trackler 2.0.5.5 → 2.0.5.6

data/tracks/ecmascript/config.json

@@ -28,7 +28,6 @@
     "scrabble-score",
     "roman-numerals",
     "circular-buffer",
-    "binary",
     "prime-factors",
     "raindrops",
     "allergies",
@@ -36,10 +35,8 @@
     "atbash-cipher",
     "accumulate",
     "crypto-square",
-    "trinary",
     "sieve",
     "simple-cipher",
-    "octal",
     "luhn",
     "pig-latin",
     "pythagorean-triplet",
@@ -48,7 +45,6 @@
     "secret-handshake",
     "linked-list",
     "wordy",
-    "hexadecimal",
     "largest-series-product",
     "kindergarten-garden",
     "binary-search",
@@ -68,7 +64,8 @@
     "bracket-push",
     "two-bucket",
     "diamond",
-    "isogram"
+    "isogram",
+    "all-your-base"
   ],
   "exercises": [
     {
@@ -209,12 +206,6 @@
       "topics": [
       ]
     },
-    {
-      "slug": "binary",
-      "difficulty": 1,
-      "topics": [
-      ]
-    },
     {
       "slug": "prime-factors",
       "difficulty": 1,
@@ -257,12 +248,6 @@
       "topics": [
       ]
     },
-    {
-      "slug": "trinary",
-      "difficulty": 1,
-      "topics": [
-      ]
-    },
     {
       "slug": "sieve",
       "difficulty": 1,
@@ -275,12 +260,6 @@
       "topics": [
       ]
     },
-    {
-      "slug": "octal",
-      "difficulty": 1,
-      "topics": [
-      ]
-    },
     {
       "slug": "luhn",
       "difficulty": 1,
@@ -329,12 +308,6 @@
       "topics": [
       ]
     },
-    {
-      "slug": "hexadecimal",
-      "difficulty": 1,
-      "topics": [
-      ]
-    },
     {
       "slug": "largest-series-product",
       "difficulty": 1,
@@ -454,11 +427,21 @@
       "difficulty": 1,
       "topics": [
       ]
+    },
+    {
+      "slug": "all-your-base",
+      "difficulty": 1,
+      "topics": [
+      ]
     }
   ],
   "deprecated": [
     "nucleotide-count",
-    "point-mutations"
+    "point-mutations",
+    "binary",
+    "trinary",
+    "hexadecimal",
+    "octal"
   ],
   "ignored": [
     "node_modules",

data/tracks/ecmascript/exercises/all-your-base/all-your-base.spec.js

@@ -0,0 +1,139 @@
+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);
+        }).toThrow(new Error('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);
+        }).toThrow(new Error('Input has wrong format'));
+    });
+
+    xit('leading zeros', () => {
+        expect(() => {
+            converter.convert([0, 6, 0], 7, 10);
+        }).toThrow(new Error('Input has wrong format'));
+    });
+
+    xit('negative digit', () => {
+        expect(() => {
+            converter.convert([1, -1, 1, 0, 1, 0], 2, 10);
+        }).toThrow(new Error('Input has wrong format'));
+    });
+
+    xit('invalid positive digit', () => {
+        expect(() => {
+            converter.convert([1, 2, 1, 0, 1, 0], 2, 10);
+        }).toThrow(new Error('Input has wrong format'));
+    });
+
+    xit('first base is one', () => {
+        expect(() => {
+            converter.convert([], 1, 10);
+        }).toThrow(new Error('Wrong input base'));
+    });
+
+    xit('second base is one', () => {
+        expect(() => {
+            converter.convert([1, 0, 1, 0, 1, 0], 2, 1);
+        }).toThrow(new Error('Wrong output base'));
+    });
+
+    xit('first base is zero', () => {
+        expect(() => {
+            converter.convert([], 0, 10);
+        }).toThrow(new Error('Wrong input base'));
+    });
+
+    xit('second base is zero', () => {
+        expect(() => {
+            converter.convert([7], 10, 0);
+        }).toThrow(new Error('Wrong output base'));
+    });
+
+    xit('first base is negative', () => {
+        expect(() => {
+            converter.convert([1], -2, 10);
+        }).toThrow(new Error('Wrong input base'));
+    });
+
+    xit('second base is negative', () => {
+        expect(() => {
+            converter.convert([1], 2, -7);
+        }).toThrow(new Error('Wrong output base'));
+    });
+
+    xit('both bases are negative', () => {
+        expect(() => {
+            converter.convert([1], -2, -7);
+        }).toThrow(new Error('Wrong input base'));
+    });
+
+    xit('missing input base throws an error', () => {
+        expect(() => {
+            converter.convert([0]);
+        }).toThrow(new Error('Wrong input base'));
+    });
+
+    xit('wrong input_base base not integer', () => {
+        expect(() => {
+            converter.convert([0], 2.5);
+        }).toThrow(new Error('Wrong input base'));
+    });
+
+    xit('missing output base throws an error', () => {
+        expect(() => {
+            converter.convert([0], 2);
+        }).toThrow(new Error('Wrong output base'));
+    });
+
+    xit('wrong output_base base not integer', () => {
+        expect(() => {
+            converter.convert([0], 3, 2.5);
+        }).toThrow(new Error('Wrong output base'));
+    });
+
+});

data/tracks/ecmascript/exercises/all-your-base/example.js

@@ -0,0 +1,55 @@
+const isValidBase = function (base) {
+  return !base || base < 2 || Math.floor(base) !== base;
+};
+
+const isInputValid = function (array, base) {
+  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 = function (num, outputBase) {
+  let tmp = num;
+  const result = [];
+  while (tmp) {
+    result.unshift(tmp % outputBase);
+    tmp = Math.floor(tmp / outputBase);
+  }
+  return result;
+};
+
+export default class Converter {
+  convert(array, inputBase, outputBase) {
+    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) => {
+        return accumulator * inputBase + value;
+      }, 0);
+    return convertFromDecimalToBase(decimalValue, outputBase);
+  }
+}

data/tracks/ecmascript/exercises/all-your-base/gulpfile.js

@@ -0,0 +1,89 @@
+function getInputDirectory(argv) {
+  if (argv.input) {
+    return argv.input;
+  }
+  return '.';
+}
+
+function getOutputDirectory(argv) {
+  if (argv.output) {
+    return argv.output;
+  }
+  return 'babel-output';
+}
+
+const gulp = require('gulp'),
+  eslint = require('gulp-eslint'),
+  jasmine = require('gulp-jasmine'),
+  babel = require('gulp-babel'),
+  polyfill = require('babel/polyfill'),
+  del = require('del'),
+  argv  = require('yargs').argv,
+  inputDir = getInputDirectory(argv),
+  outputDir = getOutputDirectory(argv);
+
+// Gulp tasks definition
+
+gulp.task('default', [ 'test' ]);
+
+gulp.task('test', [ 'babel' ], function () {
+  return gulp.src([ outputDir + '/*.spec.js' ])
+    .pipe(jasmine());
+});
+
+gulp.task('babel', function () {
+  return gulp.src([ inputDir + '/*.js', inputDir + '/lib/*.js' ])
+    .pipe(babel())
+    .pipe(gulp.dest(outputDir));
+});
+
+gulp.task('lint', function () {
+  return gulp.src([ inputDir + '/*.js' ])
+    .pipe(eslint({
+      envs: [
+        'es6'  //turns on all es6 features except modules
+      ],
+      rules: {
+        // full documentation here : http://eslint.org/docs/rules
+
+        // Possible errors
+        'comma-dangle': [2, 'never'], // don't let a comma at the end of object properties or array element
+        'no-cond-assign': [2, 'always'], // no assignments in conditional statements
+        'no-console': 2,  // no console.log() statements in production code
+        'no-constant-condition': 2, // no constants in conditional statements
+        'no-control-regex': 2,  // no control characters in regex's
+        'no-debugger': 2, // no debugger in productin code
+        'no-dupe-args': 2, // no duplicated arguments in functions
+        'no-dupe-keys': 2, // no duplicated keys when creating object literals
+        'no-duplicate-case': 2, // no duplicated `case` in `switch` statements
+        'no-empty-character-class': 2, // disallow the use of empty character classes in regular expressions
+        'no-empty': 2, // no empty blocks
+        'no-ex-assign': 2, // do not assign any value to an Exception raised
+        'no-extra-boolean-cast': 2, // do not use !!falseExpression to cast to boolean
+        'no-extra-parens': 2,  // do not use extra parenthesis
+        'no-extra-semi': 2,  // do not use extra semicolons
+        'no-func-assign': 2, // do not overwrite variables declared as functions
+        'no-inner-declarations': [2, 'both'], // only declare var's and funct's on function scope
+        'no-invalid-regexp': 2,  // validates string arguments passed to RegExp constructor
+        'no-irregular-whitespace': 2, // detects special characters used as spaces
+        'no-negated-in-lhs': 2,  // do not use negation in the left operand in an `in` expression
+        'no-obj-calls': 2, // prevent calling global objects as if they were functions
+        'no-regex-spaces': 2, // do not use multiple spaces in regex's
+        'no-sparse-arrays': 2, // do not use sparse arrays (empty elements)
+        'no-unexpected-multiline': 2, // Avoid code that looks like two expressions but is actually one
+        'no-unreachable': 2, // detects unreachable statements (after return, throw,...)
+        'use-isnan': 2, // do not compare with `NaN` value, use isNan() instead
+        'valid-jsdoc': 2, // ensure JSDoc comments are valid
+        'valid-typeof': 2 // ensure that the results of typeof are compared against a valid string
+      },
+      ecmaFeatures: {
+        'modules': true  //this gives us modules :)
+      }
+    }))
+    .pipe(eslint.format())
+    .pipe(eslint.failAfterError());
+});
+
+gulp.task('clean', function (cb) {
+  del([ outputDir ], cb);
+});

data/tracks/ecmascript/exercises/all-your-base/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "xecmascript",
+  "version": "0.0.0",
+  "description": "Exercism exercises in ECMAScript 6.",
+  "author": "Katrina Owen",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/xecmascript"
+  },
+  "devDependencies": {
+    "babel": "~5.8.29",
+    "del": "~2.0.2",
+    "gulp": "~3.9.0",
+    "gulp-babel": "~5.3.0",
+    "gulp-eslint": "^1.1.0",
+    "gulp-jasmine": "~2.0.1",
+    "yargs": "~3.27.0"
+  },
+  "scripts": {
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
+  },
+  "licenses": [
+    "MIT"
+  ],
+  "dependencies": {}
+}

data/tracks/fsharp/exercises/diffie-hellman/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+For this exercise the following F# feature comes in handy:
+- [BigInt](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/numerics.biginteger-structure-%5Bfsharp%5D)

data/tracks/fsharp/exercises/gigasecond/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+There is a property in the `DateTime` class that allows you to retrieve the date without its time component.

data/tracks/fsharp/exercises/palindrome-products/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+- The most simple way to check if a number is a palindrome is quite slow. To speed things up, you could implement a slighly more complex algorithm which uses mutable state.

data/tracks/java/config.json

@@ -55,6 +55,7 @@
     "binary-search-tree",
     "binary-search",
     "all-your-base",
+    "custom-set",
     "wordy",
     "palindrome-products"
   ],
@@ -314,6 +315,11 @@
       "difficulty": 1,
       "topics": []
     },
+    {
+      "slug": "custom-set",
+      "difficulty": 1,
+      "topics": []
+    },
     {
       "slug": "wordy",
       "difficulty": 1,