Learn practical problem-solving with algorithms and data structures at FrontendMasters. Develop better problem-solving skills using recursion, traversals, memoization, and more. Explore examples of problems that can be solved with algorithms, optimize solutions, and understand performance characteristics. Join now!
You've probably taken a few algorithms and data structures courses and know the "what", and presently it is the right time to put the information to rehearse! Foster better problem-solving abilities by considering difficulties and applying different algorithms and software engineering methods. Use recursion, traversals, acyclic paths, memoization, and garbage collection to enhance your answers and take on a similar mindset as a genuine algorithmist.
This course and others like it are accessible as a component of our Frontend Bosses video membership.
Table of Items
00:00:00 - 00:08:17
Kyle Simpson starts the course by looking at the algorithms seminars on Frontend Bosses and offers several suggested software engineering books that frame data structures and algorithms.
00:08:18 - 00:20:19
Kyle sums up this course's key focus points, including adjusting CPU and Memory usage, forming data structures to fit a problem, and figuring out the downsides of premature optimization.
00:20:20 - 00:33:56
Data Structures Outline
Kyle audits normal data structures tracked down in software engineering. These incorporate Arrays, Stacks, Queues, Sets, Objects, Maps, Trees, and Graphs.
00:33:57 - 00:47:32
Algorithms and Procedures Outline
Kyle audits normal algorithms tracked down in software engineering. These incorporate BubbleSort, QuickSort, Tree Traversals, Path Finding, and Binary Search. Procedures like Iteration, Recursion, Indexing, and Referencing are additionally talked about in this illustration.
00:47:33 - 00:56:22
Golden Weighted Ball Problem
Kyle makes sense of the Golden Weighted Ball problem, a typical inquiry question. Eight indistinguishable balls are introduced, and one of the eight balls is lighter. A scale should be utilized to figure out which ball is the lightest in the least number of endeavors.
00:56:23 - 01:09:47
Packing Algorithms and Collision Detection
Kyle shares a couple of instances of problems that could be settled with algorithms. Problems incorporate changing binary numbers over completely to decimals, packing objects into the littlest compartment conceivable, and utilizing collision detection to improve on UI markers.
01:09:48 - 01:18:52
Tetris, Puzzles, and Size Comparison
Kyle keeps sharing instances of problems that could be tackled with algorithms. Making a bot for robotizing Tetris games, dissecting unique pieces, and deciding the biggest coterminous item in a gathering are among the models given.
Periodic Table Speller
01:18:53 - 01:31:23
Periodic Table Speller Arrangement
Kyle presents the Periodic Table Speller project and gives guidelines to cloning the task store and running the code. In this undertaking, a word entered in the text box will be spelled utilizing component images from the periodic table. The "begin here" branch ought to be utilized to start the venture.
01:31:24 - 01:44:04
Kyle executes the lookup function, which returns a component based on a predefined image. The toLowerCase technique is utilized to put forth the lookup defense harsh.
01:44:05 - 01:59:25
Check Function: Recursion
Kyle starts executing the check function. It circles through the components in the periodic table and checks to check whether any images match part of the submitted word. Provided that this is true, the check function is recursively approached for any leftover characters in the word.
01:59:26 - 02:11:36
Check Function: Base Case
Kyle completes the check function by adding base cases that prevent the function from being recursively called. At the point when a base case is reached, the recursive function cancels are successively returned the call stack, and the variety of images is finished. The arrangement can be tracked down on the choice 1 branch.
02:11:37 - 02:22:12
Optimizing the Lookup Function
Kyle advances the lookup function by making a file of images when the data is stacked inside the loadPeriodicTable function. This record can be utilized inside the lookup function, dispensing with the requirement for a circle. The choice 1 branch can be utilized as a beginning stage for this illustration.
02:22:13 - 02:38:18
Kyle makes a findCandidates function to recursively find a rundown of image candidates matching one and two-letter character blends in the submitted word. Note: Better code optimizations can be found on the choice 2b and choice 3 branches.
02:38:19 - 02:54:50
spellWord Function with Character Sets
Kyle refactors the check function to utilize a spellWords function that recursively searches for matching images by focusing on two-character matches. Note: Better code optimizations can be found on the choice 2b and choice 3 branches.
02:54:51 - 03:04:04
spellWord Function question and answer session
Kyle responds to optimization questions and examines substitute executions. A little refactor is performed for consistency, and a bug is tended to. Note: Better code optimizations can be found on the choice 2b and choice 3 branches.
03:04:05 - 03:15:38
Kyle features the performance characteristics of the Periodic Table Speller and looks at hypothetical versus down to earth performance. Note: Better code optimizations can be found on the choice 2b and choice 3 branches.
03:15:39 - 03:29:41
Drawing the Chessboard
Kyle starts the Chessboard Diagonals project by composing a content that populates the page with a highly contrasting chessboard. The board comprises of eight lines and eight sections. DIV components are utilized to address each tile.
03:29:42 - 03:43:55
Navigating the Tiles
Kyle shows the way that the querySelectorAll strategy can be utilized to navigate the tiles on the chessboard. The querySelectorAll strategy returns a NodeList of components matching the provided design. A circle goes through the rundown of components and eliminates the "featured" class from every component.
03:43:56 - 03:58:21
Featuring Inclining Tiles
Kyle utilizes a progression of for circles to search for inclining tiles to feature. Each circle navigates tiles in an alternate slanting course until an upper or lower bound is reached.
03:58:22 - 04:10:28
Optimizing DOM Crossing
Kyle improves the inclining tile calculation by diminishing DOM traversals and saving a tile's line and section records to dataset properties. Utilize the choice 1 branch connected beneath as a beginning stage for this illustration.
04:10:29 - 04:19:25
Utilizing Two-Layered Arrays
Kyle develops a two-layered exhibit to save references for each tile. Crossing and getting to the exhibit is more performant than re-questioning the DOM. Utilize the choice 2 branch connected beneath as a beginning stage for this example.
04:19:26 - 04:32:12
Making a Slanting Data Design
Kyle reevaluates the ongoing data structure and makes sense of why utilizing a slanting data design can enhance the calculation. Utilize the choice 3 branch connected underneath as a beginning stage for this illustration.
04:32:13 - 04:45:24
Refactoring the Feature Function
Kyle refactors the feature function to use the inclining data structure. A Guide variable is utilized to make references to store major and minor corner to corner lists for every component. The last answer for the Chessboard Diagonals problem can be tracked down on the choice 4 branch.
04:45:25 - 04:53:32
Knights Dialer Exercise
Kyle presents the Knight's Dialer work out. Algorithms will be composed to count the quantity of particular paths that can be crossed while beginning from a particular key and which various paths can be taken without arriving on any recently visited keys.
04:53:33 - 05:08:55
Reachable Keys Function
Kyle executes the reachableKeys function, which fabricates a variety of neighboring keys for each key on the dialer cushion.
05:08:56 - 05:15:14
Optimizing with a Data Design
Kyle refactors the code to supplant the reachable keys calculation with a static data structure. The reachable keys on the dial cushion never show signs of change, so utilizing a static data structure with the accessible qualities streamlines the general application and wipes out the need to navigate the dialer while laying out the bounces a knight can make.
05:15:15 - 05:31:51
Kyle makes sense of expansiveness first search and executes the countPaths function, which is recursively called to decide the quantity of paths expected to finish the predefined jumps.
05:31:52 - 05:45:34
Enormous O Intricacy
Kyle presents enormous O intricacy and what it means for the performance of a calculation. The ongoing execution of the Knight's Dialer code has an intricacy of 2.222 to the N.
05:45:35 - 06:01:58
Kyle carries out the listAcyclicPaths function. It returns a variety of particular paths with no rehashed jumps. A followPath function is likewise made to recursively follow each jump and drive it into the paths cluster on the off chance that it doesn't exist.
06:01:59 - 06:16:03
Advance Recursion with Memoization
Kyle makes sense of how algorithms can be enhanced by utilizing memoization. At the point when a path is followed, it tends to be saved utilizing a blend of the beginning worth and the length as the record. The choice 2 branch can be utilized as a beginning stage for this example.
06:16:04 - 06:27:40
Dynamic Programming Outline
Kyle presents dynamic programming, consolidating the memoization or hierarchical methodology with the classification or granular perspective. This mix makes a calculation that is both memory effective and performant. The choice 3 branch can be utilized as a beginning stage for this example
06:27:41 - 06:37:41
Picturing Dynamic Programming
Kyle pictures how the powerful programming approach will be applied to the counthPath function. Every iteration will classify the paths with a direct algorithmic intricacy.
06:37:42 - 06:55:52
Coding with Dynamic Programming
Kyle refactors the counthPaths function to go through the base classification technique for dynamic programming to decide the number of paths that are expected for each bounce. The last arrangement can be tracked down on the choice 4 branch.
06:55:53 - 07:06:44
Longwinded Unscrambler Outline
Kyle presents the Longwinded Scrambler problem and looks at it to other word puzzles like Wordscapes where a mixed rundown of letters should be decoded to make word blends.
Zip/rar files password can be one of these :- FreeCourseUniverse / CheapUniverse
Hey Guys We are Tech Enthusiasts and we know knowledge is key to success ! We are here to open path to your success by providing what you want. Today education == business. Our moto is education should be accessible by any person who is not able to purchase overpriced content.
All TakenDown courses are available here