trackler 2.2.1.47 → 2.2.1.48

data/tracks/ruby/exercises/allergies/.meta/solutions/allergies.rb

@@ -1,3 +1,7 @@
+module BookKeeping
+  VERSION = 1
+end
+
 class Allergies
   ALLERGENS = %w(eggs peanuts shellfish strawberries tomatoes chocolate pollen cats)
 

data/tracks/ruby/exercises/allergies/allergies_test.rb

@@ -1,8 +1,10 @@
 require 'minitest/autorun'
 require_relative 'allergies'
 
+# Common test data version: 1.0.0 879bc89
 class AllergiesTest < Minitest::Test
   def test_no_allergies_means_not_allergic
+    # skip
     allergies = Allergies.new(0)
     refute allergies.allergic_to?('peanuts')
     refute allergies.allergic_to?('cats')
@@ -26,19 +28,25 @@ class AllergiesTest < Minitest::Test
   def test_no_allergies_at_all
     skip
     allergies = Allergies.new(0)
-    assert_equal [], allergies.list
+    assert_equal %w(), allergies.list
   end
 
   def test_allergic_to_just_eggs
     skip
     allergies = Allergies.new(1)
-    assert_equal ['eggs'], allergies.list
+    assert_equal %w(eggs), allergies.list
   end
 
   def test_allergic_to_just_peanuts
     skip
     allergies = Allergies.new(2)
-    assert_equal ['peanuts'], allergies.list
+    assert_equal %w(peanuts), allergies.list
+  end
+
+  def test_allergic_to_just_strawberries
+    skip
+    allergies = Allergies.new(8)
+    assert_equal %w(strawberries), allergies.list
   end
 
   def test_allergic_to_eggs_and_peanuts
@@ -47,24 +55,49 @@ class AllergiesTest < Minitest::Test
     assert_equal %w(eggs peanuts), allergies.list
   end
 
+  def test_allergic_to_more_than_eggs_but_not_peanuts
+    skip
+    allergies = Allergies.new(5)
+    assert_equal %w(eggs shellfish), allergies.list
+  end
+
   def test_allergic_to_lots_of_stuff
     skip
     allergies = Allergies.new(248)
-    expected = %w(strawberries tomatoes chocolate pollen cats)
-    assert_equal expected, allergies.list
+    assert_equal %w(strawberries tomatoes chocolate pollen cats), allergies.list
   end
 
   def test_allergic_to_everything
     skip
     allergies = Allergies.new(255)
-    expected = %w(eggs peanuts shellfish strawberries tomatoes chocolate pollen cats)
-    assert_equal expected, allergies.list
+    assert_equal %w(eggs peanuts shellfish strawberries tomatoes chocolate pollen cats), allergies.list
   end
 
   def test_ignore_non_allergen_score_parts
     skip
     allergies = Allergies.new(509)
-    expected = %w(eggs shellfish strawberries tomatoes chocolate pollen cats)
-    assert_equal expected, allergies.list
+    assert_equal %w(eggs shellfish strawberries tomatoes chocolate pollen cats), allergies.list
+  end
+
+  # Problems in exercism evolve over time, as we find better ways to ask
+  # questions.
+  # The version number refers to the version of the problem you solved,
+  # not your solution.
+  #
+  # Define a constant named VERSION inside of the top level BookKeeping
+  # module, which may be placed near the end of your file.
+  #
+  # In your file, it will look like this:
+  #
+  # module BookKeeping
+  #   VERSION = 1 # Where the version number matches the one in the test.
+  # end
+  #
+  # If you are curious, read more about constants on RubyDoc:
+  # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
+
+  def test_bookkeeping
+    skip
+    assert_equal 1, BookKeeping::VERSION
   end
 end

data/tracks/typescript/config.json

@@ -200,6 +200,21 @@
         "Parsing"
       ]
     },
+    {
+      "uuid": "3cc210e8-b3bb-11e7-abc4-cec278b6b50a",
+      "slug": "circular-buffer",
+      "core": false,
+      "unlocked_by": "linked-list",
+      "difficulty": 8,
+      "topics": [
+        "Control-flow (conditionals)",
+        "Control-flow (loops)",
+        "Data structures",
+        "Lists",
+        "Arrays",
+        "Exception handling"
+      ]
+    },
     {
       "uuid": "9dfabc5c-d2a5-4896-9fc2-2b25b9a5f62f",
       "slug": "gigasecond",
@@ -436,6 +451,37 @@
         "Mathematics",
         "Iterators"
       ]
