Algorithms 2

100%

✓ Published0🌍 Public

Last edited Sep 22, 2021

Created on Sep 22, 2021

This example compares two algorithms for summing integers from 1 to n: a loop-based approach and a direct mathematical formula. The page displays the console output of both functions, `addNumbers` and `addNumbersFormula`, for n=10, showing that both return the same result. The plain HTML body sets a 13em font size, while the JavaScript uses standard `console.log` calls to print the labeled results. The visualization emphasizes algorithmic efficiency by contrasting the loop’s O(n) time complexity against the formula’s constant-time execution.

AI-generated description

MIT Licensed

Similar vizzes

Loading thumbnail…

Algorithm_analysis_Big O

This example demonstrates two JavaScript techniques for calculating the sum of integers from 1 to n: an iterative loop and a direct arithmetic formula. The page renders the computed results for both methods to the browser console using the `console.log` API. The visualization compares the outputs of the loop-based approach against the formula-based approach, highlighting the difference in algorithmic complexity between O(n) and O(1) solutions.

NNita

81% match

Loading thumbnail…

Algorithm 1

This example demonstrates the computational complexity of nested loops versus single loops, using JavaScript’s console.log to output results of multiplication operations. The code defines constants and variables to illustrate constant-time operations (O(1)), then shows a single for loop executing in linear time (O(n)), followed by a double for loop with a nested inner loop that runs in quadratic time (O(n^2)). It also includes a second nested loop with an additional constant-time operation, representing c1 * O(n^2). The example uses basic JavaScript syntax with no external libraries, relying on the browser’s console for output.

NNita

67% match

Loading thumbnail…

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.

NNita

63% match

Loading thumbnail…

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.

NNita

62% match

Loading thumbnail…

Function

This example demonstrates a set of JavaScript functions for basic arithmetic and variable assignment, with results logged to the browser console. It shows how arrow functions like `add` and `sub` compute sums and differences, while the `copy` and `dup` functions illustrate function aliasing. The code uses plain JavaScript without any external libraries or frameworks, embedded directly in an HTML page with a large 13em body text style. The rendering approach is entirely console-based, with no visual data output.

NNita

62% match

Loading thumbnail…

Sum of First n Numbers

This example demonstrates a proof of the Gauss formula for summing the first n positive integers, showing that the sum equals n(n+1)/2. The visualization proceeds through animated steps: it first presents a random sum with a question mark, then reveals the sum value, rearranges terms to pair them, draws rectangles to represent the pairing, and finally derives the closed-form solution. The code uses D3.js v3 with SVG text and rectangle elements, animating transitions with `.transition().duration()` and `.delay()` methods. The random integer e is generated via `Math.random()` and embedded in the displayed arithmetic expression.

NNPashaP

62% match

Loading thumbnail…

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

This example visualizes the process of finding majority elements in an array by scanning through indices and logging matches. It uses plain JavaScript with a `while` loop and `for` loop to iterate over the array, while an `if` conditional checks for equality with a target number. The page renders no graphics, only console output, and presents the looping logic separately as pseudocode in the README. The code relies on basic browser console APIs rather than visualization libraries.

NNita

61% match

Loading thumbnail…

Javascript Variables

This example demonstrates how JavaScript variables work by calculating the sum of two numbers and logging the result to the browser console. The page presents a blank canvas with a large font size, emphasizing the code’s output rather than visual content. It uses plain JavaScript with `const` declarations, the arithmetic operator `+`, and `console.log` to display the total. The HTML and CSS structure is minimal, with no external libraries or frameworks involved.

NNita

61% match