Skip to main content
100%

Trie.js - super simple JavaScript implementation

✓ Published0🌍 Public
Aamundo
Last edited Nov 20, 2016
Created on Dec 16, 2016

This example shows a trie data structure implemented in plain JavaScript, demonstrating how words are inserted, searched, and retrieved by prefix. The code defines `TrieNode` and `Trie` classes with methods for `insert`, `contains`, and `find`, where `find` recursively collects all words matching a prefix. The implementation uses the standard trie operations of traversing child nodes via a hash map and tracking word endings with an `end` flag. The console output verifies the results for the words "hello" and "helium", showing the expected prefix matches.

AI-generated description

Similar vizzes

Loading thumbnail…

core trie code in new labMTsimple

This example computes a sentiment score for a corpus by traversing two prefix trees stored in `self.data`. It first checks exact word matches in the non-regex trie, then falls back to a regex trie for stemmed words using `prefixes` and `prefix_items`. The code iterates over a `wordDict` hash mapping words to counts, accumulating weighted scores and total counts before returning the average. It relies on the `labMTsimple` internal trie structure rather than external visualization libraries, with no rendering or charting API present.

Aandyreagan
61% match
Loading thumbnail…

Binary search tree implemented in js

This example demonstrates an in-order traversal of a binary search tree, printing each node’s value to the console in ascending order. The tree is built iteratively from hardcoded values (100, 5, 10, 25, 14, 140, 314, 500) using plain JavaScript functions `createNode` and `addNode`, with no external libraries. The `traverse` function recursively visits the left subtree, logs the current value, then visits the right subtree, showing the classic depth-first search pattern. The output appears as sequential `console.log` messages, not as a graphical visualization.

Aallyraza
59% match
Loading thumbnail…

Node.js as an alertnative to Lisp ;-)

This example demonstrates a Node.js command-line tool that maps numeric phone-keypad input to dictionary words, following the classic Lisp challenge from Norvig. It reads a dictionary file and an input stream, building a lookup table of character-to-digit mappings and then recursively matching digit sequences against encoded words. The implementation uses Node.js core APIs like `fs.readFileSync` and `fs.createReadStream` for file I/O, processing the input line-by-line via stream events, and outputs matching words to the console. It highlights the practicality of JavaScript for text-processing puzzles.

RRandomEtc
54% match
Loading thumbnail…

counting things in javascript

A short JavaScript snippet counts word frequencies from a fixed string of text, using the array `reduce` method to tally occurrences and building a plain object that maps each word to its count. The example demonstrates a minimal functional programming pattern for aggregating categorical data, with the source data being a literal sentence split into an array of words. The output is logged to the console, showing a frequency distribution where repeated words like “pease” and “porridge” appear with higher counts than unique terms. No external libraries are used; the code relies solely on native JavaScript array and object methods.

Aamundo
54% match
Loading thumbnail…

Eloquent JS: Chapter 3

This example demonstrates solutions to three programming exercises from Chapter 3 of Eloquent JavaScript. It implements a minimum-finding function, a recursive even-number checker, and character-counting utilities, logging results directly to the browser console. The page uses plain JavaScript functions such as `returnMin`, `isEven`, and `countChar` to test various inputs. A minimal HTML file with inline CSS centers the title text, while all computation runs client-side without external libraries or frameworks.

Eemberix@gmail.com
53% match
Loading thumbnail…

Eloquent JS: Chapter 2

This example showcases the output of four JavaScript programming exercises from Chapter 2 of *Eloquent JavaScript*, rendered directly in the browser console. It demonstrates looping with `for` and `while` statements to print a triangular pattern of `#` symbols, the FizzBuzz sequence with conditional `if`/`else` logic, and a chessboard grid built through nested loops. The code uses plain JavaScript with `console.log` for output, and the accompanying HTML page uses inline CSS for styling. No external libraries are used, focusing purely on core language syntax and algorithmic thinking.

Eemberix@gmail.com
53% match
Loading thumbnail…

Eloquent JS: Chapter 6

This example demonstrates three JavaScript exercises from Eloquent JavaScript, Chapter 6, implemented as plain JavaScript classes and console output. It shows a `Vec` class with vector addition, subtraction, and length calculation, a `Group` class with add, delete, has, and static from methods, and a custom `GroupIterator` making groups iterable via `Symbol.iterator`. The code runs directly in the browser console, logging results for each exercise, including a numeric accumulation loop and string iteration, with no external libraries or frameworks beyond vanilla JavaScript.

Eemberix@gmail.com
52% match
Loading thumbnail…

Gist 9a5e7b204b7bb4e90cc3f9b7bf5b7dad

This example shows a recursive JavaScript function that reverses a string. The function `rec` takes a word, checks if its length is zero, and returns an empty string as the base case; otherwise, it appends the last character to the result of calling `rec` on the string with that last character removed. It demonstrates the reversal of the input "hello" to "olleh" through a simple recursion pattern. The code uses plain JavaScript with no external libraries or rendering APIs.

MMistyBlunch
51% match