Skip to main content
SimilarExport ZIP
100%

Sequential Sort in Snap!

✓ Published0🌍 Public
CCliffordAnderson
Last edited May 10, 2018
Created on May 10, 2018

This example demonstrates a sequential sort algorithm implemented in Snap!, a block-based programming environment. The code defines a reporter block that repeatedly scans an unsorted list to find the largest remaining item, inserts it at the front of a new sorted list, and deletes it from the original. The visualization shows the step-by-step process of building the sorted list. The implementation uses Snap! custom blocks, list operations like `reportListLength`, `reportListItem`, `doInsertInList`, and `doDeleteFromList`, along with nested loops and conditional logic. No external JavaScript libraries are used; the data source is the input list provided by the user.

AI-generated description

Similar vizzes

Loading thumbnail…

Snap! custom block to reverse a list

This example shows a Snap! custom block that reverses a list, reporting the reversed list as its output. The block first determines the list’s length and creates an empty list for the result. It then uses a `doUntil` loop that, while the length is not zero, appends the item at the current index to the result and decrements the length. The code relies on Snap! list primitives such as `reportListLength`, `reportListItem`, and `doAddToList`, with the original list passed in as an argument.

CCliffordAnderson
73% match
Loading thumbnail…

Snap! custom block to compare two strings

This Snap! project defines two custom blocks that work together to compare strings character by character. The first block generates a numeric list from a given range, while the second block converts two input strings into lists and iterates through them. It checks whether each character from the first string appears sequentially in the second string, returning `true` if all characters match in order, and `false` if either string is empty or the sequence is not found. The visualization shows the block definitions and their interconnected control flow, using Snap!'s visual programming API to demonstrate substring detection.

CCliffordAnderson
64% match
Loading thumbnail…

Gist 810577150f4b252e8faa69e7060bf3af

This example presents a Clojure visualization of a custom sorting algorithm called `sorting-sort`. The code defines two functions: `remove-one`, which removes a specified item from a list using `split-with` and `rest`, and `sorting-sort`, which iteratively finds the minimum value in an unsorted collection via `apply min`, removes it, and appends it to a sorted vector within a `loop`/`recur` construct. The visualization likely animates this selection-sort-like process, though no graphical library is shown; the gist contains only the algorithmic logic without any rendering or charting API.

66ewis
63% match
Loading thumbnail…

Quicksort

The visualizer shows the Quicksort algorithm sorting a shuffled array of 240 items as a fan of lines, with the current pivot highlighted in red. Each step is animated via a timer, swapping line positions to reflect array changes. The code uses d3.v3 with a linear scale for angular displacement and an ordinal scale for horizontal positioning, rendering SVG lines and driving the animation through `setInterval`. The data is generated by a Fisher–Yates shuffle and processed through the quicksort function.

Mmbostock
60% match
Loading thumbnail…

quickSort.js

This example visualizes the recursive quicksort algorithm sorting a small numeric array, showing the step-by-step partition process and final sorted order. The code defines a `quickSort` function that selects a pivot from the middle of the array, uses two pointers to swap elements out of place, and recursively sorts the subarrays on either side. It demonstrates the algorithm’s logic directly in JavaScript with console output, using no external libraries. The rendering approach is textual, logging the unsorted and sorted arrays to the console, while the source data is a hardcoded array `[7, 0, 2, 1, 9, 2]`. The example highlights the algorithm’s core mechanics rather than a graphical chart.

WWill Carter
59% match
Loading thumbnail…

Snap! custom block to convert a string into a list of characters

This example shows a Snap! custom block that converts any input string into a list of its individual characters. The block, defined with the `block-definition` tag, uses a counter variable to iterate through each position of the string via `reportLetter`, adding each character to a new list with `doAddToList` until the counter matches the string’s length. It uses Snap! 4.1’s block-based API, including `doUntil` for looping and `reportStringSize` for determining the stopping condition. The accompanying XML source displays the full script and a comment explaining the block’s purpose.

CCliffordAnderson
59% match
Loading thumbnail…

Quicksort V

A visualization of quicksort on 100 elements, where each horizontal row represents the array state after a single swap and colored lines trace each element’s positional movement through the sorting process. The code uses d3.v3 with custom SVG path interpolators to render the straight and diagonal segments, and a cubehelix color scale to differentiate elements. Randomly shuffled data is generated with `d3.shuffle` and `d3.range`, and the quicksort algorithm is implemented manually to record swap operations.

Mmbostock
58% match
Loading thumbnail…

Quicksort in XQuery

This visualization compares four XQuery implementations of the quicksort algorithm, each derived from a Haskell reference, to demonstrate functional programming in a query language. It shows how the same recursive sorting logic can be expressed with different XQuery 3.1 features, including `fn:head()`, `fn:tail()`, `position()`, and a random-number generator for permutation. The code uses `local:qsort` functions with `xs:integer*` sequences, and the final example applies the sort to a shuffled list of 1 to 100 generated via `fn:random-number-generator('permute')`. The display highlights syntactical variations, such as explicit `where` clauses versus nested `if` expressions, without altering the core algorithm.

CCliffordAnderson
58% match