passes: 48
failures: 140
duration: 0.22s

Exercises in Recursion

1. Factorial

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:25:36)

expect(factorial(5)).to.be.a('number');

should return factorial for non-negative integers ‣

AssertionError: expected undefined to equal 1
    at Context.<anonymous> (spec/part1.js:29:33)

expect(factorial(0)).to.equal(1);
expect(factorial(1)).to.equal(1);
expect(factorial(4)).to.equal(24);
expect(factorial(5)).to.equal(120);

should return null for negative integers ‣

AssertionError: expected undefined to be null
    at Context.<anonymous> (spec/part1.js:36:36)

expect(factorial(-5)).to.be.null;

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:41:43)

factorial(4);
expect(factorial.callCount).to.be.above(1);

should be invoked with one argument2ms ‣

factorial(4);
factorial.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

2. Sum of Integers

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:72:42)

expect(sum([1,2,3,4,5,6])).to.be.a('number');

should return the sum of an array of non-negative integers ‣

AssertionError: expected undefined to equal 21
    at Context.<anonymous> (spec/part1.js:76:39)

expect(sum([1,2,3,4,5,6])).to.equal(21);
expect(sum([3,0,34,7,18])).to.equal(62);

should return the sum of an array of negative integers ‣

AssertionError: expected undefined to equal -21
    at Context.<anonymous> (spec/part1.js:81:45)

expect(sum([-1,-2,-3,-4,-5,-6])).to.equal(-21);
expect(sum([-3,-0,-34,-7,-18])).to.equal(-62);

should return the sum of an array of mixed non-negative and negative integers ‣

AssertionError: expected undefined to equal -3
    at Context.<anonymous> (spec/part1.js:86:42)

expect(sum([1,-2,3,-4,5,-6])).to.equal(-3);
expect(sum([-12,34,-56,78])).to.equal(44);
expect(sum([3,0,-34,-7,18])).to.equal(-20);

should return 0 for empty array ‣

AssertionError: expected undefined to equal 0
    at Context.<anonymous> (spec/part1.js:92:28)

expect(sum([])).to.equal(0);

should accept an array with a single integer ‣

AssertionError: expected undefined to equal 4
    at Context.<anonymous> (spec/part1.js:96:29)

expect(sum([4])).to.equal(4);
expect(sum([0])).to.equal(0);
expect(sum([-37])).to.equal(-37);

should not mutate the input array1ms ‣

var input = [1,2,3,4,5];
sum(input);
expect(input).to.eql([1,2,3,4,5]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:109:37)

sum([1,2,3,4,5,6]);
expect(sum.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

sum([1,2,3,4,5,6]);
sum.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

3. Sum Integers in Array

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:140:49)

expect(arraySum([[1],[[2]],3,4])).to.be.a('number');

should return the sum of nested arrays containing non-negative integers ‣

AssertionError: expected undefined to equal 15
    at Context.<anonymous> (spec/part1.js:144:50)

expect(arraySum([[1],[2,3],[[4]],5])).to.equal(15);
expect(arraySum([[12,[[34],[56]],78]])).to.equal(180);
expect(arraySum([3,[0,[34,[7,[18]]]]])).to.equal(62);

should return the sum of nested arrays containing negative integers ‣

AssertionError: expected undefined to equal -15
    at Context.<anonymous> (spec/part1.js:150:55)

expect(arraySum([[-1],[-2,-3],[[-4]],-5])).to.equal(-15);
expect(arraySum([[-12,[[-34],[-56]],-78]])).to.equal(-180);
expect(arraySum([-3,[0,[-34,[-7,[-18]]]]])).to.equal(-62);

should return the sum of nested arrays containing both non-negative and negative integers ‣

AssertionError: expected undefined to equal -3
    at Context.<anonymous> (spec/part1.js:156:55)

expect(arraySum([[1],[-2,3],[[-4]],5,-6])).to.equal(-3);
expect(arraySum([[-12,[[34],[-56]],78]])).to.equal(44);
expect(arraySum([3,[0,[-34,[-7,[18]]]]])).to.equal(-20);

should return 0 for empty array ‣

AssertionError: expected undefined to equal 0
    at Context.<anonymous> (spec/part1.js:162:33)

expect(arraySum([])).to.equal(0);

should accept an array with a single integer ‣

AssertionError: expected undefined to equal 4
    at Context.<anonymous> (spec/part1.js:166:34)

expect(arraySum([4])).to.equal(4);
expect(arraySum([0])).to.equal(0);
expect(arraySum([-37])).to.equal(-37);

should not mutate the input array1ms ‣

var input = [[1],[[2]],3,4];
arraySum(input);
expect(input).to.eql([[1],[[2]],3,4]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:179:42)

arraySum([[1],[[2]],3,4]);
expect(arraySum.callCount).to.be.above(1);

should be invoked with one argument1ms ‣

arraySum([[1],[[2]],3,4]);
arraySum.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

4. Check if Even

should return a boolean ‣

AssertionError: expected undefined to be a boolean
    at Context.<anonymous> (spec/part1.js:210:33)

expect(isEven(5)).to.be.a('boolean');
expect(isEven(8)).to.be.a('boolean');

should not use modulo2ms ‣

var stringified = originalIsEven.toString();
expect(stringified).to.not.contain('%');
expect(stringified).to.not.contain('modulo');

should return true for even numbers ‣

AssertionError: expected undefined to be true
    at Context.<anonymous> (spec/part1.js:221:33)