+    },
+    {
+      "uuid": "b646dc26-59c1-436e-883a-20290de7a526",
+      "slug": "largest-series-product",
+      "core": false,
+      "unlocked_by": "pangram",
+      "difficulty": 7,
+      "topics": [
+        "Control-flow (conditionals)",
+        "Control-flow (loops)",
+        "Mathematics",
+        "Integers",
+        "Strings",
+        "Exception handling",
+        "Regular expressions"
+      ]
+    },
+    {
+      "uuid": "abe907d0-7ca0-4fe5-83fd-72a4d2acab66",
+      "slug": "robot-simulator",
+      "core": false,
+      "unlocked_by": "wordy",
+      "difficulty": 5,
+      "topics": [
+        "Control-flow (conditionals)",
+        "Control-flow (loops)",
+        "Exception handling",
+        "Strings",
+        "Games",
+        "Parsing"
+      ]
     }
   ],
   "foregone": []

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

@@ -0,0 +1,74 @@
+# Circular Buffer
+
+A circular buffer, cyclic buffer or ring buffer is a data structure that
+uses a single, fixed-size buffer as if it were connected end-to-end.
+
+A circular buffer first starts empty and of some predefined length. For
+example, this is a 7-element buffer:
+
+    [ ][ ][ ][ ][ ][ ][ ]
+
+Assume that a 1 is written into the middle of the buffer (exact starting
+location does not matter in a circular buffer):
+
+    [ ][ ][ ][1][ ][ ][ ]
+
+Then assume that two more elements are added — 2 & 3 — which get
+appended after the 1:
+
+    [ ][ ][ ][1][2][3][ ]
+
+If two elements are then removed from the buffer, the oldest values
+inside the buffer are removed. The two elements removed, in this case,
+are 1 & 2, leaving the buffer with just a 3:
+
+    [ ][ ][ ][ ][ ][3][ ]
+
+If the buffer has 7 elements then it is completely full:
+
+    [6][7][8][9][3][4][5]
+
+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:
+
+    [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:
+
+    [ ][7][8][9][A][B][ ]
+
+## Setup
+
+Go through the setup instructions for TypeScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/typescript
+
+## Requirements
+
+Install assignment dependencies:
+
+```bash
+$ yarn install
+```
+
+## Making the test suite pass
+
+Execute the tests with:
+
+```bash
+$ yarn test
+```
+
+## Source
+
+Wikipedia [http://en.wikipedia.org/wiki/Binary_search_algorithm](http://en.wikipedia.org/wiki/Binary_search_algorithm)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/typescript/exercises/circular-buffer/circular-buffer.example.ts

@@ -0,0 +1,51 @@
+interface Buffer<T> {
+  read(): T | undefined
+  write(value: T): void
+  clear(): void
+}
+
+export class BufferOverflowError extends Error {
+  constructor() {
+    super("Buffer is full.")
+  }
+}
+
+export class BufferEmptyError extends Error {
+  constructor() {
+    super("Buffer is empty.")
+  }
+}
+
+export default class CircularBuffer<T> implements Buffer<T> {
+  private capacity: number
+  private buffer: T[] = []
+
+  constructor(capacity: number) {
+    this.capacity = capacity
+  }
+
+  public read() {
+    if (this.buffer.length === 0) {
+      throw new BufferEmptyError()
+    }
+    return this.buffer.shift()
+  }
+
+  public write(value: T) {
+    if (this.buffer.length + 1 > this.capacity) {
+      throw new BufferOverflowError()
+    }
+    this.buffer.push(value)
+  }
+
+  public forceWrite(value: T) {
+    if (this.buffer.length === this.capacity) {
+      this.read()
+    }
+    this.buffer.push(value)
+  }
+
+  public clear() {
+    this.buffer = []
+  }
+}

data/tracks/typescript/exercises/circular-buffer/circular-buffer.test.ts

@@ -0,0 +1,103 @@
+import CircularBuffer, { BufferOverflowError, BufferEmptyError } from './circular-buffer'
+
+describe('CircularBuffer', () => {
+  it('reading an empty buffer throws a BufferEmptyError', () => {
+    const buffer = new CircularBuffer<string>(1)
+    expect(() => buffer.read()).toThrow(BufferEmptyError)
+  })
+
+  it('write and read back one item', () => {
+    const buffer = new CircularBuffer<string>(1)
+    buffer.write('1')
+    expect(buffer.read()).toBe('1')
+    expect(() => buffer.read()).toThrow(BufferEmptyError)
+  })
+
+  it('write and read back multiple items', () => {
+    const buffer = new CircularBuffer<string>(2)
+    buffer.write('1')
+    buffer.write('2')
+    expect(buffer.read()).toBe('1')
+    expect(buffer.read()).toBe('2')
+    expect(() => buffer.read()).toThrow(BufferEmptyError)
+  })
+
+  it('clearing a buffer', () => {
+    const buffer = new CircularBuffer<string>(2)
+    buffer.write('1')
+    buffer.write('2')
+    buffer.clear()
+    expect(() => buffer.read()).toThrow(BufferEmptyError)
+    buffer.write('3')
+    buffer.write('4')
+    expect(buffer.read()).toBe('3')
+    expect(buffer.read()).toBe('4')
+  })
+
+  it('alternate write and read', () => {
+    const buffer = new CircularBuffer<string>(2)
+    buffer.write('1')
+    expect(buffer.read()).toBe('1')
+    buffer.write('2')
+    expect(buffer.read()).toBe('2')
+  })
+
+  it('reads back oldest item', () => {
+    const buffer = new CircularBuffer<string>(3)
+    buffer.write('1')
+    buffer.write('2')
+    buffer.read()
+    buffer.write('3')
+    expect(buffer.read()).toBe('2')
+    expect(buffer.read()).toBe('3')
+  })
+
+  it('writing to a full buffer throws a BufferOverflowError', () => {
+    const buffer = new CircularBuffer<string>(2)
+    buffer.write('1')
+    buffer.write('2')
+    expect(() => buffer.write('A')).toThrow(BufferOverflowError)
+  })
+
+  it('forced writes over write oldest item in a full buffer', () => {
+    const buffer = new CircularBuffer<string>(2)
+    buffer.write('1')
+    buffer.write('2')
+    buffer.forceWrite('A')
+    expect(buffer.read()).toBe('2')
+    expect(buffer.read()).toBe('A')
+    expect(() => buffer.read()).toThrow(BufferEmptyError)
+  })
+
+  it('forced writes act like write in a non-full buffer', () => {
+    const buffer = new CircularBuffer<string>(2)
+    buffer.write('1')
+    buffer.forceWrite('2')
+    expect(buffer.read()).toBe('1')
+    expect(buffer.read()).toBe('2')
+    expect(() => buffer.read()).toThrow(BufferEmptyError)
+  })
+
+  it('alternate force write and read into full buffer', () => {
+    const buffer = new CircularBuffer<string>(5)
+    buffer.write('1')
+    buffer.write('2')
+    buffer.write('3')
+    buffer.read()
+    buffer.read()
+    buffer.write('4')
+    buffer.read()
+    buffer.write('5')
+    buffer.write('6')
+    buffer.write('7')
+    buffer.write('8')
+    buffer.forceWrite('A')
+    buffer.forceWrite('B')
+    expect(buffer.read()).toBe('6')
+    expect(buffer.read()).toBe('7')
+    expect(buffer.read()).toBe('8')
+    expect(buffer.read()).toBe('A')
+    expect(buffer.read()).toBe('B')
+    expect(() => buffer.read()).toThrow(BufferEmptyError)
+  })
+})

data/tracks/typescript/exercises/circular-buffer/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "xtypescript",
+  "version": "1.0.0",
+  "description": "Exercism exercises in Typescript.",
+  "author": "",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/xtypescript"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "tsc --noEmit -p . && jest --no-cache",
+    "lint": "tsc --noEmit -p . && tslint \"*.ts?(x)\"",
+    "lintci": "tslint \"*.ts?(x)\" --force"
+  },
+  "dependencies": {
+    "@types/jest": "^20.0.0",
+    "@types/node": "^7.0.5",
+    "jest": "^20.0.4",
+    "ts-jest": "^20.0.6",
+    "tslint": "^5.4.3",
+    "typescript": "^2.2.1"
+  },
+  "jest": {
+    "transform": {
+      ".(ts|tsx)": "<rootDir>/node_modules/ts-jest/preprocessor.js"
+    },
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js"
+    ]
+  }
+}

data/tracks/typescript/exercises/circular-buffer/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": { 
+        "target": "es2017",
+        "module": "commonjs",
+        "alwaysStrict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "preserveConstEnums": true,
+        "noFallthroughCasesInSwitch":true,
+        "noImplicitThis":true,
+        "noImplicitReturns":true,
+        "sourceMap": true,
+        "noEmitOnError": true,
+        "outDir": "./build"
+    },
+    "compileOnSave": true, 
+    "exclude": [
+        "node_modules"
+    ]
+}