Mastering critical SKILLS for Coding Interviews C++: Part 1 from Udemy

Welcome to one of the unique and special Coding Interviews courses.

This course is all about algorithmic problem-solving for problems mainly from the Leetcode website. Specifically, the medium level frequent interview problems. The goal of this course is to sharpen your problem-solving skills to aid you in ACEing Coding Interviews from FAANG companies. During the course, you won't only be provided with a problem and its solution, but a series of hints and thinking approaches to tackle the problems.

I don't teach data structures or algorithms in this course. You must study these courses from high-quality sources and solve many problems to gain basic problem-solving skills. The problems in this course are of medium level. Without proper background and skills, the materials will be hard to learn.

Part 1 content

Part one covers the data structures:
- Arrays: Prefix Sum, Sliding Window (fixed and variable size) 2 Pointers, and Permutations.
  - Tutorials are provided for these topics only, as they are not covered in DSA courses.
- String
- Matrices
- Stack and Priority Queue
- Linked List and Binary Trees
- Hash Tables
The scope of the topics: Interviews coverage.
- Note: You are expected to solve the implementation problems over these topics during a data structure course. For example, reversing a linked list is a common interview question. I won't cover it. It is mainly an implementation task. The same for the basic binary tree DFS problems. I do cover such questions in my data structure and algorithms course. This course is about problem-solving challenges.
Although the focus of this part is Data Structures, but still your background in Algorithms is needed.
- Major: Complexity, Recursion and Sorting
- Minor: A few times I refer to: Binary Search, Divide and Conquer and Dynamic Programming
- Generally, most of the problems require serious algorithmic skills

The course level:

Most of the problems in this course are Leetcode MEDIUM level, which represent 85-90% of real interview questions.
To be more effective, the questions are mainly the most frequent interview questions according to the LeetCode website.
This means; in addition to gaining problem-solving skills, you increase the chance of meeting problems you already solved in the interviews.
Without proper background & skills ⇒ the course will be hard to learn

Prerequisites:

Strong programming skills & DSA knowledge/skills (from 3 courses)
- A high-quality programming course consisting of:
  - Good coverage for programming + many exercises on learned topics
  - Proper understanding/using for built-in algorithms/DS (e.g. C++ STL / Java Collections)
  - Optional: Several projects to be comfortable with long coding
- A high-Quality Data Structure course: good coverage + many exercises
- A high-Quality Algorithms course: good coverage + many exercises
- This implies: you already solved and coded a lot. It is time to move to medium challenges.
  - Don't join this course if you lack basic problem-solving skills

The course programming language

All slides codes are based on C++
- Mainly C++11. I intend to not use the very modern C++
  - Many people don't study after C++11
  - It will be easier for other programming languages to understand the code
- C++ code is very similar to Java and C#. To a good extent, similar to JavaScript.
The LeetCode discussion tab has solutions for many other languages
- 80% of the problems: I will download solutions for some other languages (Python, Java) .
  - No promise, but some downloads for JavaScript and a few C#
  - As the code is downloaded, expect differences in the code structure. You must understand fully the lecture first.

The course natural language:

The course is only in English with an Egyptian accent
English subtitles are provided to make it easy in case. it is easy to adapt the Egyptian accent

Videos problem-solving cycle:

Presenting a problem
Verifying assumptions and test cases
Trying to brute-force the problem
Optimizing the brute force if possible
Or analyzing the problem and test cases
Several iterative hints are provided; a missing educational key in other resources
Well-written codes.

2 training styles are possible with the materials.

A topics-based style where you focus on a specific topic and solving many of its problems. This style has a great disadvantage; you know the solution category (e.g. a stack problem), which is a big hint.
A blind-based style where sprints of problems are provided. Each sprint is 10 problems to solve.
- You don’t know the category of the problem.
- This is a more matching experience to the real interviews experience.
- This style is the recommended one.
After the course, you will be provided with more problems to solve on your own to keep enhancing your skills.
- You must solve a lot to increase your chance of passing the interviews.