expect(isEven(48)).to.be.true;
expect(isEven(0)).to.be.true;

should return false for odd numbers ‣

AssertionError: expected undefined to be false
    at Context.<anonymous> (spec/part1.js:226:33)

expect(isEven(17)).to.be.false;
expect(isEven(1)).to.be.false;

should work with negative integers ‣

AssertionError: expected undefined to be true
    at Context.<anonymous> (spec/part1.js:231:34)

expect(isEven(-14)).to.be.true;
expect(isEven(-31)).to.be.false;

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:237:40)

isEven(8);
expect(isEven.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

isEven(8);
isEven.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

5. Sum Below

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:268:36)

expect(sumBelow(10)).to.be.a('number');

should return the sum of non-negative integers below given integer ‣

AssertionError: expected undefined to equal 0
    at Context.<anonymous> (spec/part1.js:272:32)

expect(sumBelow(0)).to.equal(0);
expect(sumBelow(1)).to.equal(0);
expect(sumBelow(2)).to.equal(1);
expect(sumBelow(7)).to.equal(21);
expect(sumBelow(12)).to.equal(66);

should return the sum of negative integers above given negative integer ‣

AssertionError: expected undefined to equal 0
    at Context.<anonymous> (spec/part1.js:280:33)

expect(sumBelow(-1)).to.equal(0);
expect(sumBelow(-2)).to.equal(-1);
expect(sumBelow(-6)).to.equal(-15);
expect(sumBelow(-11)).to.equal(-55);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:288:42)

sumBelow(5);
expect(sumBelow.callCount).to.be.above(1);

should be invoked with one argument1ms ‣

sumBelow(5);
sumBelow.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

6. Integer Range

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:319:34)

expect(range(2,7)).to.be.an('array');

should return the integers between two numbers ‣

AssertionError: expected undefined to deeply equal [ 4, 5, 6, 7 ]
    at Context.<anonymous> (spec/part1.js:323:31)

expect(range(3,8)).to.eql([4,5,6,7]);
expect(range(127,131)).to.eql([128,129,130]);

should return empty array if no integers in range ‣

AssertionError: expected undefined to deeply equal []
    at Context.<anonymous> (spec/part1.js:328:31)

expect(range(5,5)).to.eql([]);
expect(range(2,3)).to.eql([]);

should accept negative integers ‣

AssertionError: expected undefined to deeply equal [ -8, -7, -6, -5 ]
    at Context.<anonymous> (spec/part1.js:333:33)

expect(range(-9,-4)).to.eql([-8,-7,-6,-5]);
expect(range(-3,2)).to.eql([-2,-1,0,1]);
expect(range(-3,-2)).to.eql([]);
expect(range(-2,-2)).to.eql([]);

should accept starting integer that's larger than ending ‣

AssertionError: expected undefined to deeply equal [ 6, 5, 4, 3 ]
    at Context.<anonymous> (spec/part1.js:340:31)

expect(range(7,2)).to.eql([6,5,4,3]);
expect(range(3,-3)).to.eql([2,1,0,-1,-2]);
expect(range(-9,-4)).to.eql([-8,-7,-6,-5]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:347:39)

range(3,8);
expect(range.callCount).to.be.above(1);

should be invoked with two arguments0ms ‣

range(3,8);
range.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

7. Compute Exponent

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:378:37)

expect(exponent(4,3)).to.be.a('number');

should not use complex math0ms ‣

expect(originalExponent.toString()).to.not.contain('Math');

should compute exponent of non-negative integers ‣

AssertionError: expected undefined to equal 81
    at Context.<anonymous> (spec/part1.js:386:34)

expect(exponent(3,4)).to.equal(81);
expect(exponent(12,5)).to.equal(248832);
expect(exponent(7,2)).to.equal(49);

returns 1 when exponent is 0 ‣

AssertionError: expected undefined to equal 1
    at Context.<anonymous> (spec/part1.js:392:34)

expect(exponent(8,0)).to.equal(1);
expect(exponent(244,0)).to.equal(1);

returns base when exponent is 1 ‣

AssertionError: expected undefined to equal 9
    at Context.<anonymous> (spec/part1.js:397:34)

expect(exponent(9,1)).to.equal(9);
expect(exponent(2300,1)).to.equal(2300);

should accept negative integer for exponent ‣

AssertionError: expected undefined to equal 0.0625
    at Context.<anonymous> (spec/part1.js:403:35)

expect(exponent(4,-2)).to.equal(0.0625);
expect(exponent(5,-4)).to.equal(0.0016);
expect(exponent(2,-5)).to.equal(0.03125);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:410:42)

exponent(3,4);
expect(exponent.callCount).to.be.above(1);

should be invoked with two arguments0ms ‣

exponent(3,4);
exponent.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

optimize for even numbers
should accept negative integer for base

8. Power of Two

should return a boolean ‣

AssertionError: expected undefined to be a boolean
    at Context.<anonymous> (spec/part1.js:464:37)

expect(powerOfTwo(5)).to.be.a('boolean');
expect(powerOfTwo(8)).to.be.a('boolean');

should return true for powers of two ‣

AssertionError: expected undefined to be true
    at Context.<anonymous> (spec/part1.js:469:36)

expect(powerOfTwo(1)).to.be.true;
expect(powerOfTwo(2)).to.be.true;
expect(powerOfTwo(128)).to.be.true;

should return false when input is not power of two ‣

AssertionError: expected undefined to be false
    at Context.<anonymous> (spec/part1.js:475:36)

