Skip to main content
SimilarExport ZIP
100%

Game of Life functional in Kotlin

✓ Published0🌍 Public
BBastiTee
Last edited Aug 8, 2018
Created on Aug 8, 2018

This example demonstrates Conway’s Game of Life as a purely functional Kotlin implementation, rendering 100 generations of a small initial board pattern as console text output. The code defines a `step` function that computes the next generation using `mapIndexed` and a `neighboursAlive` helper, checking alive neighbor counts against the standard 2–3 survival and 3 birth rules. It uses `Stream.iterate` from the Java Streams API to generate the infinite sequence of boards, limiting it to 100 steps. The rendering approach prints each board via `toMultiLineString`, encoding live cells as “Ö” and dead cells as “†”.

AI-generated description

Similar vizzes

Loading thumbnail…

Game of Life (Possibly)

A grid of 10 by 5 cells displays Conway's Game of Life, with each cell toggling between alive (yellow) and dead based on neighbor counts. The simulation updates every two seconds, using a random Bernoulli distribution (d3.randomBernoulli) to generate the initial state. React hooks manage the cell matrix state, while SVG rectangles render the grid within a VizContainer. The code implements the game rules through countNeighbors and go functions, using setInterval for animation.

WWaseem Medhat
63% match
Loading thumbnail…

Gist 69a9d27f495ef695f39947559d3ead66

This example demonstrates a Kotlin-based reactive flow pipeline that emits a sequence of eight "Hello" messages at 700-millisecond intervals. The visualization pairs two components: an `Activity_Flow.kt` file that subscribes to a lifecycle-scoped `Flow` collector, and a `ViewModel_Flow.kt` file that defines the `triggerFlow()` function using the `flow` builder with `repeat` and `delay` operators. The code highlights the use of Kotlin coroutines and the Flow API for asynchronous, time-based data streaming, though it does not render any graphical output.

HHsuHsiaoHsuan
57% match
Loading thumbnail…

Gist 598a74e0cb4c65102232

This example demonstrates a C++ program that first simulates traversal and deletion of nodes in a singly linked list, printing the values as it moves and removes each node, and then reads a board from the file `board.txt` into a 2D vector of characters. The rendering shows the board as a grid, printing each cell with its indices and value, and then updates two specific positions to display a modified board. The code relies on standard C++ libraries such as `<iostream>`, `<fstream>`, and `<vector>`, with no external visualization APIs.

NN0taN3rd
53% match
Loading thumbnail…

Gist b0f64c51570ca06b6602

This example demonstrates a recursive Boggle word-finding algorithm that visualizes its search process by printing the game board to the console at each step. The code uses Ruby’s `Array#each_with_index` to scan the 4x4 letter grid, and recursively calls the `checker` method to trace valid adjacent letter paths for a given word. A `draw` function outputs the board state, marking previously visited cells with the string `"NO"` to show the algorithm’s backtracking. The visualization relies on terminal text output rather than graphical rendering, using only the `p` method for display.

AAndrelton
51% match
Loading thumbnail…

Gist 40a7b304a32e2e0db885

This example visualizes a peg-based board game using C++ with standard libraries including iostream, fstream, vector, and unordered_map. It defines classes for pegs, board spots, and players, tracking movement through a pegMove structure with coordinates and begin/end flags. The code renders board positions as characters and supports multiple peg colors (blue, green, red, big blue) with distinct identifiers. It demonstrates object-oriented design for game state management, including move tracking, occupancy checks, and position resets, though it does not include any graphics or plotting libraries, appearing to be a logical simulation rather than a visual data display.

NN0taN3rd
51% match
Loading thumbnail…

Fibonacci in Scala

This example demonstrates a functional definition of the Fibonacci sequence in Scala, highlighting two equivalent recursive implementations: one using nested conditionals and another using pattern matching with a match expression. The visualization shows how the recursive calls unfold, with the second implementation (fib2) called for inputs 10 and 200 to illustrate growth. The code relies on Scala’s standard library, including the Int type and the match keyword, but does not use external visualization libraries. The rendering approach is minimal, focusing on the source code itself as the primary visual artifact, with no graphical output or data source beyond the hardcoded integers passed to the functions.

CCliffordAnderson
49% match
Loading thumbnail…

Factorial in Scala

This visualization demonstrates the recursive computation of factorial values in Scala, tracing the call stack from `fac(10)` down to the base case. The code defines a function `fac(num: Int): Int` that multiplies each number by the factorial of its predecessor, halting at 1. The example renders this execution as a branching tree, where each node represents a function call and its return value. The visualization uses Scala’s standard recursion mechanism, with no external libraries; the data is generated directly from the source gist by CliffordAnderson. The rendering approach likely relies on a custom drawing routine, though the code snippet itself only shows the pure function logic, not the display layer.

CCliffordAnderson
49% match
Loading thumbnail…

Fork of Curran's Face a Là Sol LeWitt - Getting it Right &B&W Game

This animated game challenges players to stop the screen when all Sol LeWitt-inspired patterns appear in black and white. The visualization uses SVG elements created via `document.createElementNS` with the `http://www.w3.org/2000/svg` namespace, rendering at full window size. Patterns consist of complex path data that flicker at varying speeds; clicking the screen checks whether all patterns are grayscale. Correct guesses increment the score and halve the timer, while wrong guesses reduce lives (displayed as icons). The game resets automatically after losing all lives, with CSS transitions controlling visibility changes.

Zzaioris
49% match