JavaScript/CoderbyteEbook.pdf.txt

1 

The Code Challenge Book 
How to Ace the Coding Bootcamp  
Technical Interview 

By 

Daniel Borowski 
Coderbyte 

	
	
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2 

Written	by:	Daniel	Borowski	|	Coderbyte	
Last	updated:	October	10th,	2016	

Cover	image:	By	R.	A.	Nonenmacher	(Own	work)	[GFDL	(http://www.gnu.org/copyleft/fdl.html)	or	CC	
BY-SA	4.0-3.0-2.5-2.0-1.0	(http://creativecommons.org/licenses/by-sa/4.0-3.0-2.5-2.0-1.0)],	via	
Wikimedia	Commons	[https://commons.wikimedia.org/wiki/File%3APascal's_Triangle_4_paths.svg]	

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
TABLE	OF	CONTENTS	

1.  Introduction	

PART	1:	BACKGROUND	

1.1.  What	is	a	coding	bootcamp?			
1.2.  What	is	the	purpose	of	a	coding	challenge?			
1.3.  Difference	in	coding	challenges	for	coding	bootcamps	vs.	job	interviews		
1.4.  How	are	coding	challenges	related	to	engineering	problems?		
1.5.  What	you’ll	learn	in	this	book		
1.6. 

Skill	level	required	for	these	challenges		

2.  Basics	
2.1. 
2.2. 

Fundamental	data	structures	you’ll	need		
Big-O:	How	to	analyze	your	algorithms		

PART	2:	CHALLENGES	

Fizzbuzz		
Two	sum	problem	
Sum	nested	arrays		
Calculate	angle	on	clock		
Is	N	a	prime	number	
Implement	map	and	filter		
Remove	characters	from	array	from	string			 	
Check	if	valid	number	of	parenthesis		
First	non-repeating	character		

3.  Practice	
3.1. 
3.2. 
3.3. 
3.4. 
3.5. 
3.6. 
3.7. 
3.8. 
3.9. 
3.10.  Count	words	that	have	at	least	3	continuous	vowels			
3.11.  Remove	all	adjacent	matching	characters			
3.12.  Find	majority	element	(element	that	appears	more	than	n/2	times)			
3.13.  Switching	light	bulbs	problem			
3.14.  List	of	integers	that	overlap	in	two	ranges			
3.15.  Return	mean,	median,	and	mode	of	array				 	
3.16.  Encode	consonants	within	a	string			 	
3.17.  Convert	array	of	strings	into	an	object	
3.18.  Three	sum	problem	

PART	3:	GENERAL	INTERVIEW	TIPS	

4.  Resources			

4.1. 
4.2. 

Personal	help	 	
Interview	preparation	articles		

3 

		5	
		5	
		6	
		7	
		8	
		8	

10	
10	

13	
15	
17	
19	
21	
23	
27	
29	
31	
33	
35	
37	
40	
42	
44	
46	
50	
54	

58	
58	

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
		
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
		
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
4 

PART	1	
BACKGROUND	

“Measuring	programming	progress	by	lines	of	code	is	like		
measuring	aircraft	building	progress	by	weight.”	

-	Bill	Gates	

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
CHAPTER	1:	Introduction	

5 

1.1.  What	is	a	coding	bootcamp?	

A	coding	bootcamp	is	an	intensive	training	program	that	teaches	students	computer	programming	
over	the	span	of	several	weeks.	The	goal	of	these	bootcamps	is	to	condense	the	concepts	taught	in	a	
standard	college	computer	science	program	into	a	crash	course	that	focuses	explicitly	on	the	practical	
skills	and	knowledge	they	offer.	That	way,	students	are	prepared	for	software	engineering	jobs	
immediately	after	they	finish	the	program.	There	are	close	to	one	hundred	coding	bootcamps	in	the	
United	States	alone	that	focus	on	teaching	software	development,	data	science,	and	mobile	
application	development.[1]	And	it’s	not	just	the	U.S.	--	bootcamps	are	sprouting	up	all	over	the	world,	
in	countries	like	Portugal,	Poland,	France,	and	the	U.K.[2]	You	can	read	more	about	bootcamps	here:	
http://bit.ly/2eb7Xzf		

During	the	bootcamp,	students	follow	a	rigorous	schedule	that	typically	runs	over	the	course	of	8-

12	weeks.		It	includes	learning	to	code	in	a	specific	language,	learning	new	software	tools	and	
methodology,	studying	algorithms,	creating	projects,	working	in	groups,	and	other	activities	that	are	
designed	to	prepare	the	student	for	the	world	of	software	engineering.	On	average,	these	bootcamps	
cost	about	$12,000	for	the	whole	experience.[3]		Their	steep	tuition	costs	are	justified	by	the	promise	
that	graduates	will	be	able	to	find	exciting	jobs	with	high	salaries	once	they’re	done.	It	can	be	a	great	
option	for	someone	with	little	to	no	coding	experience	who	is	looking	to	broaden	their	skills	and	
transition	into	a	new	job.	Once	someone	decides	that	this	is	the	route	they	want	to	take,	the	first	step	
is	to	complete	an	application	online.	One	of	the	first	challenges	that	person	(you!)	will	face	is	the	
coding	challenge.	

1.2.  What	is	the	purpose	of	a	coding	challenge?	

When	applying	for	a	software	engineering	position	at	a	company,	the	employer	is	typically	going	to	
do	more	than	look	at	your	resume	and	schedule	a	short	interview.	They	may	ask	you	to	solve	a	few	
technical	challenges,	either	online	or	on	a	whiteboard.	This	is	done	in	order	to:	

1.  Determine	how	well	you	can	code.	
2.  Gauge	your	problem-solving	abilities	when	faced	with	a	novel	challenge.	
3.  Figure	out	if	you	can	work	through	a	difficult	problem	under	a	time	limit.	
4.  See	how	you	handle	a	situation	if	you	are	stuck	or	confused.	

Coding	bootcamps	follow	the	same	model	and	typically	ask	their	applicants	to	solve	a	few	coding	

challenges	at	some	point	in	the	interview	process.	Below	are	a	couple	of	sample	bootcamp	coding	
challenges:	

[1]	Course	Report	Market	Sizing	Report	2016:	http://bit.ly/296nHFr		
[2]	Quora	question	about	international	coding	bootcamps:	http://bit.ly/2cRX0Em		
[3]	Course	Report	Market	Sizing	Report	2016:	http://bit.ly/296nHFr	

	
	
	
	
	
	
	
	
	
	
	
	
6 

You	have	been	given	a	list	of	words.	Write	a	program	that	will	take	this	list	and	return	a	new	list	with	
all	duplicate	words	removed.		

You	have	been	given	a	number.	Write	a	program	that	will	determine	if	this	number	is	a	prime	number	
or	not.	

During	the	interview,	you	will	most	likely	have	the	option	of	asking	questions	to	clarify	your	

understanding	of	the	problem.		You	will	then	be	asked	to	give	a	high-level	explanation	of	how	you	will	
work	through	the	problem	followed	by	writing	a	solution	on	the	whiteboard	or	in	a	Word	document.		
Afterwards,	you	will	most	likely	discuss	your	code	with	the	interviewer	who	may	ask	questions	like	
why	you	wrote	it	in	such	a	way,	whether	it	will	work	for	a	given	input,	or	how	it	might	be	made	more	
efficient.	

In	the	end,	you	will	(hopefully)	have	written	a	program	that	does	what	it’s	supposed	to	and	the	
interviewer	will	(hopefully)	have	gained	an	understanding	of	how	you	think	when	presented	with	a	
challenging	problem,	how	you	react	to	any	issues	that	may	arise,	and	whether	you	are	adept	at	
explaining	your	thought	processes.	

1.3. 

Coding	bootcamp	interviews	vs.	job	interviews	

As	mentioned,	most	coding	bootcamps	follow	the	same	model	for	interviews	as	companies	looking	to	
recruitcandidates	for	coding	jobs.	These	positions	usually	go	by	one	of	the	following	names:	

•  Software	Engineer	
•  Software	Developer	
•  Front-end	Developer/Engineer	
•  Back-end	Developer/Engineer	
•  Web	Developer	
•  Programmer	
• 

(Insert	programming	language	here)	developer	

While	the	interview	models	may	be	similar,	the	questions	asked	in	bootcamp	interviews	are	going	

to	be	very	different	than	those	asked	in	interviews	for	engineering	positions	at	companies	like	
Google,	for	instance.	When	applying	to	a	coding	job	at	a	company,	the	questions	will	typically	be	
more	complex.	They	may	require	knowledge	in	several	domains	of	computer	science,	including	data	
structures,	algorithms,	systems	design,	mathematical	optimization,	and	statistics.		They	may	also	
require	much	more	code	to	actually	solve	the	problem.	

Below	are	some	examples	of	challenges	you	may	encounter	at	large	technology	companies	like	

Google	or	Microsoft:	

Find	the	largest	common	subtree	within	two	binary	search	trees.	Solve	this	problem	in	linear	time	if	
you	can.	

	
	
	
	
	
	
	
	
	
	
	
	
7 

How	would	you	sort	a	1	terabyte	file	of	people’s	names	if	your	RAM	is	limited	to	4	gigabytes?	What	
data	structures	would	you	use?	

You	may	be	asking	yourself:	does	the	ability	to	solve	these	challenges	mean	someone	is	a	good	
programmer?	What	if	they	can	solve	the	problems	but	don’t	work	great	under	the	pressure	of	a	time	
constraint?	What	if	they	just	studied	the	solutions	to	a	hundred	coding	challenges	a	few	days	before	
the	interview	but	couldn’t	actually	solve	them	on	their	own?		Some	members	of	the	programming	
community	are	very	critical	of	the	“the	technical	interview,”	and	there	are	plenty	of	articles,	blog	
posts,	and	sites	online	that	explain	why	these	types	of	challenges	may	be	flawed	for	determing	
whether	someone	is	actually	a	good	programmer.[1]	Feel	free	to	read	the	resources	listed	in	the	
footnote	on	this	topic,	but	know	that	as	of	now,	you	will	most	likely	encounter	coding	challenges	
when	applying	to	coding	bootcamps	and	companies	for	engineering	positions.	

1.4.  How	are	coding	challenges	related	to	engineering	problems?		

Coding	challenges	are	meant	to	be	representative	of	real	software	engineering	tasks	that	may	arise	in	
everyday	programming.	While	coding	challenges	in	interviews	are	meant	to	be	solved	within	a	few	
minutes	and	with	limited	code,	they	can	still	be	related	to	solutions	for	real	engineering	issues.	Here	
are	some	examples	of	how	interview	questions	can	be	related	to	real	engineering	and	development	
problems:	

•  You	may	be	asked	to	write	a	program	that	sorts	a	list	of	objects	by	name	or	age.	In	a	real-

world	situation,	you	may	have	an	application	that	presents	user	data	to	an	admin	that	must	
then	be	filtered	and	sorted	in	different	ways.	

•  You	may	be	asked	to	write	a	program	that	quickly	determines	what	object	in	a	list	was	created	
last	and	then	removes	it.	This	can	be	related	to	an	application	that	presents	events	happening	
in	real-time	and	needs	to	quickly	change	or	remove	the	latest	event.	

•  You	may	be	asked	to	write	a	program	that	removes	duplicate	elements	from	a	list.	This	can	be	
related	to	a	program	that	stores	a	birthday	wishlist	and	prevents	duplicate	entries	from	being	
displayed	if	an	original	entry	for	an	item	already	exists	in	the	list.	

As	mentioned,	coding	challenges	for	bootcamp	interviews	are	generally	easier	than	coding	
challenges	you	may	get	in	a	job	interview.	For	a	bootcamp,	knowledge	of	basic	logic,	simple	looping,	
data	structures	such	as	arrays	and	objects,	and	an	understanding	of	functional	programming	may	be	
enough	to	pass.	The	challenges	may	be	presented	in	a	way	that	requires	you	to	make	use	of	different	
data	structures	and	then	combine	them,	along	with	several	different	lines	of	logical	statements.	This	
is	to	see	if	you	have	a	basic	grasp	of	programming,	problem	solving,	and	logical	thinking.	

[1]	Google	search	for	programmers	and	coding	interviews:	http://bit.ly/2dNSJ7j		

	
	
	
	
	
	
	
	
	
	
	
	
	
In	a	job	interview	however,	the	coding	challenges	can	be	a	bit	harder	and	they	may	require	use	of	
more	advanced	data	structures,	complex	algorithms,	and	clever	insights	to	solve.	We	will	cover	some	
questions	that	can	be	asked	in	job	interviews	later	on	in	the	book,	and	you	will	see	how	they	differ	
from	coding	challenges	typically	asked	in	coding	bootcamp	admissions.	Understanding	and	being	able	
to	solve	both	types	of	coding	challenges	will	prove	to	be	incredibly	useful	in	your	coding	education.	

8 

1.5.  What	you’ll	learn	in	this	book	

From	here	on	in,	this	book	will	provide	you	with	some	basic	code	examples	and	explanations.	It	will	
then	list	several	different	coding	challenges	that	are	a	combination	of	the	following	topics:	

•  Fundamental	data	structures	
•  Working	with	hashtables	
•  Looping	through	arrays	
•  Functional	programming	

Every	question	will	have	an	explanation	detailing	how	to	approach	the	problem	and	figure	out	a	
high-level	solution,	followed	by	the	presentation	of	a	working	code	solution.	Some	of	the	challenges	
will	begin	with	a	brute-force	solution	and	then	will	slowly	be	modified	towards	a	more	efficient	
program.		All	of	the	challenges	will	have	working	solutions	in	JavaScript,	Python,	and	Ruby.	

My	ultimate	goal	is	not	for	you	to	memorize	a	bunch	of	solutions	to	common	challenges.		Instead,	

my	goal	is	for	you	to	learn	how	to	approach	coding	challenges	so	that	you	can	figure	out	what	they	
are	asking	and	what	data	structures	and	algorithms	you	need	to	solve	them.	Actually	learning	to	code	
the	solutions	to	problems	takes	time,	practice,	and	a	good	grasp	of	the	programming	language	you	
are	using.	In	this	book	I	hope	to	teach	you	common	themes	between	most	coding	challenges	and	
show	you	how	specific	data	structures	and	algorithms	can	be	used	to	solve	almost	every	single	
challenge.	

1.6. 

Skill	level	required	for	these	challenges	

This	book	is	intended	for	people	who	understand	the	basic	syntax	of	JavaScript,	Python,	and/or	Ruby,	
and	have	done	some	coding	in	one	of	those	langauges.	It	will	be	easier	to	understand	the	challenge	
solutions	if	you	have	an	understanding	of	the	following	topics:	

•  Loops		
•  Arrays		
•  String	manipulation	
•  Objects	and	accessing	different	properties	
•  Hash	tables	
•  Basic	math	functions	(e.g.	ceiling,	floor,	modulo)	

If	you	still	need	to	brush	up	on	these	topics	in	any	of	the	three	languages	listed	above,	below	are	
some	resources	you	may	find	helpful:	

	
	
	
	
	
	
	
	
	
	
	
9 

JavaScript	

1.  http://eloquentjavascript.net	(especially	chapters	1,	3,	4	and	5)	
2.  https://coderbyte.com/course/learn-javascript-in-one-week	(refresher	in	JavaScript	basics)	
3.  https://www.codecademy.com/learn/javascript	(if	you’re	brand	new	to	JavaScript)	
4.  https://teamtreehouse.com/library/javascript-basics		

Python	

1.  https://learnpythonthehardway.org/book/		
2.  https://coderbyte.com/course/learn-python-in-one-week		
3.  https://www.codecademy.com/learn/python	(if	you’re	brand	new	to	Python)	
4.  http://www.learnpython.org/	(small	tutorials	with	code	samples	you	can	run	online)	

Ruby	

1.  http://tryruby.org/levels/1/	(fun	interactive	site	to	learn	Ruby)	
2.  https://coderbyte.com/course/learn-ruby-in-one-week		
3.  https://www.codecademy.com/learn/ruby	(if	you’re	brand	new	to	Ruby)	
4.  https://learnrubythehardway.org/book/		

All	of	the	challenges	in	Chapter	3	will	be	on	a	scale	similar	to	the	easy	and	medium	challenges	on	
Coderbyte	(https://coderbyte.com/challenges).	The	only	exception	is	the	last	challenge,	or	the	“Three	
sum”	problem.	This	one	is	a	bit	harder	than	the	rest,	but	is	a	good	challenge	to	study	for	a	couple	of	
reasons.		It’s	an	example	of	a	challenge	where	a	basic	solution	is	easy	to	see	at	first	(i.e.,	writing	a	few	
nested	loops)	but	which	can	be	improved	by	some	clever	manipulation	of	data	structures	and	inputs	
to	produce	a	much	faster	solution.	

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
CHAPTER	2:	Basics	

10 

2.1. 

Fundamental	data	structures	you’ll	need	for	the	bootcamp	coding	challenge	

Array	
A	data	structure	is	a	way	of	organizing	data	in	a	computer.	A	simple	example	of	a	data	structure	you	
may	be	familiar	with	already	is	the	array.	An	array	allows	you	to	create	and	store	a	list	of	elements	in	
some	specific	order	for	access	later	on.	In	some	languages,	the	elements	all	have	to	be	of	the	same	
type	(e.g.,	string,	integers,	etc.),	but	in	JavaScript,	Python,	and	Ruby,	you	can	have	an	array	that	stores	
elements	of	different	types.		

Hash	Table	
The	second	most	important	data	structure	for	coding	challenges	may	very	well	be	the	hash	table	(also	
known	as	an	‘associate	array’	or	‘hash	map’).	It	is	a	data	structure	that	maps	keys	to	values	in	an	
efficient	way.	Elements	in	hash	tables	are	not	necessarily	stored	in	the	order	they	are	added;	instead,	
they	are	accessed	by	their	given	keys.	If	you	were	checking	for	the	existence	of	a	certain	item	within	
an	array,	you	would	have	to	write	a	loop	that	checks	every	element	in	it	and	stops	once	the	desired	
element	was	found.	Even	the	built-in	functions	(e.g.,	indexOf	in	JavaScript,	in	in	Python,	include?	in	
Ruby)	that	do	this	for	us	are	written	in	a	way	that	actually	loops	through	the	array.	A	hash	table	on	
the	other	hand	does	not	need	to	loop	to	check	if	an	element	exists	because	the	values	are	associated	
with	given	keys.[1]	This	means	that	a	hash	table	lookup	and	insertion	will	run	in	constant	time	(more	
on	this	later).[2]	

Object	

An	object	allows	you	to	group	together	properties	such	as	variables,	arrays,	and	even	other	data	
structures	and	keep	all	of	them	in	a	sort	of	“container.”	In	Python	and	Ruby,	you	first	create	a	class	
which	acts	as	a	blueprint,	and	then	you	can	instantiate	objects	based	on	the	class.	For	example,	you	
can	create	a	Car	class	which	will	list	all	possible	properties	of	a	car,	and	then	you	can	create	several	
different	Car	objects.	In	JavaScript,	this	process	is	very	similar	except	you	do	not	create	a	class	and	
then	instantiate	objects;	rather,	one	object	will	act	as	the	“root”	(or	prototype)	object	and	then	you	
can	make	copies	of	that	object.	

2.2.  What	is	Big-O?	

One	main	aspect	of	computer	science	and	programming	is	analyzing	the	speed	at	which	our	programs	
run	given	certain	inputs.	For	example,	imagine	you	wrote	a	program	that	reads	in	an	array	of	names,	
sorts	the	array	into	alphabetical	order,	and	then	returns	the	result.	If	your	program	is	given	an	array	
of	10	names,	it	most	likely	runs	in	less	than	half	a	second.	But	how	long	would	it	take	for	your	
program	to	run	with	100,000	names,	or	even	1	million	names?	This	is	where	the	analysis	of	

[1]	What	is	a	HashTable	Data	Structure	Youtube	Video:	http://bit.ly/2dZ5Q3E		
[2]	Stack	Overflow	posts	about	hash	tables	and	running	time:	http://bit.ly/2dxFHFF	and	http://bit.ly/2dm1mD5		

	
	
	
	
	
	
	
	
	
	
	
	
11 

algorithms	and	Big-O	comes	into	play.	There	are	a	ton	of	great	resources	out	there	that	explain	in	
rigorous	detail	how	Big-O	works	both	theoretically	and	practically,	but	I’ll	provide	a	short	explanation	
so	that	later	on	you	can	have	an	understanding	of	the	difference	between	a	code	solution	that	runs	in	
O(n2)	vs.	O(n).	

Big-O	is	basically	a	tool	that	allows	us	to	measure	how	algorithms	respond	to	changes	in	input.	

In	other	words,	how	does	the	algorithm	perform	if	the	input	n	is	very	small	versus	if	n	is	extremely	
large?	The	syntax	for	using	Big-O	is	to	use	a	variable	(usually	the	letter	n)	which	represents	the	length	
of	the	input,	and	place	it	within	parentheses.	Given	that	O(n)	means	that	the	algorithms	grows	
linearly	with	the	input,	you	can	imagine	that	we	must	perform	a	computational	“step”	for	every	
element	in	the	input.	So	if	n	represents	an	array	with	100	elements,	then	our	algorithm	will	perform	
about	100	steps.	If	n	now	grows	to	100,000	elements,	our	algorithm	will	perform	100,000	steps.		

Now	imagine	we	have	an	algorithm	that	runs	in	O(n2).	If	n	represents	an	array	with	100	

elements,	our	algorithm	will	perform	about	10,000	steps	before	finishing	(1002	=	10,000).	If	n	now	
grows	to	100,000	elements,	our	algorithm	will	need	to	perform	about	10,000,000,000	steps	before	
finishing!	Now	you	can	see	the	extreme	difference	between	O(n)	and	O(n2)	when	n	is	equal	to	
100,000	elements.	Now	let’s	say	that	each	computational	“step”	takes	about	1	millisecond	to	run	(in	
reality,	the	time	it	takes	to	perform	a	simple	computation	is	much	faster	than	1	millisecond	on	a	
modern	computer).	If	the	input	n	is	equal	to	an	array	with	100,000	elements,	the	O(n)	time	algorithm	
will	finishing	running	in	about	100	seconds	(1	millisecond	*	100,000),	while	the	O(n2)	algorithm	will	
need	about	115	days	before	it	finishes	running.	Given	the	option	to	choose	an	algorithm	that	runs	in	
O(n)	or	O(n	2),	we	should	absolutely	always	choose	O(n).	

You	can	see	a	table	of	commonly	used	Big-O	expressions	here:	http://bit.ly/2e2YlpC,	and	here	

is	a	good	introductory	article	on	the	basics	of	Big-O:	http://bit.ly/1PzbnX4.		

	
	
	
	
		
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
12 

PART	2	
CHALLENGES	

“One	of	my	most	productive	days	was	throwing		
away	1,000	lines	of	code.”	

-	Ken	Thompson	

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
CHAPTER	3:	Practice	

13 

3.1. 

Fizz	buzz	

We	will	start	off	with	the	infamous	Fizz	buzz	challenge.	This	challenge	has	been	used	frequently	in	the	
past	as	an	initial	coding	challenge	to	filter	out	people	who	cannot	write	a	simple	solution.	The	general	
problem	is:	

Print	out	all	the	numbers	from	1	to	100.	But	for	every	number	divisible	by	3	print	replace	it	with	the	
word	“Fizz,”	for	any	number	divisible	by	5	replace	it	with	the	word	“Buzz”	and	for	a	number	divisible	
by	both	3	and	5	replace	it	with	the	word	“FizzBuzz.”		

So	your	program	should	output:	

1 
2 
Fizz 
4 
Buzz 
Fizz 
7 
. 
. 
. 

Let	us	examine	how	we	can	solve	this	problem.	The	first	thing	we	notice	is	that	we	will	definitely	need	
to	write	a	loop	because	the	problem	asks	us	to	print	numbers	within	a	range.	Then	we	need	to	check	
every	number	we	encounter	whether	it	is	divisible	by	3,	5,	or	3	and	5.	This	means	we’ll	most	likely	
need	at	least	3	conditional	statements.	To	check	if	a	number	is	divisible	by	some	number	X	we	will	be	
using	the	modulo	operator.[1]	Then	we	need	to	either	directly	print	the	numbers,	or	we	can	store	all	
of	the	numbers	in	an	array	and	then	return	the	final	array.	Below	is	a	sample	solution	with	some	
comments:	

[1]	Stack	Overflow	post	explaining	how	to	use	the	modulo	operator:	http://bit.ly/2dxq9Ss		

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
14 

JavaScript	

function fizzbuzz(n) { 

  // we will store the resulting numbers within an array 
  let result = []; 

  // loop from 1 to n 
  for (let i = 1; i <= n; i++) { 

    let add = ''; 

    // check if there is a remainder when dividing by 3, if not 
    // then we know this number is divisible by 3 
    if (i % 3 === 0) { add += 'Fizz'; } 

    // check if divisible by 5 
    if (i % 5 === 0) { add += 'Buzz'; } 

    // not divisible by either 3 or 5 
    if (add === '') { result.push(i); }  
    else { result.push(add); } 

  } 

  return result; 

}   

Python	

def fizzbuzz(n):  

  # we will store the resulting numbers within an array 
  result = [] 

  # loop from 1 to n 
  for i in range(1, n + 1): 

    add = '' 

    # check if there is a remainder when dividing by 3, if not 
    # then we know this number is divisible by 3 
    if i % 3 == 0: 
      add += 'Fizz' 

    # check if divisible by 5 
    if i % 5 == 0: 
      add += 'Buzz' 

    # not divisible by either 3 or 5 
    if add == '': 
      result.append(i) 
    else: 
      result.append(add) 

  return result 

	
	
	
	
	
 
 
 
 
 
 
 
   
 
 
 
 
 
 
 
 
 
 
15 

Ruby	

def fizzbuzz(n) 

  # we will store the resulting numbers within an array 
  result = [] 

  # loop from 1 to n 
  (1..n).each do |i| 

    add = '' 

    # check if there is a remainder when dividing by 3, if not 
    # then we know this number is divisible by 3 
    if i % 3 == 0 
      add += 'Fizz' 
    end 

    # check if divisible by 5 
    if i % 5 == 0 
      add += 'Buzz' 
    end 

    # not divisible by either 3 or 5 
    if add == '' 
      result.push(i) 
    else 
      result.push(add) 
    end 

  end 

  return result 

end 

3.2. 

Two	sum	problem	

The	two	sum	problem	is	a	classic	coding	interview	question	asked	at	both	coding	bootcamps	and	job	
interviews.	The	problem	is	as	follows:	

You	are	given	an	array	and	some	number	S.	Determine	if	any	two	numbers	within	the	array	sum	to	S.		

We’ll	first	cover	the	most	intuitive	way	to	solve	this	problem.	That	is	to	simply	loop	through	the	array	
and	for	each	element	check	if	there	is	a	second	element	that	when	both	are	summed	are	equal	to	S.	
This	will	require	us	to	write	a	nested	loop.[1]	This	solution	will	run	in	O(n2)	time	though	because	of	the	
nested	loop.	We	can	actually	do	better	and	write	an	algorithm	that	runs	only	in	O(n)	time	but	uses	
some	extra	space.	

[1]	Post	on	“Why	are	nested	loops	considered	bad	practice?”	http://bit.ly/2dL7w08		

	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
     
 
 
 
We	will	use	a	hash	table	where	insertion	and	lookup	run	in	constant	O(1)	time.	As	we	loop	through	
the	array	we	add	each	element	into	a	hash	table.	Then	we	check	to	see	if	S	minus	the	current	
elements	exists	in	the	hash	table	as	we	are	looping.	

16 

JavaScript	

function twoSum(arr, S) { 

  let hashTable = {}; 

  // check each element in array 
  for (let i = 0; i < arr.length; i++) { 

    // calculate S - current element 
    let sumMinusElement = S - arr[i]; 

    // check if this number exists in hash table 
    if (hashTable[sumMinusElement] !== undefined) {  
      return true; 
    } 

    // add the current number to the hash table 
    hashTable[arr[i]] = true; 

  } 

  return false; 

} 

Python	

def twoSum(arr, S): 

  hashTable = {} 

  # check each element in array 
  for i in range(0, len(arr)): 

    # calculate S minus current element 
    sumMinusElement = S - arr[i] 

    # check if this number exists in hash table 
    if sumMinusElement in hashTable: 
      return True 

    # add the current number to the hash table 
    hashTable[arr[i]] = True 

  return False 

	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
17 

Ruby	

def twoSum(arr, s) 

  hashTable = Hash.new 

  # check each element in array 
  arr.each_with_index do |v, i| 

    # calculate s minus current element 
    sumMinusElement = s - arr[i] 

    # check if this number exists in hash table 
    if hashTable.key?(sumMinusElement) 
      return true 
    end 

    # add the current number to the hash table 
    hashTable[arr[i]] = true 

  end 

  return false 

end 

3.3. 

Calculcate	the	sum	of	nested	arrays	

This	problem	asks	you	to	sum	up	all	of	the	numbers	within	an	array,	but	the	array	may	also	contains	
other	arrays	with	numbers.	This	is	what	we	call	a	nested	array.	For	example:	

[1, 1, 1, [3, 4, [8]], [5]]  

is	a	nested	array	and	summing	all	the	elements	should	produce	23.	We	will	solve	this	problem	by	
implementing	a	recursive	function	where	if	an	array	is	encountered	within	an	array,	we	simply	sum	all	
of	the	inner	arrays	elements	and	then	add	that	to	the	final	result.	For	example,	with	the	code	solution	
below	applied	to	the	above	array,	the	following	steps	would	take	place:		

1.  result	=	1	
2.  result	=	1	+	1	=	2	
3.  result	=	2	+	1	=	3	
4.  result	=	3	+	sumNested([3,	4,	[8]])	

4.1. 
4.2. 
4.3. 

result	=	3	
result	=	3	+	4	
result	=	7	+	sumNested([8])	

4.3.1.  result	=	8	

5.  result	=	3	+	15	=	18	
6.  result	=	18	+	sumNested([5])	
result	=	5	

6.1. 

7.  result	=	18	+	5	=	23	

	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
The	algorithm	below	simply	loops	through	the	entire	array,	and	if	a	nested	array	is	encounterd,	it	
loops	through	all	of	its	elements	as	well.	The	running	time	of	this	algorithm	is	therefore	O(n)	where	n	
is	the	length	of	the	entire	list	of	elements.		

18 

JavaScript	

function sumNested(arr) { 

  let result = 0; 

  // sum up all the numbers in array 
  for (let i = 0; i < arr.length; i++) { 

    // if element is a nested array, sum all of its elements 
    if (typeof arr[i] !== 'number') { 
      result += sumNested(arr[i]); 
    } else { 
      result += arr[i]; 
    } 

  } 

  return result; 

} 

Python	

def sumNested(arr): 

  result = 0 

  # sum up all the numbers in array 
  for i in range(0, len(arr)): 

    # if element is a nested array, sum all of its elements 
    if type(arr[i]) is not int: 
      result += sumNested(arr[i]) 
    else: 
      result += arr[i] 

  return result 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
   
 
 
 
 
 
 
 
 
 
19 

Ruby	

def sumNested(arr) 

  result = 0 

  # sum up all the numbers in array 
  arr.each_with_index do |val, i| 

    # if element is a nested array, sum all of its elements 
    if !val.instance_of? Fixnum 
      result += sumNested(val) 
    else 
      result += val 
    end 

  end 

  return result 

end 

3.4. 

Calculcate	the	angle	on	a	clock	

This	problem	asks	you	to	determine	the	angle	between	the	to	hands	on	a	clock.	For	example,	if	the	
minute	hand	is	on	the	3	and	the	hour	hand	is	on	the	12,	then	this	forms	a	90	degree	angle.	If	the	hour	
hand	is	slightly	past	the	2	and	the	minute	hand	is	on	the	4,	then	the	angle	formed	between	the	hands	
is	50	degrees	(image	below	for	reference	[Clock	angle	problem	on	Wikipedia:	http://bit.ly/2dxFmmt]).	

We	will	solve	this	problem	by	first	calculating	the	angles	for	the	hour	hand	and	minute	hand	
separately.	The	minute	hand	is	the	easiest	and	that	is	simply:	

Minute	hand	angle	=	6	*	minutes	

because	there	are	360	degrees	total	on	the	clock	and	there	are	a	total	of	60	minutes,	so	360	/	60	=	6	
degrees	per	minute.	The	hour	hand	is	a	bit	trickier	because	it	moves	slightly	every	time	the	minute	
hand	moves.	Therefore,	to	calculate	the	angle	of	the	hour	hand	we	need	to	take	into	account	how	
much	the	minute	hand	has	moved.		

	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
20 

First,	we	can	perform	the	same	calculcation	we	did	above	but	with	different	values.	The	hour	hand	
moves	around	the	entire	clock	after	12	hours,	of	720	minutes,	which	gives	us	360	/	720	=	0.5	per	
minute.	We	also	need	to	account	for	how	much	the	minute	hand	has	moved.	The	full	equation	is	
below:	

Hour	hand	angle	=	0.5	*	change	in	minutes	=	0.5	*	(60	*	hour	+	minutes)	

The	angle	between	these	two	hands	will	therefore	be	the	absolute	value	of	the	hour	hand	angle	
minus	the	minute	hand	angle.	But	one	caveat,	and	that	is	if	the	number	is	greater	than	180	degrees	
we	actually	need	to	subtract	the	value	from	360	because	the	hands	are	on	the	opposite	side	of	the	
clock.	

JavaScript	

function clockAngle(hour, min) {  

  var h = 0.5 * (60 * hour + min); 
  var m = 6 * min; 
  var angle = Math.abs(h - m); 
  return (angle > 180) ? 360 - angle : angle; 

} 

Python	

def clockAngle(hour, mins): 

  h = 0.5 * (60 * hour + mins) 
  m = 6 * mins 
  angle = abs(h - m) 

  if angle > 180: 
    return 360 - angle 
  else: 
    return angle 

Ruby	

def clockAngle(hour, min) 

  h = 0.5 * (60 * hour + min) 
  m = 6 * min 
  angle = (h - m).abs 

  if angle > 180 
    return 360 - angle 
  else 
    return angle 
  end 

end 

	
	
	
	
	
	
	
	
	
	
	
	
 
          
 
 
 
 
 
 
 
 
21 

3.5.  Determine	if	N	is	a	prime	number	

This	is	a	classic	coding	questins	that	asks	you	to	write	a	program	to	determine	whether	or	not	some	
input	N	is	a	prime	number.	A	prime	number	is	a	number	that	is	divisible	only	by	1	and	itself.	The	first	
few	prime	numbers	are:	2,	3,	5,	7,	11,	17,	…	

The	simplest	way	to	solve	this	challenge	is	to	first	see	that	the	only	way	for	a	number	to	be	a	
prime	is	for	it	to	have	no	divisors	between	2	and	itself.	For	example,	to	check	if	9	is	prime	you	would	
check	if	9	is	divisible	by	2,	if	9	is	divisible	by	3,	etc.	To	check	if	a	number	is	exactly	divisible	by	some	
other	number	we	are	going	to	using	the	modulo	operation	to	see	if	there	is	a	remainder	after	the	
divison.	For	example,	9	modulo	2	gives	us	1,	but	then	9	%	3	is	0	so	we	know	that	9	is	not	a	prime	
number	because	it	is	divisble	by	3.		

The	solution	for	this	problem	would	therefore	be	structured	the	following	way:	Write	a	loop	

from	2	to	N	to	check	if	(N	modulo	x),	where	x	is	every	number	we	are	checking,	is	equal	to	0.	If	so,	
then	the	number	is	prime,	otherwise	it	is	not.	But	there	is	a	tiny	detail	we	can	implement	to	make	the	
algorithm	run	a	bit	faster.	The	detail	is	that	if	N	is	not	a	prime	number,	then	there	are	two	numbers	
when	multipled	give	N:	a	*	b	=	N.	The	detail	is	that	one	of	the	numbers,	a	or	b,	will	always	be	less	
than	the	square	root	of	N.[1]	With	this	detail	in	mind,	we	don’t	need	to	loop	from	2	to	N	now,	we	can	
simply	loop	from	2	to	the	square	root	of	N.	The	running	time	will	therefore	be	O(√n).	

JavaScript	

function isprime(n) {  

  // all numbers less than 2 are not primes 
  if (n < 2) { return false; }        

  // loop from 2 to sqrt(n)  
  for (let i = 2; i <= Math.ceil(Math.sqrt(n)); i++) { 

    // check if (n mod i) is equal to 0, if so then there are 
    // two numbers, a and b, that can multiply to give n 
    if (n % i === 0) { return false; } 

  } 

  return true; 

} 

[1]	Stack	Overflow	post	and	comment	on	“Calculcating	and	printing	the	Nth	prime	number”	http://bit.ly/2e7gzLi		

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
   
 
 
 
   
 
22 

Python	

import math 

def isprime(n):  

  # all numbers less than 2 are not primes 
  if n < 2: 
    return False 

  # loop from 2 to sqrt(n) 
  for i in range(2, int(math.ceil(math.sqrt(n)))): 

    # check if (n mod i) is equal to 0, if so then there are 
    # two numbers, a and b, that can multiply to give n 
    if n % i == 0: 
      return False 

  return True 

Ruby	

def isprime(n) 

  # all numbers less than 2 are not primes 
  return false if n < 2 

  # loop from 2 to sqrt(n) 
  (2..Math.sqrt(n).round).each do |i| 

    # check if (n mod i) is equal to 0, if so then there are 
    # two numbers, a and b, that can multiply to give n 
    return false if n % i == 0 

  end 

  return true 

end 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
   
 
 
 
 
 
 
 
 
          
 
23 

3.6. 

Implement	map	and	filter	

Map	and	filter	are	common	functional	programming	methods	that	you’ve	most	likely	used	when	
coding.	They	are	both	functions	that	take	in	a	list,	perform	some	operation	on	that	list	without	
changing	the	original	list,	and	then	return	a	new	lists.	The	functions	do	not	change	any	other	variables	
and	do	not	touch	anything	else	except	those	lists	they	were	given.	JavaScript,	Python,	and	Ruby	all	
have	their	own	built-in	versions	of	these	functions,	but	we	are	going	to	impement	our	own.	

Map	works	by	taking	a	list	and	a	function,	and	it	applies	the	function	to	each	element	in	the	list	and	
returns	a	new	list.	For	example,	you	may	want	to	square	every	number	in	an	array	or	append	a	string	
to	every	element	in	an	array.	We	want	an	implementation	where	we	can	pass	in	two	parameters,	one	
being	the	array	and	the	second	being	some	function	that	will	be	mapped	onto	every	element.	

Filter	works	by	taking	a	list	and	a	conditional	statement,	and	it	returns	a	new	list	where	every	
element	in	the	original	list	passes	the	conditional	(returns	true).	For	example,	you	may	have	a	list	of	
ages	and	you	want	a	new	list	of	ages	where	each	one	is	between	21	and	35.	We	want	an	
implementation	where,	similar	to	the	map	function,	we	pass	in	a	list	and	a	function	that	contains	
within	it	a	conditional	statement.	

Some	extra	resources	on	functional	methods	are	listed	below:	

JavaScript	
http://cryto.net/~joepie91/blog/2015/05/04/functional-programming-in-javascript-map-filter-
reduce/		

Python	
http://blog.lerner.co.il/implementing-map-reduce/		

Ruby	
https://mauricio.github.io/2015/01/12/implementing-enumerable-in-ruby.html		
http://augustl.com/blog/2008/procs_blocks_and_anonymous_functions/		

	
	
	
	
	
	
	
	
		
	
	
	
	
	
	
	
	
	
	
	
	
	
	
24 

JavaScript	

function map(arr, fn) { 

  let result = []; 

  // apply the function to each element and store the result 
  for (let i of arr) { 
    let applied = fn(i); 
    result.push(applied); 
  } 

  return result; 

} 

// usage 
let square = (x) => x * x; 
let addZeros = (x) => parseInt(x += '00'); 

map([1, 2, 3, 4], square); // => [1, 4, 9, 16] 
map([1, 2, 3, 4], addZeros); // => [100, 200, 300, 400] 

function filter(arr, fn) { 

  let result = []; 

  // pass the element to the function and check 
  // if the result comes back true 
  for (let i of arr) { 
    let check = fn(i); 
    if (check) { result.push(i); } 
  } 

  return result; 

} 

// usage 
let isPositive = (x) => x > 0; 
filter([-2, 4, 5, 8, -44, -6], isPositive); // => [4, 5, 8] 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
 
 
25 

Python	

def map(arr, fn): 

  result = [] 

  # apply the function to each element and store the result 
  for i in arr: 
    applied = fn(i) 
    result.append(applied) 

  return result 

# usage 
square = lambda x: x * x 
addZeros = lambda x: int(str(x) + '00') 

map([1, 2, 3, 4], square) # => [1, 4, 9, 16] 
map([1, 2, 3, 4], addZeros) # => [100, 200, 300, 400] 

def filter(arr, fn): 

  result = [] 

  # pass the element to the function and check 
  # if the result comes back true 
  for i in arr: 
    check = fn(i) 
    if check: 
      result.append(i) 

  return result 

# usage 
isPositive = lambda x: x > 0 
filter([-2, 4, 5, 8, -44, -6], isPositive); # => [4, 5, 8] 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
26 

Ruby	

def map(arr, fn) 

  result = [] 

  # apply the function to each element and store the result 
  arr.each do |i| 
    applied = fn.call(i) 
    result.push(applied) 
  end 

  return result 

end 

square = lambda { |x| x * x } 
addZeros = lambda { |x| x.to_s + '00' }  

p map([1, 2, 3, 4], square) # => [1, 4, 9, 16] 
p map([1, 2, 3, 4], addZeros) # => [100, 200, 300, 400] 

def filter(arr, fn) 

  result = [] 

  # pass the element to the function and check 
  # if the result comes back true 
  arr.each do |i| 
    check = fn.call(i) 
    if check 
      result.push(i) 
    end 
  end 

  return result 

end 

# usage 
isPositive = lambda { |x| x > 0 } 
p filter([-2, 4, 5, 8, -44, -6], isPositive); # => [4, 5, 8] 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
 
 
27 

3.7. 

Remove	set	of	characters	from	a	string	

These	types	of	challenges	are	very	common	for	people	learning	to	code.	The	problem	description	is:	

You	are	given	an	array	of	characters	and	a	string	S.	Write	a	function	to	return	the	string	S	with	all	the	
characters	from	the	array	removed.	

The	first	thing	to	notice	is	that	we’ll	need	to	loop	through	the	entire	string	S	and	loop	through	the	
array	of	characters	because	we’ll	need	to	find	the	characters	to	actually	remove	from	the	string.	
There	are	two	ways	to	construct	the	loops:	

1.  Loop	through	the	array	of	characters	and	for	each	chracter,	find	all	of	the	occurences	in	S	and	

remove	them.	

2.  Loop	through	the	string	S	and	if	the	current	character	exists	in	the	array	of	characters	

somewhere,	remove	it.	

We’re	going	to	go	with	the	second	option	because	we	can	improve	the	algorithm	by	actually	storing	
all	of	the	characters	in	the	array	in	a	hash	table.	This	will	allow	us	to	loop	through	the	string	S	and	
determine	if	the	current	character	needs	to	be	removed	by	checking	if	it	exists	in	the	hash	table.	
Remember	from	before,	checking	if	an	element	exists	in	a	hash	table	is	done	in	constant	time	so	the	
running	time	of	our	algorithm	will	be	O(n)	where	n	is	the	length	of	the	string	S	plus	some	
preprocessing	where	we	loop	through	the	array	of	characters	and	store	them	in	a	hash	table.	

JavaScript	

function removeChars(arr, string) { 

  // store characters of arr in a hash table 
  var hashTable = {}; 
  for (let c of arr) { 
    hashTable[c] = true; 
  } 

  // loop through the string and check if the character exists in  
  // the hash table, if so, do not add it to the result string 
  let result = ''; 
  for (let c of string) { 
    if (hashTable[c] === undefined) { 
      result += c; 
    } 
  } 

  return result; 

} 

// usage 
removeChars(['h', 'e', 'w', 'o'], "hello world"); // => "ll rld" 

	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
28 

Python	

def removeChars(arr, string): 

  # store characters of arr in a hash table 
  hashTable = {} 
  for c in arr: 
    hashTable[c] = True  

  # loop through the string and check if the character exists in  
  # the hash table, if so, do not add it to the result string 
  result = '' 
  for c in string: 
    if c not in hashTable: 
      result += c 

  return result 

# usage 
print removeChars(['h', 'e', 'w', 'o'], 'hello world') # => "ll rld" 

Ruby	

def removeChars(arr, string) 

  # store characters of arr in a hash table 
  hashTable = Hash.new 
  arr.each { |c| hashTable[c] = true } 

  # loop through the string and check if the character exists in  
  # the hash table, if so, do not add it to the result string 
  result = '' 
  string.split('').each do |c| 
    if !hashTable.key?(c) 
      result += c 
    end 
  end 

  return result 

end 

# usage 
puts removeChars(['h', 'e', 'w', 'o'], 'hello world') # => "ll rld" 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
3.8. 

Check	if	valid	number	of	parenthesis	

This	problem	asks	you	to	determine	if	there	is	a	valid	number	of	matching	parenthsis	in	a	string,	or	
more	formally:	

You	are	given	a	string	with	the	symbols	(	and	)	and	you	need	to	write	a	function	that	will	determine	if	
the	parenthsis	are	correctly	nested	in	the	string	which	means	every	opening	(	has	a	closing	)	

There	are	countless	ways	to	actually	nest	parenthsis	and	have	them	be	valid,	for	example:	

29 

() 
(()) 
()()() 
((()())) 

Below	are	examples	of	some	invalid	matchings:	

(() 
(((( 
())() 
()()()) 

The	first	thing	to	notice	is	that	it	doesn’t	matter	how	many	parenthesis	we	actually	have,	what	
matters	is	that	every	single	opening	parenthsis	“(“	at	some	point	has	a	closing	parenthesis	“).”	What	
we	can	do	to	solve	this	challenge	is	to	maintain	a	counter	and	every	single	time	we	encounter	an	
opening	symbol	we	add	1	to	it.	Then	every	time	we	encounter	a	closing	symbol	we	remove	1.	If	all	
opening	symbols	have	a	matching	symbol	at	some	point	in	the	string,	the	end	result	of	the	counter	
should	be	0.	If	it	is	more	or	less	we’ll	know	that	all	parenthesis	aren’t	properly	matched.	You	can	see	
that	for	the	first	4	examples	above,	if	we	maintain	a	counter	we	will	end	up	at	0	once	we	reach	the	
end	of	the	string.	

JavaScript	

function matchingParens(string) { 

  let counter = 0; 

  for (let c of string) { 
    if (c === '(') { counter += 1; }  
    if (c === ')') { counter -= 1; } 
  } 

  return (counter === 0) ? true : false; 

} 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
30 

Python	

def matchingParens(string): 

  counter = 0 

  for c in string: 
    if c == '(': 
      counter += 1r 
    elif c == ')': 
      counter -= 1 

  if counter == 0: 
    return True  
  else: 
    return False 

Ruby	

def matchingParens(string) 

  counter = 0 

  string.split('').each do |c| 
    if c == '(' 
      counter += 1 
    elsif c == ')' 
      counter -= 1 
    end 
  end 

  if counter == 0 
    return true  
  else 
    return false 
  end 

end 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
31 

3.9. 

First	non-repeating	character	

For	this	challenge	you	are	given	a	string	and	you	should	return	the	first	character	that	is	unique	in	the	
entire	string.	For	example:	

• 

If	string	is	“hello henry”	then	the	first	non-repeating	character	is	the	letter	“o”	because	
the	first	three	characters	in	the	string	appear	multiple	times.	

A	simple	solution	to	this	challenge	is	to	loop	through	the	string,	and	for	each	character,	loop	
through	the	rest	of	the	string	and	check	if	that	character	appears	somewhere	else.	Then	return	the	
first	character	that	does	not	appear	anywhere	in	the	string	except	the	current	location.	This	solution	
will	run	in	O(n2)	though	because	of	the	nested	loop,	so	there	is	definitely	room	for	improvement.	

We	need	to	somehow	store	the	letters	and	their	frequencies	in	a	data	structure	that’ll	allow	

us	to	check	how	many	times	a	specific	character	occurred.	To	solve	this	challenge,	we’ll	first	loop	
through	the	string	once	and	maintain	a	hash	table	that	stores	the	count	of	each	character.	Then	we’ll	
loop	through	the	string	again	and	return	the	first	character	we	encounter	that	has	a	count	of	1	in	the	
hash	table,	meaning	it	occurs	only	once	in	the	string.	This	algorithm	will	run	in	O(2n)	because	we	are	
looping	through	the	string	twice,	and	this	reduces	to	O(n)	because	we	drop	the	constant,[1]	which	is	
much	faster	than	the	nested	loop	algorithm	from	above.	

JavaScript	

function firstNonrepChar(string) { 

  let hashTable = {}; 

  // store each character in the hash table with  
  // the frequency of times it occurs 
  for (let c of string) { 
    if (hashTable[c] === undefined) { 
      hashTable[c] = 1; 
    } else { 
      hashTable[c] += 1; 
    } 
  } 

  // loop through string and return the first character 
  // with a count of 1 in the hash table 
  for (let c of string) { 
    if (hashTable[c] === 1) { 
      return c; 
    } 
  } 

  // return -1 if no unique character exists 
  return -1; 

} 

[1]	Stack	Overflow	post	on	“Why	is	the	constant	always	dropped	from	Big-O	analysis?”	http://bit.ly/2dNSM2X		

	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
32 

Python	

def firstNonrepChar(string): 

  hashTable = {} 

  # store each character in the hash table with  
  # the frequency of times it occurs 
  for c in string: 
    if c not in hashTable: 
      hashTable[c] = 1 
    else: 
      hashTable[c] += 1 

  # loop through string and return the first character 
  # with a count of 1 in the hash table 
  for c in string: 
    if hashTable[c] == 1: 
      return c 

  # return -1 if no unique character exists 
  return -1 

Ruby	

def firstNonrepChar(string) 

  hashTable = {} 

  # store each character in the hash table with  
  # the frequency of times it occurs 
  string.split('').each do |c| 
    if !hashTable.key?(c) 
      hashTable[c] = 1 
    else 
      hashTable[c] += 1 
    end 
  end 

  # loop through string and return the first character 
  # with a count of 1 in the hash table 
  string.split('').each do |c| 
    if hashTable[c] == 1 
      return c 
    end 
  end 

  # return -1 if no unique character exists 
  return -1 

end 

	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
3.10.  Count	words	that	have	at	least	3	continuous	vowels	

This	challenge	will	require	us	to	take	a	string,	separate	it	into	words,	and	then	loop	through	the	words	
and	count	how	many	words	have	at	least	3	vowels.	This	will	require	us	to	first	convert	a	string	into	an	
array	of	words,	then	loop	through	that	array	and	for	each	word	loop	through	its	characters	and	
determine	how	many	vowels	exist	in	it	and	whether	or	not	they	are	all	adjacent	to	each	other.	There	
are	two	ways	we	can	count	the	number	or	vowels	within	a	word:	

33 

1.  Loop	through	the	string	and	maintain	a	counter.	
2.  Perform	a	regular	expression	search	that	counts	the	vowels.	

We	are	going	to	go	with	the	second	method	of	using	a	regular	expression	(regex)	to	count	the	vowels	
in	a	word	and	determine	whether	they	are	continuous.	I’ll	leave	solving	this	challenge	via	the	first	
method	as	an	exercise	for	the	reader.	The	solution	below	splits	the	string	into	an	array	of	words	and	
then	loops	through	that	array	applying	a	regex	search	on	each	word.	A	regex	search	words	by	trying	
to	find	a	search	pattern	within	a	string.[1]	The	search	pattern	we	will	be	using	is	to	search	for	a	set	of	
characters,	the	vowes	in	this	case,	and	check	whether	at	least	3	of	them	occur	next	to	each	other.	

JavaScript	

function threeVowels(string) { 

  // split string into array of words 
  let arr = string.split(' '); 
  let count = 0; 

  // this is the pattern we will be searching for 
  // more on regex patterns here: https://mzl.la/1bMbpXP 
  const pattern = /[aeiou]{3,}/gi; 

  // loop through array of words 
  for (let word of arr) { 
    if (word.match(pattern) !== null) { 
      count += 1; 
    } 
  } 

  return count; 

} 

[1]	What	is	a	Regular	Expression?	http://bit.ly/2dL7WUh		

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
34 

Python	

import re 

def threeVowels(string): 

  # split string into array of words 
  arr = string.split(' ') 
  count = 0 

  # this is the pattern we will be searching for 
  # more on regex patterns here: http://bit.ly/RGnLh4 
  # loop through array of words 
  for word in arr: 
    if re.search(r'[aeiou]{3,}', word) != None: 
      count += 1 

  return count 

Ruby	

def threeVowels(string) 

  # split string into array of words 
  arr = string.split(' ') 
  count = 0 

  # this is the pattern we will be searching for 
  # more on regex patterns here: http://bit.ly/2dAvCZl 
  pattern = /[aeiou]{3,}/ 

  # loop through array of words 
  arr.each do |word| 
    if pattern.match(word) != nil 
      count += 1 
    end 
  end 

  return count 

end 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
   
 
 
35 

3.11.  Remove	all	adjacent	matching	characters	

This	challenge	asks	you	to	remove	all	matching	adjacent	pairs	of	letters	from	a	string	and	return	the	
modified	string.	For	example,	if	the	string	is	“aaagykkok” then	your	program	would	return	
“agyok”	because	“aa”	and	“kk”	had	been	removed.		

The	first	thing	to	notice	is	that	we	can	create	a	simple	loop	that	checks	each	character	in	the	
string	and	checks	if	it	is	equal	to	the	character	right	after	it,	if	so,	it	skips	both	characters.	It	does	this	
for	every	character	with	a	special	case	added	to	check	if	the	end	of	the	string	has	been	reached	
(because	at	the	last	character,	we	cannot	check	if	it	is	equal	to	the	next	character	because	there	is	no	
next	character	once	it	reaches	the	end	of	the	string).	

JavaScript	

function removePairs(string) { 

  // new string that will be returned 
  let result = ''; 

  // loop through entire string 
  for (let i = 0; i < string.length; i++) { 
    // if on last character 
    if (i === string.length - 1) { 
      result += string[i]; 
    } 
    // characters are not equal then add to new string 
    else if (string[i] !== string[i + 1]) { 
      result += string[i]; 
    }  
    // if adjacent characters are equal to each other 
    // skip the next character entirely 
    else { 
      i += 1; 
    } 
  } 

  return result; 

} 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
36 

Python	

def removePairs(string): 

  # new string that will be returned 
  result = '' 
  i = 0 

  # loop through entire string 
  while i < len(string): 
    # if on last character 
    if i == len(string) - 1: 
      result += string[i] 
    # characters are not equal then add to new string 
    elif string[i] != string[i + 1]: 
      result += string[i] 
    # if adjacent characters are equal to each other 
    # skip the next character entirely 
    else: 
      i += 1 
    i += 1 

  return result 

Ruby	

def removePairs(string) 

  # new string that will be returned 
  result = '' 
  i = 0 

  # loop through entire string 
  while i < string.length do 
    # if on last character 
    if i == string.length - 1 
      result += string[i] 
    # characters are not equal then add to new string 
    elsif string[i] != string[i + 1] 
      result += string[i] 
    # if adjacent characters are equal to each other 
    # skip the next character entirely 
    else 
      i += 1 
    end 
    i += 1 
  end 

  return result 

end 

	
	
	
	
	
	
	
	
	
	
 
   
   
 
 
   
   
 
 
37 

3.12.  Find	the	majority	element	(element	that	appears	more	than	n/2	times)	

Finding	the	majority	element	in	an	array	involves	finding	an	element	that	appears	strictly	more	than	
n/2	times	where	n	is	the	size	of	the	array.	For	example,	in	the	array	[1, 4, 5, 5, 5, 5]	the	
element	5	appears	4	times	and	n/2	=	6/2	=	3,	so	the	element	5	is	the	majority	element.	If	on	the	other	
hand	the	array	was	[1, 4, 4, 5, 5] then	the	element	5	is	not	the	majority	element.	There	
actually	is	no	majority	element	because	no	element	appears	more	than	n/2	=	5/2	=	2	times.	

To	solve	this	challenge	we	can	create	a	nested	loop	and	in	the	outer	loop	go	through	each	

element,	and	then	in	the	inner	loop	check	all	the	other	elements	in	the	array	and	count	the	
occurences	of	the	current	element.	This	would	make	the	code	very	compact	but	the	algorithm	would	
run	in	O(n2)	time	because	of	the	nested	loop	checking	each	of	the	n	elements,	and	then	in	the	inner	
loop	checking	them	again:	n	*	n	=	n2.	There	is	a	faster	way	to	solve	this	problem	and	that	is	to	use	the	
Majority	Vote	Algorithm	(http://bit.ly/1KVeJTk).	It	works	the	following	way:	

1.  Start	with	a	candidate	element	that	is	empty	and	a	count	that	is	set	to	0.	
2.  For	each	element	in	the	array	we	check	it	against	the	candidate	element.	 	

• 

• 
• 

If	the	candidate	element	is	blank	or	the	count	is	equal	to	0,	set	the	current	element	to	be	
the	candidate	element	and	set	the	count	to	1.	
If	the	current	element	equals	the	candidate	element,	increase	the	count	by	1.	
If	the	current	element	does	not	equal	the	candidate	element,	decrease	the	count	by	1.	

This	algorithm	will	run	in	linear	time,	O(n),	because	it	only	loops	through	the	whole	array	a	single	
time	maintaining	two	variables	as	it	passes	through.	

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
38 

JavaScript	

function majorityElement(arr) { 

  let candidate = null; 
  var count = 0; 

  // 1. if candidate is null or count = 0 set candidate to the current element 
  // 2. if candidate matches current element we increase the count 
  // 3. if candidate does not match current element, decrease the count by 1 
  for (let i = 0; i < arr.length; i++) { 
    if (candidate === null || count === 0) { 
      candidate = arr[i]; 
      count = 1; 
    } else if (arr[i] === candidate) { 
      count += 1; 
    } else { 
      count -= 1; 
    } 
  } 

  // once we have a majority element we check 
  // to make sure it occurs more than n/2 times 
  count = 0; 
  for (let el of arr) { 
    if (el === candidate) { 
      count += 1; 
    } 
  } 

  return (count > Math.floor(arr.length / 2)) ? candidate : null; 

} 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
39 

Python	

import math 

def majorityElement(arr): 

  candidate = None 
  count = 0 

  # 1. if candidate is None or count = 0 set candidate to the current element 
  # 2. if candidate matches current element we increase the count 
  # 3. if candidate does not match current element, decrease the count by 1 
  for i in range(0, len(arr)): 
    if candidate is None or count == 0: 
      candidate = arr[i] 
      count = 1 
    elif arr[i] == candidate: 
      count += 1 
    else: 
      count -= 1 

  # once we have a majority element we check 
  # to make sure it occurs more than n/2 times 
  count = 0 
  for el in arr: 
    if el == candidate: 
      count += 1 

  if count > math.floor(len(arr) / 2): 
    return candidate 
  else: 
    return None 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
40 

Ruby	

def majorityElement(arr) 

  candidate = nil 
  count = 0 

  # 1. if candidate is nil or count = 0 set candidate to the current element 
  # 2. if candidate matches current element we increase the count 
  # 3. if candidate does not match current element, decrease the count by 1 
  arr.each do |i| 
    if candidate == nil || count == 0 
      candidate = i 
      count = 1 
    elsif i == candidate 
      count += 1 
    else 
      count -= 1 
    end 
  end 

  # once we have a majority element we check 
  # to make sure it occurs more than n/2 times 
  count = 0 
  arr.each do |el| 
    if el == candidate 
      count += 1 
    end 
  end 

  if count > (arr.length / 2).floor 
    return candidate 
  else 
    return nil 
  end 

end 

3.13.  Switching	light	bulbs	problem	

This	problem	has	a	lot	of	different	variations,	but	the	one	we	will	cover	here	is	the	following:	Imagine	
there	are	100	light	bulbs,	labeled	from	1	to	100,	lined	up	all	set	to	off	initially.	There	are	also	100	
people	each	numbered	1	to	100	as	well.	Person	1	will	go	through	all	the	light	bulbs	and	flip	the	switch	
turning	all	of	them	on.	Then	person	number	2	will	go	through	all	the	light	bulbs	and	flip	the	switch	on	
each	2nd	element	turning	them	off,	namely:	light	bulbs	#2,	#4,	#6,	#8,	etc.	Then	person	3	will	go	and	
do	the	same	for	the	3rd	ligh	bulb,	6th,	9th,	etc.	Then	questions	are	usually	asked	about	the	light	bulbs,	
for	example:	

•  How	many	light	bulbs	will	be	on	after	100	people	have	gone	through	them?	
•  What	is	the	status	of	the	Nth	light	bulb	(34th,	62nd,	etc.)?	Is	it	on	or	off?	
•  How	many	people	need	to	go	through	the	line	of	light	bulbs	until	exactly	K	light	bulbs	are	set	

to	on?	

	
	
	
	
	
	
	
 
 
 
 
 
 
To	answer	any	of	these	questions,	we’ll	write	a	function	that	goes	through	all	N	light	bulbs	and	
performs	each	operation	for	every	person	labeled	from	1	to	N.	What	we’ll	do	for	this	problem	is	
setup	an	array	of	N	elements	all	set	to	false,	which	will	represent	a	light	bulb	in	the	off	position.	Then	
we	will	loop	through	every	person	from	1	to	N,	and	within	that	loop	create	another	loop	that	will	
multiply	each	person’s	number	by	a	number	each	time	to	change	the	following	light	bulbs:	

41 

•  For	i	=	1,	change	1,	2,	3,	4,	etc.	
•  For	i	=	2,	change	2,	4,	6,	8,	etc.	
•  For	i	=	3,	change	3,	6,	9,	12,	etc.	

JavaScript	

function lightBulbs(N) { 

  // create N lightbulbs and set them to off 
  let lightbulbs = []; 
  for (let i = 0; i < N; i++) { 
    lightbulbs.push(false); 
  } 

  // each person i labeled from 1 to N sets each kth  
  // lightbulb on or off where k = 2*i, 3*i, etc. 
  for (let i = 1; i <= N; i++) { 
    let w = 1; 
    let k = w * i; 
    while (k <= N) { 
      lightbulbs[k - 1] = !lightbulbs[k - 1]; 
      w += 1; 
      k = w * i; 
    }  
  } 

  return lightbulbs; 

} 

Python	

def lightBulbs(N): 

  # create N lightbulbs and set them to off 
  lightbulbs = [False for i in range(0, N)] 

  # each person i labeled from 1 to N sets each kth  
  # lightbulb on or off where k = 2*i, 3*i, etc. 
  for i in range(1, N + 1): 
    w = 1 
    k = w * i 
    while k <= N: 
      lightbulbs[k - 1] = not lightbulbs[k - 1] 
      w += 1 
      k = w * i 

  return lightbulbs 

	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
42 

Ruby	

def lightBulbs(n) 

  # create N lightbulbs and set them to off 
  lightbulbs = Array.new(n, false) 

  # each person i labeled from 1 to N sets each kth  
  # lightbulb on or off where k = 2*i, 3*i, etc. 
  (1..n).each do |i| 
    w = 1 
    k = w * i 
    while k <= n do 
      lightbulbs[k - 1] = !lightbulbs[k - 1] 
      w += 1 
      k = w * i 
    end 
  end 

  return lightbulbs 

end 

3.14.  List	of	integers	that	overlap	in	two	ranges	

For	this	problem	you’ll	need	to	find	all	the	numbers	that	overlap	between	two	ranges,	for	example:	
between	the	two	ranges	of	[5,	20]	and	[17,	21]	the	overlapping	integers	are	[17,	18,	19,	20,	21].	One	
way	to	solve	this	problem	would	be	to	create	a	list	for	each	range	and	store	each	number	within	the	
respective	lists.	So	for	the	above	example,	you	would	create	two	lists:	

[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] 
[17, 18, 19, 20, 21]   

Then	you	would	just	loop	through	one	of	the	lists,	and	for	each	element	check	if	it	exists	

somewhere	in	the	second	list	using	a	built	in	array	search	function.	This	solution	would	work	and	
require	little	code,	but	it	is	not	an	efficient	way	to	solve	this	problem.	One	reason	is	because	there	
isn’t	really	any	point	in	actually	creating	the	lists	and	taking	up	space	with	them,	and	the	second	
reason	is	the	running	time	of	this	algorithm	would	be	about	O(n2)	because	this	function	would	have	a	
nested	loop.	We	can	solve	this	problem	in	a	more	efficient	way.	

We	will	simply	loop	from	the	start	of	range	1	to	the	end	of	range	1.	Then	we	will	check	if	each	
of	the	numbers	within	that	range	are	greater	than	the	beginning	of	range	2	and	lesser	than	the	end	of	
range	2.	This	algorithm	will	therefore	run	in	O(n)	time	where	n	represents	the	length	of	one	of	the	
ranges.	This	algorithm	only	performs	a	simple	check	within	the	loop,	namely,	whether	some	element	
is	smaller	and	greater	than	some	other	number	–	no	searching	required	which	is	what	speeds	up	the	
algorithm.	

	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
43 

JavaScript	

function overlapping(range1, range2) { 

  let overlap = []; 

  // check whether each number within range 1 
  // is within the numbers in range 2 
  for (let i = range1[0]; i <= range1[1]; i++) { 
    if (i >= range2[0] && i <= range2[1]) { 
      overlap.push(i); 
    } 
  } 

  return overlap; 

} 

Python	

def overlapping(range1, range2): 

  overlap = [] 

  # check whether each number within range 1 
  # is within the numbers in range 2 
  for i in range(range1[0], range1[1] + 1): 
    if i >= range2[0] and i <= range2[1]: 
      overlap.append(i) 

  return overlap 

Ruby	

def overlapping(range1, range2) 

  overlap = [] 

  # check whether each number within range 1 
  # is within the numbers in range 2 
  (range1[0]..range1[1]).each do |i| 
    if i >= range2[0] && i <= range2[1] 
      overlap.push(i) 
    end 
  end 

  return overlap 

end 

	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
 
 
 
44 

3.15.  Return	mean,	median,	and	mode	of	an	array	

This	is	more	of	a	simpler	question	that	doesn’t	require	too	much	complex	code	to	solve.	It	simply	
requires	you	to	do	3	things,	calculcate	the	mean	which	is	the	average	of	all	the	numbers,	the	median	
which	is	the	middle	number	when	the	array	is	sorted,	and	the	mode	which	is	the	number	that	
appears	the	most.	

To	calculcate	the	average	we	will	simply	add	up	all	the	numbers	and	divide	by	the	length	of	
the	array.	To	calculcate	the	median	we	will	first	sort	the	array	and	then	return	the	middle	number.	
Finally,	the	mode	will	require	some	extra	work,	but	to	find	the	number	that	appears	most	often	we	
will	use	a	hash	table	to	store	the	number	of	times	each	number	occurs	and	we	will	return	the	one	
with	the	highest	occurences.	

	JavaScript	

function meanMedianMode(arr) { 

  // to calculcate the mean we add up all the numbers 
  // and divide by the length 
  let mean = arr.reduce((prev, cur) => prev + cur) / arr.length; 

  // to calculcate the median we need to sort the array 
  // and return the middle element 
  arr = arr.sort(); 
  let median = arr[Math.floor(arr.length / 2)]; 

  // to get the mode we will store all the elements in a hash table 
  // and keep a count and also always maintain the largest count 
  let mode = undefined; 
  let hashTable = {}; 
  for (let i of arr) { 
    hashTable[i] === undefined ? hashTable[i] = 1 : hashTable[i] += 1; 
    if (mode === undefined || hashTable[i] > mode) { 
      mode = i; 
    } 
  } 

  return { 'mean': mean, 'median': median, 'mode': mode }; 

} 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
45 

Python	

def meanMedianMode(arr): 

  # to calculcate the mean we add up all the numbers 
  # and divide by the length 
  mean = sum(arr) / float(len(arr)) 

  # to calculcate the median we need to sort the array 
  # and return the middle element 
  arr = sorted(arr) 
  median = arr[int(len(arr) / 2)] 

  # to get the mode we will store all the elements in a hash table 
  # and keep a count and also always maintain the largest count 
  mode = None 
  hashTable = {} 
  for i in arr: 
    if i in hashTable: 
      hashTable[i] += 1 
    else: 
      hashTable[i] = 1 
    if mode is None or hashTable[i] > mode: 
      mode = i 

  return { 'mean': mean, 'median': median, 'mode': mode } 

Ruby	

def meanMedianMode(arr) 

  # to calculcate the mean we add up all the numbers 
  # and divide by the length 
  mean = arr.inject(:+) / arr.length.to_f 

  # to calculcate the median we need to sort the array 
  # and return the middle element 
  arr = arr.sort 
  median = arr[(arr.length / 2).floor] 

  # to get the mode we will store all the elements in a hash table 
  # and keep a count and also always maintain the largest count 
  mode = nil 
  hashTable = {} 
  arr.each do |i| 
    if hashTable.key?(i) 
      hashTable[i] += 1 
    else 
      hashTable[i] = 1 
    end 
    if mode == nil or hashTable[i] > mode 
      mode = i 
    end 
  end 

  return { :mean => mean, :median => median, :mode => mode } 

end 

	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
46 

3.16.  Encode	consonants	within	a	string	

This	challenge	asks	you	to	take	a	string	composed	of	only	lowercase	letters	and	space	characters,	for	
example	“hello world”	and	replace	every	consonant	in	the	string	with	the	next	consontant	in	the	
alphabet.	So	in	the	above	example,	the	output	should	be	“jemmo xosmf”	and	you	can	see	that	we	
left	every	vowel	in	place	and	only	changed	the	consonants.	You	should	notice	that	the	last	letter	
changed	was	from	d	to	f	and	not	from	d	to	e	because	e	is	a	vowel.	

The	first	thing	that	would	be	helpful	for	this	challenge	is	some	sort	of	listing	of	all	the	
consonants	which	would	allow	us	to	easily	change	one	letter	to	the	other	by	just	moving	one	place	
over	in	the	array.	Then	to	solve	the	challenge	we	would	just	loop	through	the	string,	and	if	a	letter	is	
not	a	vowel	we	would	find	that	letter	in	the	array	of	consonants,	move	one	place	over	and	replace	
the	letter	in	the	string	with	that	new	letter.	This	would	be	a	solution	to	the	challenge,	but	the	running	
time	involves	both	the	length	of	the	string	n	and	the	length	of	the	consonant	array	m	because	we	are	
looping	through	the	string	while	also	searching	for	a	letter	in	the	array	each	time.	The	running	time	
still	reduces	to	O(n)	because	the	consonant	array	stays	constant	meaning	it	will	never	get	shorter	or	
longer	because	there	is	a	set	amount	of	constants	in	the	alphabet.	So	this	solution	is	pretty	good,	but	
we	can	actually	do	a	bit	better.	

To	make	this	solution	a	bit	faster	we	can	actualy	get	rid	of	the	consonant	array	altogether.	
This	is	because	we	can	convert	each	letter	as	we	go	to	its	character	code	number,	add	1	to	it,	and	
then	convert	this	number	back	to	a	letter	to	get	the	next	letter	in	the	alphabet.	Then	we	simply	
perform	an	extra	check	to	make	sure	the	new	letter	is	not	a	vowel,	but	if	so,	simply	add	1	more	to	its	
character	code	to	get	the	next	letter.	

Note:	You	can	actually	perform	a	modulo	operation	at	some	point	in	the	code	and	therefore	
there	will	be	no	need	for	the	special	“z”	character	conditional	at	the	beginning	of	the	loop.	I’ll	leave	
this	as	an	exercise	for	the	reader.	

	
	
	
	
	
	
	
47 

JavaScript	

function encodeConsonants(string) { 

  let result = ''; 

  // store an array of vowels for use later 
  const vowels = ['a', 'e', 'i', 'o', 'u']; 

  // loop through entire string 
  for (let i of string) { 

    // special case for z 
    if (i === 'z') { 
      result += 'b'; 
      break; 
    } 

    // if letter is not a vowel or a space 
    else if (vowels.indexOf(i) === -1 && i !== ' ') { 

      // convert each letter to its character code 
      let newCode = i.charCodeAt(0) + 1; 

      // perform check to make sure new letter is not a vowel by seeing if 
      // the new letter exists in an array of vowels 
      if (vowels.indexOf(String.fromCharCode(newCode)) !== -1) { 
        newCode += 1; 
      } 

      // get new letter and add to new string 
      result += String.fromCharCode(newCode); 

    }  

    // otherwise character is a vowel or a space 
    else { 
      result += i; 
    } 

  } 

  return result; 

} 

	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
 
 
 
48 

Python	

def encodeConsonants(string): 

  result = '' 

  # store an array of vowels for use later 
  vowels = ['a', 'e', 'i', 'o', 'u'] 

  # loop through entire string 
  for i in string: 

    # special case for z 
    if i == 'z': 
      result += 'b' 
      break 

    # if letter is not a vowel or a space 
    elif i not in vowels and i != ' ': 

      # convert each letter to its character code 
      newCode = ord(i) + 1 

      # perform check to make sure new letter is not a vowel by seeing if 
      # the new letter exists in an array of vowels 
      if chr(newCode) in vowels: 
        newCode += 1 

      # get new letter and add to new string 
      result += chr(newCode) 

    # otherwise character is a vowel or a space 
    else: 
      result += i 

  return result 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
49 

Ruby	

def encodeConsonants(string) 

  result = '' 

  # store an array of vowels for use later 
  vowels = ['a', 'e', 'i', 'o', 'u'] 

  # loop through entire string 
  string.chars.each do |i|  

    # special case for z 
    if i == 'z' 
      result += 'b' 
      break 

    # if letter is not a vowel or a space 
    elsif vowels.include?(i) == false and i != ' ' 

      # convert each letter to its character code 
      newCode = i.ord + 1 

      # perform check to make sure new letter is not a vowel by seeing if 
      # the new letter exists in an array of vowels 
      if vowels.include?(newCode.chr) 
        newCode += 1 
      end 

      # get new letter and add to new string 
      result += newCode.chr 

    # otherwise character is a vowel or a space 
    else 
      result += i 
    end 

  end 

  return result 

end 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
 
 
50 

3.17.  Convert	an	array	of	strings	into	an	object	

This	challenge	doesn’t	strictly	have	a	single	output	like	the	previous	challenges,	rather	this	challenge	
focuses	on	you	using	certain	data	structures	correctly.	Imagine	you	have	several	users	entering	
information	through	a	form,	and	on	the	back-end	you	get	the	information	as	a	comma	separated	
string	of	information.	The	information	the	user	will	enter	in	the	form	is:	Name,	Email,	Age,	and	
Occupation	all	in	that	order.	Each	user’s	piece	of	information	will	be	separated	by	a	comma,	and	each	
user	will	be	separated	by	a	space,	but	some	pieces	of	information	can	be	blank	for	a	user	(excluding	
the	name),	for	example:	

“Daniel,me@test.com,56,Coder John,,,Teacher Michael,mike@test.com,,”   

You	can	see	above	that	all	the	information	exists	for	Daniel,	but	email	and	age	are	missing	for	

John,	and	age	and	occupation	are	missing	for	Michael.	You	should	write	a	function	that	will	take	in	
this	string	of	user	information,	and	create	an	object	(key-value	mapping)	where	the	key	is	the	
person’s	name	and	the	value	will	also	be	an	object	that	stores	the	information	of	each	user:	email,	
age,	and	occupation.	You	can	assume	people’s	names	will	be	unique.	

To	solve	this	challenge,	we’ll	split	the	string	(at	the	space	character)	into	an	array	of	different	
people,	and	then	for	each	person	we’ll	split	the	information	(at	the	comma	character).	Then	we	will	
create	a	new	user	object	and	throw	it	into	the	global	object	that	will	store	all	the	users.	

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
51 

JavaScript	

function convert(string) { 

  // create empty object 
  let obj = {}; 

  // split the string at each person 
  const people = string.split(' '); 

  // loop through all people 
  for (let p of people) { 

    // split information for each person 
    const info = p.split(','); 

    // store this information in the user object 
    let userObj = { 
      'email': info[1] || null, 
      'age': parseInt(info[2]) || null, 
      'occupation': info[3] || null 
    }; 

    // store key-value in object of users now 
    obj[info[0]] = userObj; 

  } 

  return obj; 

} 

// usage 
let s = "Daniel,me@test.com,56,Coder John,,,Teacher Michael,mike@test.com,,"; 
let people = convert(s); 

// testing 
people['Daniel']['age']; // => 56 
people['Michael']['occupation'] // => null 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
 
52 

Python	

def convert(string): 

  # create empty object 
  obj = {} 

  # split the string at each person 
  people = string.split(' ') 

  # loop through all people 
  for p in people: 

    # split information for each person 
    info = p.split(',') 

    # store this information in the user object 
    userObj = { 
      'email': info[1] or None, 
      'age': int(info[2]) if info[2] else None, 
      'occupation': info[3] or None 
    } 

    # store key-value in object of users now 
    obj[info[0]] = userObj 

  return obj 

# usage 
s = "Daniel,me@test.com,56,Coder John,,,Teacher Michael,mike@test.com,," 
people = convert(s) 

# testing 
people['Daniel']['age'] # => 56 
people['Michael']['occupation'] # => None 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
53 

Ruby	

def convert(string) 

  # create empty object 
  obj = {} 

  # split the string at each person 
  people = string.split(' ') 

  # loop through all people 
  people.each do |p| 

    # split information for each person 
    info = p.split(',') 

    # store this information in the user object 
    userObj = { 
      'email' => info[1] || nil, 
      'age' => info[2].to_i || nil, 
      'occupation' => info[3] || nil 
    } 

    # store key-value in object of users now 
    obj[info[0]] = userObj 

  end 

  return obj 

end 

# usage 
s = "Daniel,me@test.com,56,Coder John,,,Teacher Michael,mike@test.com,," 
people = convert(s) 

# testing 
p people['Daniel']['age'] # => 56 
p people['Michael']['occupation'] # => None 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
 
54 

3.18.  Three	sum	problem	

The	three	sum	problem	is	very	similar	to	the	two	sum	problem	we	covered	at	the	beginning	of	the	
chapter,	except	the	problem	statement	now	naturally	changes	to	3	elements	instead	of	two:	

You	are	given	an	array	and	some	number	S.	Determine	if	any	three	numbers	within	the	array	sum	to	S.		

As	with	the	nested	loop	solution	to	the	two	sum	problem,	we	can	create	a	set	of	three	nested	loops	
that	checks	if	any	three	elements	in	the	array	sum	to	S.	The	running	time	of	this	algorithm	is	O(n3)	
because	of	the	nested	loops.	We	can	solve	this	problem	more	efficiently	though	with	some	
modifications.	

First	we	sort	the	array	into	ascending	order.	We	can	use	a	built-in	sort	function	which	will	run	in	
O(nlogn).[1]	Then	we	loop	through	each	element	in	the	array	and	for	each	of	the	elements	we	
maintain	two	pointers	(or	indices),	one	from	the	(current	position	+	1)	and	the	second	pointer	starting	
from	the	end	of	the	array.	Then	we	check	to	see	if	these	3	elements	sum	to	S.	One	of	3	things	will	be	
true:	

1.  If	the	current	element	plus	the	2	other	elements	is	greater	than	S,	we	decrease	the	pointer	at	

the	end	of	the	array	at	1.	

2.  If	the	current	element	plus	the	other	2	elements	is	less	than	S,	we	increase	the	pointer	at	the	

beginning	by	1.	

3.  If	the	pointers	end	up	meeting,	then	we	know	we	cannot	add	2	elements	plus	the	current	
element	to	sum	to	S.	We	move	on	to	the	next	element	in	the	array	and	reset	the	pointers.	

This	algorithm	needs	to	loop	through	every	single	element	in	the	array,	and	for	each	element	in	the	
worst	case	we	will	loop	through	all	the	other	elements	until	the	pointers	end	up	at	the	same	point.	
This	algorithm	therefore	runs	in	O(nlogn)	+	O(n2)	which	reduces	to	O(n2).	

[1]	The	built-in	sorting	functions	in	JavaScript,	Python,	and	Ruby	use	either	mergesort,	quicksort,	or	some	
combination	of	them	to	create	a	fast	sorting	algorithm	that	runs	in	O(nlogn)	time.		

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
55 

JavaScript	

function threeSum(arr, S) { 

  // sort the array  
  var arr = arr.sort(); 

  // loop and check each element 
  for (let i = 0; i < arr.length - 2; i++) { 

    // start two pointers, one from the current position + 1 
    // and the other at the end of the array 
    let ptr_start = i + 1; 
    let ptr_end = arr.length - 1; 

    // check all other elements  
    while (ptr_start < ptr_end) { 

      let add = arr[i] + arr[ptr_start] + arr[ptr_end]; 

      // if we find a sum 
      if (add === S) { return true; }  

      // if the sum is < S 
      else if (add < S) { ptr_start += 1; } 

      // otherwise the sum is > S 
      else { ptr_end -= 1; } 

    } 

  } 

  return false; 

} 

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
 
 
56 

Python	

def threeSum(arr, S): 

  arr = sorted(arr) 

  for i in range(0, len(arr) - 2): 
    # start two pointers, one from the current position + 1 
    # and the other at the end of the array 
    ptr_start, ptr_end = i + 1, len(arr) - 1 

    while ptr_start < ptr_end: 
      add = arr[i] + arr[ptr_start] + arr[ptr_end] 

      # if we find a sum 
      if add == S: 
        return True  
      # if the sum < S 
      elif add < S: 
        ptr_start += 1 
      # if the sum > S 
      else: 
        ptr_end -= 1 

  return False 

Ruby	

def threeSum(arr, S) 

  arr = arr.sort() 

  (0..arr.length - 2).each do |i| 

    # start two pointers, one from the current position + 1 
    # and the other at the end of the array 
    ptr_start = i + 1 
    ptr_end = arr.length - 1 

    while ptr_start < ptr_end 
      add = arr[i] + arr[ptr_start] + arr[ptr_end] 

      # if we find a sum 
      if add == S 
        return true  

      # if the sum < S 
      elsif add < S 
        ptr_start += 1 

      # if the sum > S 
      else 
        ptr_end -= 1 

      end 

    end 

  end 

  return false 

end 

	
	
	
	
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
57 

PART	3	
GENERAL	INTERVIEW	TIPS	

“Computer	science	is	no	more	about	computers		
than	astronomy	is	about	telescopes.”	

-	Edsger	Dijkstra	

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 
	
	
	
	
	
	
	
	
	
	
	
	
	
	
CHAPTER	4:	Resources	

58 

Staying	calm	in	a	coding	interview	and	also	being	able	to	solve	the	challenge	within	a	time	limit	is	a	
skill	that	can	be	mastered	with	enough	practice	and	some	general	tips.	In	the	bulk	of	this	book	we’ve	
discussed	over	a	dozen	common	coding	questions	asked	in	a	coding	bootcamp	interview,	and	we	also	
covered	some	background	on	coding	bootcamps	and	algorithms.	Below	we’ll	provide	some	extra	
resources	where	you	can	learn	about	how	to	stay	calm	during	a	stressful	coding	question,	what	
questions	to	ask	the	interviewer,	how	to	answer	certain	questions	effectively,	etc.	

4.1. 

Personal	help	

For	personal	help,	Coderbyte	offers	the	Personalized	Study	Plan	(https://coderbyte.com/study-plan)	
that	will	help	create	a	personal	step-by-step	guide	for	you	to	help	prepare	for	a	coding	interview	to	a	
bootcamp	or	job.	It	contains	article,	resources,	challenges,	and	videos	tailored	to	your	goals	and	skill	
level	and	it’s	the	best	way	to	prepare	for	an	upcoming	coding	interview	at	a	top	company	or	elite	
coding	bootcamp	such	as	Hack	Reactor,	Fullstack	Acadaemy,	Flatiron	School,	Grace	Hopper,	
Codesmith,	etc.	

We	provide	access	to	an	online	community	with	our	own	Coderbyte	Slack	channel.	As	part	of	

the	Study	Plan	mentioned	above,	you	will	get	access	to	the	channel	and	you’ll	be	able	to	ask	
questions	and	chat	with	fellow	coders	preparing	for	upcoming	interviews.	

Aside	from	these	features,	one	of	the	best	ways	to	prepare	for	any	type	of	coding	interview	is	
to	simply	practice	solving	coding	challenges,	practice,	and	then	practice	some	more.	Coderbyte	offers	
more	than	160	coding	challenges	(https://coderbyte.com/challenges)	that	you	can	solve	directly	
online.	Then	you	can	look	at	thousands	of	user	solutions	to	see	how	others	solved	the	same	
challenges.	

4.2.		

Interview	preparation	articles	

•  Technical	Interview	Questions,	Prep	and	More	by	Hack	Reactor:	http://bit.ly/2e9niPs		
•  10	Must-Asks	in	a	Bootcamp	Interview	by	Course	Report:	http://bit.ly/2etZKcp		
•  How	to	Ace	the	Web	Developer	Job	Interview	by	Coding	Dojo:	http://bit.ly/21y4UBd		
•  5	Tips	to	Prepare	You	for	a	Coding	Bootcamp	by	Galvanize:	http://bit.ly/2dNTuxi		
•  From	Zero	to	Hack	Reactor	in	5	months	blog	post	by	Jennie	Eldon:	http://bit.ly/2dMjhT7		
•  What	I	Studied	Before	Applying	to	Hack	Reactor	post	by	Amira	Anuar:	http://bit.ly/2d8MJ7F		
• 
Inside	the	Mind	of	Hackbright’s	Director	of	Admissions	by	Hackbright:	http://bit.ly/2dNTwp4		
•  Compare	top	coding	bootcamps	tool	by	Thinkful:	http://bit.ly/2dxFhiI