Implementation of sqRoot

D3 Scale - Sqrt

This example compares linear and square-root scales for encoding data as circle radii. Two rows of circles, one red and one green, map the same dataset from 0 to 100 using D3's `d3.scaleLinear` and `d3.scaleSqrt`. The linear scale positions circles along the x-axis, while its radius is scaled for visual clarity. The square-root scale directly maps the data to the radius, ensuring that the circle's area, rather than its diameter, is proportional to the value. The SVG output includes an annotation recommending square-root scaling for area-based encodings.

SSubhendu Karmakar

49% match

nlogn algorithm for n/2 matching numbers

This example visualizes the search for majority elements in an array, specifically highlighting matches for the number 4 in a test array of six integers. It demonstrates a divide-and-conquer algorithm that repeatedly halves the array length while logging matching indices and values to the console. The plain HTML page contains no visible graphical output; instead, the visualization is purely console-based, using JavaScript’s native `console.log` to display results from the custom `matchNo` function. The implementation relies on basic array indexing and arithmetic operations rather than external libraries, rendering the algorithm’s step-by-step progression through text output alone.

48% match

Fork of Fork of nlogn algorithm for n/2 matching numbers : with function

This example demonstrates an algorithm that attempts to find matching numbers in an array by repeatedly halving the array length and checking for a target value. It shows a console-based visualization where loop iterations log both matched indices and the shrinking value of `n`. The code uses plain JavaScript array operations and `Math.floor` for integer division, with results printed to the browser console. The rendering approach is minimal, using only HTML and inline JavaScript without external libraries, while the page sets a large font size but displays no visible graphics.

48% match

Some Algorithms In Python

This example illustrates a Python implementation of the binary search algorithm, demonstrating how it recursively bisects a sorted array to locate a target value. The code defines the `binary_search` function, which prints diagnostic messages at each split and returns a boolean result. It also includes a `run_binary_search` function that searches for the integer 6 in a range of 0 through 99. The visualization shows the algorithm's step-by-step process through console output rather than graphical rendering, using standard Python logic and print statements.

RRobColeman

48% match

Map function javascript

This example demonstrates how JavaScript’s `map` method processes an array of numbers by applying a squaring function to each element. It displays the squared results directly on the page using React’s `ReactDOM.render` method, with the output styled as large text in a green background container. The code defines an array `[10, 20]`, a `sq` arrow function, and a React component that calls `array.map` to transform the values before rendering. It relies on React 16.10 and standard ES6 syntax, but does not include any external charting or visualization libraries.

Fork of Fork of nlogn algorithm for n/2 matching numbers : with psuedocode

This example demonstrates a brute-force algorithm that searches for matching numbers in an array by repeatedly halving the search range. The visualization shows a console output of the number `4` appearing in the array `[2, 4, 4, 4, 3, 6]`. The code uses plain JavaScript with a `while` loop and `Math.floor` to divide the array length, iterating through indices to log matches. No external libraries are used; the rendering relies entirely on the browser’s default console and HTML body styling with a large font size.

Adjacent JSX elements must be wrapped in an enclosing tag

This example demonstrates a React application that renders SVG circles based on squaring calculations applied to an array of numbers. It uses React and ReactDOM to compose JSX elements that display the squared values of 15 and 25, as well as their nested squares, alongside a standalone SVG circle whose radius is derived from one of these calculations. The code employs the `sq` arrow function for mathematical operations and renders all output within a single root div.

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