A problem name starts with

E for easy-level from 1 to 3
M for medium-level from 4 to 7
H for hard-level from 8 to 10

Acknowledgement: “I’d like to extend my gratitude towards Robert Bogan for his help with proofreading the slides for this course”

What's inside

Learning objectives

Sharpen your problem-solving skills
More than 70 medium level frequent interview problems
Increase the chance of seeing the same problems in the interview
Several hints not just the whole solution

After the course: other ~100 problems are provided to solve on your own
Well-written compact codes
2 training styles: the classical topics-based style and a blind-based style (sprints of 10 problems)

Sharpen your problem-solving skills
More than 70 medium level frequent interview problems
Increase the chance of seeing the same problems in the interview
Several hints not just the whole solution
After the course: other ~100 problems are provided to solve on your own
Well-written compact codes
2 training styles: the classical topics-based style and a blind-based style (sprints of 10 problems)

Syllabus

Getting Started

Prerequisites

Effective usage of the course 1

Effective usage of the course 2

Update:

Someone updated me there is a LeetCode solution for this problem

The only code difference is the handling when you don’t find an answer: Return -1

Traffic lights

Read about what's good

what should give you pause

and possible dealbreakers

Focuses on algorithmic problem-solving using LeetCode's medium-level problems, which are frequently encountered in interviews at top tech companies

Employs C++11, which strikes a balance between modern features and broad understanding, making the code accessible to those familiar with other languages

Requires a strong foundation in data structures and algorithms, suggesting it is designed for those with prior experience and not for beginners

Uses a 'blind-based style' with sprints of problems, which simulates the unpredictable nature of real coding interviews and helps build adaptability

Provides additional problems to solve after the course, encouraging continuous learning and skill enhancement, which is essential for interview preparation

Assumes familiarity with basic implementations, focusing instead on problem-solving strategies and hints, which may not be suitable for novice programmers

Reviews summary

Interview problem solving with c++

According to learners, this course is highly effective for mastering medium-level LeetCode problems relevant to coding interviews, especially for those targeting FAANG companies. Students praise the unique hint-based problem-solving cycle, which helps build independent thinking rather than just memorizing solutions. The selection of frequent medium problems is a major strength. However, learners consistently emphasize that strong prerequisites in programming and DSA are essential; students lacking this foundation may find the course too challenging. While the C++ code is clear, some mention the instructor's Egyptian accent, although subtitles are provided. Overall, it's seen as a valuable resource for polishing skills after foundational DSA study.

Difficulty is high, but builds real skills.

"It's definitely tough, don't expect it to be easy, but the struggle leads to genuine skill improvement."

"Sometimes I felt stuck, but pushing through the problems in this course was very rewarding."

"The difficulty level is appropriate for actual coding interviews, it's good preparation."

"Requires significant effort, but I feel much more prepared after tackling these problems."

Recommended style simulates interviews.

"The blind sprints are a fantastic idea! It's much closer to the real interview experience."

"I followed the recommended blind-based style, and it really helped me think on my feet."

"Doing problems without knowing the topic category is crucial practice this course provides."

"Training with the sprints made me more comfortable facing unknown problem types."

Focus on frequent medium interview problems.

"The problems chosen are highly relevant and frequently asked in interviews. Great selection!"

"I liked that the course focuses on medium problems, which are the bulk of what you face."

"Identifying the most frequent problems helps prioritize study time effectively."

"Solving these specific LeetCode medium problems feels directly applicable to interview prep."

Learn thinking process, not just solutions.

"The way the instructor provides hints step-by-step is brilliant. It trains your brain on *how* to think about the problem."

"I really appreciate that we don't just get the answer. The iterative hints help develop problem-solving intuition."

"This method of giving hints before the full solution is way more effective for learning than typical tutorials."

