Skip to main content
SimilarExport ZIP
100%

Imprime N tablas de multiplicar calculadas en paralelo por N procesos.

✓ Published0🌍 Public
OOscardR
Last edited Sep 29, 2013
Created on Sep 29, 2013

This example demonstrates a Unix C program that launches N child processes, each calculating a multiplication table (1 through 10) for a distinct integer. The parent process then reads and prints the tables in order, showing the results sequentially. The visualization uses low-level POSIX system calls including `pipe()`, `fork()`, `read()`, `write()`, and `wait()`. Each child writes its process ID and computed products to its own dedicated pipe, enabling parallel computation and ordered output collection.

AI-generated description

Similar vizzes

Loading thumbnail…

Codigo Assembly ARM64 Hola Mundo para RaspbianOS

This example shows a multiplication table for 12 printed line by line to standard output on a Raspberry Pi running RaspbianOS, using ARM64 assembly. The program constructs each line in a memory buffer by combining fixed text segments (“12x”, “ = ”, newline) with dynamically converted decimal numbers. It relies on Linux system calls via `svc` instructions—`write` (syscall 64) for output and `exit` (syscall 93) to terminate—and uses custom subroutines `memcpy_copy`, `convert_mult`, and `convert_product` rather than any external libraries or framework.

IIoTeacher
52% match
Loading thumbnail…

multiprocessing

This example demonstrates a multiprocessing pipeline where eight producer processes concurrently process one hundred documents from a shared task queue, while the main process consumes and prints the results. The code uses Python's `multiprocessing` module, specifically the `Process`, `Queue`, and `join()` APIs to coordinate work and synchronization. Each producer pulls documents, simulates variable processing time with `time.sleep` and `random.uniform`, and pushes results to a separate result queue. The consumer function tracks completion until all documents are processed, illustrating a classic producer-consumer pattern with sentinel values to terminate workers.

JJastor11
46% match
Loading thumbnail…

Para principiantes profesionales de uso shell con $ tmux

This example presents a two-part technical guide for developers using assembly and tmux. The first section walks through compiling, debugging, and versioning ARM64 assembly programs with `gcc`, `gdb`, and `git`, showing a step-by-step command table and code snippets. The second part explains tmux basics like sessions, windows, and panes, with commands such as `C-b c` and `C-b %` to manage them. The text uses plain tables and markdown to organize the workflow for students working on AWS servers.

IIoTeacher
45% 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
45% match
Loading thumbnail…

Fork of n/2 times - copy 2

This example visually represents the concept of finding majority elements in an array by rendering the number sequence [10,2,2,2,8] at a massive font size of 13em. The page uses plain HTML and CSS for styling and layout, with an empty script tag in the body where the JavaScript logic resides. The code defines a loop that attempts to set array values based on a comparison with the number 2, though the assignment is incomplete and does not perform any visible drawing. The visualization ultimately displays only static text centered on the screen, with no dynamic data-binding or chart-rendering library such as D3.js involved.

NNita
44% 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
44% match
Loading thumbnail…

Gist 23875167ddf54617f817bbd24632696b

This example shows a JavaScript function that counts down from a given number and logs each value as either “par” (even) or “impar” (odd) to the console. It uses a `while` loop with a modulo (`%`) operator to test each integer against `0` and then prints the corresponding label. The function `func(10)` is called to process numbers from 10 down to 1, producing a simple text-based output without any graphical or charting libraries. The data source is the hardcoded initial value passed as an argument.

MMistyBlunch
44% 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
43% match