This method determines if the number provided is even.

It is based on the fact that odd numbers have their last

right bit to be set to 1.

This method multiplies two signed integer numbers using bitwise operators.

This method is based on the following :

This method is based on the following facts:

The advantage of this approach is that in each recursive step one of the operands reduces to half its original value.

Hence, the run time complexity is O(log b) where b is the operand that reduces to half on each recursive step.

The advantage of this approach is that in each recursive step one of the operands

reduces to half its original value. Hence, the run time complexity is `O(log(b)` where `b` is

the operand that reduces to half on each recursive step.

expect(isEven(-2)).toBe(true);

expect(isEven(1)).toBe(false);

expect(isEven(-1)).toBe(false);

expect(isEven(-3)).toBe(false);

expect(isEven(3)).toBe(false);

expect(isEven(8)).toBe(true);

expect(isEven(9)).toBe(false);

expect(isEven(121)).toBe(false);

expect(isEven(122)).toBe(true);

expect(isEven(1201)).toBe(false);

expect(isEven(1202)).toBe(true);

});

expect(multiply(4, -2)).toBe(-8);

expect(multiply(-4, -4)).toBe(16);

expect(multiply(4, -5)).toBe(-20);

expect(multiply(2, 121)).toBe(242);

expect(multiply(121, 2)).toBe(242);

});

export default function isEven(number) {

return (number & 1) === 0;

import multiplyByTwo from './multiplyByTwo';

import divideByTwo from './divideByTwo';

import isEven from './isEven';

import multiplyByTwo from './multiplyByTwo';

export default function multiply(a, b) {

// If a is zero or b is zero or if both a and b are zeros then the production is also zero.

if (b === 0 || a === 0) {

return 0;

}

// Otherwise we will have four different cases that are described above.

const multiplyByOddPositive = () => multiply(multiplyByTwo(a), divideByTwo(b - 1)) + a;

const multiplyByOddNegative = () => multiply(multiplyByTwo(a), divideByTwo(b + 1)) - a;

const multiplyByEven = () => multiply(multiplyByTwo(a), divideByTwo(b));

const multiplyByOdd = () => (b > 0 ? multiplyByOddPositive() : multiplyByOddNegative());