Gist 3908cc252b823e449510

100%

Gist 3908cc252b823e449510

✓ Published0🌍 Public

Last edited Sep 22, 2014

Created on Sep 22, 2014

This example demonstrates a Swift extension that removes duplicate elements from an array of strings, converting the initial list containing repeated values like "P" and "C" into a unique sequence. The custom `unique()` method uses the standard library’s `reduce` function alongside a generic `contains` check to build a filtered result. The code explicitly converts each element to a generic type `T` and appends it only if it is not already present. The final output, printed via `println()`, shows the deduplicated array in its original order, preserving the first occurrence of each string.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist b7643abc7d460e1673981d3f41bb9b40

This example demonstrates a Swift language extension that optimizes the `reversed()` operation on lazy collections. It defines a `ReversedCollectionProtocol` for bidirectional collections, and an extension that lets reversing a lazy reversed collection return a lazy representation of the original, avoiding unnecessary materialization. The code uses Swift generics and associated types (`Elements.Base`) to express this optimization, and notes a fallback using parametrized extensions for Swift versions prior to 4.2.

MMoximillian

58% match

Loading thumbnail…

Gist 71504fe8a72f82b34a64b5586bf0a67f

This example demonstrates a nested-loop algorithm for removing duplicate values from an array, highlighting the logic behind the process. The code defines `removeDuplicatesNested`, which compares each element against every other element using a nested `for` loop, tracking potential matches with a `duplicateFound` flag. It pushes non-duplicate items into a new `returnArray`, though the inner loop’s condition incorrectly checks `returnArray` instead of the original `array`, leading to flawed duplicate detection. The implementation relies solely on standard JavaScript array methods and loops, with no external libraries or rendering APIs. The data source is the input array passed directly to the function, and the visualization focuses on the control flow and comparison steps rather than graphical output.

WWill Carter

57% match

Loading thumbnail…

Gist 2e867d04c508a033f4e88e66d1c3649a

This example shows a string-processing algorithm that removes repeated characters from an input word. The code defines a function, `removeRepeatedChars`, which iterates through the original string and builds a new string by appending characters only when they do not already appear in the newly constructed result. It uses nested loops to compare each character against the current new word and tracks matches with a counter variable. The implementation relies on standard C++ string operations and does not use any external visualization libraries, instead presenting the logic directly as source code.

MMistyBlunch

57% match

Loading thumbnail…

Gist 185a2d8178b2bed4fee10481cbff4953

This visualization demonstrates how a JavaScript function named `removeDuplicatesFast` processes an array by grouping values and their indices into a map object. The example shows the function’s internal logic, logging both the arrayMap structure and the final result of `Object.keys(arrayMap)`, which returns the unique keys from the original array. The code uses standard JavaScript APIs—`console.log` for output, a for loop for iteration, and `Object.keys` to extract properties—without relying on external libraries or rendering frameworks. The data source is the input array passed to the function, and the visualization highlights the algorithm’s step-by-step execution rather than any graphical or chart-based output.

WWill Carter

54% match

Loading thumbnail…

A demonstration of Swift sequences

This example demonstrates Swift sequences by pairing odd and even Fibonacci numbers, then skipping the first two pairs before printing the next two results. The code defines custom Fibonacci sequences, uses the `filter` function to generate separate odd and even number streams, and combines them with `Zip2`. A `skip(n:)` extension on `SequenceOf` filters out leading elements, while `GeneratorOf` lazily produces values. The output logs each generated Fibonacci number and the skipped pairs, showing how sequence composition and lazy evaluation work together in Swift.

CColinEberhardt

52% match

Loading thumbnail…

Gist 75454

This example demonstrates string manipulation utilities in Objective-C, converting camelCase or mixed-case strings into either underscore-separated or dash-separated formats. The code defines an NSString category with `underscore` and `dasherize` methods, which internally call a private `normalizeWith:` method that iterates over each character, detects uppercase letters and existing delimiters, and inserts the chosen separator while preserving the original text. The implementation uses NSCharacterSet, NSMutableString, and unichar APIs to perform character-by-character processing, ultimately returning a lowercase version of the transformed string.

CCaged

51% match

Loading thumbnail…

Pipe forward operator and curried free functions = fluent interface

This Swift example demonstrates how the pipe-forward operator (`|>`) and curried free functions restore a fluent interface for string manipulation. The code contrasts an initial `Stringy` struct with method chaining, a nested free-function alternative, and finally a curried `appendCurriedFreeFunction` composed with `|>`. The final pipeline chains `greeting` through three append operations and `printMe`, showing functional composition that mirrors the original object-oriented style without modifying the struct.

CColinEberhardt

49% match

Loading thumbnail…

An eventing mechanism for Swift

This example demonstrates an eventing mechanism for Swift, showing how to create type-safe events with multiple handlers and automatic cleanup. It defines an `Event<T>` class that manages a collection of handler wrappers, allowing observers to subscribe and unsubscribe dynamically. The implementation uses the `Disposable` protocol for tear-down logic and the `Invocable` private protocol to abstract handler invocation, with `EventHandlerWrapper` holding a weak reference to the target to prevent retain cycles. The code highlights Swift’s protocol-oriented and generics features, as well as curried instance methods, to build a reusable notification system without relying on external libraries.

CColinEberhardt

49% match