expect(powerOfTwo(0)).to.be.false;
expect(powerOfTwo(10)).to.be.false;
expect(powerOfTwo(270)).to.be.false;

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:482:44)

powerOfTwo(16);
expect(powerOfTwo.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

powerOfTwo(16);
powerOfTwo.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

9. Reverse String

should return a string ‣

AssertionError: expected undefined to be a string
    at Context.<anonymous> (spec/part1.js:513:39)

expect(reverse('traf')).to.be.a('string');

should return a string in reverse ‣

AssertionError: expected undefined to equal '.uoy ot gnoleb era esab ym llA'
    at Context.<anonymous> (spec/part1.js:519:35)

var input = 'All my base are belong to you.';
var tupni = '.uoy ot gnoleb era esab ym llA';
expect(reverse(input)).to.equal(tupni);

should not use native reverse method0ms ‣

// Spying on Array.prototype.reverse in testSupport.js
reverse('traf');
expect(Array.prototype.reverse.called).to.be.false;

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:530:41)

reverse('orangutan');
expect(reverse.callCount).to.be.above(1);

should be invoked with one argument1ms ‣

reverse('orangutan');
reverse.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

10. Palindrome

should return a boolean ‣

AssertionError: expected undefined to be a boolean
    at Context.<anonymous> (spec/part1.js:561:43)

expect(palindrome('rotor')).to.be.a('boolean');
expect(palindrome('motor')).to.be.a('boolean');

should not use native reverse method0ms ‣

palindrome('hannah');
expect(Array.prototype.reverse.called).to.be.false;

should return true for palindromes ‣

AssertionError: expected undefined to be true
    at Context.<anonymous> (spec/part1.js:571:38)

expect(palindrome('o')).to.be.true;
expect(palindrome('racecar')).to.be.true;
expect(palindrome('saippuakivikauppias')).to.be.true;

should return false for non-palindromes ‣

AssertionError: expected undefined to be false
    at Context.<anonymous> (spec/part1.js:577:39)

expect(palindrome('hi')).to.be.false;
expect(palindrome('orangutan')).to.be.false;

should ignore spaces and capital letters ‣

AssertionError: expected undefined to be true
    at Context.<anonymous> (spec/part1.js:582:42)

expect(palindrome('Rotor')).to.be.true;
expect(palindrome('sAip puaki v iKaup Pias')).to.be.true;

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:588:44)

palindrome('racecar');
expect(palindrome.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

palindrome('racecar');
palindrome.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

11. Modulo

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:619:35)

expect(modulo(5,2)).to.be.a('number');
expect(modulo(8,4)).to.be.a('number');

should not use complex math2ms ‣

var stringified = originalModulo.toString();
expect(stringified).to.not.contain('*');
expect(stringified).to.not.contain('/');
expect(stringified).to.not.contain('%');
expect(stringified).to.not.contain('Math');

should return the remainder of two integers ‣

AssertionError: expected undefined to equal 0
    at Context.<anonymous> (spec/part1.js:632:33)

expect(modulo(2, 1)).to.equal(2 % 1);
expect(modulo(17, 5)).to.equal(17 % 5);
expect(modulo(78, 453)).to.equal(78 % 453);
expect(modulo(0, 32)).to.equal(0 % 32);
expect(modulo(0, 0)).to.be.NaN;

should accept negative integers ‣

AssertionError: expected undefined to equal -79
    at Context.<anonymous> (spec/part1.js:640:36)

expect(modulo(-79, 82)).to.equal(-79 % 82);
expect(modulo(-275, -502)).to.equal(-275 % -502);
expect(modulo(-275, -274)).to.equal(-275 % -274);
expect(modulo(-4, 2)).to.equal(-4 % 2);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:648:40)

modulo(5,2);
expect(modulo.callCount).to.be.above(1);

should be invoked with two arguments0ms ‣

modulo(5,2);
modulo.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

12. Multiply

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:679:37)

expect(multiply(5,2)).to.be.a('number');
expect(multiply(8,4)).to.be.a('number');

should not use complex math2ms ‣

var stringified = originalMultiply.toString();
expect(stringified).to.not.contain('*');
expect(stringified).to.not.contain('/');
expect(stringified).to.not.contain('%');
expect(stringified).to.not.contain('Math');
expect(stringified).to.not.contain('modulo');

should return the product of two positive integers ‣

AssertionError: expected undefined to equal 2
    at Context.<anonymous> (spec/part1.js:693:35)

expect(multiply(1, 2)).to.equal(1 * 2);
expect(multiply(17, 5)).to.equal(17 * 5);
expect(multiply(0, 32)).to.equal(0 * 32);
expect(multiply(0, 0)).to.equal(0 * 0);
// expect(multiply(78, 453)).to.equal(78 * 453);

should return the product of two negative integers ‣

AssertionError: expected undefined to equal 4
    at Context.<anonymous> (spec/part1.js:701:37)

expect(multiply(-2, -2)).to.equal(-2 * -2);
expect(multiply(-8, -3)).to.equal(-8 * -3);
expect(multiply(-5, -27)).to.equal(-5 * -27);
// expect(multiply(-79, -82)).to.equal(-79 * -82);
// expect(multiply(-275, -502)).to.equal(-275 * -502);
// expect(multiply(-12, -10)).to.equal(-12 * -10);
// expect(multiply(-22, -3)).to.equal(-22 * -3);

should return the product of mixed positive and negative integers ‣

AssertionError: expected undefined to equal -6478
    at Context.<anonymous> (spec/part1.js:711:38)

