Merge pull request #197 from atk/robot-name

new exercise: robot-name

Author: atk

config.json

@@ -431,6 +431,14 @@
         "prerequisites": [],
         "difficulty": 5
       },
+      {
+        "slug": "robot-name",
+        "name": "Robot Name",
+        "uuid": "e84ba6b8-0b1a-434a-bbc3-47cb936be558",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 5
+      },
       {
         "slug": "robot-simulator",
         "name": "Robot Simulator",

exercises/practice/robot-name/.docs/instructions.md

@@ -0,0 +1,14 @@
+# Instructions
+
+Manage robot factory settings.
+
+When a robot comes off the factory floor, it has no name.
+
+The first time you turn on a robot, a random name is generated in the format of two uppercase letters followed by three digits, such as RX837 or BC811.
+
+Every once in a while we need to reset a robot to its factory settings, which means that its name gets wiped.
+The next time you ask, that robot will respond with a new random name.
+
+The names must be random: they should not follow a predictable sequence.
+Using random names means a risk of collisions.
+Your solution must ensure that every existing robot has a unique name.

exercises/practice/robot-name/.eslintrc

@@ -0,0 +1,18 @@
+{
+  "root": true,
+  "extends": "@exercism/eslint-config-javascript",
+  "env": {
+    "jest": true
+  },
+  "overrides": [
+    {
+      "files": [
+        "*.spec.js"
+      ],
+      "excludedFiles": [
+        "custom.spec.js"
+      ],
+      "extends": "@exercism/eslint-config-javascript/maintainers"
+    }
+  ]
+}

exercises/practice/robot-name/.meta/config.json

@@ -0,0 +1,27 @@
+{
+  "authors": [
+    "atk"
+  ],
+  "files": {
+    "solution": [
+      "robot-name.wat"
+    ],
+    "test": [
+      "robot-name.spec.js"
+    ],
+    "example": [
+      ".meta/proof.ci.wat"
+    ],
+    "invalidator": [
+      "package.json"
+    ]
+  },
+  "blurb": "Manage robot factory settings.",
+  "source": "A debugging session with Paul Blackwell at gSchool.",
+  "custom": {
+    "version.tests.compatibility": "jest-27",
+    "flag.tests.task-per-describe": false,
+    "flag.tests.may-run-long": false,
+    "flag.tests.includes-optional": false
+  }
+}

exercises/practice/robot-name/.meta/proof.ci.wat

@@ -0,0 +1,51 @@
+(module
+  (import "math" "random" (func $random (result f64)))
+  (memory (export "mem") 96)
+
+  (global $length (mut i32) (i32.const 0))
+  (global $outputOffset i32 (i32.const 2704384))
+  (global $outputLength i32 (i32.const 5))
+  (global $letter i32 (i32.const 65))
+  (global $number i32 (i32.const 48))
+  ;;
+  ;; Generate a new name for a robot, consisting of two uppercase letters and three numbers,
+  ;; avoiding already used names
+  ;;
+  ;; @results {(i32,i32)} - offset and length in linear memory
+  ;;
+  (func (export "generateName") (result i32 i32)
+    (local $pos i32)
+    (local $id i32)
+    (if (i32.eqz (global.get $length)) (then (return (i32.const 0) (i32.const 0))))
+    (local.set $pos (i32.shl (i32.trunc_f64_u (f64.mul (call $random)
+      (f64.convert_i32_u (global.get $length)))) (i32.const 2)))
+    (local.set $id (i32.load (local.get $pos)))
+    (global.set $length (i32.sub (global.get $length) (i32.const 1)))
+    (i32.store (local.get $pos) (i32.load (i32.shl (global.get $length) (i32.const 2))))
+    (i32.store8 (global.get $outputOffset)
+      (i32.add (i32.div_u (local.get $id) (i32.const 26000)) (global.get $letter)))
+    (i32.store8 (i32.add (global.get $outputOffset) (i32.const 1))
+      (i32.add (i32.rem_u (i32.div_u (local.get $id) (i32.const 1000))
+        (i32.const 26)) (global.get $letter)))
+    (i32.store8 (i32.add (global.get $outputOffset) (i32.const 2))
+      (i32.add (i32.rem_u (i32.div_u (local.get $id) (i32.const 100))
+        (i32.const 10)) (global.get $number)))
+    (i32.store8 (i32.add (global.get $outputOffset) (i32.const 3))
+      (i32.add (i32.rem_u (i32.div_u (local.get $id) (i32.const 10))
+        (i32.const 10)) (global.get $number)))
+    (i32.store8 (i32.add (global.get $outputOffset) (i32.const 4))
+      (i32.add (i32.rem_u (local.get $id) (i32.const 10)) (global.get $number)))
+    (global.get $outputOffset) (global.get $outputLength)
+  )
+
+  ;;
+  ;; Releases already used names
+  ;;
+  (func $releaseNames (export "releaseNames")
+    (global.set $length (i32.const 0))
+    (loop $release
+      (i32.store (i32.shl (global.get $length) (i32.const 2)) (global.get $length))
+      (global.set $length (i32.add (global.get $length) (i32.const 1)))
+    (br_if $release (i32.lt_u (global.get $length) (i32.const 676000))))
+  )
+)

exercises/practice/robot-name/.npmrc

@@ -0,0 +1 @@
+audit=false

exercises/practice/robot-name/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Exercism
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

exercises/practice/robot-name/babel.config.js

@@ -0,0 +1,4 @@
+export default {
+  presets: ["@exercism/babel-preset-javascript"],
+  plugins: [],
+};

exercises/practice/robot-name/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@exercism/wasm-robot-name",
+  "description": "Exercism exercises in WebAssembly.",
+  "author": "Alex Lohr",
+  "type": "module",
+  "private": true,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/wasm",
+    "directory": "exercises/practice/robot-name"
+  },
+  "jest": {
+    "maxWorkers": 1
+  },
+  "devDependencies": {
+    "@babel/core": "^7.23.3",
+    "@exercism/babel-preset-javascript": "^0.4.0",
+    "@exercism/eslint-config-javascript": "^0.6.0",
+    "@types/jest": "^29.5.8",
+    "@types/node": "^20.9.1",
+    "babel-jest": "^29.7.0",
+    "core-js": "^3.33.2",
+    "eslint": "^8.54.0",
+    "jest": "^29.7.0"
+  },
+  "dependencies": {
+    "@exercism/wasm-lib": "^0.2.0"
+  },
+  "scripts": {
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js ./*",
+    "watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch ./*",
+    "lint": "eslint ."
+  }
+}

exercises/practice/robot-name/robot-name.spec.js

@@ -0,0 +1,154 @@
+import { compileWat, WasmRunner } from "@exercism/wasm-lib";
+
+let wasmModule;
+let currentInstance;
+
+class Robot {
+  #name = '';
+  constructor() { this.reset(); }
+  get name() { return this.#name; }
+  reset() {
+    const [outputOffset, outputLength] = currentInstance.exports.generateName();
+    this.#name = currentInstance.get_mem_as_utf8(outputOffset, outputLength);
+  }
+  static releaseNames() { currentInstance.exports.releaseNames(); }
+}
+
+beforeAll(async () => {
+  try {
+    const watPath = new URL("./robot-name.wat", import.meta.url);
+    const { buffer } = await compileWat(watPath);
+    wasmModule = await WebAssembly.compile(buffer);
+  } catch (err) {
+    console.log(`Error compiling *.wat: \n${err}`);
+    process.exit(1);
+  }
+  if (!wasmModule) {
+    return Promise.reject();
+  }
+  try {
+    currentInstance = await new WasmRunner(wasmModule);
+    currentInstance.exports.releaseNames();
+    return Promise.resolve();
+  } catch (err) {
+    console.log(`Error instantiating WebAssembly module: ${err}`);
+    return Promise.reject();
+  }
+});
+
+const areSequential = (name1, name2) => {
+  const alpha1 = name1.substring(0, 2);
+  const alpha2 = name2.substring(0, 2);
+  const num1 = Number(name1.substring(2, 5));
+  const num2 = Number(name2.substring(2, 5));
+
+  const numDiff = num2 - num1;
+  const alphaDiff =
+    (alpha2.charCodeAt(0) - alpha1.charCodeAt(0)) * 26 +
+    (alpha2.charCodeAt(1) - alpha1.charCodeAt(1));
+
+  const totalDiff = alphaDiff * 1000 + numDiff;
+
+  return Math.abs(totalDiff) <= 1;
+};
+
+const TOTAL_NUMBER_OF_NAMES =
+  26 * // A-Z
+  26 * // A-Z
+  10 * // 0-9
+  10 * // 0-9
+  10; // 0-9
+
+describe('Robot', () => {
+  let robot;
+
+  beforeEach(() => {
+    robot = new Robot();
+  });
+  afterEach(() => {
+    Robot.releaseNames();
+  });
+
+  test('has a name', () => {
+    expect(robot.name).toMatch(/^[A-Z]{2}\d{3}$/);
+  });
+
+  xtest('name is the same each time', () => {
+    expect(robot.name).toEqual(robot.name);
+  });
+
+  xtest('different robots have different names', () => {
+    const differentRobot = new Robot();
+    expect(differentRobot.name).not.toEqual(robot.name);
+  });
+
+  xtest('is able to reset the name', () => {
+    const originalName = robot.name;
+
+    robot.reset();
+    const newName = robot.name;
+
+    expect(newName).toMatch(/^[A-Z]{2}\d{3}$/);
+    expect(originalName).not.toEqual(newName);
+  });
+
+  xtest('should set a unique name after reset', () => {
+    const NUMBER_OF_ROBOTS = 10000;
+    const usedNames = new Set();
+
+    usedNames.add(robot.name);
+    for (let i = 0; i < NUMBER_OF_ROBOTS; i += 1) {
+      robot.reset();
+      usedNames.add(robot.name);
+    }
+
+    expect(usedNames.size).toEqual(NUMBER_OF_ROBOTS + 1);
+  });
+
+  xtest('internal name cannot be modified', () => {
+    const modifyInternal = () => {
+      robot.name += 'a modification';
+    };
+    expect(() => modifyInternal()).toThrow();
+  });
+
+  xtest('new names should not be sequential', () => {
+    const name1 = robot.name;
+    const name2 = new Robot().name;
+    const name3 = new Robot().name;
+    expect(areSequential(name1, name1)).toBe(true);
+    expect(areSequential(name1, name2)).toBe(false);
+    expect(areSequential(name2, name3)).toBe(false);
+  });
+
+  xtest('names from reset should not be sequential', () => {
+    const name1 = robot.name;
+    robot.reset();
+    const name2 = robot.name;
+    robot.reset();
+    const name3 = robot.name;
+    expect(areSequential(name1, name2)).toBe(false);
+    expect(areSequential(name2, name3)).toBe(false);
+    expect(areSequential(name3, name3)).toBe(true);
+  });
+
+  // This test is optional.
+  //
+  // This test doesn't run on our online test runner because it will time-out
+  // with most implementations. It's up to you to test your solution locally.
+  test.skip(
+    'all the names can be generated',
+    () => {
+      const usedNames = new Set();
+      usedNames.add(robot.name);
+
+      for (let i = 0; i < TOTAL_NUMBER_OF_NAMES - 1; i += 1) {
+        const newRobot = new Robot();
+        usedNames.add(newRobot.name);
+      }
+
+      expect(usedNames.size).toEqual(TOTAL_NUMBER_OF_NAMES);
+    },
+    8 * 1000,
+  );
+});

exercises/practice/robot-name/robot-name.wat

@@ -0,0 +1,19 @@
+(module
+  (import "math" "random" (func $random (result f64)))
+  (memory (export "mem") 1)
+
+  ;;
+  ;; Generate a new name for a robot, consisting of two uppercase letters and three numbers,
+  ;; avoiding already used names
+  ;;
+  ;; @results {(i32,i32)} - offset and length in linear memory
+  ;;
+  (func (export "generateName") (result i32 i32)
+    (i32.const 0) (i32.const 0)
+  )
+
+  ;;
+  ;; Release already used names so that they can be re-used
+  ;;
+  (func (export "releaseNames"))
+)