Skip to main content
100%

Finding reduplicated words in a wordlist

✓ Published0🌍 Public
Aamundo
Last edited Nov 27, 2012
Created on Nov 27, 2012

This example scans a wordlist for reduplicated words—words whose letter pairs repeat—by analyzing bigram frequency. It computes the median frequency of all bigrams in each word and prints the word if that median equals 2, indicating a likely reduplication. The Python script uses `collections.Counter` to tally bigrams, a custom `median()` function, and `fileinput` to read lines from standard input. The output is a filtered list of words, showing a simple text-based visualization of the detected pattern.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 285672

This example demonstrates a language identification system by modeling text as bigram frequencies. It shows the most common two-letter sequences from a given input text, sorted by frequency. The Python code builds a bigram model using `ngrams` and `bigrams` functions, counts occurrences with a `defaultdict`, and removes rare bigrams below a threshold. It relies on the `collections` module and `operator.itemgetter` for sorting. The program reads a UTF-8 text file from the command line and prints the top ten bigrams with their counts.

Aamundo
57% match
Loading thumbnail…

find all the words that can be built using the letters in a list, as in Scrabble™.

This example finds all valid words that can be formed from a given set of letters, as in Scrabble™. It reads a system dictionary file (`/usr/share/dict/words`) and iterates through each word, checking whether every letter in the candidate word appears in the tile string and that no letter is used more times than it appears in the tiles. The core logic uses Python’s `set.issubset` for letter containment and `str.count` to verify letter frequencies. The user supplies the tile letters as a command-line argument, and matching words are printed to standard output.

Aamundo
56% match
Loading thumbnail…

A map-reduce class in Python, with the typical "hello, world!" word-counting example. You can download ulysses.txt file used in the example here: http://www.gutenberg.org/ebooks/4300

This example demonstrates a word-frequency analysis of James Joyce’s *Ulysses*, showing the 100 most common words and their counts. It uses a custom `MapReducer` class, built with Python’s `abc` module for abstract methods, to implement the map-reduce pattern. The `WordReducer` subclass defines a `map` method that tokenizes lines and tallies lowercase word occurrences, while `reduce` sums the counts. The `mapreduce` method groups mapped key-value pairs via `collections.defaultdict`. The final sorted output is printed with `pprint` from the text file downloaded from Project Gutenberg.

Aadewes
53% match
Loading thumbnail…

A simple tool for finding the highest scoring words with a scrabble rack

This tool finds and displays the highest-scoring words playable from a given Scrabble rack. It reads a system dictionary file, filters words to those that can be spelled with the rack’s letters, and ranks them by their Scrabble letter values. The output is a plain-text list of scores and matching words, sorted ascending. The code uses Python’s built-in file iteration, string methods, and list comprehensions, with no external visualization libraries. It demonstrates a simple algorithmic approach to word scoring and rack-based filtering.

Aamundo
53% match
Loading thumbnail…

Knuth/McIlroy word count task using Haskell

This example demonstrates a word-frequency analysis task using Haskell, showing how to compute and display the most common words from standard input. It chains data transformations through a pipeline: converting text to lowercase, replacing non-letter characters with newlines, splitting into words, and tallying counts with a hash map. The code relies on `Data.HashMap.Strict` for efficient key-value aggregation via `HashMap.fromListWith`, and uses `Data.List` for sorting and taking the top *n* results. The final output lists each word with its count, sorted in descending order of frequency. The example highlights functional composition and lazy evaluation in a concise, read-backwards data-flow style.

FFranklin Chen
51% match
Loading thumbnail…

Obligatory wordle coding

This example shows a command-line Wordle solver that filters the remaining possible five-letter words based on prior guesses and their result patterns. It uses the `click` library to parse comma-separated guesses and results, then computes letter constraints through Python list comprehensions and the `itertools.product` function to generate candidate words. The script prints all possibilities, or a message indicating too many when the combination count exceeds 10,000, leveraging the `math.prod` function for efficient count calculation.

Aandyreagan
51% match
Loading thumbnail…

Gist 4be75194a32c761f2a20

This example demonstrates how to use NLTK's frequency distribution object to analyze word frequencies in the Monty Python and the Holy Grail text (text6). The code imports the NLTK book module, creates a FreqDist from the text, and displays the top 50 word-frequency pairs, revealing unexpected results. The notebook then poses tasks for modifying the text and generating cumulative frequency plots, while also showing list comprehensions to filter words by length and frequency. The analysis relies on NLTK's FreqDist and the pre-loaded text corpus from the nltk.book module.

MMartiHearst
50% match
Loading thumbnail…

Gist 288417

This visualization displays the frequency of every character in a text file, sorted from least to most common. The Python script reads the file’s contents, counts each Unicode character’s occurrences in a dictionary, then prints the character alongside its count. It uses the `codecs` module to handle UTF-8 output and standard file reading to load the source text. The result is a plain textual ranking, not a graphical chart, with each line showing a character and its frequency.

Aamundo
50% match