Practical Problem Solving with Algorithms – FrontendMasters

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

Presentation

00:00:00 – 00:08:17

Presentation

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

Course Outline

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.

Groundwork

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.

Model Problems

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

Lookup Function

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

Finding Candidates

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

Performance Characteristics

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.

Chessboard Diagonals

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.

Knight’s Dialer

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

Recursive Crossing

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

Acyclic Paths

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.

Longwinded Problem

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.

07:

Useful links:

1. Frontend Masters website: https://frontendmasters.com/
2. Wikipedia page on algorithms: https://en.wikipedia.org/wiki/Algorithm
3. Wikipedia page on data structures: https://en.wikipedia.org/wiki/Data_structure
4. Wikipedia page on recursion: https://en.wikipedia.org/wiki/Recursion_(computer_science)