4-kyu-the-observed-pin.js

// 4 kyu | The observed PIN
// https://www.codewars.com/kata/the-observed-pin/

/*
Alright, detective, one of our colleagues successfully observed our target
person, Robby the robber. We followed him to a secret warehouse, where we
assume to find all the stolen stuff. The door to this warehouse is secured
by an electronic combination lock. Unfortunately our spy isn't sure about
the PIN he saw, when Robby entered it.

The keypad has the following layout:

+---+---+---+
│ 1 │ 2 │ 3 │
+---+---+---+
│ 4 │ 5 │ 6 │
+---+---+---+
│ 7 │ 8 │ 9 │
+---+---+---+
    │ 0 │
    +---+

He noted the PIN 1357, but he also said, it is possible that each of the
digits he saw could actually be another adjacent digit (horizontally or
vertically, but not diagonally). E.g. instead of the 1 it could also
be the 2 or 4. And instead of the 5 it could also be the 2, 4, 6 or 8.

He also mentioned, he knows this kind of locks. You can enter an unlimited
amount of wrong PINs, they never finally lock the system or sound the alarm.
That's why we can try out all possible (*) variations.

* possible in sense of: the observed PIN itself and all variations considering
the adjacent digits

Can you help us to find all those variations? It would be nice to have a
function, that returns an array (or a list in Java and C#) of all variations
for an observed PIN with a length of 1 to 8 digits. We could name the
function getPINs (get_pins in python, GetPINs in C#). But please note that
all PINs, the observed one and also the results, must be strings, because
of potentially leading '0's. We already prepared some test cases for you.

Detective, we count on you!
*/

// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

// const combinations = a =>
//   a.reduce((acc, curr) =>
//     acc
//       .map(head => curr.map(next => `${head}${next}`))
//       .reduce((flattened, item) => flattened.concat(item)),
//   );

// const getPINs = observed =>
//   combinations(
//     [...observed].map(
//       d =>
//         [
//           ['0', '8'],
//           ['1', '4', '2'],
//           ['2', '5', '1', '3'],
//           ['3', '6', '2'],
//           ['4', '1', '7', '5'],
//           ['5', '2', '8', '4', '6'],
//           ['6', '3', '9', '5'],
//           ['7', '4', '8'],
//           ['8', '5', '0', '7', '9'],
//           ['9', '6', '8'],
//         ][d],
//     ),
//   );

// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

const getPINs = observed =>
  [...observed]
    .map(
      d =>
        [
          ['0', '8'],
          ['1', '4', '2'],
          ['2', '5', '1', '3'],
          ['3', '6', '2'],
          ['4', '1', '7', '5'],
          ['5', '2', '8', '4', '6'],
          ['6', '3', '9', '5'],
          ['7', '4', '8'],
          ['8', '5', '0', '7', '9'],
          ['9', '6', '8'],
        ][d],
    )
    .reduce((acc, curr) =>
      acc
        .map(head => curr.map(next => head + next))
        .reduce((flattened, arr) => flattened.concat(arr)),
    );

// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

import { deepStrictEqual } from 'assert';

// console.log(getPINs('8'));
deepStrictEqual(getPINs('8').sort(), ['5', '7', '8', '9', '0'].sort());

// console.log(getPINs('11'));
deepStrictEqual(
  getPINs('11').sort(),
  ['11', '22', '44', '12', '21', '14', '41', '24', '42'].sort(),
);

// console.log(getPINs('369'));
deepStrictEqual(
  getPINs('369').sort(),
  [
    '339',
    '366',
    '399',
    '658',
    '636',
    '258',
    '268',
    '669',
    '668',
    '266',
    '369',
    '398',
    '256',
    '296',
    '259',
    '368',
    '638',
    '396',
    '238',
    '356',
    '659',
    '639',
    '666',
    '359',
    '336',
    '299',
    '338',
    '696',
    '269',
    '358',
    '656',
    '698',
    '699',
    '298',
    '236',
    '239',
  ].sort(),
);

// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

// const getPossibilities = () => {
//   const pad = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [, 0]];
//   const moves = [[-1, 0], [1, 0], [0, -1], [0, 1]];
//   const possibilities = new Array(10).fill().map(u => []);
//   for (let i = 0; i < 4; i++) {
//     for (let j = 0; j < 3; j++) {
//       if ('undefined' === typeof pad[i][j]) continue;
//       possibilities[pad[i][j]].push(pad[i][j]);
//       for (let k = 0; k < 4; k++) {
//         if (
//           'undefined' !== typeof pad[i + moves[k][0]] &&
//           'undefined' !== typeof pad[i + moves[k][0]][j + moves[k][1]]
//         ) {
//           possibilities[pad[i][j]].push(pad[i + moves[k][0]][j + moves[k][1]]);
//         }
//       }
//     }
//   }
//   return possibilities;
// };
// console.log(getPossibilities());