trackler 2.0.6.16 → 2.0.6.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93c7f99da67e82bacb69b2baa1335f4fe2fcc2da
-  data.tar.gz: 789b2e7a4936b344dcefb2dcf594d603889c762f
+  metadata.gz: 7c9fb8ec96523d44264d1bf0b40ac46df372476e
+  data.tar.gz: 1397df691f26c2341401fe216a78ab3bbe533eb2
 SHA512:
-  metadata.gz: d558ac9c0cea44feb34714b50a7447eda5c3cc0ff7f3ac6c8e9e357f073117ea060ae7b3867d3be38d2f37903275c5b07196bc1c6870754956c7081bb5a33bb0
-  data.tar.gz: d206b1b48daee6f9d5a178f4c50dadec5874bfbf42a0103671bdae92d5994c2c2d116ba6f0e119d538c2204a1b2ddd0c9f8e459c4d2bc0982bb5d5efb6b7bf0b
+  metadata.gz: dcda4af88a5631881d96e39a4c0f300fc92dc50d54f10a98d70bfeca546be73de9c4b7da0b86047affd413fc63145aa8ce0703ee7b0bcb434d3fc884f8746857
+  data.tar.gz: c049d690afb0c20c6c190df3d80a7b6568aa47afa54c46ea5286bb772b04c61ab4e209d112afd3f1368419d5970d806ab7e5240a33fb335a55c490ca451dfd84

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.16"
+  VERSION = "2.0.6.17"
 end

data/tracks/ecmascript/exercises/luhn/example.js

