Algorithms in JavaScript Design techniques

Data Structures, Complexity Analysis,Recursion, backtracking, Dynamic Programming,Greedy algorithm, Divide and Conquer
Algorithms in JavaScript Design techniques
File Size :
2.29 GB
Total length :
17h 21m

Category

Instructor

Basics Strong

Language

Last update

9/2022

Ratings

4.5/5

Algorithms in JavaScript Design techniques

What you’ll learn

Algorithm Design in JavaScript

Algorithms in JavaScript Design techniques

Requirements

Basic Java Script

Description

Algorithm Design Techniques : Live problem solving in Java ScriptAlgorithms are everywhere! One great algorithm applied sensibly can result into a System like GOOGLE! Larry Page, founder of google designed “Page Rank” algorithm that is behind the search in google. That is why when we search on google we generally find the most relevant result on the First Page itself.Every Computer Programmer should learn how to design algorithms which are not only correct but also efficient in terms of TIME and SPACE!Completer scientists have worked from 100s of years !! – (Put images of some of the scientists…)And derived some of the techniques that can be applied to write and design algorithms!So Why to reinvent the wheel ??Let’s go through some of the most famous algorithm design techniques in this course!!Once you will come to know these design techniques It will become very easy for you to approach a problem by identifying which technique to apply to solve that correctly and efficiently.We will start this course with some measurement techniques in algorithms that is called complexity analysis so that we can measure -The time and space in an algorithm when we design that.Then we will start with understanding recursion and deep dive into that.Recursion is the base of any algorithm design … because most of the algorithms has to be solved using recursion!Recursion is executed in computers in a very special way using stack frames… we will understand all that..There are many types of recursion and we will have a look into that. We will solve some classic problems like the Tower of Hanoi, Binary subtree… to understand the recursion deeply… And WE WILL WRITE THE CODE LINE BY LINE IN JAVA !! To make it very easy to understand and code…Then we will move into another design technique backtracking !! Backtracking algorithms are enhanced recursion where we can revert our decision from inside a recursion…We will understand how to Identify and approach this kind of problems.. Also, we will solve some classical problems Rat In Maze, NQueens, KnightsTour problems… and Code them LINE by LINE …Then, We will then move to the next section Divide and Conquer… Greedy algorithmsAnd will take the same approach !! To understand identify and Solve some problems… and code some classic problems.Then there will be a very important section! Dynamic programming That is not only important for Algorithms design but also, InterviewsThis is a very favorite paradigm for the interviewer to ask questions from – We will solve a lot of problems in section along with code… and understand how to approach this kind of problem!!All in all!By the end of this course –    1. You will understand how to design algorithms     2. A lot of coding practice and design live problems in Java    3. Algorithm Complexity analysis AND If you are preparing for your coding Interview or doing competitive programming This course will be a Big help for you!I think this is enough to create the THRILL !! I welcome you to the course and I am sure this will be fun!!If it does not – It comes with a 30 Days money-back guarantee so don’t think twice to give it a shot…Welcome Again !! And See you in the course.

Overview

Section 1: Course Introduction

Lecture 1 Introduction

Lecture 2 Course Resources

Section 2: Introduction To Algorithms

Lecture 3 Introduction to Algorithms

Section 3: Complexity Analysis

Lecture 4 Section Introduction

Lecture 5 Complexity Analysis 1

Lecture 6 Complexity Analysis 2

Lecture 7 Section Summary

Section 4: Recurrence Relation

Lecture 8 Section Introduction

Lecture 9 Recurrence Relation

Lecture 10 Solving Recurrence Relation

Lecture 11 Master’s Theorem

Lecture 12 Section Summary

Section 5: Thinking Recursively

Lecture 13 Section Introduction

Lecture 14 Recursion

Lecture 15 Identification

Lecture 16 Approaching

Lecture 17 Problem 01 : FindingSubstrings – Logic

Lecture 18 Problem 01 : FindingSubstrings – Live Code JavaScript

Lecture 19 Problem 01 : FindingSubstrings – Complexity Analysis

Lecture 20 Problem 02 : Tower of Hanoi – Logic

Lecture 21 Problem 02 : Tower of Hanoi – Live Code JavaScript

Lecture 22 Problem 02 : Tower of Hanoi – Complexity Analysis

