Nanodegree key: nd256
Version: 2.0.0
Locale: en-us
Get hands-on practice with over 100 data structures and algorithm exercises and guidance from a dedicated mentor to help prepare you for interviews and on-the-job scenarios.
Content
Part 01 : Introduction
Start with a warm welcome to the program by refreshing your Python skills and learning about problem solving and efficiency!
-
Module 01: Introduction
-
Lesson 01: Introduction
Welcome to the Data Structures and Algorithms nanodegree program!
-
Lesson 02: Python Refresher
A quick refresh on Python basics!
-
Lesson 03: How to Solve Problems
A systematic way of approaching and breaking down problems.
- Concept 01: About this Lesson
- Concept 02: How to Solve Problems
- Concept 03: Days Between Dates
- Concept 04: Attempting the Problem [workspace]
- Concept 05: First Step
- Concept 06: Understanding a Problem
- Concept 07: The First Rule
- Concept 08: What Are the Inputs
- Concept 09: How Are Inputs Represented
- Concept 10: What Are the Outputs
- Concept 11: Obey the Rules
- Concept 12: Next Step
- Concept 13: The Expected Output
- Concept 14: Take the Next Step
- Concept 15: Try an Example
- Concept 16: Harder Example
- Concept 17: Algorithm Pseudocode
- Concept 18: Should We Implement It
- Concept 19: Different Approach
- Concept 20: Simple Mechanical Algorithm
- Concept 21: Don't Optimize Prematurely
- Concept 22: What Should We Write First
- Concept 23: Define Simple nextDay
- Concept 24: Making Progress Is Good
- Concept 25: What Should We Do Next
- Concept 26: Define daysBetweenDates
- Concept 27: Step One Pseudocode
- Concept 28: Step Two Helper Function
- Concept 29: Step Three daysBetweenDates
- Concept 30: Test for Valid Inputs
- Concept 31: Real World Problem
- Concept 32: Best Strategy
- Concept 33: Completing the Problem
- Concept 34: Finish daysBetweenDates
- Concept 35: Solution Step I
- Concept 36: Solution Step II
- Concept 37: Solution Step III
- Concept 38: Solution Step IV
- Concept 39: Conclusion
-
Lesson 04: Efficiency
Understanding the importance of efficiency when working with data structures and algorithms.
-
Lesson 05: Unscramble Computer Science Problems
Deconstruct a series of open-ended problems into smaller components (e.g, inputs, outputs, series of functions).
-
Part 02 : Data Structures
Learn about the core data structures used in programming.
-
Module 01: Data Structures
-
Lesson 01: Arrays and Linked Lists
Learn about Arrays and Linked Lists
- Concept 01: Collections
- Concept 02: Lists
- Concept 03: Arrays
- Concept 04: Strings
- Concept 05: Linked Lists Introduction
- Concept 06: Linked Lists Continued
- Concept 07: Implement a Linked List
- Concept 08: Types of Linked Lists
- Concept 09: Linked List Practice
- Concept 10: Reverse a Linked List
- Concept 11: Loop Detection
- Concept 12: Flatten a Nested Linked List
- Concept 13: Add One
- Concept 14: Duplicate Number
- Concept 15: Max Sum Subarray
- Concept 16: Pascal's Triangle
- Concept 17: Even After Odd
- Concept 18: Skip i, delete j
- Concept 19: Swap Nodes
- Concept 20: Interlude
-
Lesson 02: Stacks and Queues
Build Stacks and Queues
- Concept 01: Stacks Introduction
- Concept 02: Stacks Details
- Concept 03: Implement a Stack Using an Array
- Concept 04: Implement a Stack Using a Linked List
- Concept 05: Build a Stack
- Concept 06: Practice: Balanced Parentheses
- Concept 07: Reverse Polish Notation
- Concept 08: Reverse a Stack
- Concept 09: Minimum Bracket Reversals
- Concept 10: Queues
- Concept 11: Build a Queue Using an Array
- Concept 12: Build a Queue Using a Linked List
- Concept 13: Build a Queue Using a Stack
- Concept 14: Build a Queue Using High-Level Python
- Concept 15: Reverse a Queue
- Concept 16: Interlude
-
Lesson 03: Recursion
Apply Recursion to Problems
- Concept 01: Recursion Introduction
- Concept 02: Recursion
- Concept 03: Factorial Function
- Concept 04: Reverse a String
- Concept 05: Palindrome Checking
- Concept 06: List Permutations
- Concept 07: String Permutations
- Concept 08: Keypad Combinations
- Concept 09: Deep Reverse
- Concept 10: The Call Stack and Recursion
- Concept 11: Recurrence Relations
- Concept 12: Tower of Hanoi
- Concept 13: Return Codes
- Concept 14: Return Subsets
- Concept 15: Staircase
- Concept 16: Last Index
- Concept 17: Interlude
-
Lesson 04: Trees
Learn about basic tree's, tree traversal and binary search trees.
- Concept 01: Trees
- Concept 02: Tree Basics
- Concept 03: Tree Terminology
- Concept 04: Tree Traversal
- Concept 05: Depth-First Traversals
- Concept 06: Search and Delete
- Concept 07: Insert
- Concept 08: Binary Search Trees
- Concept 09: BSTs
- Concept 10: BST Complications
- Concept 11: Practice overview
- Concept 12: Code: Create a Binary Tree
- Concept 13: Code: DFS
- Concept 14: Code: BFS
- Concept 15: Code: BST
- Concept 16: Diameter of a Binary Tree
- Concept 17: Path From Root to Node
- Concept 18: Interlude
-
Lesson 05: Maps and Hashing
Explore the concepts of maps and hashes.
- Concept 01: Introduction to Maps
- Concept 02: Sets and Maps
- Concept 03: Exploring the Map Concept
- Concept 04: Introduction to Hashing
- Concept 05: Hashing
- Concept 06: Collisions
- Concept 07: Hash Maps
- Concept 08: Hash Maps Notebook
- Concept 09: String Keys
- Concept 10: Caching
- Concept 11: String Key Hash Table
- Concept 12: Practice: Pair Sum to Target
- Concept 13: Practice: Longest Consecutive Subsequence
- Concept 14: Interlude
-
Lesson 06: Show Me the Data Structures
Solve a series of open-ended practice problems. Hone your skills to identify and implement appropriate data structures and corresponding methods that meet given constraints.
-
Part 03 : Basic Algorithms
Learn about the basic algorithms used in programming.
-
Module 01: Basic Algorithms
-
Lesson 01: Basic Algorithms
Start out with some elementary algorithms such as binary search, tries, heaps and more.
- Concept 01: Binary Search
- Concept 02: Efficiency of Binary Search
- Concept 03: Binary Search Practice
- Concept 04: Binary Search Variation
- Concept 05: Binary search: First and last indexes
- Concept 06: Tries
- Concept 07: Heaps
- Concept 08: Heapify
- Concept 09: Heap Implementation
- Concept 10: Heaps Exercise
- Concept 11: Self-Balancing Tree
- Concept 12: Red-Black Tree Insertion
- Concept 13: Tree Rotations
- Concept 14: Build a Red-Black Tree
- Concept 15: Interlude
-
Lesson 02: Sorting Algorithms
Learn about the most common sorting algorithms.
- Concept 01: Intro to Sorting
- Concept 02: Bubble Sort
- Concept 03: Efficiency of Bubble Sort
- Concept 04: Practice: Bubble Sort
- Concept 05: Merge Sort
- Concept 06: Efficiency of Merge Sort
- Concept 07: Merge Sort Walkthrough
- Concept 08: Merge Sort: Counting Inversions
- Concept 09: Case Specific Sorting of Strings
- Concept 10: Quicksort
- Concept 11: Quicksort Efficiency
- Concept 12: Quick Sort Walkthrough
- Concept 13: Heapsort
- Concept 14: Pair Sum
- Concept 15: Sort 0, 1, 2
-
Lesson 03: Faster Divide & Conquer Algorithms
Go deeper into algorithms with faster divide and conquer algorithms.
-
Lesson 04: Problems vs. Algorithms
A series of real-world open ended problems which train you to apply suitable data structures and algorithms under different context.
- Concept 01: Introduction to the Project
- Concept 02: Problem 1: Square Root of an Integer
- Concept 03: Problem 2: Search in a Rotated Sorted Array
- Concept 04: Problem 3: Rearrange Array Digits
- Concept 05: Problem 4: Dutch National Flag Problem
- Concept 06: Problem 5: Autocomplete with Tries
- Concept 07: Problem 6: Unsorted Integer Array
- Concept 08: Problem 7: Request Routing in a Web Server with a Trie
-
Part 04 : Advanced Algorithms
Learn about the basic algorithms used in programming.
-
Module 01: Advanced Algorithms
-
Lesson 01: Greedy Algorithms
Get familiar with and practice greedy algorithms.
-
Lesson 02: Graph Algorithms
Learn about the many aspects of graph algorithms!
- Concept 01: Graph Introduction
- Concept 02: What is a Graph?
- Concept 03: Directions and Cycles
- Concept 04: Connectivity
- Concept 05: Graph Representation
- Concept 06: Adjacency Matricies
- Concept 07: Graph Traversal
- Concept 08: DFS
- Concept 09: Implement DFS — Iterative Solution
- Concept 10: Implement DFS — Recursive Solution
- Concept 11: BFS
- Concept 12: Implement BFS
- Concept 13: Shortest Path & Diijkstra's Algorithm
- Concept 14: Diijkstra's Algorithm Exercise
- Concept 15: Connecting Islands
-
Lesson 03: Dynamic Programming
Learn about dynamic programming and apply your learnings to challenging exercises.
-
Lesson 04: A*
- Concept 01: Introduction
- Concept 02: What Is A Problem?
- Concept 03: Example: Route Finding
- Concept 04: Uniform Cost Search
- Concept 05: Uniform Cost Search 1
- Concept 06: Uniform Cost Search 2
- Concept 07: Uniform Cost Search 3
- Concept 08: Uniform Cost Search 4
- Concept 09: Uniform Cost Search 5
- Concept 10: On Uniform Cost
- Concept 11: A* Search
- Concept 12: A* Search 1
- Concept 13: A* Search 2
- Concept 14: A* Search 3
- Concept 15: A* Search 4
- Concept 16: A* Search 5
-
Lesson 05: Route Planner
In this project, you will build a route-planning algorithm like the one used in Google Maps to calculate the shortest path between two points on a map.
-
Part 05 (Elective): Introduction to Python Programming
Review fundamental Python programming syntax and concepts.
-
Module 01: Introduction to Python Programming
-
Lesson 01: Why Python Programming
Welcome to Introduction to Python! Here's an overview of the course.
-
Lesson 02: Data Types and Operators
Familiarize yourself with the building blocks of Python! Learn about data types and operators, built-in functions, type conversion, whitespace, and style guidelines.
- Concept 01: Introduction
- Concept 02: Arithmetic Operators
- Concept 03: Quiz: Arithmetic Operators
- Concept 04: Solution: Arithmetic Operators
- Concept 05: Variables and Assignment Operators
- Concept 06: Quiz: Variables and Assignment Operators
- Concept 07: Solution: Variables and Assignment Operators
- Concept 08: Integers and Floats
- Concept 09: Quiz: Integers and Floats
- Concept 10: Booleans, Comparison Operators, and Logical Operators
- Concept 11: Quiz: Booleans, Comparison Operators, and Logical Operators
- Concept 12: Solution: Booleans, Comparison and Logical Operators
- Concept 13: Strings
- Concept 14: Quiz: Strings
- Concept 15: Solution: Strings
- Concept 16: Type and Type Conversion
- Concept 17: Quiz: Type and Type Conversion
- Concept 18: Solution: Type and Type Conversion
- Concept 19: String Methods
- Concept 20: String Methods
- Concept 21: Another String Method - Split
- Concept 22: Quiz: String Methods Practice
- Concept 23: Solution: String Methods Practice
- Concept 24: "There's a Bug in my Code"
- Concept 25: Conclusion
- Concept 26: Summary
-
Lesson 03: Data Structures
Use data structures to order and group different data types together! Learn about the types of data structures in Python, along with more useful built-in functions and operators.
- Concept 01: Introduction
- Concept 02: Lists and Membership Operators
- Concept 03: Quiz: Lists and Membership Operators
- Concept 04: Solution: List and Membership Operators
- Concept 05: Why Do We Need Lists?
- Concept 06: List Methods
- Concept 07: Quiz: List Methods
- Concept 08: Check for Understanding: Lists
- Concept 09: Tuples
- Concept 10: Quiz: Tuples
- Concept 11: Sets
- Concept 12: Quiz: Sets
- Concept 13: Dictionaries and Identity Operators
- Concept 14: Quiz: Dictionaries and Identity Operators
- Concept 15: Solution: Dictionaries and Identity Operators
- Concept 16: Quiz: More With Dictionaries
- Concept 17: When to Use Dictionaries?
- Concept 18: Check for Understanding: Data Structures
- Concept 19: Compound Data Structures
- Concept 20: Quiz: Compound Data Structures
- Concept 21: Solution: Compound Data Structions
- Concept 22: Practice Questions
- Concept 23: Solution: Practice Questions
- Concept 24: Conclusion
-
Lesson 04: Control Flow
Build logic into your code with control flow tools! Learn about conditional statements, repeating code with loops and useful built-in functions, and list comprehensions.
- Concept 01: Introduction
- Concept 02: Conditional Statements
- Concept 03: Practice: Conditional Statements
- Concept 04: Solution: Conditional Statements
- Concept 05: Quiz: Conditional Statements
- Concept 06: Solution: Conditional Statements
- Concept 07: Boolean Expressions for Conditions
- Concept 08: Quiz: Boolean Expressions for Conditions
- Concept 09: Solution: Boolean Expressions for Conditions
- Concept 10: For Loops
- Concept 11: Practice: For Loops
- Concept 12: Solution: For Loops Practice
- Concept 13: Quiz: For Loops
- Concept 14: Solution: For Loops Quiz
- Concept 15: Quiz: Match Inputs To Outputs
- Concept 16: Building Dictionaries
- Concept 17: Iterating Through Dictionaries with For Loops
- Concept 18: Quiz: Iterating Through Dictionaries
- Concept 19: Solution: Iterating Through Dictionaries
- Concept 20: While Loops
- Concept 21: Practice: While Loops
- Concept 22: Solution: While Loops Practice
- Concept 23: Quiz: While Loops
- Concept 24: Solution: While Loops Quiz
- Concept 25: For Loops vs. While Loops
- Concept 26: Check for Understanding: For and While Loops
- Concept 27: Solution: Check for Understanding: For and While Loops
- Concept 28: Break, Continue
- Concept 29: Quiz: Break, Continue
- Concept 30: Solution: Break, Continue
- Concept 31: Practice: Loops
- Concept 32: Solution: Loops
- Concept 33: Zip and Enumerate
- Concept 34: Quiz: Zip and Enumerate
- Concept 35: Solution: Zip and Enumerate
- Concept 36: List Comprehensions
- Concept 37: Quiz: List Comprehensions
- Concept 38: Solution: List Comprehensions
- Concept 39: Practice Questions
- Concept 40: Solutions to Practice Questions
- Concept 41: Conclusion
-
Lesson 05: Functions
Learn how to use functions to improve and reuse your code! Learn about functions, variable scope, documentation, lambda expressions, iterators, and generators.
- Concept 01: Introduction
- Concept 02: Defining Functions
- Concept 03: Quiz: Defining Functions
- Concept 04: Solution: Defining Functions
- Concept 05: Check For Understanding: Functions
- Concept 06: Variable Scope
- Concept 07: Variable Scope
- Concept 08: Solution: Variable Scope
- Concept 09: Check For Understanding: Variable Scope
- Concept 10: Documentation
- Concept 11: Quiz: Documentation
- Concept 12: Solution: Documentation
- Concept 13: Lambda Expressions
- Concept 14: Quiz: Lambda Expressions
- Concept 15: Solution: Lambda Expressions
- Concept 16: Conclusion
-
Lesson 06: Scripting
Setup your own programming environment to write and run Python scripts locally! Learn good scripting practices, interact with different inputs, and discover awesome tools.
- Concept 01: Introduction
- Concept 02: Python Installation
- Concept 03: Install Python Using Anaconda
- Concept 04: [For Windows] Configuring Git Bash to Run Python
- Concept 05: Running a Python Script
- Concept 06: Programming Environment Setup
- Concept 07: Editing a Python Script
- Concept 08: Scripting with Raw Input
- Concept 09: Quiz: Scripting with Raw Input
- Concept 10: Solution: Scripting with Raw Input
- Concept 11: Errors and Exceptions
- Concept 12: Errors and Exceptions
- Concept 13: Handling Errors
- Concept 14: Practice: Handling Input Errors
- Concept 15: Solution: Handling Input Errors
- Concept 16: Accessing Error Messages
- Concept 17: Reading and Writing Files
- Concept 18: Quiz: Reading and Writing Files
- Concept 19: Solution: Reading and Writing Files
- Concept 20: Quiz: Practice Debugging
- Concept 21: Solutions for Quiz: Practice Debugging
- Concept 22: Importing Local Scripts
- Concept 23: The Standard Library
- Concept 24: Quiz: The Standard Library
- Concept 25: Solution: The Standard Library
- Concept 26: Techniques for Importing Modules
- Concept 27: Quiz: Techniques for Importing Modules
- Concept 28: Third-Party Libraries
- Concept 29: Experimenting with an Interpreter
- Concept 30: Online Resources
- Concept 31: Practice Question
- Concept 32: Solution for Practice Question
- Concept 33: Conclusion
-
Lesson 07: Advanced Topics
In this lesson we cover some advanced topics of iterators and generators. You are not required to complete this but we have provided these to give you a taste of these.
-
Part 06 : Career Services
These Career Services will ensure you make meaningful connections with industry professionals to accelerate your career growth - whether looking for a job or opportunities to collaborate with your peers. Unlike your Nanodegree projects, you do not need to meet specifications on these Services to progress in your program. Submit these Career Services once, and get honest, personalized feedback and next steps from Udacity Career Coaches!
-
Module 01: Career Services
-
Lesson 01: Industry Research
You're building your online presence. Now learn how to share your story, understand the tech landscape better, and meet industry professionals.
- Concept 01: Self-Reflection: Design Your Blueprint for Success
- Concept 02: Debrief: Self-Reflection Exercise Part 1
- Concept 03: Debrief: Self-Reflection Exercise Part 2
- Concept 04: Map Your Career Journey
- Concept 05: Debrief: Map Your Career Journey
- Concept 06: Conduct an Informational Interview
- Concept 07: How to Request an Informational Interview
- Concept 08: Ways to Connect
- Concept 09: Ask Good Questions
- Concept 10: Debrief: Sample Questions Quiz
- Concept 11: Keep the Conversation Going
-
Lesson 02: Take 30 Min to Improve your LinkedIn
Find your next job or connect with industry peers on LinkedIn. Ensure your profile attracts relevant leads that will grow your professional network.
- Concept 01: Get Opportunities with LinkedIn
- Concept 02: Use Your Story to Stand Out
- Concept 03: Why Use an Elevator Pitch
- Concept 04: Create Your Elevator Pitch
- Concept 05: Use Your Elevator Pitch on LinkedIn
- Concept 06: Create Your Profile With SEO In Mind
- Concept 07: Profile Essentials
- Concept 08: Work Experiences & Accomplishments
- Concept 09: Build and Strengthen Your Network
- Concept 10: Reaching Out on LinkedIn
- Concept 11: Boost Your Visibility
- Concept 12: Up Next
-
Lesson 03: Optimize Your GitHub Profile
Other professionals are collaborating on GitHub and growing their network. Submit your profile to ensure your profile is on par with leaders in your field.
- Concept 01: Prove Your Skills With GitHub
- Concept 02: Introduction
- Concept 03: GitHub profile important items
- Concept 04: Good GitHub repository
- Concept 05: Interview with Art - Part 1
- Concept 06: Identify fixes for example “bad” profile
- Concept 07: Quick Fixes #1
- Concept 08: Quick Fixes #2
- Concept 09: Writing READMEs with Walter
- Concept 10: Interview with Art - Part 2
- Concept 11: Commit messages best practices
- Concept 12: Reflect on your commit messages
- Concept 13: Participating in open source projects
- Concept 14: Interview with Art - Part 3
- Concept 15: Participating in open source projects 2
- Concept 16: Starring interesting repositories
- Concept 17: Next Steps
-
Part 07 (Elective): Technical Interview Practice
-
Module 01: Technical Interview Practice
-
Lesson 01: Technical Interview - Python
Practice with five technical interviewing questions on topics discussed in the data structures and algorithms course and get a personalized review on both your code and solutions.
- Concept 01: Interview Introduction
- Concept 02: Clarifying the Question
- Concept 03: Confirming Inputs
- Concept 04: Test Cases
- Concept 05: Brainstorming
- Concept 06: Runtime Analysis
- Concept 07: Coding
- Concept 08: Coding 2
- Concept 09: Debugging
- Concept 10: Interview Wrap-Up
- Concept 11: Time for Live Practice with Pramp
- Concept 12: Next Steps
- Concept 13: Resources in Your Career Portal
-