Snap! custom block to reverse a list

100%

Snap! custom block to reverse a list

✓ Published0🌍 Public

Last edited Mar 18, 2018

Created on Mar 18, 2018

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.

AI-generated description

Similar vizzes

Loading thumbnail…

Sequential Sort in Snap!

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.

CCliffordAnderson

73% 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

72% 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

66% match

Loading thumbnail…

Gist 08456313799c0608872fb13ff336426c

This example demonstrates a custom predicate block that checks whether a given number falls inclusively between two comparison values. The visualization, embedded as a static image, shows a visual representation of this logical test. The code defines a Snap! block using the block-definition XML format, employing reporter blocks for boolean logic. It relies on Snap!'s built-in operators such as `reportGreaterThan`, `reportLessThan`, `reportEquals`, and `reportAnd`/`reportOr` to evaluate the condition. The block returns a true/false report, and the image likely illustrates sample comparisons or a chart of results, though the exact rendering method is not specified in the provided files.

CCliffordAnderson

53% match

Loading thumbnail…

Function for reversing the bits in a 32bit number

The example demonstrates a custom function that reverses the order of bits in a 32-bit unsigned integer, a common low-level operation used in bit manipulation. It shows the step-by-step isolation and recombination of individual bytes (b0 through b3) before reversing the bits within each byte. The code relies on Power Query’s `Number.BitwiseAnd`, `Number.BitwiseShiftRight`, `Number.BitwiseShiftLeft`, and `Number.BitwiseOr` functions to mask, shift, and reassemble the bytes. A helper `reverse` function is implied for per-byte bit reversal, though not defined here. The visualization itself is a code snippet, not a graphical chart, highlighting the algorithmic logic rather than data representation.

HHugoberry

51% 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

50% match

Loading thumbnail…

Swapping the list elements in positions _from and _to. Power Query implementation

This example demonstrates a reusable Power Query function that swaps two elements in a list by their zero-based positions. The visualization highlights the function’s logic: it first normalizes the _from and _to indices by sorting them, then reconstructs the list using List.Range, concatenating the segments before, between, and after the swapped elements. The function returns the original list unchanged if the indices are equal. The implementation relies solely on Power Query’s standard library functions, such as List.Range and the concatenation operator, with no external libraries. The gist shows a compact, purely functional approach to list manipulation, making the data transformation explicit and testable.

HHugoberry

49% match

Loading thumbnail…

Yale Library Coding Meetup

This visualization, sourced from a gist by CliffordAnderson, documents a Yale Library coding meetup that teaches block-based programming through Snap! and NetsBlox. It shows the process of building custom blocks—specifically a Fibonacci sequence generator—and then applying it to create colorful braided circles and spiral patterns on the stage. The code examples rely on Snap!'s visual block APIs for sprite drawing, color changing, and custom block definitions, with the Fibonacci calculation implemented via if/else control structures. The data source is the mathematical Fibonacci sequence, visualized through procedural drawing on the stage.

CCliffordAnderson

47% match