expect(multiply(-79, 82)).to.equal(-79 * 82);
expect(multiply(79, -82)).to.equal(79 * -82);
expect(multiply(2, -2)).to.equal(2 * -2);
expect(multiply(5, -27)).to.equal(5 * -27);
// expect(multiply(-275, 502)).to.equal(-275 * 502);
// expect(multiply(275, -502)).to.equal(275 * -502);
// expect(multiply(-8, 3)).to.equal(-8 * 3);
// expect(multiply(12, -10)).to.equal(12 * -10);
// expect(multiply(-22, 3)).to.equal(-22 * 3);

should accept parameters in any order ‣

AssertionError: expected undefined to equal 2
    at Context.<anonymous> (spec/part1.js:723:35)

expect(multiply(2, 1)).to.equal(1 * 2);
expect(multiply(5, 17)).to.equal(5 * 17);
expect(multiply(32, 0)).to.equal(0 * 32);
// expect(multiply(453, 78)).to.equal(78 * 453);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:731:42)

multiply(8,4);
expect(multiply.callCount).to.be.above(1);

should be invoked with two arguments0ms ‣

multiply(8,4);
multiply.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

13. Divide

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:762:35)

expect(divide(5,2)).to.be.a('number');
expect(divide(8,4)).to.be.a('number');

should not use complex math2ms ‣

var stringified = originalDivide.toString();
expect(stringified).to.not.contain('*');
expect(stringified).to.not.contain('/');
expect(stringified).to.not.contain('%');
expect(stringified).to.not.contain('Math');
expect(stringified).to.not.contain('modulo');

should return the quotient of two integers ‣

AssertionError: expected undefined to equal 2
    at Context.<anonymous> (spec/part1.js:776:33)

expect(divide(2, 1)).to.equal(~~(2 / 1));
expect(divide(17, 5)).to.equal(~~(17 / 5));
expect(divide(78, 453)).to.equal(~~(78 / 453));
expect(divide(-79, 82)).to.equal(~~(-79 / 82));
expect(divide(-275, -582)).to.equal(~~(-275 / -582));
expect(divide(0, 32)).to.equal(~~(0 / 32));
expect(divide(0, 0)).to.be.NaN;

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:787:40)

divide(17, 5);
expect(divide.callCount).to.be.above(1);

should be invoked with two arguments0ms ‣

divide(8,4);
divide.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

14. Greatest Common Divisor

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:818:33)

expect(gcd(4,36)).to.be.a('number');

should return greatest common divisor of two positive integers ‣

AssertionError: expected undefined to equal 4
    at Context.<anonymous> (spec/part1.js:822:30)

expect(gcd(4,36)).to.equal(4);
expect(gcd(24,88)).to.equal(8);
expect(gcd(339,17)).to.equal(1);
expect(gcd(126,900)).to.equal(18);

should return null for negative integers ‣

AssertionError: expected undefined to be null
    at Context.<anonymous> (spec/part1.js:829:33)

expect(gcd(-4, 2)).to.be.null;
expect(gcd(-5, 5)).to.be.null;
expect(gcd(5, -5)).to.be.null;
expect(gcd(7, -36)).to.be.null;
expect(gcd(-10, -58)).to.be.null;
expect(gcd(-92, -5)).to.be.null;
// expect(gcd(0, 0)).to.be.null;
// expect(gcd(0, 5)).to.be.null;
// expect(gcd(5, 0)).to.be.null;
// expect(gcd(-5, 0)).to.be.null;
// expect(gcd(0, -5)).to.be.null;

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:844:37)

gcd(17, 5);
expect(gcd.callCount).to.be.above(1);

should be invoked with two arguments1ms ‣

gcd(17,5);
gcd.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

15. Compare Strings

should return a boolean ‣

AssertionError: expected undefined to be a boolean
    at Context.<anonymous> (spec/part1.js:875:53)

expect(compareStr('house', 'houses')).to.be.a('boolean');
expect(compareStr('', '')).to.be.a('boolean');
expect(compareStr('tomato', 'tomato')).to.be.a('boolean');

should return true for identical strings ‣

AssertionError: expected undefined to be false
    at Context.<anonymous> (spec/part1.js:881:52)

expect(compareStr('house', 'houses')).to.be.false;
expect(compareStr('', '')).to.be.true;
expect(compareStr('tomato', 'tomato')).to.be.true;
expect(compareStr('', 'pop')).to.be.false;
expect(compareStr('foot', '')).to.be.false;
expect(compareStr('big dog', 'big dog')).to.be.true;

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:891:44)

compareStr('house', 'houses');
expect(compareStr.callCount).to.be.above(1);

should be invoked with two arguments1ms ‣

compareStr('house', 'houses');
compareStr.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

16. Create array from string

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:922:44)

expect(createArray('hello')).to.be.an('array');

should return an array where each index is a letter of the string ‣

AssertionError: expected undefined to deeply equal [ Array(18) ]
    at Context.<anonymous> (spec/part1.js:926:54)

expect(createArray('this is not a pipe')).to.eql(['t','h','i','s',' ','i','s',' ','n','o','t',' ','a',' ','p','i','p','e']);
expect(createArray('hologram')).to.eql(['h','o','l','o','g','r','a','m']);
expect(createArray('i')).to.eql(['i']);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:933:45)

createArray('hello');
expect(createArray.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

createArray('hello');
createArray.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

17. Reverse an array

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:964:43)

expect(reverseArr([3,2,1])).to.be.an('array');

should return array in reversed order ‣

AssertionError: expected undefined to deeply equal [ 5, 4, 3, 2, 1 ]
    at Context.<anonymous> (spec/part1.js:968:44)

expect(reverseArr([1,2,3,4,5])).to.eql([5,4,3,2,1]);
expect(reverseArr([8,6,4,2])).to.eql([2,4,6,8]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:974:44)

reverseArr([3,2,1]);
expect(reverseArr.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

reverseArr([5,4,3]);
reverseArr.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

18. Build an array with a given value and length

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:1005:38)

expect(buildList(0,5)).to.be.an('array');

should return array of given length with given value at each index ‣

AssertionError: expected undefined to deeply equal [ 0, 0, 0, 0, 0 ]
    at Context.<anonymous> (spec/part1.js:1009:36)

expect(buildList(0, 5)).to.eql([0,0,0,0,0]);
expect(buildList('banana', 3)).to.eql(['banana','banana','banana']);
expect(buildList(NaN, 4)).to.eql([NaN, NaN, NaN, NaN]);
expect(buildList(undefined, 1)).to.eql([undefined]);
expect(buildList([], 2)).to.eql([[],[]]);
expect(buildList({}, 4)).to.eql([{},{},{},{}]);
expect(buildList(true, 3)).to.eql([true,true,true]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1020:43)

buildList(2,4);
expect(buildList.callCount).to.be.above(1);

should be invoked with two arguments1ms ‣

buildList('five',3);
buildList.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

19. FizzBuzz

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:1051:35)

expect(fizzBuzz(3)).to.be.an('array');

should return string representations of numbers 1 to n ‣

TypeError: Cannot read properties of undefined (reading 'forEach')
    at Context.<anonymous> (spec/part1.js:1056:22)

actualResult = fizzBuzz(10);
actualResult.forEach(function(value) {
  expect(value).to.be.a('string');
});

should output "Fizz" for multiples of three ‣

AssertionError: expected undefined to deeply equal [ '1', '2', 'Fizz' ]
    at Context.<anonymous> (spec/part1.js:1064:33)

actualResult = fizzBuzz(3);
expectedResult = ['1','2','Fizz'];
expect(actualResult).to.eql(expectedResult);

should output "Buzz" for multiples of five ‣

AssertionError: expected undefined to deeply equal [ Array(12) ]
    at Context.<anonymous> (spec/part1.js:1070:33)

actualResult = fizzBuzz(12);
expectedResult = ['1','2','Fizz','4','Buzz','Fizz','7','8','Fizz','Buzz','11','Fizz'];
expect(actualResult).to.eql(expectedResult);

should output "FizzBuzz" for multiples of both three and five ‣

AssertionError: expected undefined to deeply equal [ Array(15) ]
    at Context.<anonymous> (spec/part1.js:1076:33)

actualResult = fizzBuzz(15);
expectedResult = ['1','2','Fizz','4','Buzz','Fizz','7','8','Fizz','Buzz','11','Fizz','13','14','FizzBuzz'];
expect(actualResult).to.eql(expectedResult);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1081:42)

fizzBuzz(5);
expect(fizzBuzz.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

fizzBuzz(5);
fizzBuzz.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

20. Count value in array

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:1112:57)

expect(countOccurrence([2,7,4,4,1,4], 4)).to.be.a('number');
expect(countOccurrence([2,'banana',4,4,1,'banana'], 'banana')).to.be.a('number');

should return the number of occurrences of the value ‣

AssertionError: expected undefined to equal 3
    at Context.<anonymous> (spec/part1.js:1117:54)

expect(countOccurrence([2,7,4,4,1,4], 4)).to.equal(3);
expect(countOccurrence([2,'banana',4,4,1,'banana'], 'banana')).to.equal(2);
expect(countOccurrence([undefined,7,undefined,4,1,4], undefined)).to.equal(2);
expect(countOccurrence(['',null,0,'0',false], 0)).to.equal(1);
expect(countOccurrence(['',null,0,'false',false], false)).to.equal(1);
expect(countOccurrence(['',7,null,0,'0',false], null)).to.equal(1);
expect(countOccurrence(['',7,null,0,'0',false], '')).to.equal(1);
// expect(countOccurrence(['',7,null,0,NaN,'0',false], NaN)).to.equal(1);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1129:49)

countOccurrence([2,7,4,4,1,4], 4);
expect(countOccurrence.callCount).to.be.above(1);

should be invoked with two arguments1ms ‣

countOccurrence([2,7,4,4,1,4], 4);
countOccurrence.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

21. Recursive Map

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:1165:45)

expect(rMap(input, timesTwo)).to.be.an('array');

should not use the native version of map0ms ‣

// Spying on Array.prototype.map in testSupport.js
rMap(input, timesTwo);
expect(Array.prototype.map.called).to.be.false;

should return new array without mutating the input array ‣

AssertionError: expected undefined to deeply equal [ 1, 2, 3, 4, 5 ]
    at Context.<anonymous> (spec/part1.js:1178:27)

result = rMap(input, num => num);
expect(input).to.eql([1,2,3,4,5]);
// should deeply equal input
expect(result).to.eql(input);
// should not be same array in memory
expect(result).to.not.equal(input);

should apply a function to every value in an array ‣

AssertionError: expected undefined to deeply equal [ 2, 4, 6 ]
    at Context.<anonymous> (spec/part1.js:1185:27)

result = rMap([1,2,3], timesTwo);
expect(result).to.eql([2,4,6]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1190:38)

rMap([1,2,3,4], timesTwo);
expect(rMap.callCount).to.be.above(1);

should be invoked with two arguments1ms ‣

rMap([1,2,3,4], timesTwo);
rMap.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

22. Count key in object

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:1222:50)

expect(countKeysInObj(input, 'r')).to.be.a('number');

should return the number of occurrences of the property ‣

AssertionError: expected undefined to equal 2
    at Context.<anonymous> (spec/part1.js:1226:47)

expect(countKeysInObj(input, 'e')).to.equal(2);
expect(countKeysInObj(input, 'x')).to.equal(1);
expect(countKeysInObj(input, 'y')).to.equal(2);
expect(countKeysInObj(input, 't')).to.equal(1);
expect(countKeysInObj(input, 'r')).to.equal(1);
expect(countKeysInObj(input, 'p')).to.equal(1);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1236:48)

countKeysInObj(input, 'e');
expect(countKeysInObj.callCount).to.be.above(1);

should be invoked with two arguments0ms ‣

countKeysInObj(input, 'e');
countKeysInObj.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

23. Count value in object

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:1268:52)

expect(countValuesInObj(input, 'r')).to.be.a('number');

should return the count of the occurrences of the property ‣

AssertionError: expected undefined to equal 1
    at Context.<anonymous> (spec/part1.js:1272:49)

expect(countValuesInObj(input, 'e')).to.equal(1);
expect(countValuesInObj(input, 'x')).to.equal(0);
expect(countValuesInObj(input, 'y')).to.equal(1);
expect(countValuesInObj(input, 't')).to.equal(0);
expect(countValuesInObj(input, 'r')).to.equal(2);
expect(countValuesInObj(input, 'p')).to.equal(0);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1282:50)

countValuesInObj(input, 'r');
expect(countValuesInObj.callCount).to.be.above(1);

should be invoked with two arguments1ms ‣

countValuesInObj(input, 'r');
countValuesInObj.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

24. Replace keys in object

should return an object ‣

AssertionError: expected undefined to be an object
    at Context.<anonymous> (spec/part1.js:1318:30)

output = replaceKeysInObj(input, 'r', 'a');
expect(output).to.be.an('object');

should mutate the input object ‣

AssertionError: expected { Object (e, t, ...) } to equal undefined
    at Context.<anonymous> (spec/part1.js:1323:26)

output = replaceKeysInObj(input, 'y', 'u');
expect(input).to.equal(output);

should return object containing renamed keys ‣

AssertionError: expected { Object (e, t, ...) } to have keys 'f', 't', and 'y'
    at Context.<anonymous> (spec/part1.js:1329:35)

replaceKeysInObj(input, 'e', 'f');
expect(input).to.have.all.keys('f','t','y');
expect(input.f).to.be.an('object');
expect(input.f).to.have.all.keys('x');
expect(input.f.x).to.be.a('string');
expect(input.f.x).to.equal('y');
expect(input.t).to.be.an('object');
expect(input.t).to.have.all.keys('r','p');
expect(input.t.r).to.be.an('object');
expect(input.t.r).to.have.all.keys('f');
expect(input.t.r.f).to.be.a('string');
expect(input.t.r.f).to.equal('r');
expect(input.t.p).to.be.an('object');
expect(input.t.p).to.have.all.keys('y');
expect(input.t.p.y).to.be.a('string');
expect(input.t.p.y).to.equal('r');
expect(input.y).to.be.a('string');
expect(input.y).to.equal('e');
expect(input).to.not.have.ownProperty('e');
expect(input.t.r).to.not.have.ownProperty('e');

should return object with same number of keys ‣

AssertionError: expected 0 to equal 8
    at Context.<anonymous> (spec/part1.js:1359:36)

expect(analyze(input)).to.equal(8);
output = replaceKeysInObj(input, 'e', 'f');
expect(analyze(output)).to.equal(8);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1364:50)

replaceKeysInObj(input, 'r', 'a');
expect(replaceKeysInObj.callCount).to.be.above(1);

should be invoked with three arguments0ms ‣

replaceKeysInObj(input, 'r', 'a');
replaceKeysInObj.args.forEach(arg => {
  expect(arg).to.have.length(3);
});

25. First n Fibonacci

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:1395:36)

expect(fibonacci(5)).to.be.an('array');

should return first n Fibonacci numbers where n starts at index 1 ‣

AssertionError: expected undefined to deeply equal [ 0, 1 ]
    at Context.<anonymous> (spec/part1.js:1399:33)

expect(fibonacci(1)).to.eql([0,1]);
expect(fibonacci(2)).to.eql([0,1,1]);
expect(fibonacci(3)).to.eql([0,1,1,2]);
expect(fibonacci(4)).to.eql([0,1,1,2,3]);
expect(fibonacci(5)).to.eql([0,1,1,2,3,5]);
expect(fibonacci(8)).to.eql([0,1,1,2,3,5,8,13,21]);

should return null for zero and negative integers ‣

AssertionError: expected undefined to be null
    at Context.<anonymous> (spec/part1.js:1408:35)

expect(fibonacci(0)).to.be.null;
expect(fibonacci(-7)).to.be.null;

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1414:43)

fibonacci(5);
expect(fibonacci.callCount).to.be.above(1);

should be invoked with one argument1ms ‣

fibonacci(5);
fibonacci.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

26. Return nth Fibonacci

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:1445:34)

expect(nthFibo(5)).to.be.a('number');

should return the nth nthFibo number ‣

