70+ JavaScript Challenges: Data Structures & Algorithms

70+ JavaScript Challenges: Data Structures & Algorithms, available at $19.99, has an average rating of 4.74, with 114 lectures, based on 529 reviews, and has 5195 subscribers.

You will learn about Explore 70+ coding challenges from beginner, intermediate and advanced levels Ace coding interviews by learning how to solve problems with iteration, recursion, array methods & more Master data structures like stacks, queues, linked lists, trees, maps and hash maps Learn about sorting algorithms like bubble sort, insertion, merge and quick sort Full sandbox with explanations and Jest tests for every challenge You do NOT have to take on the challenges alone. Follow along and learn from the explanations This course is ideal for individuals who are Developers that want to build better foundational problem solving skills and pass job interviews It is particularly useful for Developers that want to build better foundational problem solving skills and pass job interviews.

Enroll now: 70+ JavaScript Challenges: Data Structures & Algorithms

Summary

Title: 70+ JavaScript Challenges: Data Structures & Algorithms

Price: $19.99

Average Rating: 4.74

Number of Lectures: 114

Number of Published Lectures: 114

Number of Curriculum Items: 114

Number of Published Curriculum Objects: 114

Original Price: $39.99

Quality Status: approved

Status: Live

What You Will Learn

Explore 70+ coding challenges from beginner, intermediate and advanced levels
Ace coding interviews by learning how to solve problems with iteration, recursion, array methods & more
Master data structures like stacks, queues, linked lists, trees, maps and hash maps
Learn about sorting algorithms like bubble sort, insertion, merge and quick sort
Full sandbox with explanations and Jest tests for every challenge
You do NOT have to take on the challenges alone. Follow along and learn from the explanations

Who Should Attend

Developers that want to build better foundational problem solving skills and pass job interviews

Target Audiences

Developers that want to build better foundational problem solving skills and pass job interviews

Most of my students know me for my practical, project-based courses and tutorials. I wanted to create something to give you more fundamental skills for problem solving. That’s where the idea for this challenges course came from. I want to take my down-to-earth explanations to help you get a better understanding of the code that you write and help you write more efficient code.

This course is for all levels as long as you have a basic understanding of things like loops, functions, arrays, etc. We are writing JavaScript in this course, but about 95% of it can translate to any other language. So even if you are a Python, PHP or C# developer, you can still follow along.

Basic Challenges:

We start with a bunch of basic challenges that have to do with iteration and loops. Things like FizzBuzz and string reversals. These are very popular questions for entry-level interviews. We also move on to solving problems with high order array methods like filter and map.

Recursion:

Recursion is one of the toughest things to learn in programming. We have an entire section dedicated to it with challenges that we solve using recursion.

Time & Space Complexity:

We talk about how to measure an algorithm or function’s efficiency by using time and space complexity to see how the runtime and memory scale when inscreasing the input.

Data Structures: Stacks, Queues, Trees, Linked Lists, Graphs, HashMaps

We go over all of the common data structures and create our own implementation of them using JavaScript classes, but like I said, you could use any language. We also learn how to traverse them and complete challenges using them.

Sorting Algorithms:

We get into different sorting algorithms like bubble sort, insertion, selection, merge and quick sort. These are popular topics for interviews.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Welcome To The Course

Lecture 2: Course Structure

Lecture 3: DSA – The What & Why

Lecture 4: Tools & Basic Setup

Lecture 5: Sandbox Environment Setup

Chapter 2: Basic Challenges – Part 1

Lecture 1: Hello World (Starter Challenge)

Lecture 2: Get Sum (Starter Challenege)

Lecture 3: Calculator

Lecture 4: Count Occurences

Lecture 5: Find Max Number

Lecture 6: Title Case

Lecture 7: Reverse String

Lecture 8: Palindrome

Lecture 9: Count Vowels

Lecture 10: Remove Duplicates

