trackler 2.2.1.29 → 2.2.1.30

data/tracks/delphi/config/maintainers.json

@@ -1,25 +1,25 @@
 {
+  "docs_url": "https://github.com/exercism/docs/blob/master/maintaining-a-track/maintainer-configuration.md",
   "maintainers": [
     {
-      "github_username": "kotp",
-      "show_on_website": false,
       "alumnus": false,
-      "name": null,
+      "avatar_url": null,
       "bio": null,
+      "github_username": "kotp",
       "link_text": null,
       "link_url": null,
-      "avatar_url": null
+      "name": null,
+      "show_on_website": false
     },
     {
-      "github_username": "rpottsoh",
-      "show_on_website": true,
       "alumnus": false,
-      "name": "Ryan Potts",
+      "avatar_url": null,
       "bio": "I have been using Delphi professionally since 1996.  At my day job I develop software used in the control of various types of test machines used by the auto industry.  Exercism is my first real push into Open Source and I'm happy to have this opportunity to teach and share the virtures of Delphi with others.",
+      "github_username": "rpottsoh",
       "link_text": null,
       "link_url": null,
-      "avatar_url": null
+      "name": "Ryan Potts",
+      "show_on_website": true
     }
-  ],
-  "docs_url": "https://github.com/exercism/docs/blob/master/maintaining-a-track/maintainer-configuration.md"
-}
+  ]
+}

data/tracks/delphi/exercises/circular-buffer/README.md

@@ -31,18 +31,25 @@ If the buffer has 7 elements then it is completely full:
 When the buffer is full an error will be raised, alerting the client
 that further writes are blocked until a slot becomes free.
 
-The client can opt to overwrite the oldest data with a forced write. In
-this case, two more elements — A & B — are added and they overwrite the
-3 & 4:
+When the buffer is full, the client can opt to overwrite the oldest
+data with a forced write. In this case, two more elements — A & B —
+are added and they overwrite the 3 & 4:
 
     [6][7][8][9][A][B][5]
 
-Finally, if two elements are now removed then what would be returned is
-not 3 & 4 but 5 & 6 because A & B overwrote the 3 & the 4 yielding the
-buffer with:
+3 & 4 have been replaced by A & B making 5 now the oldest data in the
+buffer. Finally, if two elements are removed then what would be
+returned is 5 & 6 yielding the buffer:
 
     [ ][7][8][9][A][B][ ]
 
+Because there is space available, if the client again uses overwrite
+to store C & D then the space where 5 & 6 were stored previously will
+be used not the location of 7 & 8. 7 is still the oldest element and
+the buffer is once again full.
+
+    [D][7][8][9][A][B][C]
+
 ## Testing
 
 In order to run the tests for this track, you will need to install

data/tracks/ecmascript/config.json

@@ -1003,6 +1003,18 @@
         "Algorithms"
       ]
     },
+    {
+      "uuid": "a1591026-2f02-45f9-b189-24b2359eb43f",
+      "slug": "simple-linked-list",
+      "core": false,
+      "unlocked_by": "linked-list",
+      "difficulty": 8,
+      "topics": [
+        "Arrays",
+        "Data structures",
+        "Lists"
+      ]
+    },
     {
       "uuid": "2fa2c262-77ae-409b-bfd8-1d643faae772",
       "slug": "connect",

data/tracks/ecmascript/exercises/custom-set/custom-set.spec.js

@@ -1,115 +1,222 @@
 import CustomSet from './custom-set';
 
 describe('CustomSet', () => {
-  test('can delete elements', () => {
-    const expected = new CustomSet([1, 3]);
-    const actual = new CustomSet([3, 2, 1]).delete(2);
-    expect(actual.eql(expected)).toBe(true);
-
-    const expected2 = new CustomSet([1, 2, 3]);
-    const actual2 = new CustomSet([3, 2, 1]).delete(4);
-    expect(actual2.eql(expected2)).toBe(true);
-  });
+  describe('empty: returns true if the set contains no elements', () => {
+    xtest('sets with no elements are empty', () => {
+      const actual = new CustomSet().empty();
+      expect(actual).toBe(true);
+    });
 
-  xtest('can check for difference', () => {
-    const expected = new CustomSet([1, 3]);
-    const actual = new CustomSet([3, 2, 1]).difference(new CustomSet([2, 4]));
-    expect(actual.eql(expected)).toBe(true);
-    const expected2 = new CustomSet([1, 2, 3]);
-    const actual2 = new CustomSet([1, 2, 3]).difference(new CustomSet([4]));
-    expect(actual2.eql(expected2)).toBe(true);
+    xtest('sets with elements are not empty', () => {
+      const actual = new CustomSet([1]).empty();
+      expect(actual).toBe(false);
+    });
   });
 
-  xtest('can test disjoint', () => {
-    const actual = new CustomSet([1, 2]).disjoint(new CustomSet([3, 4]));
-    expect(actual).toBe(true);
-    const actual2 = new CustomSet([1, 2]).disjoint(new CustomSet([2, 3]));
-    expect(actual2).toBe(false);
-    const actual3 = new CustomSet().disjoint(new CustomSet());
-    expect(actual3).toBe(true);
-  });
+  describe('contains: sets can report if they contain an element', () => {
+    xtest('nothing is contained in an empty set', () => {
+      const actual = new CustomSet().contains(1);
+      expect(actual).toBe(false);
+    });
 
-  xtest('can be emptied', () => {
-    const actual = new CustomSet([1, 2]).empty();
-    const expected = new CustomSet();
-    expect(actual.eql(expected)).toBe(true);
-    const actual2 = new CustomSet().empty();
-    const expected2 = new CustomSet();
-    expect(actual2.eql(expected2)).toBe(true);
+    xtest('when the element is in the set', () => {
+      const actual = new CustomSet([1, 2, 3]).contains(1);
+      expect(actual).toBe(true);
+    });
+
+    xtest('when the element is not in the set', () => {
+      const actual = new CustomSet([1, 2, 3]).contains(4);
+      expect(actual).toBe(false);
+    });
   });
 
-  xtest('can check for intersection', () => {
-    const actual = new CustomSet(['a', 'b', 'c']).intersection(new CustomSet(['a', 'c', 'd']));
-    const expected = new CustomSet(['a', 'c']);
-    expect(actual.eql(expected)).toBe(true);
+  describe('subset: a set is a subset if all of its elements are contained in the other set', () => {
+    xtest('empty set is a subset of another empty set', () => {
+      const actual = new CustomSet().subset(new CustomSet());
+      expect(actual).toBe(true);
+    });
+
+    xtest('empty set is a subset of non-empty set', () => {
+      const actual = new CustomSet().subset(new CustomSet([1]));
+      expect(actual).toBe(true);
+    });
+
+    xtest('non-empty set is not a subset of empty set', () => {
+      const actual = new CustomSet([1]).subset(new CustomSet());
+      expect(actual).toBe(false);
+    });
+
+    xtest('set is a subset of set with exact same elements', () => {
+      const actual = new CustomSet([1, 2, 3]).subset(new CustomSet([1, 2, 3]));
+      expect(actual).toBe(true);
+    });
+
+    xtest('set is a subset of larger set with same elements', () => {
+      const actual = new CustomSet([1, 2, 3]).subset(new CustomSet([4, 1, 2, 3]));
+      expect(actual).toBe(true);
+    });
 
-    const actual2 = new CustomSet([1, 2, 3]).intersection(new CustomSet([3, 5, 4]));
-    const expected2 = new CustomSet([3]);
-    expect(actual2.eql(expected2)).toBe(true);
+    xtest('set is not a subset of set that does not contain its elements', () => {
+      const actual = new CustomSet([1, 2, 3]).subset(new CustomSet([4, 1, 3]));
+      expect(actual).toBe(false);
+    });
   });
 
-  xtest('can test for a member', () => {
-    const actual = new CustomSet([1, 2, 3]).member(2);
-    expect(actual).toBe(true);
-    const actual2 = new CustomSet([1, 2, 3]).member(4);
-    expect(actual2).toBe(false);
+  describe('disjoint: sets are disjoint if they share no elements', () => {
+    xtest('the empty set is disjoint with itself', () => {
+      const actual = new CustomSet().disjoint(new CustomSet([]));
+      expect(actual).toBe(true);
+    });
+
+    xtest('empty set is disjoint with non-empty set', () => {
+      const actual = new CustomSet().disjoint(new CustomSet([1]));
+      expect(actual).toBe(true);
+    });
+
+    xtest('non-empty set is disjoint with empty set', () => {
+      const actual = new CustomSet([1]).disjoint(new CustomSet([]));
+      expect(actual).toBe(true);
+    });
+
+    xtest('sets are not disjoint if they share an element', () => {
+      const actual = new CustomSet([1, 2]).disjoint(new CustomSet([2, 3]));
+      expect(actual).toBe(false);
+    });
+
+    xtest('sets are disjoint if they share no elements', () => {
+      const actual = new CustomSet([1, 2]).disjoint(new CustomSet([3, 4]));
+      expect(actual).toBe(true);
+    });
   });
 
-  xtest('can add a member with put', () => {
-    const actual = new CustomSet([1, 2, 4]).put(3);
-    const expected = new CustomSet([1, 2, 3, 4]);
-    expect(actual.eql(expected)).toBe(true);
-    const actual2 = new CustomSet([1, 2, 3]).put(3);
-    const expected2 = new CustomSet([1, 2, 3]);
-    expect(actual2.eql(expected2)).toBe(true);
+  describe('eql: sets with the same elements are equal', () => {
+    xtest('empty sets are equal', () => {
+      const actual = new CustomSet().eql(new CustomSet());
+      expect(actual).toBe(true);
+    });
+
+    xtest('empty set is not equal to non-empty set', () => {
+      const actual = new CustomSet().eql(new CustomSet([1, 2, 3]));
+      expect(actual).toBe(false);
+    });
+
+    xtest('non-empty set is not equal to empty set', () => {
+      const actual = new CustomSet([1, 2, 3]).eql(new CustomSet());
+      expect(actual).toBe(false);
+    });
+
+    xtest('sets with the same elements are equal', () => {
+      const actual = new CustomSet([1, 2]).eql(new CustomSet([2, 1]));
+      expect(actual).toBe(true);
+    });
+
+    xtest('sets with different elements are not equal', () => {
+      const actual = new CustomSet([1, 2, 3]).eql(new CustomSet([1, 2, 4]));
+      expect(actual).toBe(false);
+    });
   });
 
-  xtest('knows its size', () => {
-    const actual = new CustomSet().size();
-    expect(actual).toBe(0);
-    const actual2 = new CustomSet([1, 2, 3]).size();
-    expect(actual2).toBe(3);
-    const actual3 = new CustomSet([1, 2, 3, 2]).size();
-    expect(actual3).toBe(3);
+  describe('add: unique elements can be added to a set', () => {
+    xtest('add to empty set', () => {
+      const actual = new CustomSet().add(3);
+      const expected = new CustomSet([3]);
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('add to non-empty set', () => {
+      const actual = new CustomSet([1, 2, 4]).add(3);
+      const expected = new CustomSet([1, 2, 3, 4]);
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('adding an existing element does not change the set', () => {
+      const actual = new CustomSet([1, 2, 3]).add(3);
+      const expected = new CustomSet([1, 2, 3]);
+      expect(actual.eql(expected)).toBe(true);
+    });
   });
 
-  xtest('can test for subsets', () => {
-    const actual = new CustomSet([1, 2, 3]).subset(new CustomSet([1, 2, 3]));
-    expect(actual).toBe(true);
-    const actual2 = new CustomSet([4, 1, 2, 3]).subset(new CustomSet([1, 2, 3]));
-    expect(actual2).toBe(true);
-    const actual3 = new CustomSet([4, 1, 3]).subset(new CustomSet([1, 2, 3]));
-    expect(actual3).toBe(false);
-    const actual4 = new CustomSet([4, 1, 3]).subset(new CustomSet());
-    expect(actual4).toBe(true);
-    const actual5 = new CustomSet().subset(new CustomSet());
-    expect(actual5).toBe(true);
+  describe('intersection: returns a set of all shared elements', () => {
+    xtest('intersection of two empty sets is an empty set', () => {
+      const actual = new CustomSet().intersection(new CustomSet());
+      const expected = new CustomSet();
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('intersection of an empty set and non-empty set is an empty set', () => {
+      const actual = new CustomSet().intersection(new CustomSet([3, 2, 5]));
+      const expected = new CustomSet([]);
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('intersection of a non-empty set and an empty set is an empty set', () => {
+      const actual = new CustomSet([1, 2, 3, 4]).intersection(new CustomSet([]));
+      const expected = new CustomSet([]);
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('intersection of two sets with no shared elements is an empty set', () => {
+      const actual = new CustomSet([1, 2, 3]).intersection(new CustomSet([4, 5, 6]));
+      const expected = new CustomSet([]);
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('intersection of two sets with shared elements is a set of the shared elements', () => {
+      const actual = new CustomSet([1, 2, 3, 4]).intersection(new CustomSet([3, 2, 5]));
+      const expected = new CustomSet([2, 3]);
+      expect(actual.eql(expected)).toBe(true);
+    });
   });
 
-  xtest('can give back a list', () => {
-    const actual = new CustomSet().toList();
-    const expected = [];
-    expect(actual.sort()).toEqual(expected);
-    const actual2 = new CustomSet([3, 1, 2]).toList();
-    const expected2 = [1, 2, 3];
-    expect(actual2.sort()).toEqual(expected2);
-    const actual3 = new CustomSet([3, 1, 2, 1]).toList();
-    const expected3 = [1, 2, 3];
-    expect(actual3.sort()).toEqual(expected3);
+  describe('difference of a set is a set of all elements that are only in the first set', () => {
+    xtest('difference of two empty sets is an empty set', () => {
+      const actual = new CustomSet().difference(new CustomSet());
+      const expected = new CustomSet();
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('difference of empty set and non-empty set is an empty set', () => {
+      const actual = new CustomSet().difference(new CustomSet([3, 2, 5]));
+      const expected = new CustomSet();
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('difference of a non-empty set and an empty set is the non-empty set', () => {
+      const actual = new CustomSet([1, 2, 3, 4]).difference(new CustomSet());
+      const expected = new CustomSet([1, 2, 3, 4]);
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('difference of two non-empty sets is a set of elements that are only in the first set', () => {
+      const actual = new CustomSet([3, 2, 1]).difference(new CustomSet([2, 4]));
+      const expected = new CustomSet([1, 3]);
+      expect(actual.eql(expected)).toBe(true);
+    });
   });
 
-  xtest('can test for union', () => {
-    const actual = new CustomSet([1, 3]).union(new CustomSet([2]));
-    const expected = new CustomSet([3, 2, 1]);
-    expect(actual.eql(expected)).toBe(true);
-    const actual2 = new CustomSet([1, 3]).union(new CustomSet([2, 3]));
-    const expected2 = new CustomSet([3, 2, 1]);
-    expect(actual2.eql(expected2)).toBe(true);
-    const actual3 = new CustomSet([1, 3]).union(new CustomSet());
-    const expected3 = new CustomSet([3, 1]);
-    expect(actual3.eql(expected3)).toBe(true);
-    const actual4 = new CustomSet().union(new CustomSet());
-    const expected4 = new CustomSet();
-    expect(actual4.eql(expected4)).toBe(true);
+  describe('union: returns a set of all elements in either set', () => {
+    xtest('union of empty sets is an empty set', () => {
+      const actual = new CustomSet().union(new CustomSet());
+      const expected = new CustomSet();
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('union of an empty set and non-empty set is the non-empty set', () => {
+      const actual = new CustomSet().union(new CustomSet([2]));
+      const expected = new CustomSet([2]);
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('union of a non-empty set and empty set is the non-empty set', () => {
+      const actual = new CustomSet([1, 3]).union(new CustomSet());
+      const expected = new CustomSet([1, 3]);
+      expect(actual.eql(expected)).toBe(true);
+    });
+
+    xtest('union of non-empty sets contains all unique elements', () => {
+      const actual = new CustomSet([1, 3]).union(new CustomSet([2, 3]));
+      const expected = new CustomSet([1, 2, 3]);
+      expect(actual.eql(expected)).toBe(true);
+    });
   });
 });

data/tracks/ecmascript/exercises/custom-set/example.js

@@ -1,11 +1,12 @@
 export default class CustomSet {
   constructor(data = []) {
     this.data = {};
-    data.forEach(el => this.put(el));
-    this.comparator = typeof data[0] === 'number' ?
-      (a, b) => a - b
-      : (a, b) => b <= a
-      ? 1 : -1;
+    data.forEach(el => this.add(el));
+  }
+
+  add(el) {
+    this.data[el] = el;
+    return this;
   }
 
   delete(el) {
@@ -13,8 +14,20 @@ export default class CustomSet {
     return this;
   }
 
+  size() {
+    return Object.keys(this.data).length;
+  }
+
+  empty() {
+    return this.size() === 0;
+  }
+
+  contains(el) {
+    return this.data[el] !== undefined;
+  }
+
   eql(other) {
-    return this.difference(other).size() === 0;
+    return this.size() === other.size() && this.difference(other).size() === 0;
   }
 
   difference(other) {
@@ -30,36 +43,14 @@ export default class CustomSet {
   }
 
   union(other) {
-    return new CustomSet(this.toList().concat(this.difference(other).toList()));
+    return new CustomSet(this.toList().concat(other.toList()));
   }
 
   subset(other) {
-    return other.eql(this.intersection(other));
+    return this.eql(this.intersection(other));
   }
 
   toList() {
-    return Object.keys(this.data).map(el => +el);
-  }
-
-  member(el) {
-    return this.data[el] !== undefined;
-  }
-
-  put(value) {
-    this.data[value] = value;
-    return this;
-  }
-
-  sort() {
-    this.data.sort(this.comparator);
-  }
-
-  size() {
-    return Object.keys(this.data).length;
-  }
-
-  empty() {
-    this.data = {};
-    return this;
+    return Object.values(this.data);
   }
 }