AssertionError: expected undefined to equal 0
    at Context.<anonymous> (spec/part1.js:1449:31)

expect(nthFibo(0)).to.equal(0);
expect(nthFibo(1)).to.equal(1);
expect(nthFibo(2)).to.equal(1);
expect(nthFibo(3)).to.equal(2);
expect(nthFibo(4)).to.equal(3);
expect(nthFibo(5)).to.equal(5);
expect(nthFibo(8)).to.equal(21);

should return null for negative integers ‣

AssertionError: expected undefined to be null
    at Context.<anonymous> (spec/part1.js:1459:34)

expect(nthFibo(-5)).to.be.null;
expect(nthFibo(-7)).to.be.null;

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1465:41)

nthFibo(5);
expect(nthFibo.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

nthFibo(5);
nthFibo.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

27. Capitalize words in array

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:1496:54)

expect(capitalizeWords(['recursion'])).to.be.an('array');

should capitalize all words in array ‣

AssertionError: expected undefined to deeply equal [ Array(5) ]
    at Context.<anonymous> (spec/part1.js:1500:73)

expect(capitalizeWords(["ceci","n'est","pas","une","pipe"])).to.eql(["CECI", "N'EST", "PAS", "UNE", "PIPE"]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1505:49)

capitalizeWords(['i','am','learning','recursion']);
expect(capitalizeWords.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

capitalizeWords(['you','got','this']);
capitalizeWords.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

28. Capitalize first letter of words in array

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:1536:54)

expect(capitalizeFirst(['recursion'])).to.be.an('array');

should capitalize first letter of each word in array ‣

AssertionError: expected undefined to deeply equal [ Array(5) ]
    at Context.<anonymous> (spec/part1.js:1540:73)

expect(capitalizeFirst(["ceci","n'est","pas","une","pipe"])).to.eql(["Ceci", "N'est", "Pas", "Une", "Pipe"]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1545:49)

capitalizeFirst(["ceci","n'est","pas","une","pipe"]);
expect(capitalizeFirst.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

capitalizeFirst(['you','got','this']);
capitalizeFirst.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

29. Sum even numbers in nested objects

should return a number ‣

AssertionError: expected undefined to be a number
    at Context.<anonymous> (spec/part1.js:1583:44)

expect(nestedEvenSum(input)).to.be.a('number');

should sum even numbers ‣

AssertionError: expected undefined to equal 10
    at Context.<anonymous> (spec/part1.js:1587:41)

expect(nestedEvenSum(input)).to.equal(10);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1592:47)

nestedEvenSum(input);
expect(nestedEvenSum.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

nestedEvenSum(input);
nestedEvenSum.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

30. Flatten nested arrays

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:1623:46)

expect(flatten([1,[2],[[3]]])).to.be.an('array');

should return flattened array ‣

AssertionError: expected undefined to deeply equal [ 1, 2, 3, 4, 5 ]
    at Context.<anonymous> (spec/part1.js:1627:49)

expect(flatten([[1],[2,3],[[4]],5])).to.eql([1,2,3,4,5]);
expect(flatten([3,[0,[34,[7,[18]]]]])).to.eql([3,0,34,7,18]);
expect(flatten([[[[[3],0],34],7],18])).to.eql([3,0,34,7,18]);
expect(flatten([[1],[2,[],3],[],[[4]],5])).to.eql([1,2,3,4,5]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1635:41)

flatten([3,[0,[34]]]);
expect(flatten.callCount).to.be.above(1);

should be invoked with one argument1ms ‣

flatten([3,[0,[34]]]);
flatten.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

31. Tally letters in string

should return an object ‣

AssertionError: expected undefined to be an object
    at Context.<anonymous> (spec/part1.js:1666:48)

expect(letterTally('orangutan')).to.be.an('object');

should return object containing tallies of unique letters ‣

TypeError: Cannot read properties of undefined (reading 'p')
    at Context.<anonymous> (spec/part1.js:1672:23)

var output = letterTally('potato');
expect(output.p).to.equal(1);
expect(output.o).to.equal(2);
expect(output.t).to.equal(2);
expect(output.a).to.equal(1);

should return object containing the number of keys corresponding to unique letters ‣

TypeError: Cannot convert undefined or null to object
    at Function.keys (<anonymous>)
    at Context.<anonymous> (spec/part1.js:1680:31)

var output = letterTally('mississippi');
var keyCount = Object.keys(output).length;
expect(keyCount).to.equal(4);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1686:45)

letterTally('invasion');
expect(letterTally.callCount).to.be.above(1);

should be invoked with at most two arguments0ms ‣

letterTally('invasion');
letterTally.args.forEach(arg => {
  expect(arg).to.have.length.of.at.most(2);
});

32. Eliminate consecutive duplicates

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:1719:40)

expect(compress(input1)).to.be.an('array');

should not mutate the input array1ms ‣

var result = compress(input1);
expect(input1).to.eql([1,2,2,3,4,4,5,5,5]);
expect(input1).to.not.equal(result);

should remove consecutive duplicates ‣

AssertionError: expected undefined to deeply equal [ 1, 2, 3, 4, 5 ]
    at Context.<anonymous> (spec/part1.js:1729:37)

expect(compress(input1)).to.eql([1,2,3,4,5]);
expect(compress(input2)).to.eql([1,2,3,4,2,5,4]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1735:42)

compress(input1);
expect(compress.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

compress(input1);
compress.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

33. Augment each element in nested arrays

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:1766:52)

expect(augmentElements([[],[3]], 5)).to.be.an('array');

should augment each element with given value ‣

AssertionError: expected undefined to deeply equal [ [ 5 ], [ 3, 5 ], [ 7, 5 ] ]
    at Context.<anonymous> (spec/part1.js:1770:53)

expect(augmentElements([[],[3],[7]], 5)).to.eql([[5],[3,5],[7,5]]);
expect(augmentElements([[],[3],[7]], null)).to.eql([[null],[3,null],[7,null]]);
expect(augmentElements([[],[3],[7]], '')).to.eql([[''],[3,''],[7,'']]);
expect(augmentElements([[],[3],[7]], false)).to.eql([[false],[3,false],[7,false]]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1778:49)

augmentElements([[],[3]], 5);
expect(augmentElements.callCount).to.be.above(1);

should be invoked with two arguments1ms ‣

augmentElements([[],[3]], 5);
augmentElements.args.forEach(arg => {
  expect(arg).to.have.length(2);
});

34. Minimize zeroes

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:1814:46)

expect(minimizeZeroes(input1)).to.be.an('array');

should not mutate the input array0ms ‣

expect(minimizeZeroes(input2)).to.not.equal(input2);

should remove excess zeroes ‣

AssertionError: expected undefined to deeply equal [ 2, 0, 1, 4 ]
    at Context.<anonymous> (spec/part1.js:1822:43)

expect(minimizeZeroes(input1)).to.eql([2,0,1,4]);
expect(minimizeZeroes(input2)).to.eql([2,0,1,0,4]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1828:48)

minimizeZeroes(input1);
expect(minimizeZeroes.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

minimizeZeroes(input2);
minimizeZeroes.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

35. Alternate sign

should return an array ‣

AssertionError: expected undefined to be an array
    at Context.<anonymous> (spec/part1.js:1864:45)

expect(alternateSign(input1)).to.be.an('array');

should not mutate the input array0ms ‣

expect(alternateSign(input2)).to.not.equal(input2);

should alternate signs ‣

AssertionError: expected undefined to deeply equal [ 2, -7, 8, -3, 1, -4 ]
    at Context.<anonymous> (spec/part1.js:1872:42)

expect(alternateSign(input1)).to.eql([2,-7,8,-3,1,-4]);
expect(alternateSign(input2)).to.eql([2,-7,8,-3,1,-4]);

should use recursion by calling self ‣

AssertionError: expected 1 to be above 1
    at Context.<anonymous> (spec/part1.js:1878:47)

alternateSign(input1);
expect(alternateSign.callCount).to.be.above(1);

should be invoked with one argument0ms ‣

alternateSign(input2);
alternateSign.args.forEach(arg => {
  expect(arg).to.have.length(1);
});

36. Convert numbers to text

should return a number ‣

should return factorial for non-negative integers ‣

should return null for negative integers ‣

should use recursion by calling self ‣

should be invoked with one argument2ms ‣

should return a number ‣

should return the sum of an array of non-negative integers ‣

should return the sum of an array of negative integers ‣

should return the sum of an array of mixed non-negative and negative integers ‣

should return 0 for empty array ‣

should accept an array with a single integer ‣

should not mutate the input array1ms ‣

should use recursion by calling self ‣

should be invoked with one argument0ms ‣

should return a number ‣

should return the sum of nested arrays containing non-negative integers ‣

should return the sum of nested arrays containing negative integers ‣

should return the sum of nested arrays containing both non-negative and negative integers ‣

should return 0 for empty array ‣

should accept an array with a single integer ‣

should not mutate the input array1ms ‣

should use recursion by calling self ‣

should be invoked with one argument1ms ‣

should return a boolean ‣

should not use modulo2ms ‣

should return true for even numbers ‣

should return false for odd numbers ‣

should work with negative integers ‣

should use recursion by calling self ‣

should be invoked with one argument0ms ‣

should return a number ‣

should return the sum of non-negative integers below given integer ‣

should return the sum of negative integers above given negative integer ‣

should use recursion by calling self ‣

should be invoked with one argument1ms ‣

should return an array ‣

should return the integers between two numbers ‣

should return empty array if no integers in range ‣

should accept negative integers ‣

should accept starting integer that's larger than ending ‣

should use recursion by calling self ‣

should be invoked with two arguments0ms ‣

should return a number ‣

should not use complex math0ms ‣

should compute exponent of non-negative integers ‣

returns 1 when exponent is 0 ‣

returns base when exponent is 1 ‣

should accept negative integer for exponent ‣

should use recursion by calling self ‣

should be invoked with two arguments0ms ‣

optimize for even numbers

should accept negative integer for base

should return a boolean ‣

should return true for powers of two ‣

should return false when input is not power of two ‣

should use recursion by calling self ‣

should be invoked with one argument0ms ‣

should return a string ‣

should return a string in reverse ‣

should not use native reverse method0ms ‣

should use recursion by calling self ‣

should be invoked with one argument1ms ‣

should return a boolean ‣

should not use native reverse method0ms ‣

should return true for palindromes ‣

should return false for non-palindromes ‣

should ignore spaces and capital letters ‣

should use recursion by calling self ‣

should be invoked with one argument0ms ‣

should return a number ‣

should not use complex math2ms ‣

should return the remainder of two integers ‣

should accept negative integers ‣

should use recursion by calling self ‣

should be invoked with two arguments0ms ‣

should return a number ‣

should not use complex math2ms ‣

should return the product of two positive integers ‣

should return the product of two negative integers ‣

should return the product of mixed positive and negative integers ‣