Lecture 23 Problem 03 : Array Product Sum – Logic

Lecture 24 Problem 03 : Array Product Sum – Live Code JavaScript

Lecture 25 Problem 03 : Array Product Sum – Complexity Analysis

Lecture 26 Problem 04 : Binary Subtree – Logic

Lecture 27 Problem 04 : Binary Subtree : Live code

Lecture 28 Problem 04 : Binary Subtree – Complexity Analysis

Lecture 29 Why and Why not Recursion

Lecture 30 Types Of Recursion

Lecture 31 Tail Recursion

Lecture 32 Summary

Section 6: Backtracking

Lecture 33 Section Introduction

Lecture 34 Introduction to Backtracking

Lecture 35 Identification

Lecture 36 Approaching The Solution

Lecture 37 Problem 01 : Rat In Maze – Logic

Lecture 38 Problem 01 : Rat In Maze – Code

Lecture 39 Problem 01 : Rat In Maze – Complexity Analysis

Lecture 40 Problem 02 : N-Queens – Logic

Lecture 41 Problem 02 : N-Queens – Live Code in Javascript

Lecture 42 Problem 02 : NQueen – Complexity Analysis

Lecture 43 Problem 03 : Knight Tour Problem – Logic

Lecture 44 Problem 03 : Knight’s Tour Problem – Live Code in Javascript

Lecture 45 Problem 03 : Knight Tour Problem – Complexity Analysis

Lecture 46 Problem 04 : Boggle | Word Search – Logic

Lecture 47 Problem 04 : Boggle | Word Search – Live Code in Javascript

Lecture 48 Problem 04 : Boggle | Word Search – Complexity Analysis

Lecture 49 Section Summary

Section 7: Divide and Conquer

Lecture 50 Section Introduction

Lecture 51 Introduction To Divide And Conquer

Lecture 52 Identification and Approaching

Lecture 53 Problem 01 : MergeSort – Logic

Lecture 54 Problem 01 : MergeSort – Live Javascript Code

Lecture 55 Problem 01 : MergeSort – Complexity Analysis

Lecture 56 Problem 02 : QuickSort – Logic

Lecture 57 Problem 02 : QuickSort – Live Javascript Code

Lecture 58 Problem 02 : QuickSort – Complexity Analysis

Lecture 59 Problem 03 : Median Of Medians – Logic

Lecture 60 Problem 03 : Median Of Medians – Live Javascript Code

Lecture 61 Section Summary

Section 8: Greedy Technique

Lecture 62 Section Introduction

Lecture 63 Introduction to Greedy

Lecture 64 Identification & Approaching the Solution

Lecture 65 Problem 01 : Fractional Knapsack – Logic

Lecture 66 Problem 01 : Fractional Knapsack – Live Code Javascript

Lecture 67 Problem 01 : Fractional Knapsack – Complexity Analysis

Lecture 68 Problem 02 : IntervalScheduling – Logic

Lecture 69 Problem 02 : IntervalScheduling – Live Code Javascript

Lecture 70 Problem 02 : IntervalScheduling – Complexity Analysis

Lecture 71 Problem 03 : Huffman Code – Logic

Lecture 72 Problem 03 : Huffman Code – Live Code Javascript

Lecture 73 Problem 03 : Huffman Code – Complexity Analysis

Lecture 74 Problem 04 : Dijkstra – Logic

Lecture 75 Problem 04 : Dijkstra Logic – Live Code Javascript

Lecture 76 Problem 04 : Dijkstra – Complexity Analysis

Lecture 77 Summary

Section 9: Dynamic Programming

Lecture 78 Section Introduction

Lecture 79 Introduction to Dynamic Programming

Lecture 80 Identification

Lecture 81 Compare DP, D&C and Greedy

Lecture 82 Approaching the Solution

Lecture 83 Example 01 : Staircase Problem Explanation & Live Code

Lecture 84 Example 01 : Staircase Problem Complexity Analysis

Lecture 85 Example 02 – 0/1 Knapsack Explanation & Live code

Lecture 86 Example 02 – 0/1 Knapsack Complexity Analysis

Lecture 87 Example 03 – Coin Change Problem Explanation and Code

Lecture 88 Example 03 – Coin Change Problem Complexity Analysis

