Skip to main content
100%

Gist 8131253

✓ Published0🌍 Public
YYonet
Last edited Dec 26, 2013
Created on Dec 26, 2013

This example simulates a perfect out-shuffle on a deck of cards and tracks how many shuffles are needed for the deck to return to its original order. The code implements two approaches: a fast solution that uses greatest common divisor and least common multiple calculations to determine the shuffle count, and a naive solution that iteratively compares the shuffled deck against a sorted version until they match. The visualization relies on JavaScript and the Underscore.js library for utility functions like memoization, array manipulation, and uniqueness checks, with shuffle counts logged to the console.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 3d2406a594700ec447ebd0b208ead916

This example demonstrates a JavaScript implementation of the Fisher–Yates shuffle algorithm, providing two distinct array manipulation methods. The `shuffle()` function returns a new, shuffled copy of the original array without modifying it, while `permShuffle()` permanently rearranges the elements in place. The code extends the native `Array.prototype` with these custom methods, using modern JavaScript syntax including spread operators and destructuring assignments for element swapping. A usage example with a five-element array illustrates both behaviors, showing the original array preserved after copying and altered after permanent shuffling. The implementation relies solely on core JavaScript array operations and the built-in `Math.random()` function.

MMAKIO135
73% match
Loading thumbnail…

Shuffle II

An array of 200 vertical lines rotates in place to visualize a Fisher–Yates shuffle, with shuffled elements rendered in black while unshuffled ones stay light gray. The animation plays the swap sequence in reverse, shuffling the array from a fully shuffled state back to its original order. Built with D3 v3, it uses ordinal and linear scales, SVG line elements, and chained transitions to update each line’s rotation transform after every swap. The shuffle function generates random pairwise swaps, and the code references DOM nodes directly to swap their positions efficiently.

Mmbostock
67% match
Loading thumbnail…

Shuffle I

A Fisher–Yates shuffle is animated as 200 vertical line segments, each rotating to illustrate the random swapping of array positions. The visualization uses D3.js v3 with SVG and a transition system that chains animations step-by-step, reversing the shuffle steps to trace the algorithm’s progression. The `d3.scale.ordinal` and `d3.scale.linear` maps data indices to x-coordinates and rotation angles, while the `shuffle` function generates swap pairs for the animation sequence.

Mmbostock
66% match
Loading thumbnail…

Array method

This example demonstrates a JavaScript array-shuffling algorithm. It creates an array containing the numbers 1 through 90, then randomizes the order of those elements using the Fisher–Yates shuffle technique. The shuffled array is output to the browser’s console via `console.log`. The page uses no external libraries; it relies solely on vanilla JavaScript and the native `Math.random` function for randomness. The code is embedded directly in a minimal HTML file and executes on page load, with commented-out variations showing alternate array sizes.

EErik L
65% match
Loading thumbnail…

Card Shuffler

Two labeled rectangular cards, one green and one red, sit stacked in the center of the screen. Every second, the top card slides down over the bottom card, swaps its color and text label with the bottom card, and then the bottom card slides back up, repeatedly cycling their positions. The animation uses D3 v4 transitions with `transition.attr` and `transition.on` callbacks to chain the shuffling loop. Both cards are SVG groups containing a styled `<rect>` and `<text>` element, rendered with Impact font and black outlines.

TTommyCoin80
64% match
Loading thumbnail…

Gist 7e0901a05c7628a8da57d24617231ce0

This example demonstrates a manual JavaScript algorithm for rotating the elements of an array-like object, shifting the last item to the front while moving each preceding item one position backward. It uses no external libraries, relying on native object property access and assignment via `Object.keys()` and array index notation. The code defines a hardcoded sequence of four swap operations, storing the final value in a temporary `aux` variable to preserve it during reassignment, then logs the updated object to the console after each call. The data originates from an `images` object with an unspecified number of keys, though the logic assumes at least four properties to function correctly.

MMistyBlunch
62% match
Loading thumbnail…

The Fisher–Yates shuffle is an algorithm for generating a random permutation of a finite set—in plain terms, the algorithm shuffles the set. The algorithm effectively puts all the elements into a hat; it continually determines the next element by randomly drawing an element from the hat until no elements remain. The algorithm produces an unbiased permutation: every permutation is equally likely. The modern version of the algorithm is efficient: it takes time proportional to the number of items being shuffled and shuffles them in place https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle

This visualization demonstrates the Fisher–Yates shuffle algorithm by animating its in-place swapping process across a list of numeric values. It shows how each iteration randomly selects an unshuffled position and exchanges it with the current index, progressively building a random permutation. The implementation uses a custom `swap` function built from Power Query’s `List.Range` and `List.Buffer` operations, with `Number.RandomBetween` driving the random selection. The code, written in the M language, relies on `List.Accumulate` to iterate through the list, highlighting the algorithm’s efficiency and unbiased nature without external libraries.

HHugoberry
60% match
Loading thumbnail…

Gist d740d28ab2549ada2394dbbe9728cd71

This visualization prints an alternating checkerboard pattern of spaces and hash symbols to the console, using standard JavaScript string concatenation and a nested `for` loop structure. The outer loop controls each row, while the inner loop builds the pattern by checking whether the row and column indices are even or odd. The code defines a fixed grid size of 8, generates each line into a string variable, and logs it with `console.log` before resetting the string for the next iteration. No external libraries are used; it relies solely on core JavaScript syntax and the console API.

MMistyBlunch
59% match