"It forces you to try and solve it yourself with guidance, which is key for interviews."

Instructor's accent requires some adjustment.

"The instructor's Egyptian accent can be a bit hard to follow sometimes, but the subtitles are helpful."

"Took a little while to get used to the accent, but his explanations are generally clear."

"If you're not used to the accent, you'll rely heavily on the subtitles. They are accurate."

"While the accent is present, it didn't significantly hinder my learning thanks to the provided subtitles."

Course is difficult without solid DSA foundation.

"This course demands a strong background in data structures and algorithms. If you don't have that, you will struggle."

"As the instructor clearly states, this is NOT a beginner course. You must have DSA mastered first."

"I found it challenging initially because my DSA wasn't as strong as required. It pushes you."

"You need to have completed quality DSA courses before attempting this one. It's not a review of basics."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Mastering critical SKILLS for Coding Interviews C++: Part 1 with these activities:

Review C++ STL

Show steps

Refresh your knowledge of the C++ STL, including containers and algorithms, to efficiently implement solutions during coding interviews.

Show steps

Review documentation for common STL containers.
Practice using STL algorithms for sorting and searching.
Implement data structures using STL containers.

Introduction to Algorithms

Show steps

Review 'Introduction to Algorithms' to gain a deeper understanding of the theoretical foundations behind the algorithms covered in the course.

View Introduction to Algorithms, fourth edition on Amazon

Show steps

Read chapters on relevant algorithms like sorting and searching.
Work through the examples and exercises in the book.
Relate the theoretical concepts to practical coding problems.

Cracking the Coding Interview

Show steps

Review 'Cracking the Coding Interview' to reinforce your understanding of data structures, algorithms, and problem-solving strategies for coding interviews.

View Cracking the Coding Interview: 189 Programming... on Amazon

Show steps

Read relevant chapters on arrays, strings, and linked lists.
Solve practice problems from the book.
Compare your solutions with the book's solutions.

Four other activities

Expand to see all activities and additional details

Show all seven activities

LeetCode Array Problems

Show steps

Practice solving array-based problems on LeetCode to improve your problem-solving skills and familiarity with common interview questions.

Show steps

Select 5-10 LeetCode medium array problems.
Solve each problem within a time limit.
Analyze your solutions and compare with others.

Mock Interview with a Peer

Show steps

Participate in a mock coding interview with a peer to practice your problem-solving and communication skills in a simulated interview environment.

Show steps

Find a peer who is also preparing for coding interviews.
Choose a problem from LeetCode or a similar platform.
Conduct the mock interview, taking turns as interviewer and interviewee.
Provide feedback to each other on your performance.

Create a Blog Post on Prefix Sum Techniques

Show steps

Create a blog post explaining prefix sum techniques with examples to solidify your understanding and share your knowledge with others.

Show steps

Research and gather information on prefix sum techniques.
Write a clear and concise explanation of the techniques.
Include examples and code snippets in C++.
Publish the blog post on a platform like Medium.

Implement a Sliding Window Algorithm Visualizer

Show steps

Start a project to visualize the sliding window algorithm, solidifying your understanding and creating a useful tool for others.

Show steps

Design the visualizer interface.
Implement the sliding window algorithm in C++.
Integrate the algorithm with the visualizer.
Test and refine the visualizer.

Career center

Learners who complete Mastering critical SKILLS for Coding Interviews C++: Part 1 will develop knowledge and skills that may be useful to these careers:

Algorithm Developer

An Algorithm Developer is responsible for designing and implementing efficient algorithms to solve specific problems. This course, 'Mastering critical SKILLS for Coding Interviews C++: Part 1', is exceptionally relevant, as it focuses on algorithmic problem-solving using C++. The course emphasizes techniques to tackle interview problems, improving skills in algorithm design and optimization. Algorithm Developers benefit directly from the course's focus on data structures like arrays, strings, matrices, and hash tables, and its coverage of complexity analysis and recursion. The problem-solving sprints and the provided hints may help Algorithm Developers enhance their ability to develop novel and efficient algorithms.

