Aug 22, 2020 · Aug 20, 2020 · Aug 20, 2020 · Aug 20, 2020 · Aug 20, 2020 · Aug 20, 2020
diff --git a/book/D-interview-questions-solutions.asc b/book/D-interview-questions-solutions.asc
diff --git a/book/content/part02/array.asc b/book/content/part02/array.asc
diff --git a/book/interview-questions/max-subarray.data.js b/book/interview-questions/max-subarray.data.js
diff --git a/book/interview-questions/max-subarray.js b/book/interview-questions/max-subarray.js
diff --git a/book/interview-questions/max-subarray.spec.js b/book/interview-questions/max-subarray.spec.js
diff --git a/book/interview-questions/rotate-array-left.spec.js b/book/interview-questions/rotate-array-left.spec.js
diff --git a/.../interview-questions/rotate-array-left.js → lab/exercises/01-arrays/rotate-array-left.js b/.../interview-questions/rotate-array-left.js → lab/exercises/01-arrays/rotate-array-left.js
diff --git a/lab/exercises/01-arrays/rotate-array-left.spec.js b/lab/exercises/01-arrays/rotate-array-left.spec.js
diff --git a/package.json b/package.json
Original file line number	Diff line number	Diff line change
Expand Up		@@ -6,32 +6,42 @@
		=== Solutions for Array Questions
		(((Interview Questions Solutions, Arrays)))

	==== Rotate Left
	include::content/part02/array.asc[tag=array-q-rotate-left]
	==== Max Subarray [[array-q-max-subarray]]
	include::content/part02/array.asc[tag=array-q-max-subarray]

	We are asked to rotate an array multiple times (`k`).
	The first step, is making sure we understand the problem well. Let's do a basic examples:

	One brute force solution, would be removing the first element and appending it to the end `k` times:
	----
	A = [-5, 6, 9, -8]
	B = [-1, 6, -3, 8]
	----

	What's the subarrays with the maximum sum? For A, it will be `[6, 9]` and for B it will be `[6, -3, 8]`.

	One intution could be to generate all possible subarrays, add them up and then pick the max number.

		[source, javascript]
		----
	include::interview-questions/rotate-array-left.js[tag=bruteForce]
	include::interview-questions/max-subarray.js[tag=maxSubArrayBrute1]
		----

	However, what would happen if the array is huge (millions of elements)?
	How efficient will be if `k` number is large (thousands)?

	When k is bigger than the array, it will loop back over and over again. We can avoid extra computation by calculating the final place using modulus.
	This is a simple to understand however not very efficient. The runtime is `O(n^3)`.

	Here's the final solution:
	If you noticed we adding up the numbers from `i` to `j` on each cycle. But, we can optimize this. We can keep a local variable and add the new number to it. That way we don't have to revisit previous numebers again.

		[source, javascript]
		----
	include::interview-questions/rotate-array-left.js[tag=description]
	include::interview-questions/rotate-array-left.js[tag=solution]
	include::interview-questions/max-subarray.js[tag=maxSubArrayBrute2]
		----

	It runs on `O(n^2)` while the brute force solution was doing `O(n^2 * k)`.
	The runtime is much better: `O(n)`. Can we still do better?

	We can use a greedy approach, where do one pass through the array. We only add the numbers if their sum is larger than just taking the current element.

	[source, javascript]
	----
	include::interview-questions/max-subarray.js[tag=description]
	include::interview-questions/max-subarray.js[tag=solution]
	----

	==== Sum
	include::content/part02/array.asc[tag=array-sum]
	The runtime is `O(n)`! and a space complexity of `O(1)`.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,7 +4,7 @@ ifndef::imagesdir[]
		endif::[]

		[[array]]
	=== Array
	=== Array [[array-chap]]
		(((Array)))
		(((Data Structures, Linear, Array)))
		Arrays are one of the most used data structures. You probably have used it a lot but are you aware of the runtimes of `splice`, `shift`, `indexOf` and other operations? In this chapter, we are going deeper into the most common operations and their runtimes.
Expand Down Expand Up		@@ -279,35 +279,18 @@ To sum up, the time complexity of an array is:
		==== Interview Questions
		(((Interview Questions, Arrays)))

	// tag::array-q-rotate-left[]
	1) Implement an efficient algorithm that rotate an array `a` an `k` number of times.
	===== Max Subarray
	// tag::array-q-max-subarray[]
	Given an array of integers, find the maximum sum of consecutive elements (subarray).
	// end::array-q-max-subarray[]

		[source, javascript]
		----
	include::../../interview-questions/rotate-array-left.js[tag=description]
	include::../../interview-questions/max-subarray.js[tag=description]
		// write you code here
		}
		----
	// end::array-q-rotate-left[]

	// tag::array-sum[]
	2) Implement an algorithm that takes two arrays of numbers and return a new array with the sum.
	_Solution: <<array-q-max-subarray>>_

	[source, javascript]
	----
	/**
	* Return the sum of two arrays as a new array.
	*
	* @example
	* sum([1,2,3], [1,1,1]); // [2,3,4]
	* sum([1], [9,9,9]); // [1,0,0,0]
	*
	* @param {number[]} a - Array of numbers.
	* @param {number[]} b - Array of numbers.
	* @returns {number[]} the sum array.
	*/
	function sum(a, b) {
	// write you code and test with examples
	}
	----
	// end::array-sum[]
	// https://leetcode.com/problemset/algorithms/?topicSlugs=array
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,54 @@
	// tag::description[]
	/**
	* Find the maximun sum of contiguous elements in an array.
	* @examples
	* maxSubArray([1, -3, 10, -5]); // => 10
	* maxSubArray([-3,4,-1,2,1,-5]); // => 6
	* @param {number[]} a - Array
	*/
	function maxSubArray(a) {
	// end::description[]
	// tag::solution[]
	let max = -Infinity;
	let local = 0;

	a.forEach((n) => {
	local = Math.max(n, local + n);
	max = Math.max(max, local);
	});

	return max;
	}
	// end::solution[]

	// tag::maxSubArrayBrute1[]
	function maxSubArrayBrute1(nums) {
	let max = -Infinity;

	for (let i = 0; i < nums.length; i++) { // O(n^3)
	for (let j = i + 1; j <= nums.length; j++) { // O(n^2)
	const sum = nums.slice(i, j).reduce((a, n) => n + a, 0); // O(n)
	max = Math.max(max, sum); // O(1)
	}
	}

	return max;
	}
	// end::maxSubArrayBrute1[]

	// tag::maxSubArrayBrute2[]
	function maxSubArrayBrute2(nums) {
	let max = -Infinity;

	for (let i = 0; i < nums.length; i++) { // O(n) * O(n)
	let local = 0;
	for (let j = i; j < nums.length; j++) { // O(n)
	local += nums[j];
	max = Math.max(max, local);
	}
	}
	return max;
	}
	// end::maxSubArrayBrute2[]

	module.exports = { maxSubArrayBrute1, maxSubArrayBrute2, maxSubArray };
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,16 @@
	const { maxSubArray, maxSubArrayBrute1, maxSubArrayBrute2 } = require('./max-subarray');
	const largeArray = require('./max-subarray.data');

	describe('Max Subarray Sum', () => {
	[maxSubArray, maxSubArrayBrute1, maxSubArrayBrute2].forEach((fn) => {
	describe(`with ${fn.name}`, () => {
	it('should work with small arrays', () => {
	expect(fn([-2, 1, -3, 4, -1, 2, 1, -5, 4])).toEqual(6);
	});

	it('should work with large arrays', () => {
	expect(fn(largeArray)).toEqual(4853);
	});
	});
	});
	});
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,23 @@
	const { rotateLeft, rotateLeftBruteForce } = require('./rotate-array-left');

	const largeArray = Array(1e6).fill(1).map((t) => t * Math.random());

	[rotateLeft, rotateLeftBruteForce].forEach((fn) => {
	xdescribe(`Rotate Left ${fn.name}`, () => {
	describe('when data is small', () => {
	it('should work with 1', () => {
	expect(fn([1, 2, 3], 1)).toEqual([2, 3, 1]);
	});

	it('should work with 4', () => {
	expect(fn([1, 2, 3, 4, 5], 4)).toEqual([5, 1, 2, 3, 4]);
	});
	});

	xdescribe('when data is large', () => {
	it('should work at scale', () => {
	expect(fn(largeArray, 75863)).toEqual(largeArray);
	});
	});
	});
	});
Original file line number	Diff line number	Diff line change
Expand Up		@@ -13,8 +13,8 @@
		"src/*/.js"
		],
		"scripts": {
	"test": "jest",
	"watch": "jest --watch --coverage",
	"test": "jest --verbose",
	"watch": "jest --watch --verbose --coverage",
		"coverage": "jest --coverage && open coverage/lcov-report/index.html",
		"coverage:win": "jest --coverage && cmd.exe /C start coverage/lcov-report/index.html",
		"lint": "npx eslint --fix --format codeframe src/",
Expand Down