@@ -1,57 +1,34 @@
-export default class Luhn {
-
-  constructor(number) {
-    this.checkDigit = number % 10;
-    this.addends = Luhn.calculateAddends(number);
-    this.checksum = Luhn.calculateChecksum(this.addends);
-    this.valid = Luhn.determineIfValid(this.checksum);
-  }
-
-  static calculateAddends(number) {
-    const numberAsString = '' + number + '',
-      numbers = [...numberAsString],
-      addends = [];
-
-    for (let i = 0; i < numbers.length; i++) {
-      const index = numbers.length - 1 - i;
-      let currentAddend = parseInt(numbers[index], 10);
-
-      if ((i + 1) % 2 === 0) {
-        currentAddend = currentAddend * 2;
-        if (currentAddend > 10) {
-          currentAddend = currentAddend - 9;
-        }
+function isValid(number) {
+  number = number.replace(/\s/g, '');
+  const digits = [...number];
+
+  const sum = digits
+    // convert to integers
+    .map(d => parseInt(d, 10))
+    // double even positions (odd indexes)
+    .map((d, i) => {
+      if (i % 2 !== 0) {
+        return d * 2;
       }
-      addends.push(currentAddend);
-    }
-    return addends.reverse();
-  }
-
-  static calculateChecksum(numbers) {
-    let sum = 0;
-    for (let i = 0; i < numbers.length; i++) {
-      sum += numbers[i];
-    }
-    return sum;
-  }
+      return d;
+    })
+    // limit to digits less than 10
+    .map(d => {
+      if (d > 9) {
+        return d - 9;
+      }
+      return d;
+    })
+    // sum all digits
+    .reduce((d, acc) => d + acc, 0);
 
-  static determineIfValid(sum) {
-    return sum % 10 === 0;
-  }
+  return sum > 0 && sum % 10 === 0;
+}
 
-  static create(number) {
-    let finalNumber = number * 10,
-      luhnNumber = new Luhn(finalNumber),
-      index = 0;
+export default class Luhn {
 
-    while (!luhnNumber.valid) {
-      finalNumber = number * 10 + index;
-      luhnNumber = new Luhn(finalNumber);
-      if (luhnNumber.valid) {
-        break;
-      }
-      index += 1;
-    }
-    return finalNumber;
+  constructor(number) {
+    this.valid = isValid(number);
   }
+
 }

data/tracks/ecmascript/exercises/luhn/luhn.spec.js

@@ -2,59 +2,34 @@ import Luhn from './luhn';
 
 describe('Luhn',() => {
 
-  it('check digit',() => {
-    const luhn = new Luhn(34567);
-    expect(luhn.checkDigit).toEqual(7);
-  });
-
-  xit('check digit again',() => {
-    const luhn = new Luhn(91370);
-    expect(luhn.checkDigit).toEqual(0);
-  });
-
-  xit('addends',() => {
-    const luhn = new Luhn(12121);
-    expect(luhn.addends).toEqual([1, 4, 1, 4, 1]);
-  });
-
-  xit('too large added',() => {
-    const luhn = new Luhn(8631);
-    expect(luhn.addends).toEqual([7, 6, 6, 1]);
-  });
-
-  xit('checksum',() => {
-    const luhn = new Luhn(4913);
-    expect(luhn.checksum).toEqual(22);
-  });
-
-  xit('checksum again',() => {
-    const luhn = new Luhn(201773);
-    expect(luhn.checksum).toEqual(21);
+  it('single digit strings can not be valid', () => {
+    const luhn = new Luhn('1');
+    expect(luhn.valid).toEqual(false);
   });
 
-  xit('invalid number',() => {
-    const luhn = new Luhn(738);
+  xit('A single zero is invalid', () => {
+    const luhn = new Luhn('0');
     expect(luhn.valid).toEqual(false);
   });
 
-  xit('invalid number',() => {
-    const luhn = new Luhn(8739567);
+  xit('valid Canadian SIN', () => {
+    const luhn = new Luhn('046 454 286');
     expect(luhn.valid).toEqual(true);
   });
 
-  xit('create valid number',() => {
-    const number = Luhn.create(123);
-    expect(number).toEqual(1230);
+  xit('invalid Canadian SIN', () => {
+    const luhn = new Luhn('046 454 287');
+    expect(luhn.valid).toEqual(false);
   });
 
-  xit('create other valid number',() => {
-    const number = Luhn.create(873956);
-    expect(number).toEqual(8739567);
+  xit('invalid credit card', () => {
+    const luhn = new Luhn('8273 1232 7352 0569');
+    expect(luhn.valid).toEqual(false);
   });
 
-  xit('create yet another valid number',() => {
-    const number = Luhn.create(837263756);
-    expect(number).toEqual(8372637564);
+  xit('valid strings with a non-digit added become invalid', () => {
+    const luhn = new Luhn('046a 454 286');
+    expect(luhn.valid).toEqual(false);
   });
 
 });

data/tracks/fsharp/exercises/simple-cipher/SimpleCipherTest.fs

@@ -25,7 +25,7 @@ let ``Encode random uses randomly generated key`` () =
     let keys = List.init 100 (fun _ -> encodeRandom plainText |> fst)
     Assert.That(keys |> List.distinct, Is.EqualTo(keys))
 
-// Here we take advantage of the fact that plaintext of "aaa..." doesn't output
+// Here we take advantage of the fact that plaintext of "aaa..." outputs
 // the key. This is a critical problem with shift ciphers, some characters
 // will always output the key verbatim.
 [<Test>]
@@ -62,6 +62,7 @@ let ``Cipher is reversible given key`` () =
     Assert.That(encode key plainText |> decode key, Is.EqualTo(plainText))
     
 [<Test>]
+[<Ignore("Remove to run test")>]
 let ``Cipher can double shift encode`` () =
     let plainText = "iamapandabear"
     Assert.That(encode plainText plainText, Is.EqualTo("qayaeaagaciai"))
@@ -109,4 +110,4 @@ let ``Encode throws with any numeric key`` () =
 [<Ignore("Remove to run test")>]
 let ``Encode throws with empty key`` () =
     let key = ""
-    Assert.That((fun () -> encode key plainText |> ignore), Throws.Exception)
+    Assert.That((fun () -> encode key plainText |> ignore), Throws.Exception)

data/tracks/go/exercises/custom-set/cases_test.go

@@ -1,368 +1,223 @@
 package stringset
 
 // Source: exercism/x-common
-// Commit: 269f498 Merge pull request #48 from soniakeys/custom-set-json
+// Commit: cda8f98 Create new exercises structure
 
-// Test two sets for equality.
-var eqCases = []binBoolCase{
-	{ // order doesn't matter
-		[]string{"a", "c"},
-		[]string{"c", "a"},
-		true,
-	},
-	{ // dupicates don't matter
-		[]string{"a", "a"},
-		[]string{"a"},
-		true,
-	},
-	{ // empty sets are equal
-		[]string{},
-		[]string{},
-		true,
-	},
-	{ // set with single element is equal to itself
-		[]string{"a"},
-		[]string{"a"},
-		true,
-	},
-	{ // different sets are not equal
-		[]string{"a", "b", "c"},
-		[]string{"c", "d", "e"},
-		false,
-	},
-	{ // empty set is not equal to non-empty set
-		[]string{},
-		[]string{"a", "b", "c"},
-		false,
-	},
-	{ // non-empty set is not equal to empty set
-		[]string{"a", "b", "c"},
-		[]string{},
-		false,
-	},
-	{ // having most in common is not good enough
-		[]string{"a", "b", "c", "d"},
-		[]string{"b", "c", "d", "e"},
-		false,
-	},
-}
-
-// Add an element to a set.
-var addCases = []eleOpCase{
-	{ // add to empty set
-		[]string{},
-		"c",
-		[]string{"c"},
-	},
-	{ // add to non-empty set
-		[]string{"a", "b", "d"},
-		"c",
-		[]string{"a", "b", "c", "d"},
-	},
-	{ // add existing element
-		[]string{"a", "b", "c"},
-		"c",
-		[]string{"a", "b", "c"},
-	},
-}
-
-// Delete an element from a set.
-var delCases = []eleOpCase{
-	{ // delete an element
-		[]string{"c", "b", "a"},
-		"b",
-		[]string{"a", "c"},
-	},
-	{ // delete an element not in set
-		[]string{"c", "b", "a"},
-		"d",
-		[]string{"a", "b", "c"},
-	},
-}
-
-// Test if is a set is empty.
+// Returns true if the set contains no elements
 var emptyCases = []unaryBoolCase{
-	{ // empty
+	{ // sets with no elements are empty
 		[]string{},
 		true,
 	},
-	{ // single element
+	{ // sets with elements are not empty
 		[]string{"a"},
 		false,
 	},
-	{ // a few elements
-		[]string{"a", "b", "c", "b"},
-		false,
-	},
-}
-
-// Return the cardinality of a set.
-var lenCases = []unaryIntCase{
-	{ // empty set
-		[]string{},
-		0,
-	},
-	{ // non-empty set
-		[]string{"a", "b", "c"},
-		3,
-	},
-	{ // duplicate element
-		[]string{"a", "b", "c", "b"},
-		3,
-	},
 }
 
-// Test if a value is an element of a set.
+// Sets can report if they contain an element
 var hasCases = []eleBoolCase{
-	{ // nothing is an element of the empty set
+	{ // nothing is contained in an empty set
 		[]string{},
 		"a",
 		false,
 	},
-	{ // 1 is in the set
-		[]string{"a", "b", "c", "b"},
+	{ // when the element is in the set
+		[]string{"a", "b", "c"},
 		"a",
 		true,
 	},
-	{ // 2 is in the set
-		[]string{"a", "b", "c", "b"},
-		"b",
-		true,
-	},
-	{ // 3 is in the set
-		[]string{"a", "b", "c", "b"},
-		"c",
-		true,
-	},
-	{ // 4 not in the set
-		[]string{"a", "b", "c", "b"},
+	{ // when the element is not in the set
+		[]string{"a", "b", "c"},
 		"d",
 		false,
 	},
 }
 
-// Test if set1 is a subset of set2.
+// A set is a subset if all of its elements are contained in the other set
 var subsetCases = []binBoolCase{
-	{ // empty set is subset of itself
+	{ // empty set is a subset of another empty set
 		[]string{},
 		[]string{},
 		true,
 	},
-	{ // empty set is subset of non-empty set
+	{ // empty set is a subset of non-empty set
 		[]string{},
 		[]string{"a"},
 		true,
 	},
-	{ // non-empty set is not subset of empty set
+	{ // non-empty set is not a subset of empty set
 		[]string{"a"},
 		[]string{},
 		false,
 	},
-	{ // non-empty set is subset of itself
+	{ // set is a subset of set with exact same elements
 		[]string{"a", "b", "c"},
 		[]string{"a", "b", "c"},
 		true,
 	},
-	{ // proper subset
+	{ // set is a subset of larger set with same elements
 		[]string{"a", "b", "c"},
 		[]string{"d", "a", "b", "c"},
 		true,
 	},
-	{ // same number of elements
+	{ // set is not a subset of set that does not contain its elements
 		[]string{"a", "b", "c"},
 		[]string{"d", "a", "c"},
 		false,
 	},
-	{ // superset
-		[]string{"a", "b", "c", "d", "e"},
-		[]string{"b", "c", "d"},
-		false,
-	},
-	{ // fewer elements but not a subset
-		[]string{"a", "b", "c", "k"},
-		[]string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"},
-		false,
-	},
 }
 
-// Test if two sets are disjoint.
+// Sets are disjoint if they share no elements
 var disjointCases = []binBoolCase{
 	{ // the empty set is disjoint with itself
 		[]string{},
 		[]string{},
 		true,
 	},
-	{ // empty set disjoint with non-empty set
+	{ // empty set is disjoint with non-empty set
 		[]string{},
 		[]string{"a"},
 		true,
 	},
-	{ // non-empty set disjoint with empty set
+	{ // non-empty set is disjoint with empty set
 		[]string{"a"},
 		[]string{},
 		true,
 	},
-	{ // one element in common
+	{ // sets are not disjoint if they share an element
 		[]string{"a", "b"},
 		[]string{"b", "c"},
 		false,
 	},
-	{ // no elements in common
+	{ // sets are disjoint if they share no elements
 		[]string{"a", "b"},
 		[]string{"c", "d"},
 		true,
 	},
 }
 
-// Produce the union of two sets.
-var unionCases = []binOpCase{
-	{ // union of empty sets
-		[]string{},
-		[]string{},
+// Sets with the same elements are equal
+var eqCases = []binBoolCase{
+	{ // empty sets are equal
 		[]string{},
-	},
-	{ // union of empty set with set of one element
 		[]string{},
-		[]string{"b"},
-		[]string{"b"},
+		true,
 	},
-	{ // union of empty set with non-empty set
+	{ // empty set is not equal to non-empty set
 		[]string{},
-		[]string{"c", "b", "e"},
-		[]string{"b", "c", "e"},
+		[]string{"a", "b", "c"},
+		false,
 	},
-	{ // union of non-empty set with empty set
-		[]string{"a", "c"},
+	{ // non-empty set is not equal to empty set
+		[]string{"a", "b", "c"},
 		[]string{},
-		[]string{"a", "c"},
+		false,
 	},
-	{ // union of a set with itself
-		[]string{"a", "c"},
-		[]string{"c", "a"},
-		[]string{"a", "c"},
+	{ // sets with the same elements are equal
+		[]string{"a", "b"},
+		[]string{"b", "a"},
+		true,
 	},
-	{ // union with one element
-		[]string{"a", "c"},
-		[]string{"b"},
+	{ // sets with different elements are not equal
 		[]string{"a", "b", "c"},
+		[]string{"a", "b", "d"},
+		false,
 	},
-	{ // one element in common, one different
-		[]string{"a", "c"},
-		[]string{"b", "c"},
-		[]string{"c", "b", "a"},
+}
+
+// Unique elements can be added to a set
+var addCases = []eleOpCase{
+	{ // add to empty set
+		[]string{},
+		"c",
+		[]string{"c"},
 	},
-	{ // two elements in common
+	{ // add to non-empty set
+		[]string{"a", "b", "d"},
+		"c",
 		[]string{"a", "b", "c", "d"},
-		[]string{"c", "b", "e"},
-		[]string{"a", "b", "c", "d", "e"},
+	},
+	{ // adding an existing element does not change the set
+		[]string{"a", "b", "c"},
+		"c",
+		[]string{"a", "b", "c"},
 	},
 }
 
-// Intersect two sets.
+// Intersect returns a set of all shared elements
 var intersectionCases = []binOpCase{
-	{ // intersect empty sets
+	{ // intersection of two empty sets is an empty set
 		[]string{},
 		[]string{},
 		[]string{},
 	},
-	{ // intersect empty set with non-empty set
+	{ // intersection of an empty set and non-empty set is an empty set
 		[]string{},
 		[]string{"c", "b", "e"},
 		[]string{},
 	},
-	{ // intersect non-empty set with empty set
+	{ // intersection of a non-empty set and an empty set is an empty set
 		[]string{"a", "b", "c", "d"},
 		[]string{},
 		[]string{},
 	},
-	{ // intersect one element with itself
-		[]string{"c"},
-		[]string{"c"},
-		[]string{"c"},
-	},
-	{ // one element in common, extra elements in both sets
+	{ // intersection of two sets with no shared elements is an empty set
 		[]string{"a", "b", "c"},
-		[]string{"c", "e", "d"},
-		[]string{"c"},
+		[]string{"d", "e", "f"},
+		[]string{},
 	},
-	{ // two elements in common, extras in both sets
+	{ // intersection of two sets with shared elements is a set of the shared elements
 		[]string{"a", "b", "c", "d"},
 		[]string{"c", "b", "e"},
 		[]string{"b", "c"},
 	},
-	{ // intersect with subset
-		[]string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"},
-		[]string{"e", "f", "g", "h", "i", "j"},
-		[]string{"e", "f", "g", "h", "i", "j"},
-	},
-	{ // nothing in common
-		[]string{"a", "b", "c"},
-		[]string{"d", "e", "f"},
-		[]string{},
-	},
 }
 
-// Produce the set difference (set1 - set2)
-// or more specifically, (set1 ∖ set2)
+// Difference (or Complement) of a set is a set of all elements that are only in the first set
 var differenceCases = []binOpCase{
-	{ // difference of two empty sets
+	{ // difference of two empty sets is an empty set
 		[]string{},
 		[]string{},
 		[]string{},
 	},
-	{ // difference of empty set and non-empty set
+	{ // difference of empty set and non-empty set is an empty set
 		[]string{},
 		[]string{"c", "b", "e"},
 		[]string{},
 	},
-	{ // difference of non-empty set and empty set
+	{ // difference of a non-empty set and an empty set is the non-empty set
 		[]string{"a", "b", "c", "d"},
 		[]string{},
 		[]string{"a", "b", "c", "d"},
 	},
-	{ // no elements in common
-		[]string{"a", "b", "c"},
-		[]string{"d"},
-		[]string{"a", "b", "c"},
-	},
-	{ // one element in common, one extra
+	{ // difference of two non-empty sets is a set of elements that are only in the first set
 		[]string{"c", "b", "a"},
 		[]string{"b", "d"},
 		[]string{"a", "c"},
 	},
-	{ // two elements in common, one extra
-		[]string{"a", "b", "c", "d"},
-		[]string{"c", "b", "e"},
-		[]string{"a", "d"},
-	},
 }
 
-// Produce the symmetric difference of two sets.  The symmetric
-// difference consists of elements in one or the other but not both.
-var symmetricDifferenceCases = []binOpCase{
-	{ // two empty sets
+// Union returns a set of all elements in either set
+var unionCases = []binOpCase{
+	{ // union of empty sets is an empty set
 		[]string{},
 		[]string{},
 		[]string{},
 	},
-	{ // empty set and non-empty set
+	{ // union of an empty set and non-empty set is the non-empty set
 		[]string{},
-		[]string{"c", "b", "e"},
-		[]string{"c", "b", "e"},
+		[]string{"b"},
+		[]string{"b"},
 	},
-	{ // non-empty set and empty set
-		[]string{"a", "b", "c", "d"},
+	{ // union of a non-empty set and empty set is the non-empty set
+		[]string{"a", "c"},
 		[]string{},
-		[]string{"a", "b", "c", "d"},
-	},
-	{ // no elements in common
-		[]string{"a", "b", "c"},
-		[]string{"d"},
-		[]string{"a", "b", "c", "d"},
+		[]string{"a", "c"},
 	},
-	{ // one element in common
+	{ // union of non-empty sets contains all unique elements
+		[]string{"a", "c"},
+		[]string{"b", "c"},
 		[]string{"c", "b", "a"},
-		[]string{"b", "d"},
-		[]string{"a", "c", "d"},
 	},
 }