University of Washington Seattle, 2014
33 |BS in Informatics: Human-Computer Interaction (HCI)
34 |I've been programming for over 10 years and have worked professionally as a full stack software engineer specializing in web technology since graduating college in 2014.
36 |Some companies I've worked at include Microsoft, education nonprofit Code.org, casual game company Zhurosoft, and sports software company Fencing Time. I program up and down the stack in frameworks including Ruby on Rails, C#/ASP.NET, Express, and Angular. Some of my professional work includes an email-HTML templating system, internal automation tools, and data front-ends.
37 |captainstack@gmail.com
Schedule an appointment
GitHub
Stack Overflow
59 | JavaScript functions are loaded into this page and can be run from the browser console.
38 |solutions_will_be_displayed_here(input) {
90 | // Problems will be specified in comments.
91 | } blocks are highlighted multiple times. It is necessary
714 | * to cleanup any left-over tags, because the whitespace inside of the
715 | * tags change the content of the tag.
716 | */
717 | var num = 0;
718 | $$('.line-highlight', pre).forEach(function (line) {
719 | num += line.textContent.length;
720 | line.parentNode.removeChild(line);
721 | });
722 |
723 | // Remove extra whitespace
724 | if (num && /^( \n)+$/.test(env.code.slice(-num))) {
725 | env.code = env.code.slice(0, -num);
726 | }
727 | });
728 |
729 | Prism.hooks.add('complete', function(env) {
730 | var pre = env.element.parentNode;
731 | var lines = pre && pre.getAttribute('data-line');
732 |
733 | if (!pre || !lines || !/pre/i.test(pre.nodeName)) {
734 | return;
735 | }
736 |
737 | clearTimeout(fakeTimer);
738 |
739 | highlightLines(pre, lines);
740 |
741 | fakeTimer = setTimeout(applyHash, 1);
742 | });
743 |
744 | if(window.addEventListener) {
745 | window.addEventListener('hashchange', applyHash);
746 | }
747 |
748 | })();
749 |
750 | (function() {
751 |
752 | if (typeof self === 'undefined' || !self.Prism || !self.document) {
753 | return;
754 | }
755 |
756 | Prism.hooks.add('complete', function (env) {
757 | if (!env.code) {
758 | return;
759 | }
760 |
761 | // works only for wrapped inside (not inline)
762 | var pre = env.element.parentNode;
763 | var clsReg = /\s*\bline-numbers\b\s*/;
764 | if (
765 | !pre || !/pre/i.test(pre.nodeName) ||
766 | // Abort only if nor the nor the have the class
767 | (!clsReg.test(pre.className) && !clsReg.test(env.element.className))
768 | ) {
769 | return;
770 | }
771 |
772 | if (env.element.querySelector(".line-numbers-rows")) {
773 | // Abort if line numbers already exists
774 | return;
775 | }
776 |
777 | if (clsReg.test(env.element.className)) {
778 | // Remove the class "line-numbers" from the
779 | env.element.className = env.element.className.replace(clsReg, '');
780 | }
781 | if (!clsReg.test(pre.className)) {
782 | // Add the class "line-numbers" to the
783 | pre.className += ' line-numbers';
784 | }
785 |
786 | var match = env.code.match(/\n(?!$)/g);
787 | var linesNum = match ? match.length + 1 : 1;
788 | var lineNumbersWrapper;
789 |
790 | var lines = new Array(linesNum + 1);
791 | lines = lines.join('');
792 |
793 | lineNumbersWrapper = document.createElement('span');
794 | lineNumbersWrapper.setAttribute('aria-hidden', 'true');
795 | lineNumbersWrapper.className = 'line-numbers-rows';
796 | lineNumbersWrapper.innerHTML = lines;
797 |
798 | if (pre.hasAttribute('data-start')) {
799 | pre.style.counterReset = 'linenumber ' + (parseInt(pre.getAttribute('data-start'), 10) - 1);
800 | }
801 |
802 | env.element.appendChild(lineNumbersWrapper);
803 |
804 | });
805 |
806 | }());
807 |
--------------------------------------------------------------------------------
/object-instances/sample_arrays.js:
--------------------------------------------------------------------------------
1 | let basic_list = [1, 2, 3, 4, 5, 6, 7, 8];
2 | let moderate_list = [3, 4, 5, 7, 9, 14, 15, 16, 17, 18, 20];
3 | let complex_list = [-3, -1, 0, 1, 2, 4, 99];
4 |
5 | let A = [1, 1, 3, 7, 8, 9, null, null, null, null, null, null];
6 | let B = [2, 3, 5, 5, 6, 10];
7 |
8 | let character_array = 'Mr John Smith '.split('');
9 |
10 | // Stacks
11 | let mixed_order = [1, 6, 3, 4, 5, 2];
12 | let sorted_order = [10, 9, 8, 7, 6, 5];
13 | let reverse_sorted = [90, 91, 92, 93, 94, 95];
14 |
15 | // Matricies
16 | let four_by_four = [[0, 0, 0, 0], [1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]];
17 | let three_by_three = [[9, 2, 1], [8, 4, 2], [7, 6, 3]];
--------------------------------------------------------------------------------
/object-instances/sample_graphs.js:
--------------------------------------------------------------------------------
1 | let graph_without_cycles = GraphNode("A");
2 | let b_node = GraphNode("B");
3 | let c_node = GraphNode("C");
4 | let d_node = GraphNode("D");
5 | b_node.children = [c_node, d_node];
6 | c_node.children = [d_node];
7 | graph_without_cycles.children = [b_node, c_node];
8 |
9 | let graph_with_cycle = GraphNode("1");
10 | let two_node = GraphNode("2");
11 | let three_node = GraphNode("3");
12 | let four_node = GraphNode("4");
13 | two_node.children = [three_node];
14 | three_node.children = [four_node];
15 | four_node.children = [two_node];
16 | graph_with_cycle.children = [two_node];
17 |
18 | let single_node_graph = GraphNode("S");
19 |
--------------------------------------------------------------------------------
/object-instances/sample_linked_lists.js:
--------------------------------------------------------------------------------
1 | let list_with_duplicates = ListNode(1);
2 | list_with_duplicates.appendTail(ListNode(1));
3 | list_with_duplicates.appendTail(ListNode(2));
4 | list_with_duplicates.appendTail(ListNode(2));
5 | list_with_duplicates.appendTail(ListNode(3));
6 | list_with_duplicates.appendTail(ListNode(3));
7 |
8 | let single_node_list = ListNode(0);
9 |
10 | let all_duplicates = ListNode(7);
11 | all_duplicates.appendTail(ListNode(7));
12 | all_duplicates.appendTail(ListNode(7));
13 | all_duplicates.appendTail(ListNode(7));
14 | all_duplicates.appendTail(ListNode(7));
15 |
16 | let ten_node_list = ListNode(0);
17 | ten_node_list.appendTail(ListNode(1));
18 | ten_node_list.appendTail(ListNode(2));
19 | ten_node_list.appendTail(ListNode(3));
20 | ten_node_list.appendTail(ListNode(4));
21 | ten_node_list.appendTail(ListNode(5));
22 | ten_node_list.appendTail(ListNode(6));
23 | ten_node_list.appendTail(ListNode(7));
24 | ten_node_list.appendTail(ListNode(8));
25 | ten_node_list.appendTail(ListNode(9));
26 |
27 | let unordered_list = ListNode(5);
28 | unordered_list.appendTail(ListNode(10));
29 | unordered_list.appendTail(ListNode(2));
30 | unordered_list.appendTail(ListNode(6));
31 | unordered_list.appendTail(ListNode(3));
32 | unordered_list.appendTail(ListNode(3));
33 | unordered_list.appendTail(ListNode(7));
34 |
35 | let reverse_ordered_list = ListNode(10);
36 | reverse_ordered_list.appendTail(ListNode(9));
37 | reverse_ordered_list.appendTail(ListNode(8));
38 | reverse_ordered_list.appendTail(ListNode(7));
39 | reverse_ordered_list.appendTail(ListNode(6));
40 | reverse_ordered_list.appendTail(ListNode(5));
41 | reverse_ordered_list.appendTail(ListNode(4));
42 | reverse_ordered_list.appendTail(ListNode(3));
43 | reverse_ordered_list.appendTail(ListNode(2));
44 | reverse_ordered_list.appendTail(ListNode(1));
45 | reverse_ordered_list.appendTail(ListNode(0));
46 |
47 | let addend_1 = ListNode(7);
48 | addend_1.appendTail(ListNode(1));
49 | addend_1.appendTail(ListNode(6));
50 |
51 | let addend_2 = ListNode(5);
52 | addend_2.appendTail(ListNode(9));
53 | addend_2.appendTail(ListNode(2));
54 |
55 | let addend_3 = ListNode(2);
56 | addend_3.appendTail(ListNode(9));
57 | addend_3.appendTail(ListNode(0));
58 | addend_3.appendTail(ListNode(1));
59 |
60 | let addend_4 = ListNode(7);
61 | addend_4.appendTail(ListNode(3));
62 |
63 | let palindrome_list = ListNode('r');
64 | palindrome_list.appendTail(ListNode('a'));
65 | palindrome_list.appendTail(ListNode('c'));
66 | palindrome_list.appendTail(ListNode('e'));
67 | palindrome_list.appendTail(ListNode('c'));
68 | palindrome_list.appendTail(ListNode('a'));
69 | palindrome_list.appendTail(ListNode('r'));
70 |
71 | let intersecting_list_1 = ListNode('a');
72 | intersecting_list_1.appendTail(ListNode('b'));
73 | let c_link = ListNode('c');
74 | intersecting_list_1.appendTail(c_link);
75 | intersecting_list_1.appendTail(ListNode('d'));
76 | intersecting_list_1.appendTail(ListNode('e'));
77 |
78 | let intersecting_list_2 = ListNode(1);
79 | intersecting_list_2.appendTail(ListNode(2));
80 | intersecting_list_2.appendTail(ListNode(3));
81 | intersecting_list_2.appendTail(ListNode(4));
82 | intersecting_list_2.appendTail(ListNode(5));
83 | intersecting_list_2.appendTail(c_link);
84 |
--------------------------------------------------------------------------------
/object-instances/sample_strings.js:
--------------------------------------------------------------------------------
1 | let valid_source_code = '[[abc]][({Andre Stackhouse})]0';
2 | // 012345678901234567890123456789
3 | let improper_nesting = '12([)]444';
4 | // 012345678
5 | let wrong_closing_bracket = '[a](3){#$}[)';
6 | // 012345678901
7 | let unclosed_bracket = '[][(){}';
8 | // 0123456
9 | let no_braces = 'abcdefg';
10 | // 0123456
11 |
12 | let note = "I have your daughter";
13 | let string_repo = "I have your daughter and her birthday present";
14 |
15 |
--------------------------------------------------------------------------------
/object-instances/sample_trees.js:
--------------------------------------------------------------------------------
1 | // Single node tree
2 | let single_node = TreeNode(10);
3 |
4 | // Valid BST
5 | let valid_bst = TreeNode(8);
6 | valid_bst.left = TreeNode(5);
7 | valid_bst.right = TreeNode(11);
8 |
9 | valid_bst.left.left = TreeNode(2);
10 | let shallow_left = TreeNode(7);
11 | valid_bst.left.right = shallow_left;
12 |
13 | valid_bst.left.left.right = TreeNode(4);
14 | let far_left_node = TreeNode(3);
15 | valid_bst.left.left.right.left = far_left_node;
16 |
17 | valid_bst.right.left = TreeNode(10);
18 | valid_bst.right.right = TreeNode(18);
19 |
20 | let close_to_bottom = TreeNode(20);
21 | valid_bst.right.right.right = close_to_bottom;
22 |
23 | // Invalid BST
24 | let invalid_bst = TreeNode(8);
25 | invalid_bst.left = TreeNode(4);
26 | invalid_bst.right = TreeNode(10);
27 |
28 | invalid_bst.left.left = TreeNode(2);
29 | invalid_bst.left.right = TreeNode(12);
30 |
31 | invalid_bst.right.right = TreeNode(20);
32 |
--------------------------------------------------------------------------------
/portfolio/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Portfolio | Public Stackhouse
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 | Public Stack<House>
20 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 | Environmental Enforcement Watch
36 | 
37 | A citizen science data project from EDGI
38 | Built with: Gatsby, React
39 | Built for: Environmental Data Governance Initiative (EDGI).
40 |
41 |
42 | View code on GitHub
43 |
44 |
45 |
46 | Chromattis
47 | 
48 | A simple, fun, and challenging 2D puzzle game.
49 | Built with: React, Redux, CSS Grid
50 | Built for: Fans of puzzles like 2048 and the Rubicks cube.
51 |
52 |
53 | View code on GitHub
54 |
55 |
56 |
57 |
58 | Overcomp
59 | 
60 | A tool for optimizing team composition for the video game Overwatch.
61 | Built with: React, Redux, Flexbox
62 | Built for: A fun tool for the Overwatch community
63 |
64 |
65 | View code on GitHub
66 |
67 |
68 |
69 |
70 | Code.org/promote
71 | 
72 | An interactive infographic to help spread awareness of computer science jobs, legislation, and education.
73 | Built with: Sinatra, jQuery, Raphael
74 | Built for: Code.org's outreach team
75 |
76 |
77 | View code on GitHub
78 |
79 |
80 |
81 |
82 | Chess Scouter
83 | 
84 | A chess training tool that helps players learn chess tactics through active visualization overlayed on a chess board.
85 | Built with: JavaScript, jQuery, CSS
86 | Built for: Informatics senior capstone
87 |
88 |
89 | View code on GitHub
90 |
91 |
92 |
103 |
104 |
115 |
116 |
117 |
118 |
138 |
139 |
140 |
141 |
--------------------------------------------------------------------------------
/resume/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Resume | Public Stackhouse
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | Public Stack<House>
17 |
25 |
26 |
27 |
28 |
29 |
30 | 
31 |
32 |
33 |
34 | [Download .docx]
35 | [Download .PDF]
36 |
37 |
38 |
58 |
59 |
60 |
61 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/01-02-check_permutation.js:
--------------------------------------------------------------------------------
1 | function check_permutation(word1, word2) {
2 | // Cracking the Coding Interview problem 1.2
3 | // Given two strings, write a method to decide if one is a permutation of the other
4 |
5 | let character_map = new Map();
6 | for (character of word1) {
7 | let quantity = character_map.get(character);
8 | character_map.set(character, quantity + 1 || 1);
9 | }
10 | for (character of word2) {
11 | let quantity = character_map.get(character);
12 | if (!quantity || quantity < 1) {
13 | return false;
14 | } else {
15 | character_map.set(character, quantity - 1);
16 | }
17 | }
18 | for (value of character_map.values()) {
19 | if (value > 0) {
20 | return false;
21 | }
22 | }
23 | return true;
24 | }
25 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/01-03-urlify.js:
--------------------------------------------------------------------------------
1 | function urlify(character_array, actual_length) {
2 | // Write a method to replace all spaces in a string with '%20'. You may assume that the string has
3 | // sufficient space at the end to hold the additional characters, and that you are given the "true"
4 | // length of the string. Use a character array so that you can perform this operation in place.
5 | // EXAMPLE: (input: "Mr John Smith ", 13) (output: "Mr%20John%20Smith")
6 |
7 | let current_string_index = actual_length - 1;
8 | let swap_index = character_array.length - 1;
9 |
10 | while (current_string_index >= 0) {
11 | if (character_array[current_string_index] !== ' ') {
12 | character_array.swap(current_string_index, swap_index);
13 | current_string_index--;
14 | swap_index--;
15 | } else {
16 | character_array[swap_index] = '0';
17 | character_array[swap_index - 1] = '2';
18 | character_array[swap_index - 2] = '%';
19 | current_string_index--;
20 | swap_index -= 3;
21 | }
22 | }
23 | return character_array;
24 | }
25 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/01-05-one_away.js:
--------------------------------------------------------------------------------
1 | function one_away(s1, s2) {
2 | // Cracking the Coding Interview 1.5
3 | // There are three types of edits that can be performed on strings: insert a character, remove a
4 | // character, or replace a character. Given two strings, write a function to check if they are one
5 | // edit (or zero edits) away.
6 | // EXAMPLE
7 | // pale, ple -> true
8 | // pales, pale -> true
9 | // pale, bale -> true
10 | // pale, bake -> false
11 |
12 | s1_length = s1.length;
13 | s2_length = s2.length;
14 | // If one string is more than a character longer, then one operation cannot make them equivalent.
15 | if (Math.abs(s1_length - s2_length) > 1) {
16 | return false;
17 | } else {
18 | let i = 0;
19 | // Find the index of the first string difference.
20 | while (s1.charAt(i) === s2.charAt(i) && (i < s1_length) && (i < s2_length)) {
21 | i++;
22 | }
23 | // If the strings are the same length, and the strings are identical after i,
24 | // then a single replace edit will make them equivalent.
25 | if (s1_length === s2_length) {
26 | return s2.slice(i + 1, s2_length) === s1.slice(i + 1, s1_length);
27 | } else {
28 | // Remove the character at i from the longer string.
29 | // Remove and insert can be caught with one test.
30 | s1_length > s2_length ?
31 | s1 = s1.slice(0, i) + s1.slice(i + 1, s1_length) :
32 | s2 = s2.slice(0, i) + s2.slice(i + 1, s2_length);
33 | return s1 === s2;
34 | }
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/01-06-string_compression.js:
--------------------------------------------------------------------------------
1 | function string_compression(string) {
2 | // Cracking the Coding Interview 1.6
3 | // Implement a method to perform basic string compression using the counts of repeated characters.
4 | // For example, the string aabcccccaaa would become a2b3c5a3. If the "compressed" string would
5 | // not become smaller than the original string, your method should return the original string. You
6 | // can assume the string has only uppercase and lowercase letters (a-z).
7 |
8 | let current_character = string.charAt(0);
9 | let character_count = 0;
10 | let original_length = string.length;
11 | let new_string = '';
12 |
13 | for (character of string) {
14 | if (new_string.length >= original_length) {
15 | return string;
16 | } else if (character !== current_character) {
17 | new_string += current_character + character_count;
18 | current_character = character;
19 | character_count = 1;
20 | } else {
21 | character_count += 1;
22 | }
23 | }
24 | new_string += current_character + character_count;
25 | return new_string.length < original_length ? new_string : string;
26 | }
27 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/01-07-rotate_matrix.js:
--------------------------------------------------------------------------------
1 | function rotate_matrix(matrix) {
2 | // Cracking the Coding Interview 1.7
3 | // Given an image represented by an NxN matrix, where each pixel in the image is 4 bytes,
4 | // write a method to rotate the image by 90 degrees. Can you do this in place?
5 |
6 | let m_index = matrix.length - 1;
7 | let rotated_matrix = [];
8 | for (let i = 0; i <= m_index; i++) {
9 | rotated_matrix.push([]);
10 | }
11 |
12 | for (let [i, row] of matrix.entries()) {
13 | for (let [j, value] of row.entries()) {
14 | rotated_matrix[m_index - (m_index - j)][m_index - i] = value;
15 | }
16 | }
17 | return rotated_matrix;
18 | }
19 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/01-08-zero_matrix.js:
--------------------------------------------------------------------------------
1 | function zero_matrix(matrix) {
2 | // Cracking the Coding Interview 1.8
3 | // Write an algorithm such that if an element in an MxN matrix is 0,
4 | // its entire row and column are set to 0.
5 |
6 | let zero_rows = [];
7 | let zero_columns = [];
8 |
9 | // Find the row and column of every 0 in the original matrix
10 | for (let [r, row] of matrix.entries()) {
11 | for (let [c, value] of row.entries()) {
12 | if (value === 0) {
13 | zero_rows.push(r);
14 | zero_columns.push(c);
15 | }
16 | }
17 | }
18 | // Iterate through the matrix and replace the appropriate values with 0
19 | for (let [r, row] of matrix.entries()) {
20 | for (let [c, value] of row.entries()) {
21 | if (zero_rows.includes(r) || zero_columns.includes(c)) {
22 | matrix[r][c] = 0;
23 | }
24 | }
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/01-09-string_rotation.js:
--------------------------------------------------------------------------------
1 | function string_rotation(s1, s2) {
2 | // Assume you have a method isSubstring which checks if one word is a substring of another. Given two
3 | // strings, s1 and s2, write code to check if s2 is a rotation of s1 using only one call to isSubstring
4 | // (e.g., "waterbottle" is a rotation of "erbottlewat").
5 |
6 | let s2_sub = s2;
7 | let pivot_index = 0;
8 | while (s1.indexOf(s2_sub) === -1 && s2_sub.length > 0) {
9 | s2_sub = s2_sub.slice(1);
10 | pivot_index++;
11 | }
12 | return s1.replace(s2_sub, '') === s2.slice(0, pivot_index);
13 | }
14 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/corresponding_bracket_index.js:
--------------------------------------------------------------------------------
1 | function corresponding_bracket_index(source_code, caret_index) {
2 | // Write a function that takes a string that represents source code and an int that represents a
3 | // caret index in the source code. If the caret index is pointed at a bracket, curly brace, or
4 | // parenthesis, return the index of the corresponding brace.
5 |
6 | // Throw error if caret_index is not pointing to a bracket
7 | if (!'(){}[]'.includes(source_code[caret_index])) {
8 | throw new Error('Invalid caret index. Caret must point to a bracket.');
9 | }
10 |
11 | // Store the indexes of opening brackets that have not been closed
12 | let active_opening_brackets = [];
13 | let corresponding_index;
14 |
15 | for (let current_index = 0; current_index < source_code.length; current_index++) {
16 | let character = source_code.charAt(current_index);
17 | if (character === '[' || character === '(' || character === '{') {
18 | active_opening_brackets.push({index: current_index, type: character});
19 | } else if (character === ']' || character === ')' || character === '}') {
20 | let last_active_opening_bracket = active_opening_brackets.pop();
21 |
22 | // Throw an error if closing brackets are not properly nested within opening ones
23 | // Or if a closing bracket does not have a corresponding opening one.
24 | if (!last_active_opening_bracket||
25 | character === ']' && last_active_opening_bracket.type != '[' ||
26 | character === ')' && last_active_opening_bracket.type != '(' ||
27 | character === '}' && last_active_opening_bracket.type != '{') {
28 | throw new Error('Invalid brackets in source code.');
29 | }
30 |
31 | if (last_active_opening_bracket.index === caret_index) {
32 | // If you reach a closing bracket and the last active opening bracket is at the caret,
33 | // Then the closing bracket you have reached is the corresponding closing bracket
34 | corresponding_index = current_index;
35 | } else if (current_index === caret_index) {
36 | // If the closing bracket is at the caret,
37 | // then the corresponding opening one is the last active opening bracket
38 | corresponding_index = last_active_opening_bracket.index;
39 | }
40 | // If neither conditional is met, deactivate the last active opening bracket by removing
41 | // it from the stack of active opening brackets. Continue to iterate through the source code.
42 | }
43 | }
44 |
45 | // Throw error if any brackets are unclosed
46 | if (!active_opening_brackets.isEmpty()) {
47 | throw new Error('Unclosed brackets in source code.');
48 | } else {
49 | return corresponding_index;
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/is_saturated.js:
--------------------------------------------------------------------------------
1 | function is_saturated(range_array, head, tail) {
2 | // Write a function that takes an array of integer ranges, and an upper and lower bound.
3 | // It returns true if the ranges in the array include every value within the bounds.
4 | // It returnsfalse if any of the following conditions are met:
5 | // 1. The ranges do not cover every value between head and tail.
6 | // 2. Any ranges include values outside of head and tail.
7 | // 3. Any ranges overlap. The ranges are inclusive, but it is okay if they overlap at their edges.
8 |
9 | // EXAMPLES:
10 | // is_saturated([range(0, 5), range(5, 10)], 0, 10) -> true
11 | // is_saturated([range(0, 5), range(6, 10)], 0, 10) -> true
12 | // is_saturated([range(0, 5), range(3, 10)], 0, 10) -> false
13 | // is_saturated([range(0, 11)], 0, 10) -> false
14 |
15 | // Store the number of times a value has been encountered in encountered_values at the index of value.
16 | // E.g. let times_value_encountered = encountered_values[value];
17 | let encountered_values = [];
18 |
19 | // Iterate through each range and check that its values are within head and tail.
20 | for (let range of range_array) {
21 | if (range.start < head || range.end > tail) {
22 | return false;
23 | } else {
24 | for (let i = range.start; i <= range.end; i++) {
25 | encountered_values[i] ? encountered_values[i] += 1 : encountered_values[i] = 1;
26 | if (encountered_values[i] == 2 && (encountered_values[i - 1] === 2 ||
27 | encountered_values[i + 1] === 2)) {
28 | return false;
29 | }
30 | }
31 | }
32 | }
33 |
34 | for (let i = head; i <= tail; i++) {
35 | let quantity = encountered_values[i];
36 | if (!quantity) {
37 | return false;
38 | }
39 | }
40 | return true;
41 | }
42 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/pretty_print.js:
--------------------------------------------------------------------------------
1 | function pretty_print(string) {
2 | /* Write a function that takes a string of curly braces and letters and prints a reformatted version
3 | in which the brackets sit on their own line and subsequent content is indented one level per bracket
4 | Example input:
5 | test1{test2}
6 |
7 | Would become:
8 | test1
9 | {
10 | test2
11 | }
12 | */
13 |
14 | let output_string = '';
15 | let indentation = '';
16 | let last_char = '';
17 | let active_opening_brackets = [];
18 |
19 | for (let char of string) {
20 | if (char !== '{' && char !== '}') {
21 | if (last_char === '{' || last_char === '}') {
22 | output_string += "\n";
23 | output_string += indentation;
24 | }
25 | output_string += char;
26 | } else if (char === '{') {
27 | output_string += "\n";
28 | active_opening_brackets.push(char);
29 | output_string += indentation;
30 | output_string += char;
31 | indentation += ' ';
32 | } else if (char === '}') {
33 | if (active_opening_brackets.pop()) {
34 | output_string += "\n";
35 | indentation = indentation.slice(0, indentation.length - 2);
36 | output_string += indentation;
37 | output_string += char;
38 | } else {
39 | return;
40 | }
41 | }
42 | last_char = char;
43 | }
44 | if (active_opening_brackets.length === 0) {
45 | console.log(output_string);
46 | } else {
47 | return;
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/print_combinations.js:
--------------------------------------------------------------------------------
1 | function print_combinations() {
2 | // Write a function that prints all possible "combinations" to a lock in which a valid combination
3 | // is a four digit number that represents a month and day e.g. 0123 corresponds to January 23rd
4 | // a valid combination cannot have two repeating digits. Assume all months have 31 days.
5 |
6 | // Loop through months and days
7 | for (let i = 1; i <= 12; i++) {
8 | // November will never be valid because of repeating digits
9 | if (i === 11) {
10 | continue;
11 | }
12 | for (let j = 1; j <= 31; j++) {
13 | // Create both digits for day and month
14 | let m1 = Math.floor(i / 10);
15 | let m2 = i % 10;
16 | let d1 = Math.floor(j /10);
17 | let d2 = j % 10;
18 |
19 | // Check that no two digits are the same.
20 | // Only four digits means a Set would be too resource intensive
21 | if (!(m1 === m2 || m1 === d1 || m1 === d2 ||
22 | m2 === d1 || m2 === d2 || d1 === d2)) {
23 | console.log(m1 + "" + m2 + "" + d1 + "" + d2);
24 | }
25 | }
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/ransom_note.js:
--------------------------------------------------------------------------------
1 | function ransom_note(note, string_repo) {
2 | // Given a string, a "ransom note," and a second string, a "collection of newspapers/magazines,"
3 | // write a function that returns true if the second string contains the correct collection of
4 | // characters such that the ransom note can be recreated and return false otherwise.
5 |
6 | // Helper to convert a string into a map of characters to number of instances
7 | let convert_string_to_character_map = (string) => {
8 | let character_map = new Map();
9 | for (let character of string) {
10 | let quantity = character_map.get(character) || 0;
11 | character_map.set(character, quantity + 1);
12 | }
13 | return character_map;
14 | }
15 |
16 | // Helper to check if a map has no values over 0
17 | let map_is_empty = (map) => {
18 | let values = map.values();
19 | for (let value of values) {
20 | if (value > 0) {
21 | return false;
22 | }
23 | }
24 | return true;
25 | }
26 |
27 | let note_character_map = convert_string_to_character_map(note);
28 |
29 | // Iterate through the string repo and remove characters from the character map one at a time if
30 | // they were in the original ransom note. If the map is successfully emptied, the note can be
31 | // recreated and the function returns true.
32 | for (let character of string_repo) {
33 | if (map_is_empty(note_character_map)) {
34 | return true;
35 | } else {
36 | let quantity = note_character_map.get(character);
37 | if (quantity) {
38 | note_character_map.set(character, quantity - 1);
39 | }
40 | }
41 | }
42 | return false;
43 | }
44 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/sum_pairs_to_target.js:
--------------------------------------------------------------------------------
1 | function sum_pairs_to_target(values, target) {
2 | // Find all pairs of integers in an array that sum up to a given value.
3 | // Values in the integer array may repeat.
4 |
5 | // Example: [1,2,3,5,6], target value = 8
6 | // Answer:
7 | // 3 + 5 = 8
8 | // 2 + 6 = 8
9 |
10 | // Build a map of
11 | let value_map = new Map();
12 | for (let value of values) {
13 | let quantity = value_map.get(value) || 0;
14 | value_map.set(value, quantity + 1);
15 | }
16 |
17 | // Iterate through the unique values
18 | for (let value of value_map.keys()) {
19 | let search_value = target - value;
20 | let quantity = value_map.get(value) || 0;
21 |
22 | // Decrement the quantity of each value in the map as they are used
23 | value_map.set(value, quantity - 1);
24 | let search_value_quantity = value_map.get(search_value);
25 |
26 | // Log the combination if a corresponding value is found. Decrement the found value's quantity.
27 | if (search_value_quantity > 0) {
28 | value_map.set(search_value, search_value_quantity - 1);
29 | console.log(`${value} + ${search_value} = ${target}`);
30 | }
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/solutions/01-arrays-and-strings/validate_brackets.js:
--------------------------------------------------------------------------------
1 | function validate_brackets(string) {
2 | // Given a string that represents source code, write a function that checks if the braces are
3 | // properly paired and nested.
4 | // E.g. [({aa})] <- valid [(aa]) <- invalid [aa} <- invalid [hello <- invalid
5 |
6 | let brackets = [];
7 | for (character of string) {
8 | if (character === "(" || character === "{" || character === "[") {
9 | brackets.push(character);
10 | } else if (character === ")" && brackets.pop() !== "(" ||
11 | character === "}" && brackets.pop() !== "{" ||
12 | character === "]" && brackets.pop() !== "[") {
13 | return false;
14 | }
15 | }
16 | return brackets.isEmpty();
17 | }
18 |
--------------------------------------------------------------------------------
/solutions/02-linked-lists/02-01-remove_dupes.js:
--------------------------------------------------------------------------------
1 | function remove_dupes(list) {
2 | // Cracking the Coding Interview problem 2.1
3 | // Write code to remove duplicates from an unsorted linked list
4 | // FOLLOW UP: How would you solve this problem if a temporary buffer is not allowed?
5 |
6 | let encountered_nodes = new Set();
7 | let previous = list;
8 | let current = list.next;
9 | encountered_nodes.add(previous.data);
10 |
11 | while (current) {
12 | if (encountered_nodes.has(current.data)) {
13 | previous.next = current.next;
14 | current = previous.next;
15 | } else {
16 | encountered_nodes.add(current.data);
17 | previous = current;
18 | current = current.next;
19 | }
20 | }
21 | return list;
22 | }
23 |
--------------------------------------------------------------------------------
/solutions/02-linked-lists/02-02-return_kth_to_last.js:
--------------------------------------------------------------------------------
1 | function return_kth_to_last(list, k) {
2 | // Cracking the Coding Interview problem 2.2
3 | // Implement an algorithm to find the kth to last element of a singly linked list.
4 |
5 | let size = 0;
6 | let current = list;
7 | while (current) {
8 | size++;
9 | current = current.next;
10 | }
11 | let index = 0;
12 | current = list;
13 | while (index < size - k) {
14 | current = current.next;
15 | index++;
16 | }
17 | return current;
18 | }
19 |
--------------------------------------------------------------------------------
/solutions/02-linked-lists/02-03-delete_middle_node.js:
--------------------------------------------------------------------------------
1 | function delete_middle_node(list, node) {
2 | // Cracking the Coding Interview problem 2.3
3 | // Implement an algorithm to delete a node in the middle (i.e., any node but the first and last node,
4 | // not necessarily the exact middle) of a singly linked list, given only access to that node.
5 | // EXAMPLE
6 | // Input: the node c from the linked list a->b->c->d->e->f
7 | // Result: nothing is returned by the new linked list looks like a->b->d->e->f
8 |
9 | let previous = list;
10 | let current = list.next;
11 |
12 | while (current) {
13 | if (node === current) {
14 | previous.next = current.next;
15 | break;
16 | } else {
17 | previous = current;
18 | current = current.next;
19 | }
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/solutions/02-linked-lists/02-04-partition.js:
--------------------------------------------------------------------------------
1 | function partition(x, list) {
2 | // Cracking the Coding Interview 2.4
3 | // Write code to partition a linked list around a value x, such that all nodes less than x come
4 | // before all nodes greater than or exual to x. If x is contained within the list, the values of x
5 | // only need to be after the elements less than x (see below). The partition element x can appear
6 | // anywhere in the "right partition"; it does not need to appear between the left and right partitions.
7 |
8 | let right_partition;
9 | let previous = list;
10 | let current = list;
11 | let front = list;
12 | while (current) {
13 | if (current.data >= x) {
14 | if (current === front) {
15 | front = previous.next;
16 | current.next = right_partition;
17 | right_partition = current;
18 | previous = front;
19 | current = front;
20 | } else {
21 | previous.next = current.next;
22 | current.next = right_partition;
23 | right_partition = current;
24 | current = previous.next;
25 | }
26 | } else {
27 | previous = current;
28 | current = current.next;
29 | }
30 | }
31 | previous.next = right_partition;
32 | return front;
33 | }
34 |
--------------------------------------------------------------------------------
/solutions/02-linked-lists/02-05-sum_lists.js:
--------------------------------------------------------------------------------
1 | function sum_lists(addend_1, addend_2) {
2 | // Cracking the Coding Interview 2.5
3 | // You have two numbers represented by a linked list, where each node contains a single digit.
4 | // The digits are stored in reverse order, such that the 1's digit is at the head of the list. Write
5 | // a function that adds the two numbers and returns the sum as a linked list.
6 | // EXAMPLE Input: (7 -> 1 -> 6) + (5 -> 9 -> 2). That is, 617 + 295.
7 | // Output: 2 -> 1 -> 9. That is, 912.
8 | // FOLLOW UP Suppose the digits are stored in forward order. Repeat the above problem.
9 |
10 | let digit_node_1 = addend_1;
11 | let digit_node_2 = addend_2;
12 | let result;
13 | let carry = 0;
14 |
15 | while (digit_node_1 || digit_node_2) {
16 | let new_digit = 0;
17 | if (digit_node_1) {
18 | new_digit += digit_node_1.data;
19 | digit_node_1 = digit_node_1.next;
20 | }
21 | if (digit_node_2) {
22 | new_digit += digit_node_2.data;
23 | digit_node_2 = digit_node_2.next;
24 | }
25 | new_node = ListNode(new_digit % 10 + carry);
26 | carry = Math.floor(new_digit / 10);
27 | new_node.next = result;
28 | result = new_node;
29 | }
30 | return result;
31 | }
32 |
--------------------------------------------------------------------------------
/solutions/02-linked-lists/02-06-palindrome.js:
--------------------------------------------------------------------------------
1 | function palindrome(list) {
2 | // Cracking the Coding Interview 2.6
3 | // Implement a function to check if a linked list is a palindrome.
4 |
5 | let reverse_list = null;
6 | let current = list;
7 | let length = 0;
8 |
9 | // Iterate through the original list and build a new one in reverse order. Keep track of length.
10 | while (current) {
11 | length++;
12 | let node_clone = ListNode(current.data);
13 | node_clone.next = reverse_list;
14 | reverse_list = node_clone;
15 | current = current.next;
16 | }
17 |
18 | current = list;
19 | reverse_current = reverse_list;
20 | let i = 0;
21 | // Compare the original list to the reverse list. If the first half is the same so is the second.
22 | while (i < Math.floor(length / 2)) {
23 | i++;
24 | if (current.data !== reverse_current.data) {
25 | return false;
26 | }
27 | current = current.next;
28 | reverse_current = reverse_current.next;
29 | }
30 | return true;
31 | }
32 |
--------------------------------------------------------------------------------
/solutions/02-linked-lists/02-07-intersection.js:
--------------------------------------------------------------------------------
1 | function intersection (l1, l2) {
2 | // Cracking the Coding Interview 2.7
3 | // Given two (singly) linked lists, determine if the two lists intersect. Return the intersecting node.
4 | // Note that the intersection is defined based on reference, not value. That is, if the kth node of the
5 | // first linked list is the exact same node (by reference) as the jth node of the second linked list,
6 | // then they are intersecting.
7 |
8 | let current_1 = l1;
9 | let current_2 = l2;
10 | let visited_nodes = new Set();
11 | while (current_1 || current_2) {
12 | // Check if either ListNode has been seen before. If so, return it.
13 | if (visited_nodes.has(current_1)) {
14 | return current_1;
15 | } else if (visited_nodes.has(current_2)) {
16 | return current_2;
17 | }
18 |
19 | // Continue traversing the lists and adding nodes to the visited set.
20 | if (current_1) {
21 | visited_nodes.add(current_1);
22 | current_1 = current_1.next;
23 | } else if (current_2) {
24 | visited_nodes.add(current_2);
25 | current_2 = current_2.next;
26 | }
27 | }
28 | return undefined;
29 | }
30 |
--------------------------------------------------------------------------------
/solutions/03-stacks-and-queues/03-05-sort_stack.js:
--------------------------------------------------------------------------------
1 | function sort_stack(stack) {
2 | // Cracking the Coding Interview 3.5
3 | // Write a program to sort a stack such that the smallet itmes are on the top. You can use an
4 | // additional temporary stack, but you may not copy the elements into any other data structure
5 | // (such as an array). The stack supports the following operations: push, pop, peek, and isEmpty.
6 |
7 | let reverse_sorted = []; // Create a stack to place elements in reverse sorted order.
8 | let current = stack.pop();
9 |
10 | // Sort items into reverse_sorted stack until all original items are in second stack.
11 | while (!stack.isEmpty() || current) {
12 | // If the top of stack is greater than the item on top of reverse_sorted, add it to reverse_sorted
13 | if (reverse_sorted.peek() < current || !reverse_sorted.peek()) {
14 | reverse_sorted.push(current);
15 | current = stack.pop();
16 | }
17 | // If top of reverse_sorted is greater than current element, move items to
18 | // stack until there is a proper spot for current in reverse_sorted stack.
19 | while (reverse_sorted.peek() > current) {
20 | stack.push(reverse_sorted.pop());
21 | }
22 | }
23 |
24 | // When all elements have been put into reverse_sorted in proper order,
25 | // pop them into stack to get them into sorted order.
26 | while(!reverse_sorted.isEmpty()) {
27 | stack.push(reverse_sorted.pop());
28 | }
29 | return stack;
30 | }
31 |
--------------------------------------------------------------------------------
/solutions/04-trees-and-graphs/04-01-route_between_nodes.js:
--------------------------------------------------------------------------------
1 | function route_between_nodes(start, destination) {
2 | // Cracking the Coding Interview problem 4.1
3 | // Given a directed graph, design an algorithm to find out whether this is a route between two nodes.
4 |
5 | let helper = function (current, destination) {
6 | if (current === destination) {
7 | return true;
8 | } else if (current.children.isEmpty() || current.visited) {
9 | return false;
10 | } else {
11 | current.visited = true;
12 | for (child of current.children) {
13 | let destination_found = helper(child, destination);
14 | if (destination_found) {
15 | return true;
16 | }
17 | }
18 | return false;
19 | }
20 | }
21 | return helper(start, destination);
22 | }
23 |
--------------------------------------------------------------------------------
/solutions/04-trees-and-graphs/04-02-minimal_tree.js:
--------------------------------------------------------------------------------
1 | function minimal_tree(elements) {
2 | // Cracking the Coding Interview problem 4.2
3 | // Given a sorted (increasing order) array with unique integer elements, write an algorithm to create
4 | // a binary search tree with minimal height
5 |
6 | if (elements.length === 1) {
7 | return create_tree_node(elements[0]);
8 | } else {
9 | let root_index = Math.floor((elements.length - 1) / 2);
10 | let branch = create_tree_node(elements[root_index]);
11 | let left_elements = elements.slice(0, root_index);
12 | let right_elements = elements.slice(root_index + 1);
13 | if (!left_elements.isEmpty()) {
14 | branch.left = minimal_tree(left_elements);
15 | }
16 | if (!right_elements.isEmpty()) {
17 | branch.right = minimal_tree(right_elements);
18 | }
19 | return branch;
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/solutions/04-trees-and-graphs/04-03-list_of_depths.js:
--------------------------------------------------------------------------------
1 | function list_of_depths(tree) {
2 | // Cracking the Coding Interview 4.3
3 | // Given a binary tree, design an algorithm which creates a linked list of all the nodes
4 | // at each depth (e.g., if you have a tree with depth D, you'll have D linked lists).
5 |
6 | let lists = [];
7 | let helper = (branch, depth) => {
8 | if (lists[depth]) {
9 | lists[depth].appendTail(ListNode(branch.data));
10 | } else {
11 | lists[depth] = ListNode(branch.data);
12 | }
13 | if (branch.left) {
14 | helper(branch.left, depth + 1);
15 | }
16 | if (branch.right) {
17 | helper(branch.right, depth + 1);
18 | }
19 | }
20 | helper(tree, 0);
21 | return lists;
22 | }
23 |
--------------------------------------------------------------------------------
/solutions/04-trees-and-graphs/04-04-check_balanced.js:
--------------------------------------------------------------------------------
1 | function check_balanced(root) {
2 | // Cracking the Coding Interview 4.4
3 | // Implement a function to check if a binary tree is balanced. For the purposes of this question, a
4 | // balanced tree is defined to be a tree such that the heights of the two subtrees of any node never
5 | // differ by more than one.
6 |
7 | let helper = (node) => {
8 | if (!node) {
9 | return 0;
10 | }
11 | let left_level = helper(node.left);
12 | if (left_level === -1) {
13 | return -1;
14 | }
15 | let right_level = helper(node.right);
16 | if (right_level === -1) {
17 | return -1;
18 | }
19 | if (Math.abs(left_level - right_level) > 1) {
20 | return -1;
21 | }
22 | return left_level > right_level ? left_level + 1 : right_level + 1;
23 | }
24 |
25 | return helper(root) !== -1;
26 | }
27 |
--------------------------------------------------------------------------------
/solutions/04-trees-and-graphs/04-08-first_common_ancestor.js:
--------------------------------------------------------------------------------
1 | function first_common_ancestor(root, target_1, target_2) {
2 | let helper = (current) => {
3 | if (current.left && current.left.depthFirstSearch(target_1) !== -1 && current.left.depthFirstSearch(target_2) !== -1) {
4 | return helper(current.left);
5 | } else if (current.right && current.right.depthFirstSearch(target_1) !== -1 && current.right.depthFirstSearch(target_2) !== -1) {
6 | return helper(current.right);
7 | } else {
8 | return current;
9 | }
10 | }
11 | return helper(root);
12 | }
13 |
--------------------------------------------------------------------------------
/solutions/04-trees-and-graphs/is_binary_search_tree.js:
--------------------------------------------------------------------------------
1 | function is_binary_search_tree(root) {
2 | // Write a function that takes the root node of a binary tree and returns
3 | // true if the tree is a binary search tree.
4 |
5 | let helper = function (node, min_value, max_value) {
6 | if (!node) {
7 | return true;
8 | } else {
9 | return node.data > min_value &&
10 | node.data < max_value &&
11 | helper(node.left, min_value, node.data) &&
12 | helper(node.right, node.data, max_value);
13 | }
14 | }
15 | return helper(root, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
16 | }
17 |
--------------------------------------------------------------------------------
/solutions/08-recursion-and-dynamic-programming/08-01-triple_step.js:
--------------------------------------------------------------------------------
1 | function triple_step(n) {
2 | // Cracking the Coding Interview problem 8.1
3 | // A child is running up a staircase with n steps and can hop either 1 step, 2 steps, or 3 steps at a
4 | // time. Implement a method to count how many possible ways the child can run up the stairs.
5 |
6 | let cache_table = [];
7 | let helper = (current_step, total_steps) => {
8 | if (current_step === total_steps) {
9 | return 1;
10 | } else if (current_step > total_steps) {
11 | return 0;
12 | } else {
13 | if (!cache_table[current_step]) {
14 | cache_table[current_step] = helper(current_step + 1, total_steps) +
15 | helper(current_step + 2, total_steps) +
16 | helper(current_step + 3, total_steps);
17 | return cache_table[current_step];
18 | } else {
19 | return cache_table[current_step];
20 | }
21 | }
22 | }
23 | return helper(0, n);
24 | }
25 |
--------------------------------------------------------------------------------
/solutions/08-recursion-and-dynamic-programming/08-03-magic_index.js:
--------------------------------------------------------------------------------
1 | function magic_index(array) {
2 | // A magic index in an array A[0 ... n-1] is defined to be an index such that A[i] = i. Given a sorted
3 | // array of distinct integeres, write a method to find a magic index, if one exists in array A.
4 | // FOLLOW UP What if the values are not distinct?
5 |
6 | let helper = (array, index) => {
7 | let value_at_index = array[0];
8 | if (value_at_index === index) {
9 | return index;
10 | } else if (array.length === 0) {
11 | return -1;
12 | } else {
13 | if (value_at_index > index) {
14 | return helper(array.slice(value_at_index - index), value_at_index);
15 | } else {
16 | return helper(array.slice(1), index + 1);
17 | }
18 | }
19 | }
20 | return helper(array, 0);
21 | }
22 |
--------------------------------------------------------------------------------
/solutions/08-recursion-and-dynamic-programming/08-04-power_set.js:
--------------------------------------------------------------------------------
1 | function match_query(words, query) {
2 | let result = [];
3 |
4 | let query_components = query.split('?');
5 |
6 | words.filter(word => {
7 | let word_copy = word;
8 | if (word.length !== query.length) {
9 | return false;
10 | } else {
11 | for (let component of query_components) {
12 | if (component === '') {
13 | word_copy.slice(1, word_copy.length);
14 | } else {
15 | if (word_copy.indexOf(component) !== 0) {
16 | return false;
17 | }
18 | }
19 | }
20 | return true;
21 | }
22 | });
23 |
24 | return result;
25 | }
26 |
27 |
28 | function getAllKeys() {
29 | return(fs.ls);
30 | }
31 |
32 | function removeItem(key) {
33 | fs.remove(key);
34 | console.log('Deleted');
35 | }
36 |
37 | function setItem(key, value, callback) {
38 | operations.add_operation_to_queue(fs.writeFile(hash(key), value)
39 | .done(result => {
40 | callback();
41 | return result
42 | })
43 | );
44 | }
45 |
46 | function execute_file_operations(operations) {
47 | for (operation of operations) {
48 | operation().done(() => {
49 | continue;
50 | });
51 | }
52 | }
53 |
54 | function add_operation_to_queue(key, value, operation) {
55 | operations.push(setItem(key, value, print_result));
56 | }
57 |
58 | function execute_operations() {
59 | while (!operations.empty()) {
60 | execute_file_operations(operations);
61 | }
62 | }
--------------------------------------------------------------------------------
/solutions/08-recursion-and-dynamic-programming/08-05-recursive_multiply.js:
--------------------------------------------------------------------------------
1 | function recursive_multiply(a, b) {
2 | // Cracking the Coding Interview 8.5
3 | // Write a recursive function to multiply two positive integers without using the * operator. You can
4 | // use addition, subtraction, and bit-shifting, but you should minimie the number of those operators.
5 |
6 | // Using the larger number for the addition will mean fewer recursive calls.
7 | // E.g. (3 * 2) === (2 + 2 + 2) === (3 + 3) <-- Fewer operations
8 | let [factor_1, factor_2] = a > b ? [a, b] : [b, a];
9 | let helper = (factor_2, total) => {
10 | if (factor_2 === 0) {
11 | return total;
12 | } else if (factor_2 === 1) {
13 | return factor_1;
14 | } else if (factor_2 % 2 === 0) {
15 | // If factor_2 is even, calculate the product of half of factor_2 and factor_1 and double it.
16 | // E.g. 5 * 6 === 5(3 * 2)
17 | total += helper(factor_2 >> 1, total);
18 | return total + total;
19 | } else {
20 | // If factor_2 is odd, subtract 1 to make it even, do the same halving and doubling as above, and
21 | // add factor_1 at the end to calculate the final result.
22 | // E.g. 5 * 7 === 5(3 * 2) + 5
23 | total += helper((factor_2 - 1) >> 1, total);
24 | total += total;
25 | total += factor_1;
26 | return total;
27 | }
28 | }
29 | return helper(factor_2, 0);
30 | }
31 |
--------------------------------------------------------------------------------
/solutions/08-recursion-and-dynamic-programming/max_nonadjacent_subset.js:
--------------------------------------------------------------------------------
1 | function max_nonadjacent_subset(numbers) {
2 | let one_previous = 0;
3 | let two_previous = 0;
4 |
5 | let helper = index => {
6 | let new_addend = numbers[index];
7 | let new_max = one_previous > two_previous + new_addend ? one_previous : new_addend + two_previous;
8 | two_previous = one_previous;
9 | one_previous = new_max;
10 | }
11 |
12 | for (let i = 0; i < numbers.length; i++) {
13 | helper(i);
14 | }
15 |
16 | return one_previous;
17 | }
18 |
--------------------------------------------------------------------------------
/solutions/10-sorting-and-searching/10-01-sorted_merge.js:
--------------------------------------------------------------------------------
1 | function sorted_merge(A, B) {
2 | // Cracking the Coding Interview problem 10.1
3 | // You are given two sorted arrays, A and B, where A has a large enough buffer at the end to hold B.
4 | // Write a method to merge B into A in sorted order.
5 |
6 | let swap_index = A.length - 1;
7 | let B_index = B.length - 1;
8 | let A_index = 0;
9 | for (let [index, value] of A.entries()) {
10 | if (!value) {
11 | A_index = index - 1;
12 | break;
13 | }
14 | }
15 |
16 | while (B_index >= 0) {
17 | if (B[B_index] >= A[A_index] || !A[A_index]) {
18 | A[swap_index] = B[B_index];
19 | B_index--;
20 | swap_index--;
21 | } else {
22 | A[swap_index] = A[A_index];
23 | A[A_index] = null;
24 | A_index--;
25 | swap_index--;
26 | }
27 | }
28 | return A;
29 | }
30 |
--------------------------------------------------------------------------------
/solutions/10-sorting-and-searching/10-03-search_in_rotated_array.js:
--------------------------------------------------------------------------------
1 | function search_in_rotated_array(list, target) {
2 | // Cracking the Coding Interview 10.3
3 | // Given a sorted array of n integers that has been rotated an unknown number of times, write code to
4 | // find an element in the array. You may assume that the array was originally sorted in increasing order.
5 | // EXAMPLE: search_in_rotated_array([15, 16, 19, 20, 25, 1, 3, 4, 5, 7, 10, 14], 5) === 8
6 |
7 | let start = 0;
8 | let end = list.length - 1;
9 | let search_index = Math.floor((end - start) / 2);
10 | let search_element = list[search_index];
11 |
12 | while (search_element !== target && search_index !== -1) {
13 | if (start === end) {
14 | search_index = -1;
15 | } else if (target > list[end] || target < search_element) {
16 | end = search_index - 1;
17 | search_index = start + Math.floor((end - start) / 2);
18 | search_element = list[search_index];
19 | } else {
20 | start = search_index + 1;
21 | search_index = start + Math.floor((end - start) / 2);
22 | search_element = list[search_index];
23 | }
24 | }
25 |
26 | return search_index;
27 | }
28 |
--------------------------------------------------------------------------------
/solutions/10-sorting-and-searching/binary_search.js:
--------------------------------------------------------------------------------
1 | function binary_search(list, target) {
2 | let start = 0;
3 | let end = list.length - 1;
4 | let search_index = Math.floor((end - start) / 2);
5 |
6 | while (list[search_index] !== target && search_index !== -1) {
7 | if (start === end) {
8 | search_index = -1;
9 | } else if (list[search_index] > target) {
10 | end = search_index - 1;
11 | search_index = start + Math.floor((end - start) / 2);
12 | } else {
13 | start = search_index + 1;
14 | search_index = start + Math.floor((end - start) / 2);
15 | }
16 | }
17 |
18 | return search_index;
19 | }
20 |
--------------------------------------------------------------------------------
/test/check_permutation_test.js:
--------------------------------------------------------------------------------
1 | mocha.setup('bdd');
2 |
3 | describe('check_permutation_test', () => {
4 | describe('valid_permutation', () => {
5 | it('should return true for "read" and "dear"', () => {
6 | chai.assert.equal(check_permutation('read', 'dear'), true);
7 | });
8 | it('should return true for equivalent strings', () => {
9 | chai.assert.equal(check_permutation('equivalent', 'equivalent'), true);
10 | });
11 | it('should return true for two empty strings', () => {
12 | chai.assert.equal(check_permutation('', ''), true);
13 | });
14 | });
15 | describe('invalid_permutation', () => {
16 | it('should return false for "noon" and "moon"', () => {
17 | chai.assert.equal(check_permutation('noon', 'moon'), false);
18 | });
19 | });
20 | });
21 |
--------------------------------------------------------------------------------
/test/corresponding_bracket_index_test.js:
--------------------------------------------------------------------------------
1 | describe('corresponding_bracket_index_test', () => {
2 | describe('valid_source_code', () => {
3 | it('should return 6 when the caret index is 0', () => {
4 | chai.assert.equal(corresponding_bracket_index(valid_source_code, 0), 6);
5 | });
6 |
7 | it('should return 0 when the caret index is 6', () => {
8 | chai.assert.equal(corresponding_bracket_index(valid_source_code, 6), 0);
9 | });
10 |
11 | it('should return 26 when the caret index is 9', () => {
12 | chai.assert.equal(corresponding_bracket_index(valid_source_code, 9), 26);
13 | });
14 |
15 | it('should return 8 when the caret index is 27', () => {
16 | chai.assert.equal(corresponding_bracket_index(valid_source_code, 27), 8);
17 | });
18 | });
19 |
20 | describe('invalid_source_code', () => {
21 | it('should throw "invalid brackets in source code" on improper nesting', () => {
22 | chai.assert.throws(() => { corresponding_bracket_index(improper_nesting, 2) }, Error, 'Invalid brackets in source code.');
23 | });
24 |
25 | it('should throw "invalid brackets in source code" on incorrect closing bracket', () => {
26 | chai.assert.throws(() => { corresponding_bracket_index(wrong_closing_bracket, 2) }, Error, 'Invalid brackets in source code.');
27 | });
28 |
29 | it('should throw "Unclosed brackets in source code" on unclosed bracket', () => {
30 | chai.assert.throws(() => { corresponding_bracket_index(unclosed_bracket, 2) }, Error, 'Unclosed brackets in source code.');
31 | });
32 |
33 | it('should throw "Invalid caret index. Caret must point to a bracket" if no braces', () => {
34 | chai.assert.throws(() => { corresponding_bracket_index(no_braces, 2) }, Error, 'Invalid caret index. Caret must point to a bracket.');
35 | });
36 |
37 | it('should throw "Invalid caret index. Caret must point to a bracket" on invalid caret index', () => {
38 | chai.assert.throws(() => { corresponding_bracket_index(valid_source_code, 2) }, Error, 'Invalid caret index. Caret must point to a bracket.');
39 | });
40 | });
41 | });
42 |
--------------------------------------------------------------------------------
/test/one_away_test.js:
--------------------------------------------------------------------------------
1 | describe('one_away_test', () => {
2 | describe('insert/remove', () => {
3 | it('should return true for "pale and "ple"', () => {
4 | chai.assert.equal(one_away('pale', 'ple'), true);
5 | });
6 | it('should return false for "pale and "pl"', () => {
7 | chai.assert.equal(one_away('pale', 'pl'), false);
8 | });
9 | });
10 | describe('replace', () => {
11 | it('should return true for "pale" and "bale"', () => {
12 | chai.assert.equal(one_away("pale", "pales"), true);
13 | });
14 | it('should return false for "pale" and "bald"', () => {
15 | chai.assert.equal(one_away("pale", "bald"), false);
16 | });
17 | });
18 | describe('equivalent', function () {
19 | it('should return true for "hello" and "hello"', () => {
20 | chai.assert.equal(one_away("hello", "hello"), true);
21 | });
22 | it('should return true for two empty strings', () => {
23 | chai.assert.equal(one_away("", ""), true);
24 | });
25 | });
26 | });
27 |
--------------------------------------------------------------------------------
/test/sort_stack_test.js:
--------------------------------------------------------------------------------
1 | describe('sort_stack_test', () => {
2 | describe('mixed_order', () => {
3 | it('should return [6, 5, 4, 3, 2, 1]', () => {
4 | chai.assert.deepEqual(sort_stack(mixed_order), [6, 5, 4, 3, 2, 1]);
5 | });
6 | });
7 | describe('sorted_order', () => {
8 | it('should return [10, 9, 8, 7, 6, 5]', () => {
9 | chai.assert.deepEqual(sort_stack(sorted_order), [10, 9, 8, 7, 6, 5]);
10 | });
11 | });
12 | describe('reverse_sorted', () => {
13 | it('should return [95, 94, 93, 92, 91, 90]', () => {
14 | chai.assert.deepEqual(sort_stack(reverse_sorted), [95, 94, 93, 92, 91, 90]);
15 | });
16 | });
17 | });
18 |
--------------------------------------------------------------------------------
/test/string_compression_test.js:
--------------------------------------------------------------------------------
1 | describe('string_compression_test', () => {
2 | describe('compressable_strings', () => {
3 | it('should return "a3b1c5a3" for "aaabcccccaaa"', () => {
4 | chai.assert.deepEqual(string_compression('aaabcccccaaa'), 'a3b1c5a3');
5 | });
6 | it('should return "r2e2d3i2t2" for "rreedddiitt"', () => {
7 | chai.assert.deepEqual(string_compression('rreedddiitt'), 'r2e2d3i2t2');
8 | });
9 | });
10 | describe('uncompressable_strings', () => {
11 | it('should return "andre" for "andre"', () => {
12 | chai.assert.deepEqual(string_compression('andre'), 'andre');
13 | });
14 | it('should return "" for ""', () => {
15 | chai.assert.deepEqual(string_compression(''), '');
16 | });
17 | });
18 | });
19 |
--------------------------------------------------------------------------------
/ui/about.css:
--------------------------------------------------------------------------------
1 | #bio {
2 | display: flex;
3 | flex-wrap: wrap-reverse;
4 | justify-content: center;
5 | }
6 | #left-column {
7 | width: 30em;
8 | margin-right: 3em;
9 | }
10 | #right-column img {
11 | width: 30em;
12 | }
13 | a p {
14 | margin: 0;
15 | display: inline;
16 | }
17 | ul {
18 | margin: 0;
19 | padding-left: 1em;
20 | }
21 | h1 {
22 | text-align: center;
23 | }
24 |
--------------------------------------------------------------------------------
/ui/footer.css:
--------------------------------------------------------------------------------
1 | #footer-content {
2 | display: flex;
3 | justify-content: space-between;
4 | }
5 | footer {
6 | border-top: 1px solid #eee;
7 | margin-top: 2em;
8 | padding-top: 1em;
9 | padding-bottom: 2em;
10 | }
11 | #footer-content div p {
12 | margin: 0;
13 | padding: 0;
14 | font-size: 0.8em;
15 | color: #767676;
16 | }
17 | #footer-content div a p:hover {
18 | color: #4EC9B0;
19 | }
20 | #footer-content img:hover {
21 | opacity: 0.8;
22 | }
23 | footer img {
24 | width: 1.5em;
25 | }
26 | #footer-center {
27 | display: flex;
28 | justify-content: space-between;
29 | width: 8em;
30 | }
31 |
--------------------------------------------------------------------------------
/ui/header.css:
--------------------------------------------------------------------------------
1 | #header-content {
2 | display: flex;
3 | flex-wrap: wrap;
4 | align-items: center;
5 | justify-content: space-between;
6 | font-family: "Courier New", monospace;
7 | font-size: 2em;
8 | font-weight: bold;
9 | white-space: nowrap;
10 | margin-top: 0.6em;
11 | margin-bottom: 0.6em;
12 | }
13 | nav ul {
14 | list-style: none;
15 | padding: 0;
16 | margin: 0;
17 | }
18 | nav ul li {
19 | display: inline-block;
20 | }
21 | #home-link:hover {
22 | color: black;
23 | }
24 | #home-link:hover span {
25 | color: #4EC9B0;
26 | }
27 |
--------------------------------------------------------------------------------
/ui/home.css:
--------------------------------------------------------------------------------
1 | #main-content {
2 | display: flex;
3 | flex-wrap: wrap;
4 | }
5 | #code-container {
6 | min-width: 56em;
7 | width: 60%;
8 | flex-grow: 1;
9 | }
10 | #code-container h3, #test-output h3 {
11 | display: inline-block;
12 | margin-right: 0.5em;
13 | }
14 | #test-output {
15 | margin-left: 0.5em;
16 | min-width: 28em;
17 | width: 38%;
18 | flex-grow: 1;
19 | margin-left: 0.75em;
20 | }
21 | #employment-status {
22 | padding: 0.1em 0.3em 0.1em 0.3em;
23 | color: white;
24 | background-color: #4EC9B0;
25 | /*background-color: #B1364F;*/
26 | border-radius: 0.3em;
27 | }
28 | pre {
29 | font-size: 0.9em;
30 | }
31 |
--------------------------------------------------------------------------------
/ui/main.css:
--------------------------------------------------------------------------------
1 | body {
2 | padding: 0 2em 0 2em;
3 | overflow-y: scroll;
4 | max-width: 120em;
5 | margin-left: auto;
6 | margin-right: auto;
7 | background-color: white;
8 | }
9 | p, h1, h2, h3 {
10 | font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
11 | }
12 | .accent {
13 | color: #4EC9B0;
14 | }
15 | a {
16 | text-decoration: none;
17 | color: black;
18 | }
19 | a:hover {
20 | color: #4EC9B0;
21 | }
22 | /* These styles are duplicated here from Prism.css so the formatting loads more quickly. */
23 | pre {
24 | background-color: #272822;
25 | padding: 1em;
26 | margin: .5em 0;
27 | overflow: auto;
28 | border-radius: 0.3em;
29 | }
30 |
--------------------------------------------------------------------------------
/ui/portfolio.css:
--------------------------------------------------------------------------------
1 | #portfolio {
2 | display: flex;
3 | flex-direction: row;
4 | justify-content: space-around;
5 | flex-wrap: wrap;
6 | }
7 | #portfolio img {
8 | width: 100%;
9 | }
10 | .portfolio-item {
11 | border: 1px solid lightgrey;
12 | border-radius: 0.8em;
13 | width: 18em;
14 | padding: 1.2em;
15 | text-align: center;
16 | margin-top: 1.2em;
17 | }
18 | a:hover img {
19 | opacity: 0.5;
20 | }
21 | .portfolio-item h3 {
22 | margin: 0;
23 | margin-bottom: 1em;
24 | }
25 |
--------------------------------------------------------------------------------
/ui/resume.css:
--------------------------------------------------------------------------------
1 | #resume {
2 | width: 60%;
3 | max-width: 50em;
4 | margin-left: auto;
5 | margin-right: auto;
6 | margin-top: 2em;
7 | border: 1px solid lightgrey;
8 | }
9 | #resume img {
10 | width: 100%;
11 | }
12 | #resume img:hover {
13 | opacity: 0.55;
14 | }
15 | #download-links {
16 | margin-top: 1em;
17 | text-align: center;
18 | }
19 |
--------------------------------------------------------------------------------
/ui/ui.js:
--------------------------------------------------------------------------------
1 | document.addEventListener('DOMContentLoaded', () => {
2 | // Watch for a problem being selected from the select input. Look up selected solution and
3 | // display it in the code container.
4 | let problem_select = document.querySelector('select');
5 | let selected_option;
6 | let all_tests_button = document.querySelector('#all-tests-button');
7 | problem_select.addEventListener('change', () => {
8 | selected_option = problem_select[problem_select.selectedIndex].innerText;
9 | let fn = window[selected_option];
10 | document.querySelector('code').textContent = fn.toString();
11 | Prism.highlightAll();
12 | });
13 |
14 | // Watch for clicks on the 'run mocha tests' button and run them when clicked.
15 | all_tests_button.onclick = () => {
16 | mocha.run();
17 | all_tests_button.disabled = true;
18 | all_tests_button.title = "Refresh page to run Mocha tests again.";
19 | };
20 | }, false );
21 |
--------------------------------------------------------------------------------
96 | 
108 |