Skip to main content
100%

Gist 0a0d7789633e1b7dddb0b7892df6e429

✓ Published0🌍 Public
Aadisastew2
Last edited Jul 13, 2017
Created on Jul 13, 2017

This example generates Pascal’s triangle as a series of nested arrays. The `generate` function recursively builds each row, using the values from the previous row to compute interior entries by adding the two numbers above them. The code shows a pure JavaScript algorithm with no external visualization libraries; it constructs the triangle data structure through array concatenation and iterative row assembly. The rendering approach is not implemented in this snippet, as the gist only contains the data-generation logic.

AI-generated description

Similar vizzes

Loading thumbnail…

Pascal's Triangle

This visualization displays Pascal’s Triangle as a series of 22 rows of numerically generated values, arranged as an SVG in a stepped diagonal layout. Each row is computed from the previous one using a custom `nextRow` function that sums adjacent elements with a coefficient of 2, producing the triangle’s entries. The code uses D3 v6 data joins to append SVG groups and text elements, positioning rows vertically via `translate` transforms and columns horizontally with a fixed offset. Circles styled with red strokes are defined in CSS but not rendered in the visible output.

MMTR
75% match
Loading thumbnail…

variation Pascal's Triangle

This visualization presents a variation of Pascal's Triangle, where each row is a sequence of circles colored green or red based on whether the value is divisible by the row index. The triangle is built procedurally, generating 22 rows using a custom `nextRow` function that computes each row's sum-based values. Rendered as SVG via D3 v6, the code uses `d3.select` and `d3.append` to create a single SVG, with each row as a `<g>` element translated vertically and each circle horizontally. The fill color is determined by `j%i`, showing the modulo pattern across the structure.

MMTR
71% match
Loading thumbnail…

Gist e8e67bab8a73e27d741e5a1d793bb5bd

This example demonstrates how to multiply all numbers within a nested array structure, flattening the multiplication across sub-arrays. The code uses nested `for` loops to iterate through each inner array, updating a running `product` variable. A test case with `[[1,2],[3,4],[5,6,7]]` is provided at the end, showing the expected result of 5040. The visualization highlights the logic of nested iteration and cumulative multiplication, with the data source being the hardcoded test array. No external libraries or rendering APIs are used, as the focus is on the algorithmic pattern in plain JavaScript.

DDocwali777
65% match
Loading thumbnail…

flatten Arrays

This example visualizes the recursive flattening of nested arrays into a single linear sequence. It shows a branching tree of values collapsing inward as the algorithm traverses each level, with individual elements animating into a final horizontal row. The code uses a custom `flatten` function that recursively iterates through nested arrays and pushes non-array values into a result array. Rendering relies on D3’s force simulation to position the collapsing nodes and transition paths, while the data itself is generated from arbitrary nested array structures defined in the source gist.

MMAKIO135
65% 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
64% match
Loading thumbnail…

Gist 41ebb2653c9e933a9403679c689ae599

This visualization renders the integers from 1 to 7 as a triangular stack of text lines, each line showing a progressively shrinking substring of the concatenated sequence. The code builds raw HTML with inline CSS, using a `p` element per number and increasing then decreasing `padding-left` values (in em units) to create the staggered layout. It relies on Python string slicing and a simple loop, with `SPACE` controlling the horizontal offset per step, and writes the output to `result.html`. The result is a static, center-aligned pyramid-like text display generated entirely through string manipulation and style attributes.

Aanemochore
63% match
Loading thumbnail…

Gist 3745f53a79313afd139b4eb0a4e97bd2

This example visualizes the nested execution of JavaScript closures by tracing function calls and their returned values. It shows how `makeASum(a)` returns an inner function `sum(b)` that captures the outer variable `a`, and how different instances like `sumOne` and `sumTen` preserve distinct contexts. The rendering uses a custom SVG-based trace, likely driven by D3’s `d3.forceSimulation` for layout and `d3.select` for DOM updates, with console logs mapping to animated nodes and edges. The data originates from the inline script’s execution sequence, displaying call stacks and computed sums in real time.

MMistyBlunch
62% match
Loading thumbnail…

Gist c7122eee6247b95dba09

This example generates a continuously evolving abstract animation by drawing Voronoi polygons in alternating black and white. It shows a recursive process where each polygon’s edges are traced with short, sequential line segments that slowly shrink the polygon’s boundary, creating a spiral-like contraction. The animation uses D3’s `d3.geom.voronoi()` with a clip extent to create the polygons from random points, and then employs Canvas 2D API calls like `beginPath`, `lineTo`, and `stroke` to draw each step. A queue (`queue.js`) schedules the drawing of each polygon, and the code alternates stroke colors (`#000` and `#fff`) after each full pass, repeating indefinitely.

11wheel
61% match