trackler 2.2.0.0 → 2.2.0.1

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

@@ -3,137 +3,135 @@ import Converter from './all-your-base';
 const converter = new Converter();
 
 describe('Converter', () => {
-
-    test('single bit one to decimal', () => {
-        expect(converter.convert([1], 2, 10)).toEqual([1]);
-    });
-
-    xtest('binary to single decimal', () => {
-        expect(converter.convert([1, 0, 1], 2, 10)).toEqual([5]);
-    });
-
-    xtest('single decimal to binary', () => {
-        expect(converter.convert([5], 10, 2)).toEqual([1, 0, 1]);
-    });
-
-    xtest('binary to multiple decimal', () => {
-        expect(converter.convert([1, 0, 1, 0, 1, 0], 2, 10)).toEqual([4, 2]);
-    });
-
-    xtest('decimal to binary', () => {
-        expect(converter.convert([4, 2], 10, 2)).toEqual([1, 0, 1, 0, 1, 0]);
-    });
-
-    xtest('trinary to hexadecimal', () => {
-        expect(converter.convert([1, 1, 2, 0], 3, 16)).toEqual([2, 10]);
-    });
-
-    xtest('hexadecimal to trinary', () => {
-        expect(converter.convert([2, 10], 16, 3)).toEqual([1, 1, 2, 0]);
-    });
-
-    xtest('15-bit integer', () => {
-        expect(converter.convert([3, 46, 60], 97, 73)).toEqual([6, 10, 45]);
-    });
-
-    xtest('empty list', () => {
-        expect(() => {
-            converter.convert([], 2, 10);
-        }).toThrow(new Error('Input has wrong format'));
-    });
-
-    xtest('single zero', () => {
-        expect(converter.convert([0], 10, 2)).toEqual([0]);
-    });
-
-    xtest('multiple zeros', () => {
-        expect(() => {
-            converter.convert([0, 0, 0], 10, 2);
-        }).toThrow(new Error('Input has wrong format'));
-    });
-
-    xtest('leading zeros', () => {
-        expect(() => {
-            converter.convert([0, 6, 0], 7, 10);
-        }).toThrow(new Error('Input has wrong format'));
-    });
-
-    xtest('negative digit', () => {
-        expect(() => {
-            converter.convert([1, -1, 1, 0, 1, 0], 2, 10);
-        }).toThrow(new Error('Input has wrong format'));
-    });
-
-    xtest('invalid positive digit', () => {
-        expect(() => {
-            converter.convert([1, 2, 1, 0, 1, 0], 2, 10);
-        }).toThrow(new Error('Input has wrong format'));
-    });
-
-    xtest('first base is one', () => {
-        expect(() => {
-            converter.convert([], 1, 10);
-        }).toThrow(new Error('Wrong input base'));
-    });
-
-    xtest('second base is one', () => {
-        expect(() => {
-            converter.convert([1, 0, 1, 0, 1, 0], 2, 1);
-        }).toThrow(new Error('Wrong output base'));
-    });
-
-    xtest('first base is zero', () => {
-        expect(() => {
-            converter.convert([], 0, 10);
-        }).toThrow(new Error('Wrong input base'));
-    });
-
-    xtest('second base is zero', () => {
-        expect(() => {
-            converter.convert([7], 10, 0);
-        }).toThrow(new Error('Wrong output base'));
-    });
-
-    xtest('first base is negative', () => {
-        expect(() => {
-            converter.convert([1], -2, 10);
-        }).toThrow(new Error('Wrong input base'));
-    });
-
-    xtest('second base is negative', () => {
-        expect(() => {
-            converter.convert([1], 2, -7);
-        }).toThrow(new Error('Wrong output base'));
-    });
-
-    xtest('both bases are negative', () => {
-        expect(() => {
-            converter.convert([1], -2, -7);
-        }).toThrow(new Error('Wrong input base'));
-    });
-
-    xtest('missing input base throws an error', () => {
-        expect(() => {
-            converter.convert([0]);
-        }).toThrow(new Error('Wrong input base'));
-    });
-
-    xtest('wrong input_base base not integer', () => {
-        expect(() => {
-            converter.convert([0], 2.5);
-        }).toThrow(new Error('Wrong input base'));
-    });
-
-    xtest('missing output base throws an error', () => {
-        expect(() => {
-            converter.convert([0], 2);
-        }).toThrow(new Error('Wrong output base'));
-    });
-
-    xtest('wrong output_base base not integer', () => {
-        expect(() => {
-            converter.convert([0], 3, 2.5);
-        }).toThrow(new Error('Wrong output base'));
-    });
-
+  test('single bit one to decimal', () => {
+    expect(converter.convert([1], 2, 10)).toEqual([1]);
+  });
+
+  xtest('binary to single decimal', () => {
+    expect(converter.convert([1, 0, 1], 2, 10)).toEqual([5]);
+  });
+
+  xtest('single decimal to binary', () => {
+    expect(converter.convert([5], 10, 2)).toEqual([1, 0, 1]);
+  });
+
+  xtest('binary to multiple decimal', () => {
+    expect(converter.convert([1, 0, 1, 0, 1, 0], 2, 10)).toEqual([4, 2]);
+  });
+
+  xtest('decimal to binary', () => {
+    expect(converter.convert([4, 2], 10, 2)).toEqual([1, 0, 1, 0, 1, 0]);
+  });
+
+  xtest('trinary to hexadecimal', () => {
+    expect(converter.convert([1, 1, 2, 0], 3, 16)).toEqual([2, 10]);
+  });
+
+  xtest('hexadecimal to trinary', () => {
+    expect(converter.convert([2, 10], 16, 3)).toEqual([1, 1, 2, 0]);
+  });
+
+  xtest('15-bit integer', () => {
+    expect(converter.convert([3, 46, 60], 97, 73)).toEqual([6, 10, 45]);
+  });
+
+  xtest('empty list', () => {
+    expect(() => {
+      converter.convert([], 2, 10);
+    }).toThrow(new Error('Input has wrong format'));
+  });
+
+  xtest('single zero', () => {
+    expect(converter.convert([0], 10, 2)).toEqual([0]);
+  });
+
+  xtest('multiple zeros', () => {
+    expect(() => {
+      converter.convert([0, 0, 0], 10, 2);
+    }).toThrow(new Error('Input has wrong format'));
+  });
+
+  xtest('leading zeros', () => {
+    expect(() => {
+      converter.convert([0, 6, 0], 7, 10);
+    }).toThrow(new Error('Input has wrong format'));
+  });
+
+  xtest('negative digit', () => {
+    expect(() => {
+      converter.convert([1, -1, 1, 0, 1, 0], 2, 10);
+    }).toThrow(new Error('Input has wrong format'));
+  });
+
+  xtest('invalid positive digit', () => {
+    expect(() => {
+      converter.convert([1, 2, 1, 0, 1, 0], 2, 10);
+    }).toThrow(new Error('Input has wrong format'));
+  });
+
+  xtest('first base is one', () => {
+    expect(() => {
+      converter.convert([], 1, 10);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  xtest('second base is one', () => {
+    expect(() => {
+      converter.convert([1, 0, 1, 0, 1, 0], 2, 1);
+    }).toThrow(new Error('Wrong output base'));
+  });
+
+  xtest('first base is zero', () => {
+    expect(() => {
+      converter.convert([], 0, 10);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  xtest('second base is zero', () => {
+    expect(() => {
+      converter.convert([7], 10, 0);
+    }).toThrow(new Error('Wrong output base'));
+  });
+
+  xtest('first base is negative', () => {
+    expect(() => {
+      converter.convert([1], -2, 10);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  xtest('second base is negative', () => {
+    expect(() => {
+      converter.convert([1], 2, -7);
+    }).toThrow(new Error('Wrong output base'));
+  });
+
+  xtest('both bases are negative', () => {
+    expect(() => {
+      converter.convert([1], -2, -7);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  xtest('missing input base throws an error', () => {
+    expect(() => {
+      converter.convert([0]);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  xtest('wrong input_base base not integer', () => {
+    expect(() => {
+      converter.convert([0], 2.5);
+    }).toThrow(new Error('Wrong input base'));
+  });
+
+  xtest('missing output base throws an error', () => {
+    expect(() => {
+      converter.convert([0], 2);
+    }).toThrow(new Error('Wrong output base'));
+  });
+
+  xtest('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

@@ -47,9 +47,7 @@ export default class Converter {
       return [1];
     }
     const decimalValue = array
-      .reduce((accumulator, value) => {
-        return accumulator * inputBase + value;
-      }, 0);
+      .reduce((accumulator, value) => accumulator * inputBase + value, 0);
     return convertFromDecimalToBase(decimalValue, outputBase);
   }
 }

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

@@ -1,7 +1,6 @@
 import Allergies from './allergies';
 
 describe('Allergies', () => {
-
   test('no allergies at all', () => {
     const allergies = new Allergies(0);
     expect(allergies.list()).toEqual([]);
@@ -9,37 +8,37 @@ describe('Allergies', () => {
 
   xtest('allergies to eggs', () => {
     const allergies = new Allergies(1);
-    expect(allergies.list()).toEqual([ 'eggs' ]);
+    expect(allergies.list()).toEqual(['eggs']);
   });
 
   xtest('allergies to peanuts', () => {
     const allergies = new Allergies(2);
-    expect(allergies.list()).toEqual([ 'peanuts' ]);
+    expect(allergies.list()).toEqual(['peanuts']);
   });
 
   xtest('allergies to strawberries', () => {
     const allergies = new Allergies(8);
-    expect(allergies.list()).toEqual([ 'strawberries' ]);
+    expect(allergies.list()).toEqual(['strawberries']);
   });
 
   xtest('allergies to eggs and peanuts', () => {
     const allergies = new Allergies(3);
-    expect(allergies.list()).toEqual([ 'eggs', 'peanuts' ]);
+    expect(allergies.list()).toEqual(['eggs', 'peanuts']);
   });
 
   xtest('allergies to more than eggs but not peanuts', () => {
     const allergies = new Allergies(5);
-    expect(allergies.list()).toEqual([ 'eggs', 'shellfish' ]);
+    expect(allergies.list()).toEqual(['eggs', 'shellfish']);
   });
 
   xtest('allergic to lots of stuff', () => {
     const allergies = new Allergies(248);
-    expect(allergies.list()).toEqual([ 'strawberries', 'tomatoes', 'chocolate', 'pollen', 'cats' ]);
+    expect(allergies.list()).toEqual(['strawberries', 'tomatoes', 'chocolate', 'pollen', 'cats']);
   });
 
   xtest('allergic to everything', () => {
     const allergies = new Allergies(255);
-    expect(allergies.list()).toEqual([ 'eggs', 'peanuts', 'shellfish', 'strawberries', 'tomatoes', 'chocolate', 'pollen', 'cats' ]);
+    expect(allergies.list()).toEqual(['eggs', 'peanuts', 'shellfish', 'strawberries', 'tomatoes', 'chocolate', 'pollen', 'cats']);
   });
 
   xtest('no allergic means not allergic', () => {
@@ -61,7 +60,6 @@ describe('Allergies', () => {
 
   xtest('ignore non allergen score parts', () => {
     const allergies = new Allergies(509);
-    expect(allergies.list()).toEqual([ 'eggs', 'shellfish', 'strawberries', 'tomatoes', 'chocolate', 'pollen', 'cats' ]);
+    expect(allergies.list()).toEqual(['eggs', 'shellfish', 'strawberries', 'tomatoes', 'chocolate', 'pollen', 'cats']);
   });
-
 });

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

@@ -6,8 +6,8 @@ const possibleAllergies = [
   'tomatoes',
   'chocolate',
   'pollen',
-  'cats'
-]; 
+  'cats',
+];
 
 class Allergies {
   constructor(allergenIndex) {
@@ -15,9 +15,7 @@ class Allergies {
   }
 
   list() {
-    return possibleAllergies.filter((allergy, i) => {
-      return this.allergenIndex & Math.pow(2, i);
-    });
+    return possibleAllergies.filter((allergy, i) => this.allergenIndex & Math.pow(2, i));
   }
 
   allergicTo(food) {

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

@@ -1,95 +1,93 @@
 import solve from './alphametics';
 
-describe("Solve the alphametics puzzle", () =>  {
-
-  test("puzzle with three letters", () =>  {
-    let puzzle = "I + BB == ILL";
-    let expected = {
-      "I": 1,
-      "B": 9,
-      "L": 0
+describe('Solve the alphametics puzzle', () => {
+  test('puzzle with three letters', () => {
+    const puzzle = 'I + BB == ILL';
+    const expected = {
+      I: 1,
+      B: 9,
+      L: 0,
     };
     expect(solve(puzzle)).toEqual(expected);
   });
 
-  xtest("solution must have unique value for each letter", () =>  {
-    let puzzle = "A == B";
+  xtest('solution must have unique value for each letter', () => {
+    const puzzle = 'A == B';
     expect(solve(puzzle)).toBeNull();
   });
 
-  xtest("leading zero solution is invalid", () =>  {
-    let puzzle = "ACA + DD == BD";
+  xtest('leading zero solution is invalid', () => {
+    const puzzle = 'ACA + DD == BD';
     expect(solve(puzzle)).toBeNull();
   });
 
-  xtest("puzzle with four letters", () =>  {
-    let puzzle = "AS + A == MOM";
-    let expected =  {
-      "A": 9,
-      "S": 2,
-      "M": 1,
-      "O": 0
+  xtest('puzzle with four letters', () => {
+    const puzzle = 'AS + A == MOM';
+    const expected = {
+      A: 9,
+      S: 2,
+      M: 1,
+      O: 0,
     };
     expect(solve(puzzle)).toEqual(expected);
   });
 
-  xtest("puzzle with six letters", () =>  {
-    let puzzle = "NO + NO + TOO == LATE";
-    let expected =  {
-      "N": 7,
-      "O": 4,
-      "T": 9,
-      "L": 1,
-      "A": 0,
-      "E": 2
+  xtest('puzzle with six letters', () => {
+    const puzzle = 'NO + NO + TOO == LATE';
+    const expected = {
+      N: 7,
+      O: 4,
+      T: 9,
+      L: 1,
+      A: 0,
+      E: 2,
     };
     expect(solve(puzzle)).toEqual(expected);
   });
 
-  xtest("puzzle with seven letters", () =>  {
-    let puzzle = "HE + SEES + THE == LIGHT";
-    let expected =  {
-      "E": 4,
-      "G": 2,
-      "H": 5,
-      "I": 0,
-      "L": 1,
-      "S": 9,
-      "T": 7
+  xtest('puzzle with seven letters', () => {
+    const puzzle = 'HE + SEES + THE == LIGHT';
+    const expected = {
+      E: 4,
+      G: 2,
+      H: 5,
+      I: 0,
+      L: 1,
+      S: 9,
+      T: 7,
     };
     expect(solve(puzzle)).toEqual(expected);
   });
 
-  xtest("puzzle with eight letters", () =>  {
-    let puzzle = "SEND + MORE == MONEY";
-    let expected =  {
-      "S": 9,
-      "E": 5,
-      "N": 6,
-      "D": 7,
-      "M": 1,
-      "O": 0,
-      "R": 8,
-      "Y": 2
+  xtest('puzzle with eight letters', () => {
+    const puzzle = 'SEND + MORE == MONEY';
+    const expected = {
+      S: 9,
+      E: 5,
+      N: 6,
+      D: 7,
+      M: 1,
+      O: 0,
+      R: 8,
+      Y: 2,
     };
     expect(solve(puzzle)).toEqual(expected);
   });
 
-  xtest("puzzle with ten letters", () =>  {
-    let puzzle = "AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE";
-    let expected =   {
-      "A": 5,
-      "D": 3,
-      "E": 4,
-      "F": 7,
-      "G": 8,
-      "N": 0,
-      "O": 2,
-      "R": 1,
-      "S": 6,
-      "T": 9
+  xtest('puzzle with ten letters', () => {
+    const puzzle = 'AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE';
+    const expected = {
+      A: 5,
+      D: 3,
+      E: 4,
+      F: 7,
+      G: 8,
+      N: 0,
+      O: 2,
+      R: 1,
+      S: 6,
+      T: 9,
     };
     expect(solve(puzzle)).toEqual(expected);
   });
-
 });