See salaries and explore the career path for Algorithm Developer

Software Engineer

A Software Engineer designs, develops, and tests software applications. Mastering data structures and algorithms is crucial for success as a Software Engineer, especially when dealing with performance-critical applications. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course directly addresses this need by focusing on algorithmic problem-solving using C++, a language widely used in software engineering. The course provides a strong foundation for tackling complex coding challenges, similar to those encountered in real-world software development. The emphasis on LeetCode medium-level problems and frequent interview questions may help any Software Engineer improve their skills and confidence.

See salaries and explore the career path for Software Engineer

Game Developer

Game Developers create video games for various platforms. A strong understanding of data structures and algorithms is essential for optimizing game performance and creating engaging gameplay experiences. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course is highly relevant for Game Developers, as it focuses on algorithmic problem-solving using C++, a primary language in game development. The course's focus on data structures, algorithm design, and problem-solving techniques will directly translate to improved game performance and efficient game logic. The content on matrices, trees, and priority queues may be especially useful.

See salaries and explore the career path for Game Developer

Machine Learning Engineer

Machine Learning Engineers develop and deploy machine learning models. They need expertise in both machine learning algorithms and software engineering principles. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course helps Machine Learning Engineers strengthen their understanding of data structures and algorithms, essential for optimizing model performance and implementing custom solutions. The course covers arrays, strings, matrices, and other data structures and focuses on algorithmic problem-solving skills relevant to machine learning tasks. Machine Learning Engineers may benefit from the course's focus on complexity, recursion, and sorting.

See salaries and explore the career path for Machine Learning Engineer

Backend Developer

Backend Developers build and maintain the server-side logic and databases that power web applications. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course is helpful for Backend Developers because proficiency in data structures and algorithms is invaluable for optimizing database queries, handling large datasets, and ensuring application scalability. Backend Developers will find that the course's coverage of arrays, strings, matrices, trees, and hash tables directly translates into improved code efficiency and performance. The focus on problem-solving techniques prepares Backend Developers to tackle complex challenges in designing and maintaining robust backend systems.

See salaries and explore the career path for Backend Developer

Data Scientist

Data Scientists analyze large datasets to extract meaningful insights and build predictive models. While data science involves statistical analysis and machine learning, understanding data structures and algorithms is important for efficient data manipulation and model implementation. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course helps Data Scientists sharpen these skills. Even though C++ is not the primary language of Data Scientists, the course's focus on data structures, algorithmic problem-solving, and complexity analysis will translate to better efficiency when working with other languages like Python. The emphasis on problem-solving strategies strengthens the analytical capabilities of Data Scientists.

See salaries and explore the career path for Data Scientist

Embedded Systems Engineer

Embedded Systems Engineers design and develop software for embedded systems, which are specialized computer systems within devices. Proficiency in C++ and a deep understanding of data structures and algorithms are essential for efficient resource utilization and real-time performance. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course provides a solid basis in these areas, as it focuses on algorithmic problem-solving using C++. The course's focus on data structures like arrays and linked lists, algorithm design, and complexity analysis prepares Embedded Systems Engineers to optimize their code for resource-constrained environments. The problem-solving techniques may help in tackling the unique challenges of embedded systems development.

See salaries and explore the career path for Embedded Systems Engineer

Robotics Engineer

A Robotics Engineer designs, builds, and programs robots for various applications. Expertise in data structures, algorithms, and programming is crucial for developing efficient and robust robot control systems. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course provides a strong foundation, as it focuses on algorithmic problem-solving using C++, a common language in robotics. The course's focus on data structures, algorithm design, and complexity analysis equips Robotics Engineers with the tools to optimize robot performance and implement complex control algorithms. The emphasis on problem-solving strategies may help in developing innovative solutions to robotics challenges.