Chapter 3: Basic Challenges – Part 2

Lecture 1: FizzBuzz Array

Lecture 2: Array Intersection

Lecture 3: Display Likes

Lecture 4: Find Missing Number

Lecture 5: Find Missing Letter

Lecture 6: Are All Chars Unique?

Lecture 7: First Non-Repeating Character

Lecture 8: Dice Game Simulation

Lecture 9: Format Phone Number

Lecture 10: Validate Email

Chapter 4: High Order Array Methods

Lecture 1: Simple Examples

Lecture 2: Sum Of Even Squares

Lecture 3: Calculate Total Sales

Lecture 4: Highest Scoring Word

Lecture 5: Valid Anagrams

Lecture 6: Hashtag Generator

Lecture 7: Valid IPv4

Lecture 8: Analyze Car Mileage

Lecture 9: Password Validator

Lecture 10: Find Missing Letter Refactor

Chapter 5: Recursion

Lecture 1: Recursion Intro (Countdown)

Lecture 2: Recursive Unwinding

Lecture 3: Reverse String Using Recursion

Lecture 4: Fibonacci Sequence

Lecture 5: Factorial

Lecture 6: Power

Lecture 7: Array Sum

Lecture 8: Number Range

Lecture 9: Flatten Array

Lecture 10: Permutations

Chapter 6: Time & Space Complexity

Lecture 1: What Is Time Complexity?

Lecture 2: Big O Notation

Lecture 3: Constant Time Complexity – O(1)

Lecture 4: Linear Time Complexity – O(n)

Lecture 5: Quadratic Time Complexity – O(n^2)

Lecture 6: Logarithmic Time Complexity – O(log n)

Lecture 7: Space Complexity

Lecture 8: Max Subarray – Quadratic

Lecture 9: Sliding Window Technique

Lecture 10: Max Subarray – Linear

Chapter 7: Hash Tables, Maps & Sets

Lecture 1: Hash Table Intro

Lecture 2: Maps

Lecture 3: Word Frequency Counter

Lecture 4: Phone Number Directory

Lecture 5: Anagram Grouping

Lecture 6: Sets

Lecture 7: Symmetric Difference

Lecture 8: Two Sum

Lecture 9: Longest Consecutive

Lecture 10: Custom Hash Table – Part 1

Lecture 11: Custom Hash Table – Part 2

Lecture 12: Word Instance Counter Using Custom Hash Table

Lecture 13: Add getValues Method

Lecture 14: Anagram Grouping With Custom Hash Table

Chapter 8: Stacks, Queues & Linked Lists

Lecture 1: What Is A Stack?

Lecture 2: Stack Implementation

Lecture 3: Reverse String Using A Stack

Lecture 4: Balanced Parenthesis

Lecture 5: What Is A Queue?

Lecture 6: Queue Implementation

Lecture 7: Reverse String With A Queue

Lecture 8: Palindrome With A Queue & Stack

Lecture 9: What Is A LInked LIst?

Lecture 10: Linked List Implementation

Lecture 11: Reverse String With A Linked List

Lecture 12: Fast & Slow Pointers

Lecture 13: Find Middle

Lecture 14: What Is A Doubly Linked List?

Lecture 15: Doubly Linked List Implementation – Part 1

Lecture 16: Doubly Linked List Implementation – Part 2

Lecture 17: Find Pair Sum

Chapter 9: Binary Trees, BST & Graphs

Lecture 1: What Is a Tree / Binary Tree?

Lecture 2: Tree Node Class

Lecture 3: Depth-First Traversal

Lecture 4: Depth-First Traversal Using Recursion

Lecture 5: Breadth-First Traversal

Instructors

Brad Traversy
Full Stack Web Developer & Instructor at Traversy Media

Rating Distribution

1 stars: 3 votes
2 stars: 0 votes
3 stars: 13 votes
4 stars: 109 votes
5 stars: 404 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu