Munching squares: Difference between revisions

=={{header|Action!}}==

BYTE i

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Munching_squares.png Screenshot from Atari 8-bit computer]

{{libheader|GtkAda}}

Uses the Cairo component of GtkAda to create and save as png

with Cairo.Png; use Cairo.Png;

with Cairo.Image_Surface; use Cairo.Image_Surface;

Status := Write_To_Png (Surface, "AdaXorPattern.png");

pragma Assert (Status = Cairo_Status_Success);

{{out}} [[Image:AdaXorPattern.png|Ada Output|200px]]

=={{header|Applesoft BASIC}}==

110 DATA 0,1, 3,10,5, 3,11,15

120 DATA 0,8, 9,10,5, 9,13,15

320 COLOR= C( PEEK (235))

330 VLIN Y1,Y1 + 1 AT W * S + X

=={{header|AWK}}==

{{works with|gawk}}

This program generates a PPM image, that you can view/convert using The GIMP or ImageMagick

BEGIN {

# square size

}

}

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

VDU 23,22,size%;size%;8,8,16,0

REPEAT WAIT 1 : UNTIL FALSE

=={{header|Befunge}}==

Writes the image to stdout using the PPM format.

>2%*28*:**-2/\1-:v<:8:-1<_@ v

=={{header|Burlesque}}==

blsq ) 0 25r@{0 25r@\/{$$Sh2' P[}\/+]m[}m[sp

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

24 25 26 27 28 29 30 31 16 17 18 19 20 21 22 23 8 9 10 11 12 13 14 15 0 1

25 24 27 26 29 28 31 30 17 16 19 18 21 20 23 22 9 8 11 10 13 12 15 14 1 0

Must be converted to an image with a seperate program.

=={{header|C}}==

#include <stdio.h>

#include <math.h>

return 0;

{{out}} [[Image:Xor_pattern_c.png|C output|200px]]

=={{header|C sharp}}==

using System.Drawing.Imaging;

using System.Linq;

}

}

{{out}}

[[File:XORPatternCSharp.png|XORPatternCSharp.png]]

=={{header|C++}}==

[[File:msquares_cpp2.png|300px]]

#include <windows.h>

#include <string>

}

//--------------------------------------------------------------------------------------------------

=={{header|Commodore BASIC}}==

The TED machines (C-16, Plus/4) are the only Commodore 8-bits with a large- or structured- enough color palette to make this interesting. Here's an extremely low-res version (40x25 character-sized "pixels"):

110 : Y=INT(I*127/24)

120 : FOR J=0 TO 39

190 : NEXT J

210 NEXT I

{{Out}}

=={{header|D}}==

import std.stdio;

f.rawWrite(u3);

}

=={{header|EchoLisp}}==

Use the '''plot''' library, hsv->rgb ((x xor y) modulo m) as color table, and see the nice results here : http://www.echolalie.org/echolisp/help.html#bit-map .

(lib 'types)

(lib 'plot)

(plot-much) ;; ESC to see tge drawing

=={{header|Factor}}==

IN: rosetta-code.munching-squares

: main ( -- ) <munching-img> "munching.png" save-graphic-image ;

Output image is identical to the Racket version.

{{out}}

=={{header|FreeBASIC}}==

' compile with: fbc -s gui

WindowTitle "Close window or hit any key to end program"

Sleep

=={{header|Fōrmulæ}}==

=={{header|GLSL}}==

This is an example that will work directly on shadertoy.com, Example [https://www.shadertoy.com/view/Mss3Rs]

float c,p;

vec2 b;

gl_FragColor = vec4(color,1.0);

=={{header|Gnuplot}}==

set size square

set isosamples 255,255

{{out}} [[Image:gnuplot_xor.png|Gnuplot output|200px]]

=={{header|Go}}==

import (

png.Encode(f, g)

f.Close()

=={{header|Haskell}}==

import Data.Bits (xor)

[ x `xor` y

| x <- [0 .. 255]

=={{header|Icon}} and {{header|Unicon}}==

[[File:XORimage-unicon-GR512.png|thumb|right|512x512 bit green and red]]

procedure main(A) #: XOR graphic

until Event() == &lpress # wait for left button to quit

close(&window)

{{libheader|Icon Programming Library}}

=={{header|J}}==

=={{header|Java}}==

{{libheader|Swing}}

This example will repeat the pattern if you expand the window.

import java.awt.Graphics;

new XorPattern();

}

[[Image:Xor pattern Java.png|200px]]

{{works with|jq|1.4}}

The following is an adaptation of the Ruby entry, but generates an SVG image file:

'''Part 1: Infrastructure'''

def integer_to_lsb:

[recurse(if . > 0 then ./2|floor else empty end) | . % 2] ;

| reduce range(0;$length) as $i

([]; . + [ lxor($s[$i]; $t[$i]) ] )

'''Part 2: SVG'''

def p: (. + 0.5) | floor; # to nearest integer

"rgb(\(.red|p),\(.green|p),\(.blue|p))";

def pixel(x; y; color):

(color | if type == "string" then . else rgb2rgb end) as $c

'''Part 3: xor pattern'''

def xor_pattern(width; height; rgb1; rgb2):

| range(0;height) as $y

| pixel($x; $y; $colours[ xor($x; $y) % $size] ) ) ),

'''Part 4: Example'''

def red: black + { "red": 255 };

def yellow: red + { "green": 255 };

=={{header|Julia}}==

const can = @GtkCanvas()

signal_connect(endit, win, :destroy)

wait(cond)

=={{header|Kotlin}}==

import javax.swing.JFrame

}

}

=={{header|Liberty BASIC}}==

nomainwin

end

end sub

