Skip to main content
100%

core trie code in new labMTsimple

✓ Published0🌍 Public
Aandyreagan
Last edited Mar 9, 2015
Created on Mar 9, 2015

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.

AI-generated description

Similar vizzes

Loading thumbnail…

Trie.js - super simple JavaScript implementation

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.

Aamundo
61% match
Loading thumbnail…

Gist 0d3ef677475862ba439fd5dacfd4a60d

The visualization maps the scoring patterns of five-letter words, showing how letter positions and letter values contribute to total word scores. It displays a grid or distribution of words, likely sorted or clustered by score, with each word’s score calculated from per-letter point values and a bonus for non-repeated letters. The implementation uses Python’s pandas to load and transform the word list, adding columns for each letter’s position and score, while the letter-to-value mapping follows standard Scrabble tile distributions. The final score sums individual letter scores and adds a two-point bonus when all letters are unique, as seen in the `duplicates` logic. The rendering itself is not shown in the code, but the data processing relies on pandas dataframes and string operations to derive the visualization’s underlying dataset.

CConorAspell
51% match
Loading thumbnail…

Gist 641fc44c27c66ee9ef09

This example demonstrates a Latin text preprocessing pipeline that converts raw words into lemmata and macronized dictionary entries. It shows how a sample sentence like "quo usque tandem abutere catilina nostra patientia" is tokenized, cleaned of punctuation, and processed word-by-word. The code uses the CLTK `LemmaReplacer` for lemmatization, lxml’s `etree` to parse the Perseus Latin lexicon XML file, and custom string manipulation to transform entries like "a^bu_tor" into "abūtor". The workflow defines classes for text and word-level morphological analysis, though the dictionary lookup for full texts runs too slowly to complete.

TTylerKirby
50% match
Loading thumbnail…

loading in LIWC

The example shows how LIWC (Linguistic Inquiry and Word Count) dictionary words are loaded and assigned sentiment scores, distinguishing positive and negative emotion words from neutral function words. The Python script `speedy.py` reads a tab-separated file, checks each line for category markers like `125`, `126`, `127`, and `1`, and builds a dictionary `LIWC` mapping each word to a tuple of its score and a sequential index. It uses plain file iteration and string operations (`split`, `in`) without external libraries, incrementing a counter `i` for every accepted word.

Aandyreagan
50% match
Loading thumbnail…

Gist e049bb6d7696d1b2d4ff242e68fcd062

This example analyzes text data by performing topic modeling and visualization. It shows the resulting topics and their associated terms, revealing latent themes in the dataset. The code uses NLTK for tokenization and stopword removal, TextBlob for sentiment analysis, and Gensim’s LdaModel and CoherenceModel for topic extraction. Plotly’s `scatter` and `bar` traces render the interactive visualizations, with data processed from a pandas DataFrame. The rendering approach relies on Plotly’s offline mode, initiated via `pyo.init_notebook_mode()`.

AArizonaTay
49% match
Loading thumbnail…

Gist 6c1ae0e4fff5fb8d4704

This example shows a text-parsing utility that cleans and tokenizes a raw string into lowercase words. It first replaces common punctuation sequences like dashes and double quotes with spaces, then uses a regular expression with Unicode flags to extract word tokens, allowing characters such as `@`, `#`, `&`, and hyphens. The code relies on Python’s standard `re` module and basic string methods, with no external visualization libraries or rendering pipeline. The output is a list of normalized words, illustrating a preprocessing step rather than a visual chart or graph.

Aandyreagan
48% match
Loading thumbnail…

Fork of Front-End for IR project

This interactive scatterplot visualizes sentiment analysis across a corpus of text data, with each point representing a word mapped by its sentiment score and frequency. Users can enter two words into text inputs to compare their associated topics and related terms, which display as lists beside the plot. The visualization uses D3 v6 to render SVG points with hover effects that highlight individual data, while color coding indicates positive, negative, or neutral sentiment based on threshold values. The code includes fake sample data for testing, demonstrating word-topic relationships and word-word similarity rankings.

LLeah Mitchell
48% match
Loading thumbnail…

Gist 6499e03ffdfc7479408da70f20af3625

This visualization maps the semantic relationships between words extracted from a text corpus. It shows a network of nodes and edges, where connected words cluster together based on their contextual similarity. The layout uses a force-directed graph, likely powered by d3.forceSimulation, to position nodes and links. The code loads a spaCy NLP model (`en_core_web_lg`) to compute word vectors, and filters out stop words using NLTK’s stopwords list before processing the raw text.

AArizonaTay
48% match