See salaries and explore the career path for Robotics Engineer

Full-Stack Developer

Full Stack Developers work on both the frontend and backend of web applications. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course is useful for Full Stack Developers who aim to improve their backend development skills. It provides a foundation in data structures and algorithms which is useful in optimizing server-side code and database interactions. The course enhances problem-solving abilities and improves coding skills, making Full Stack Developers more versatile and effective in their roles. The C++ skills acquired in this course can be applied to other roles.

See salaries and explore the career path for Full-Stack Developer

Quantitative Analyst

Quantitative Analysts, often working in the finance industry, develop and implement mathematical models for pricing derivatives, managing risk, and other financial applications. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' may be useful for Quantitative Analysts, especially those involved in implementing their models in C++. The course's focus on algorithmic problem-solving, data structures, and complexity analysis helps them write efficient and optimized code. The course's emphasis on problem-solving approaches and the use of data structures enhances the performance of Quantitative Analysts.

See salaries and explore the career path for Quantitative Analyst

Data Engineer

Data Engineers design, build, and maintain the infrastructure for data storage and processing. While their work is distinct from data analysis, a solid understanding of data structures and algorithms is essential for efficient data handling and pipeline optimization. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course helps Data Engineers strengthen these core skills. The course's emphasis on problem-solving strategies may also help Data Engineers design robust and scalable data infrastructure. Even though Data Engineers may not use C++ on a daily basis, the principles learned will translate to better code practices.

See salaries and explore the career path for Data Engineer

Test Engineer

Test Engineers are responsible for designing and executing tests to ensure software quality. A strong understanding of algorithms allows Test Engineers to create effective test cases and identify potential performance bottlenecks. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course is helpful for Test Engineers, as it focuses on algorithmic problem-solving. The course's focus on data structures and algorithm design enables Test Engineers to develop comprehensive test suites and analyze test results effectively. The emphasis on problem-solving techniques enhances the ability to identify and address potential software defects.

See salaries and explore the career path for Test Engineer

Technical Lead

A Technical Lead guides and mentors a team of developers, making key technical decisions. While they may not be writing code every day, a solid understanding of algorithms and data structures is still essential for making informed design choices and providing effective guidance. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course helps Technical Leads maintain and sharpen their technical skills, even if they are primarily focused on leadership responsibilities. The course's emphasis on problem-solving and algorithmic thinking helps Technical Leads make sound technical decisions and guide their teams in developing efficient and robust solutions. Even though they may not be using C++ specifically, the general principles from this course is still useful.

See salaries and explore the career path for Technical Lead

Security Engineer

Security Engineers protect computer systems and networks from threats. A strong understanding of data structures and algorithms is useful for analyzing security vulnerabilities and developing secure code. The 'Mastering critical SKILLS for Coding Interviews C++: Part 1' course may be useful for Security Engineers who need to analyze and optimize security-related code or implement custom security tools. The course helps Security Engineers to strengthen their problem-solving abilities. This course may help in the field.

See salaries and explore the career path for Security Engineer

DevOps Engineer

DevOps Engineers automate and streamline software development and deployment processes. While a deep understanding of algorithms is not always required, the ability to write efficient scripts and tools is valuable. 'Mastering critical SKILLS for Coding Interviews C++: Part 1' may be useful for DevOps Engineers who need to develop custom solutions or optimize existing infrastructure. The course's focus on algorithmic problem-solving and the use of data structures helps in writing efficient and maintainable code. The emphasis on problem-solving techniques enhances the ability to automate complex tasks and troubleshoot issues efficiently.

See salaries and explore the career path for DevOps Engineer

Mastering critical SKILLS for Coding Interviews C++

Part 1

What's inside

Learning objectives

Syllabus

Traffic lights

Save this course

Reviews summary

Interview problem solving with c++

Activities

Career center

Reading list

Share

Similar courses