trackler 2.2.1.29 → 2.2.1.30

data/tracks/ecmascript/exercises/simple-linked-list/README.md

@@ -0,0 +1,57 @@
+# Simple Linked List
+
+Write a simple linked list implementation that uses Elements and a List.
+
+The linked list is a fundamental data structure in computer science,
+often used in the implementation of other data structures. They're
+pervasive in functional programming languages, such as Clojure, Erlang,
+or Haskell, but far less common in imperative languages such as Ruby or
+Python.
+
+The simplest kind of linked list is a singly linked list. Each element in the
+list contains data and a "next" field pointing to the next element in the list
+of elements.
+
+This variant of linked lists is often used to represent sequences or
+push-down stacks (also called a LIFO stack; Last In, First Out).
+
+As a first take, lets create a singly linked list to contain the range (1..10),
+and provide functions to reverse a linked list and convert to and from arrays.
+
+When implementing this in a language with built-in linked lists,
+implement your own abstract data type.
+
+## Setup
+
+Go through the setup instructions for ECMAScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/ecmascript
+
+## Requirements
+
+Install assignment dependencies:
+
+```bash
+$ npm install
+```
+
+## Making the test suite pass
+
+Execute the tests with:
+
+```bash
+$ npm test
+```
+
+In the test suites all tests but the first have been skipped.
+
+Once you get a test passing, you can enable the next one by
+changing `xtest` to `test`.
+
+## Source
+
+Inspired by 'Data Structures and Algorithms with Object-Oriented Design Patterns in Ruby', singly linked-lists. [http://www.brpreiss.com/books/opus8/html/page96.html#SECTION004300000000000000000](http://www.brpreiss.com/books/opus8/html/page96.html#SECTION004300000000000000000)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/ecmascript/exercises/simple-linked-list/example.js

@@ -0,0 +1,111 @@
+export class ElementValueRequiredException extends Error {}
+export class ElementNextNotInstanceException extends Error {}
+
+export class Element {
+  constructor(value, next) {
+    if (value === undefined) {
+      throw new ElementValueRequiredException();
+    }
+
+    if (next !== undefined && !(next instanceof Element)) {
+      throw new ElementNextNotInstanceException();
+    }
+
+    this.value = value;
+    this.next = next;
+  }
+}
+
+export class List {
+  static fromArray(array) {
+    const list = new List();
+    array.forEach(item => list.push(new Element(item)));
+
+    return list;
+  }
+
+  push(value) {
+    const newEl = (value instanceof Element)
+      ? value
+      : new Element(value);
+
+    if (!this.head) {
+      this.head = newEl;
+      return;
+    }
+
+    let lastEl = this.head;
+    while (lastEl.next) {
+      lastEl = lastEl.next;
+    }
+
+    lastEl.next = newEl;
+  }
+
+  unshift(value) {
+    const newEl = (value instanceof Element)
+      ? value
+      : new Element(value);
+
+    newEl.next = this.head;
+    this.head = newEl;
+  }
+
+  shift() {
+    if (!this.head) {
+      return;
+    }
+
+    this.head = this.head.next;
+  }
+
+  pop() {
+    if (!this.head) {
+      return;
+    }
+
+    let penultEl;
+    let lastEl = this.head;
+
+    while (lastEl.next) {
+      penultEl = lastEl;
+      lastEl = lastEl.next;
+    }
+
+    if (!penultEl) {
+      this.head = undefined;
+    } else {
+      penultEl.next = undefined;
+    }
+  }
+
+  reverse() {
+    if (!this.head) {
+      return;
+    }
+
+    let current;
+    let previous;
+
+    while (this.head) {
+      current = this.head;
+      this.shift();
+      current.next = previous;
+      previous = current;
+    }
+
+    this.head = previous;
+  }
+
+  toArray() {
+    const array = [];
+    let current = this.head;
+
+    while (current) {
+      array.push(current.value);
+      current = current.next;
+    }
+
+    return array;
+  }
+}

data/tracks/ecmascript/exercises/simple-linked-list/package.json

@@ -0,0 +1,69 @@
+{
+  "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-jest": "^20.0.3",
+    "babel-plugin-transform-builtin-extend": "^1.1.2",
+    "babel-preset-env": "^1.4.0",
+    "eslint": "^3.19.0",
+    "eslint-config-airbnb": "^15.0.1",
+    "eslint-plugin-import": "^2.2.0",
+    "eslint-plugin-jsx-a11y": "^5.0.1",
+    "eslint-plugin-react": "^7.0.1",
+    "jest": "^20.0.4"
+  },
+  "jest": {
+    "modulePathIgnorePatterns": [
+      "package.json"
+    ]
+  },
+  "babel": {
+    "presets": [
+      "env"
+    ],
+    "plugins": [
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ],
+      ["transform-regenerator"]
+    ]
+},
+  "scripts": {
+    "test": "jest --no-cache ./*",
+    "watch": "jest --no-cache --watch ./*",
+    "lint": "eslint .",
+    "lint-test": "eslint . && jest --no-cache ./* "
+  },
+  "eslintConfig": {
+    "parserOptions": {
+      "ecmaVersion": 6,
+      "sourceType": "module"
+    },
+    "env": {
+      "es6": true,
+      "node": true,
+      "jest": true
+    },
+    "extends": "airbnb",
+    "rules": {
+      "import/no-unresolved": "off",
+      "import/extensions": "off"
+    }
+  },
+  "licenses": [
+    "MIT"
+  ],
+  "dependencies": {}
+}

data/tracks/ecmascript/exercises/simple-linked-list/simple-linked-list.spec.js

@@ -0,0 +1,146 @@
+import {
+  List,
+  Element,
+  ElementValueRequiredException,
+  ElementNextNotInstanceException,
+} from './simple-linked-list';
+
+describe('simple-linked-list', () => {
+  test('exports a List constructor', () => {
+    expect(List).toBeDefined();
+  });
+
+  xtest('exports a Element constructor', () => {
+    expect(Element).toBeDefined();
+  });
+
+  describe('Element', () => {
+    xtest('is a constructor', () => {
+      const el = new Element(1);
+      expect(el).toBeDefined();
+
+      expect(() => {
+        Element(1);
+      }).toThrow();
+    });
+
+    xtest('requires an argument', () => {
+      const el = new Element(1);
+      expect(el).toBeDefined();
+
+      expect(() => new Element()).toThrow(ElementValueRequiredException);
+    });
+
+    xtest('has as a value', () => {
+      const el = new Element(1);
+      expect(el.value).toBe(1);
+    });
+
+    xtest('reference to next is undefined by default', () => {
+      const el = new Element(1);
+      expect(el.next).toBeUndefined();
+    });
+  });
+
+  xtest('accepts a reference to the next element', () => {
+    const elOne = new Element(1);
+    const elTwo = new Element(2, elOne);
+    expect(elTwo.next).toBe(elOne);
+  });
+
+  xtest('requires an instance of Element as next element', () => {
+    expect(() => new Element(1, true)).toThrow(ElementNextNotInstanceException);
+    expect(() => new Element(1, 'lorem ipsum')).toThrow(ElementNextNotInstanceException);
+    expect(() => new Element(1, [])).toThrow(ElementNextNotInstanceException);
+    expect(() => new Element(1, {})).toThrow(ElementNextNotInstanceException);
+  });
+
+  describe('List', () => {
+    xtest('is a constructor', () => {
+      const ll = new List();
+      expect(ll).toBeDefined();
+    });
+
+    xtest('allows you to append an element', () => {
+      const ll = new List();
+      const el = new Element(1);
+      ll.push(el);
+      expect(ll.head).toBe(el);
+
+      const ll2 = new List();
+      const elOne = new Element(1);
+      const elTwo = new Element(2);
+      ll2.push(elOne);
+      ll2.push(elTwo);
+      expect(ll2.head.next).toBe(elTwo);
+    });
+
+    xtest('allows you to prepend an element', () => {
+      const ll = new List();
+      const el = new Element(1);
+      ll.unshift(el);
+      expect(ll.head).toBe(el);
+
+      const ll2 = new List();
+      const elOne = new Element(1);
+      const elTwo = new Element(2);
+      ll2.unshift(elOne);
+      ll2.unshift(elTwo);
+      expect(ll2.head).toBe(elTwo);
+    });
+
+    xtest('allows you to remove the first element', () => {
+      const ll = new List();
+      ll.push(new Element(1));
+      ll.shift();
+      expect(ll.head).toBeUndefined();
+
+      ll.push(new Element(2));
+      ll.push(new Element(3));
+      ll.shift();
+      expect(ll.head.value).toBe(3);
+    });
+
+    xtest('allows you to remove the last element', () => {
+      const ll = new List();
+      ll.push(new Element(1));
+      ll.pop();
+      expect(ll.head).toBeUndefined();
+
+      ll.push(new Element(2));
+      ll.push(new Element(3));
+      ll.pop();
+      expect(ll.head.next).toBeUndefined();
+    });
+
+    xtest('allows you to convert an array to a List', () => {
+      const ll = List.fromArray([1, 2]);
+
+      expect(ll.head.value).toBe(1);
+      expect(ll.head.next.value).toBe(2);
+    });
+
+    xtest('allows you to convert a List into an array', () => {
+      const ll = new List();
+      ll.push(new Element(1));
+      ll.push(new Element(2));
+      const a = ll.toArray();
+
+      expect(a instanceof Array).toBe(true);
+      expect(a.length).toBe(2);
+      expect(a[0]).toBe(1);
+      expect(a[1]).toBe(2);
+
+      expect(ll.head.value).toBe(1);
+    });
+
+    xtest('allows you to reverse a List', () => {
+      const ll = List.fromArray([1, 2, 3]);
+      ll.reverse();
+
+      expect(ll.head.value).toBe(3);
+      expect(ll.head.next.value).toBe(2);
+      expect(ll.head.next.next.value).toBe(1);
+    });
+  });
+});

data/tracks/go/.travis.yml

@@ -18,8 +18,8 @@ sudo: false
 # but since Travis only runs five jobs at a time throughout all of Exercism,
 # it is better citizenship to not test the additional versions.
 go:
-  - 1.7.5
-  - 1.8
+  - 1.8.3
+  - 1.9
   - tip
 
 # Travis runs in a 64 bit environment but beginning with Go 1.5, building a

data/tracks/go/exercises/perfect-numbers/perfect_numbers_test.go

@@ -62,3 +62,11 @@ func TestClassificationsNotEqual(t *testing.T) {
 		}
 	}
 }
+
+func BenchmarkClassify(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, c := range classificationTestCases {
+			Classify(c.input)
+		}
+	}
+}

data/tracks/powershell/docs/INSTRUCTIONS.md

@@ -0,0 +1,14 @@
+### Installing Windows PowerShell
+
+PowerShell comes pre-installed on all Windows operating systems from Windows 7 SP1 onward.
+
+You can find the latest version of PowerShell and installation instructions for all platforms [here](https://github.com/PowerShell/PowerShell/blob/master/README.md#get-powershell).
+
+### Using an IDE
+
+If you want a more full-featured editing experience, you probably want to use an IDE. These are the most popular IDE's that support building PowerShell projects:
+
+##### All platforms
+* [Visual Studio Code](https://code.visualstudio.com/download) with the [PowerShell extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode.PowerShell)
+* [Atom](https://atom.io/) with the [PowerShell package](https://atom.io/packages/language-powershell)
+* [Sublime Text 3](https://www.sublimetext.com/3) with the [PowerShell package](https://packagecontrol.io/packages/PowerShell)

data/tracks/scala/exercises/variable-length-quantity/src/test/scala/VariableLengthQuantityTest.scala

@@ -1,162 +1,153 @@
-import org.scalatest.{FunSuite, Matchers}
+import org.scalatest.{Matchers, FunSuite}
 
+/** @version 1.0.0 */
 class VariableLengthQuantityTest extends FunSuite with Matchers {
 
-  // Encode a series of integers, producing a series of bytes.
-  test("encode: zero") {
-    val encoded = VariableLengthQuantity.encode(List(0x0))
-    encoded should be (List(0x0))
+  test("zero") {
+    VariableLengthQuantity.encode(List(0x0)) should be(List(0x0))
   }
 
-  test("encode: arbitrary single byte") {
+  test("arbitrary single byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x40))
-    encoded should be (List(0x40))
+    VariableLengthQuantity.encode(List(0x40)) should be(List(0x40))
   }
 
-  test("encode: largest single byte") {
+  test("largest single byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x7f))
-    encoded should be (List(0x7f))
+    VariableLengthQuantity.encode(List(0x7F)) should be(List(0x7F))
   }
 
-  test("encode: smallest double byte") {
+  test("smallest double byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x80))
-    encoded should be (List(0x81, 0x0))
+    VariableLengthQuantity.encode(List(0x80)) should be(List(0x81, 0x0))
   }
 
-  test("encode: arbitrary double byte") {
+  test("arbitrary double byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x2000))
-    encoded should be (List(0xc0, 0x0))
+    VariableLengthQuantity.encode(List(0x2000)) should be(List(0xC0, 0x0))
   }
 
-  test("encode: largest double byte") {
+  test("largest double byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x3fff))
-    encoded should be (List(0xff, 0x7f))
+    VariableLengthQuantity.encode(List(0x3FFF)) should be(List(0xFF, 0x7F))
   }
 
-  test("encode: smallest triple byte") {
+  test("smallest triple byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x4000))
-    encoded should be (List(0x81, 0x80, 0x0))
+    VariableLengthQuantity.encode(List(0x4000)) should be(List(0x81, 0x80, 0x0))
   }
 
-  test("encode: arbitrary triple byte") {
+  test("arbitrary triple byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x100000))
-    encoded should be (List(0xc0, 0x80, 0x0))
+    VariableLengthQuantity.encode(List(0x100000)) should be(
+      List(0xC0, 0x80, 0x0))
   }
 
-  test("encode: largest triple byte") {
+  test("largest triple byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x1fffff))
-    encoded should be (List(0xff, 0xff, 0x7f))
+    VariableLengthQuantity.encode(List(0x1FFFFF)) should be(
+      List(0xFF, 0xFF, 0x7F))
   }
 
-  test("encode: smallest quadruple byte") {
+  test("smallest quadruple byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x200000))
-    encoded should be (List(0x81, 0x80, 0x80, 0x0))
+    VariableLengthQuantity.encode(List(0x200000)) should be(
+      List(0x81, 0x80, 0x80, 0x0))
   }
 
-  test("encode: arbitrary quadruple byte") {
+  test("arbitrary quadruple byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x8000000))
-    encoded should be (List(0xc0, 0x80, 0x80, 0x0))
+    VariableLengthQuantity.encode(List(0x8000000)) should be(
+      List(0xC0, 0x80, 0x80, 0x0))
   }
 
-  test("encode: largest quadruple byte") {
+  test("largest quadruple byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0xfffffff))
-    encoded should be (List(0xff, 0xff, 0xff, 0x7f))
+    VariableLengthQuantity.encode(List(0xFFFFFFF)) should be(
+      List(0xFF, 0xFF, 0xFF, 0x7F))
   }
 
-  test("encode: smallest quintuple byte") {
+  test("smallest quintuple byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x10000000))
-    encoded should be (List(0x81, 0x80, 0x80, 0x80, 0x0))
+    VariableLengthQuantity.encode(List(0x10000000)) should be(
+      List(0x81, 0x80, 0x80, 0x80, 0x0))
   }
 
-  test("encode: arbitrary quintuple byte") {
+  test("arbitrary quintuple byte") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0xff000000))
-    encoded should be (List(0x8f, 0xf8, 0x80, 0x80, 0x0))
+    VariableLengthQuantity.encode(List(0xFF000000)) should be(
+      List(0x8F, 0xF8, 0x80, 0x80, 0x0))
   }
 
-  test("encode: maximum 32-bit integer input") {
+  test("maximum 32-bit integer input") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0xffffffff))
-    encoded should be (List(0x8f, 0xff, 0xff, 0xff, 0x7f))
+    VariableLengthQuantity.encode(List(0xFFFFFFFF)) should be(
+      List(0x8F, 0xFF, 0xFF, 0xFF, 0x7F))
   }
 
-  test("encode: two single-byte values") {
+  test("two single-byte values") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x40, 0x7f))
-    encoded should be (List(0x40, 0x7f))
+    VariableLengthQuantity.encode(List(0x40, 0x7F)) should be(List(0x40, 0x7F))
   }
 
-  test("encode: two multi-byte values") {
+  test("two multi-byte values") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x4000, 0x123456))
-    encoded should be (List(0x81, 0x80, 0x0, 0xc8, 0xe8, 0x56))
+    VariableLengthQuantity.encode(List(0x4000, 0x123456)) should be(
+      List(0x81, 0x80, 0x0, 0xC8, 0xE8, 0x56))
   }
 
-  test("encode: many multi-byte values") {
+  test("many multi-byte values") {
     pending
-    val encoded = VariableLengthQuantity.encode(List(0x2000, 0x123456, 0xfffffff, 0x0, 0x3fff, 0x4000))
-    encoded should be (List(0xc0, 0x0, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f, 0x0, 0xff, 0x7f, 0x81, 0x80, 0x0))
+    VariableLengthQuantity.encode(
+      List(0x2000, 0x123456, 0xFFFFFFF, 0x0, 0x3FFF, 0x4000)) should be(
+      List(0xC0, 0x0, 0xC8, 0xE8, 0x56, 0xFF, 0xFF, 0xFF, 0x7F, 0x0, 0xFF, 0x7F,
+        0x81, 0x80, 0x0))
   }
 
-  // Decode a series of bytes, producing a series of integers.
-  test("decode: one byte") {
+  test("one byte") {
     pending
-    val decoded = VariableLengthQuantity.decode(List(0x7f))
-    decoded should be (Right(List(0x7f)))
+    VariableLengthQuantity.decode(List(0x7F)) should be(Right(List(0x7F)))
   }
 
-  test("decode: two bytes") {
+  test("two bytes") {
     pending
-    val decoded = VariableLengthQuantity.decode(List(0xc0, 0x0))
-    decoded should be (Right(List(0x2000)))
+    VariableLengthQuantity.decode(List(0xC0, 0x0)) should be(
+      Right(List(0x2000)))
   }
 
-  test("decode: three bytes") {
+  test("three bytes") {
     pending
-    val decoded = VariableLengthQuantity.decode(List(0xff, 0xff, 0x7f))
-    decoded should be (Right(List(0x1fffff)))
+    VariableLengthQuantity.decode(List(0xFF, 0xFF, 0x7F)) should be(
+      Right(List(0x1FFFFF)))
   }
 
-  test("decode: four bytes") {
+  test("four bytes") {
     pending
-    val decoded = VariableLengthQuantity.decode(List(0x81, 0x80, 0x80, 0x0))
-    decoded should be (Right(List(0x200000)))
+    VariableLengthQuantity.decode(List(0x81, 0x80, 0x80, 0x0)) should be(
+      Right(List(0x200000)))
   }
 
-  test("decode: maximum 32-bit integer") {
+  test("maximum 32-bit integer") {
     pending
-    val decoded = VariableLengthQuantity.decode(List(0x8f, 0xff, 0xff, 0xff, 0x7f))
-    decoded should be (Right(List(0xffffffff)))
+    VariableLengthQuantity.decode(List(0x8F, 0xFF, 0xFF, 0xFF, 0x7F)) should be(
+      Right(List(0xFFFFFFFF)))
   }
 
-  test("decode: incomplete sequence causes error") {
+  test("incomplete sequence causes error") {
     pending
-    val decoded = VariableLengthQuantity.decode(List(0xff))
-    decoded.isLeft should be (true)
+    VariableLengthQuantity.decode(List(0xFF)).isLeft should be(true)
   }
 
-  test("decode: incomplete sequence causes error, even if value is zero") {
+  test("incomplete sequence causes error, even if value is zero") {
     pending
-    val decoded = VariableLengthQuantity.decode(List(0x80))
-    decoded.isLeft should be (true)
+    VariableLengthQuantity.decode(List(0x80)).isLeft should be(true)
   }
 
-  test("decode: multiple values") {
+  test("multiple values") {
     pending
-    val decoded = VariableLengthQuantity.decode(List(0xc0, 0x0, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f, 0x0, 0xff, 0x7f, 0x81, 0x80, 0x0))
-    decoded should be (Right(List(0x2000, 0x123456, 0xfffffff, 0x0, 0x3fff, 0x4000)))
+    VariableLengthQuantity.decode(
+      List(0xC0, 0x0, 0xC8, 0xE8, 0x56, 0xFF, 0xFF, 0xFF, 0x7F, 0x0, 0xFF, 0x7F,
+        0x81, 0x80, 0x0)) should be(
+      Right(List(0x2000, 0x123456, 0xFFFFFFF, 0x0, 0x3FFF, 0x4000)))
   }
-
 }