Image available at [[http://www.diga.me.uk/xorRC.gif]]

=={{header|Lua}}==

{{works with|LÖVE|11.0 or higher}}

function drawMSquares()

local points = {}

love.graphics.setColor(1,1,1)

love.graphics.draw(canvas)

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Table[Table[

FromDigits[BitXor[IntegerDigits[x, 2, 8], IntegerDigits[y, 2, 8]],

{{out|Output #1}}

[[File:xorpattern3.png|Mathematica output #1|200px]]

{{out|Output #2}}

[[File:xorpattern4.png|Mathematica output #2|200px]]

=={{header|MATLAB}}==

[x,y] = meshgrid([0:size-1]);

colormap bone(size);

image(c);

{{out}} [[File:matlab_xor.png|MATLAB output|200px]]

=={{header|Microsoft Small Basic}}==

size=256

GraphicsWindow.Width=size

x=t

EndFor

{{out}}

[https://github.com/Pat-Garrett/RC/blob/master/Munching%20squares%20-%20vbnet.jpg Munching squares - SmallBasic]

This version runs in Mini Micro (for the graphics). Note that because MiniScript does not currently have any bit operations (all numbers are floating-point), we have to implement an <code>xor</code> function the hard way.

result = 0

bit = 1

gfx.setPixel x, y, color.rgb(0, xor(x,y), 0)

end for

{{out}}

=={{header|Nim}}==

{{libheader|imageman}}

import imageman

image[i, j] = colors[i xor j]

=={{header|OCaml}}==

let () =

done;

done;

Run with:

=={{header|Octave}}==

[x,y] = meshgrid([0:size-1]);

colormap(jet(size));

image(c);

{{out}} [[File:Xor_pattern_octave.png|Octave output|320px]]

=={{header|Perl}}==

my $img = new GD::Image(256, 256, 1);

}

{{out}} [[File:perl_xor_pattern.png|Perl output|200px]]

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/Munching_squares.htm here].

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Munching_squares.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

=={{header|PHP}}==

$w = 256;

imagepng($im);

{{out}}

[[File:xor_pattern_php.png|PHP output|200px]]

=={{header|PL/I}}==

declare screen (0:255, 0:255) bit(24) aligned;

end;

call writeppm(screen);

=={{header|Processing}}==

Renders grayscale image, the larger the window the more the squares will repeat along the main diagonal from top left to bottom right.

//Aamrun, 26th June 2022

updatePixels();

=={{header|Prolog}}==

Works with SWI-Prolog and his GUI XPCE.

new(D, window('XOR Pattern')),

send(D, size, size(512,512)),

send(D, display, Bmp, point(0,0)),

send(D, open).

[[File:Prolog_xor_pattern.png|200px]]

=={{header|PureBasic}}==

Procedure.f XorPattern(x, y) ;compute the gradient value from the pixel values

Protected result = x ! y

event = WaitWindowEvent(20)

Until event = #PB_Event_CloseWindow

[[File:PureBasic_XOR_Pattern.png|Sample display of PureBasic solution|200px]]

=={{header|Python}}==

{{libheader|PIL}}

image = Image.new("RGB", (256, 256))

del drawingTool

[[File:PythonXORPic.png|Sample produced by the above code|200px]]

=={{header|QBasic}}==

SCREEN 13

PSET (x, y)

NEXT y

=={{header|Racket}}==

[[File:munching-racket.png|thumb|right]]

#lang racket

(require racket/draw)

(send dc set-pixel x y c))

bm

=={{header|Raku}}==

Here's one simple way:

$ppm.print(q :to 'EOT');

$ppm.close();

Another way:

map -> $x { floor ($x/256) ** 3 * 256 },

(flat (0...255) Z

$PPM.write: @colors[$_] for ^256 X+^ ^256;

[[File:perl_6_xor_pattern.png|Raku output|200px]]

=={{header|REXX}}==

{{trans|Burlesque}}

/*───────────────────────────────────────── from an arbitrary constructed color table. */

rows= 2 /*the number of rows in the color table*/

@.x.y= bitxor(@.x, @.y) /*renders 3 bytes (a pixel) at a time. */

end /*y*/

Must be converted to an image with a separate program. <br><br>

=={{header|Ring}}==

# Project : Munching squares

label1 { setpicture(p1) show() }

return

Output:

Uses [[Raster graphics operations/Ruby]]

[[File:xorpattern_rb.png|thumb|right|Sample output from Ruby program]]

class Pixmap

img = Pixmap.xor_pattern(384, 384, RGBColour::RED, RGBColour::YELLOW)

=={{header|Run BASIC}}==

graphic #g, w,w

for x = 0 to w

next x

render #g

=={{header|Rust}}==

use image::{ImageBuffer, Pixel, Rgb};

let _ = img.save("output.png");

=={{header|Scala}}==

===Scala Swing===

{{libheader|org.scala-lang.modules scala-swing}}

import scala.swing.{Color, Graphics2D, MainFrame, Panel, SimpleSwingApplication}

centerOnScreen()

}

=={{header|Sidef}}==

{{trans|Perl}}

var img = %O<Imager>.new(xsize => 256, ysize => 256)

}

Output image: [https://github.com/trizen/rc/blob/master/img/munching-squares-sidef.png Munching squares]

=={{header|Tcl}}==

proc xorImage {img table} {

set img [image create photo -width 512 -height 512]

xorImage $img [mkTable 0 255 64 192 255 0]

=={{header|TI-83 BASIC}}==

" •.-,+-°-1+o*:πOX"→Str1

End

Pause

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|2011}}

Public Class MunchingSquares

Const xsize = 256

End Sub 'Paint

{{out}}

[https://github.com/Pat-Garrett/RC/blob/7e9842513d361a5b4241bc6bb28f9985c2bfe161/Munching%20squares%20-%20vbnet.jpg Munching squares - vbnet]

{{trans|D}}

{{libheader|DOME}}

import "dome" for Window

static draw(alpha) {}

=={{header|XPL0}}==

int X, Y;

[SetVid($101); \set 640x480 graphics with 8-bit color

X:= ChIn(1); \wait for keystroke

SetVid(3); \restore normal text mode

{{out}} [[File:MunchXPL0.png]]

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

open window w, w

dot x, y

Next

=={{header|zkl}}==

{{trans|XPL0}}

For a kaleidoscopic image, play with coolness.

bitmap:=PPM(256,256);

coolness:=(1).random(0x10000); // 55379, 18180, 40, 51950, 57619, 43514, 65465

}

bitmap.write(File("foo.ppm","wb"));

For a cheap slide show (on Linux):

run ImageViewer on foo.ppm and watch it [auto] update as the image changes.

{{out}}