Lecture 89 Example 04 : Longest Decreasing Subsequence Explanation And Code

Lecture 90 Example 04 : Longest Decreasing Subsequence | Complexity Analysis

Lecture 91 Example 05 : Levenshtein problem

Lecture 92 Example 05 : Levenshtein Complexity Analysis

Lecture 93 Example 06 : Rod Cutting

Lecture 94 Example 06 : Rod Cutting – Complexity Analysis

Lecture 95 Example 07 : Matrix Chain Multiplication

Lecture 96 Example 07 : Matrix Chain Multiplication | Complexity Analysis

Lecture 97 Summary

Section 10: Famous Algorithms

Lecture 98 Kadane’s Algo

Lecture 99 Kadane’s Algo Live Code Javascript

Lecture 100 Kadane’s Algo Complexity Analysis

Lecture 101 BellmanFord’s Algo

Lecture 102 BellmanFord’s Algo Live Code Javascript

Lecture 103 BellmanFord’s Algo Complexity Analysis

Lecture 104 Topological Sort : Kahn’s Algo

Lecture 105 Topological Sort Live Code Javascript

Lecture 106 Topological Sort Complexity Analysis

Lecture 107 Edmon’s Karp/ Ford-Fulkerson Algorithm

Lecture 108 Edmon’s Karp/ Ford-Fulkerson Live Code

Section 11: Trees

Lecture 109 Tree Overview

Lecture 110 Identification

Lecture 111 Approaching Tree Problems

Lecture 112 Problem 1: Sum Tree – Logic

Lecture 113 Problem 1: Sum Tree – Live Code

Lecture 114 Problem 2: Invert Binary Tree – Logic

Lecture 115 Problem 2: Invert Binary Tree – Live Code

Lecture 116 Problem 3: Binary Search Tree – Logic

Lecture 117 Problem 3: Binary Search Tree – Live Code

Lecture 118 Problem 4: Binary Tree from InOrder & LevelOrder – Logic

Lecture 119 Problem 4: Binary Tree from InOrder & LevelOrder – Live Code

Section 12: Graphs

Lecture 120 Google’s Knowledge Graph

Lecture 121 Graphs – In Real World

Lecture 122 Graphs – Overview

Lecture 123 Terminologies

Lecture 124 Identification of Problem

Lecture 125 Approaching the Problem

Lecture 126 Mind-Map

Lecture 127 Graph Traversal – Types

Lecture 128 Depth First Search Traversal

Lecture 129 DFS – Implementation (Recursive)

Lecture 130 DFS – Implementation (Iterative)

Lecture 131 Breadth First Search Traversal

Lecture 132 BFS – Implementation

Lecture 133 Type – Minimum Spanning Tree

Lecture 134 Prim’s Algorithm

Lecture 135 Prim’s Algorithm – Implementation

Lecture 136 Kruskal’s Algorithm

Lecture 137 Union-Find Algorithm

Lecture 138 Kruskal’s Algorithm – Implementation

Lecture 139 Type – Shortest Path

Lecture 140 Dijkstra’s Algorithm

Lecture 141 Dijkstra’s Algorithm – Implementation

Lecture 142 Bellman Ford’s Algorithm

Lecture 143 Bellman Ford’s Algorithm – Implementation

Lecture 144 Floyd Warshall Algorithm

Lecture 145 Floyd-Warshall Algorithm – Implementation

Lecture 146 Johnson’s Algorithm

Lecture 147 Johnson’s Algorithm – Implementation

Lecture 148 Type – Network Flow

Lecture 149 Ford-Fulkerson Algorithm

Lecture 150 Ford-Fulkerson Theorem – Implementation

Lecture 151 Max-Flow Min-Cut Theorem

Lecture 152 Type – Strongly Connected Components

Lecture 153 Tarjan’s Algorithm

Lecture 154 Tarjan’s Algorithm – Implementation

Lecture 155 Kosaraju’s Algorithm

Lecture 156 Kosaraju’s Algorithm – Implementation

Section 13: Thank you!

Lecture 157 Thank you!

Want to learn Algo Designing in JavaScript

Course Information:

Udemy | English | 17h 21m | 2.29 GB
Created by: Basics Strong

You Can See More Courses in the Developer >> Greetings from CourseDown.com

New Courses

Scroll to Top