Secret Handshake#
Objective was relatively simple.
- A numeral will be provided as input.
- Based on the binary equivalent, one needs to compute the secret handshake.
Rule for handshake.
1 = wink 10 = double blink 100 = close your eyes 1000 = jump 10000 = Reverse the order of the operations in the secret handshake.
## Example
Let’s say the input is 2 the output should be [“double blink”].
## Version 1.0
```text
function binaryOptimized(number) {
var binaryRep = [];
do {
binaryRep.push(parseInt(number%2));
number /= 2;
} while (parseInt(number) > 0);
return binaryRep;
}
function getCommand(pseudo, arr) { switch(pseudo) {
case 1: arr.push ("wink"); break;
case 10: arr.push ("double blink"); break;
case 100: arr.push ("close your eyes"); break;
case 1000: arr.push ("jump"); break;
case 10000: arr = arr.reverse();
}
return arr;
}
export const commands = (input) => {
var rep = binaryOptimized(input);
var commands = [];
rep.map((element, i) => {
getCommand(element * Math.pow(10, i), commands)
});
return commands;
};The code is self explanatory
Defined a binary calculation function, computed the equivalent binary representation. Used the individual element to compute the corresponding command and responded back with the response.
Can it be optimized?#
The think I misinterpreted was that, binary calculation of number is an optional thing.
BITWISE Operator#
There are two basic bitwise operation ‘&’ and ‘|’.
Bitwise operators treat their operands as a sequence of 32 bits (zeroes and ones), rather than as decimal, hexadecimal, or octal numbers.
Example#
5 => 101
We can check the bits now
2^0 = 1 => 1
2^1 = 2 => 10
2^2 = 4 => 100
2^3 = 8 => 1000
2^4 = 16 => 10000
2^5 = 32 => 100000Now instead of converting it to binary I can simply & to compute the on bits.
5&1 = 101 & 1 => 1
5&2 = 101 & 10 => 0
5&4 = 101 & 100 => 4
5&8 = 101 & 1000 => 0
5&16 = 101 & 10000 => 0
5&32 = 101 & 100000 => 0Also you can define the left shift to compute the bit rep.
1<<0 = 1
1<<1 = 10 = 2
1<<2 = 100 = 4
1<<3 = 1000 = 8
1<<4 = 10000 = 16
1<<5 = 100000 = 32So to compute the secret handshake it is just matter of computing the on bits and add it to the final array.
I defined the Array of handshakes
HANDSHAKES = ["wink", "double blink", "close your eyes", "jump"];To compute the handshake sequence I just to validate the ON bits.
Array.filter#
let newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
Documentation is available here.
Now utilizing the left shift operator, and bitwise & it was easy to compute the final array of handshakes.
HANDSHAKES.filter( (signal, index) => n & (1 << index));Where n is the input number from user.
Illustration#
If n = 3 then,
HANDSHAKES.filter() will Execute from 0..3
3 = (11)BASE2
Now,
[], 0 => 3&1, ["wink"]
[], 1 => 3&2, ["wink", "double blink"]
[], 2 => 3&4, ["wink", "double blink"]
[], 3 => 3&8, ["wink", "double blink"]For the last condition to reverse we can employ
if (n & (1 << HANDSHAKES.length)) {
result.reverse();
}For n = 3, above condition evaluates false so the final result comes out as
[“wink”, “double blink”]
const HANDSHAKES = ["wink", "double blink", "close your eyes", "jump"];
export const commands = (n) => {
if (typeof n !== "number") {
throw new Error("Handshake must be a number");
}
const result = HANDSHAKES.filter((signal, index) => n & (1 << index));
if (n & (1 << HANDSHAKES.length)) {
result.reverse();
}
return result;
};— THE – END —
