# Munching squares

Munching squares
You are encouraged to solve this task according to the task description, using any language you may know.

Render a graphical pattern where each pixel is colored by the value of 'x xor y' from an arbitrary color table.

Uses the Cairo component of GtkAda to create and save as png <lang Ada>with Cairo; use Cairo; with Cairo.Png; use Cairo.Png; with Cairo.Image_Surface; use Cairo.Image_Surface; procedure XorPattern is

```  type xorable is mod 256;
Surface : Cairo_Surface;
Data : RGB24_Array_Access;
Status : Cairo_Status;
Num : Byte;
```

begin

```  Data := new RGB24_Array(0..256*256-1);
for x in Natural range 0..255 loop
for y in Natural range 0..255 loop
Num := Byte(xorable(x) xor xorable(y));
Data(x+256*y) := RGB24_Data'(Num,0,Num);
end loop;
end loop;
Surface := Create_For_Data_RGB24(Data, 256, 256);
pragma Assert (Status = Cairo_Status_Success);
```

end XorPattern;</lang>

Output:

## BBC BASIC

<lang bbcbasic> size% = 256

```     VDU 23,22,size%;size%;8,8,16,0
OFF
```
```     DIM coltab%(size%-1)
FOR I% = 0 TO size%-1
coltab%(I%) = ((I% AND &FF) * &010101) EOR &FF0000
NEXT
```
```     GCOL 1
FOR I% = 0 TO size%-1
FOR J% = 0 TO size%-1
C% = coltab%(I% EOR J%)
COLOUR 1, C%, C%>>8, C%>>16
PLOT I%*2, J%*2
NEXT
NEXT I%
```
```     REPEAT WAIT 1 : UNTIL FALSE
```

</lang>

## Burlesque

<lang 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
1  0  3  2  5  4  7  6  9  8 11 10 13 12 15 14 17 16 19 18 21 20 23 22 25 24
2  3  0  1  6  7  4  5 10 11  8  9 14 15 12 13 18 19 16 17 22 23 20 21 26 27
3  2  1  0  7  6  5  4 11 10  9  8 15 14 13 12 19 18 17 16 23 22 21 20 27 26
4  5  6  7  0  1  2  3 12 13 14 15  8  9 10 11 20 21 22 23 16 17 18 19 28 29
5  4  7  6  1  0  3  2 13 12 15 14  9  8 11 10 21 20 23 22 17 16 19 18 29 28
6  7  4  5  2  3  0  1 14 15 12 13 10 11  8  9 22 23 20 21 18 19 16 17 30 31
7  6  5  4  3  2  1  0 15 14 13 12 11 10  9  8 23 22 21 20 19 18 17 16 31 30
8  9 10 11 12 13 14 15  0  1  2  3  4  5  6  7 24 25 26 27 28 29 30 31 16 17
9  8 11 10 13 12 15 14  1  0  3  2  5  4  7  6 25 24 27 26 29 28 31 30 17 16
```

10 11 8 9 14 15 12 13 2 3 0 1 6 7 4 5 26 27 24 25 30 31 28 29 18 19 11 10 9 8 15 14 13 12 3 2 1 0 7 6 5 4 27 26 25 24 31 30 29 28 19 18 12 13 14 15 8 9 10 11 4 5 6 7 0 1 2 3 28 29 30 31 24 25 26 27 20 21 13 12 15 14 9 8 11 10 5 4 7 6 1 0 3 2 29 28 31 30 25 24 27 26 21 20 14 15 12 13 10 11 8 9 6 7 4 5 2 3 0 1 30 31 28 29 26 27 24 25 22 23 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 31 30 29 28 27 26 25 24 23 22 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 0 1 2 3 4 5 6 7 8 9 17 16 19 18 21 20 23 22 25 24 27 26 29 28 31 30 1 0 3 2 5 4 7 6 9 8 18 19 16 17 22 23 20 21 26 27 24 25 30 31 28 29 2 3 0 1 6 7 4 5 10 11 19 18 17 16 23 22 21 20 27 26 25 24 31 30 29 28 3 2 1 0 7 6 5 4 11 10 20 21 22 23 16 17 18 19 28 29 30 31 24 25 26 27 4 5 6 7 0 1 2 3 12 13 21 20 23 22 17 16 19 18 29 28 31 30 25 24 27 26 5 4 7 6 1 0 3 2 13 12 22 23 20 21 18 19 16 17 30 31 28 29 26 27 24 25 6 7 4 5 2 3 0 1 14 15 23 22 21 20 19 18 17 16 31 30 29 28 27 26 25 24 7 6 5 4 3 2 1 0 15 14 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 </lang>

Must be converted to an image with a seperate program.

## C

<lang c>#include <stdlib.h>

1. include <stdio.h>
2. include <math.h>
3. include <string.h>

void hue_to_rgb(double hue, double sat, unsigned char *p) { double x; int c = 255 * sat; hue /= 60; x = (1 - fabs(fmod(hue, 2) - 1)) * 255;

switch((int)hue) { case 0: p[0] = c; p[1] = x; p[2] = 0; return; case 1: p[0] = x; p[1] = c; p[2] = 0; return; case 2: p[0] = 0; p[1] = c; p[2] = x; return; case 3: p[0] = 0; p[1] = x; p[2] = c; return; case 4: p[0] = x; p[1] = 0; p[2] = c; return; case 5: p[0] = c; p[1] = 0; p[2] = x; return; } }

int main(void) { const int size = 512; int i, j; unsigned char *colors = malloc(size * 3); unsigned char *pix = malloc(size * size * 3), *p; FILE *fp;

for (i = 0; i < size; i++) hue_to_rgb(i * 240. / size, i * 1. / size, colors + 3 * i);

for (i = 0, p = pix; i < size; i++) for (j = 0; j < size; j++, p += 3) memcpy(p, colors + (i ^ j) * 3, 3);

fp = fopen("xor.ppm", "wb"); fprintf(fp, "P6\n%d %d\n255\n", size, size); fwrite(pix, size * size * 3, 1, fp); fclose(fp);

return 0; }</lang>

Output:

## C++

<lang cpp>

1. include <windows.h>
2. include <string>

//-------------------------------------------------------------------------------------------------- using namespace std;

//-------------------------------------------------------------------------------------------------- const int BMP_SIZE = 512;

//-------------------------------------------------------------------------------------------------- class myBitmap { public:

```   myBitmap() : pen( NULL ), brush( NULL ), clr( 0 ), wid( 1 ) {}
~myBitmap()
{
```

DeleteObject( pen ); DeleteObject( brush ); DeleteDC( hdc ); DeleteObject( bmp );

```   }

bool create( int w, int h )
{
```

HDC dc = GetDC( GetConsoleWindow() ); bmp = CreateDIBSection( dc, &bi, DIB_RGB_COLORS, &pBits, NULL, 0 ); if( !bmp ) return false;

hdc = CreateCompatibleDC( dc ); SelectObject( hdc, bmp ); ReleaseDC( GetConsoleWindow(), dc );

width = w; height = h; return true;

```   }

void clear( BYTE clr = 0 )
{
```

memset( pBits, clr, width * height * sizeof( DWORD ) );

```   }

void setBrushColor( DWORD bClr )
{
```

if( brush ) DeleteObject( brush ); brush = CreateSolidBrush( bClr ); SelectObject( hdc, brush );

```   }

void setPenColor( DWORD c ) { clr = c; createPen(); }

void setPenWidth( int w )   { wid = w; createPen(); }

void saveBitmap( string path )
{
```

GetObject( bmp, sizeof( bitmap ), &bitmap ); DWORD* dwpBits = new DWORD[bitmap.bmWidth * bitmap.bmHeight];

ZeroMemory( dwpBits, bitmap.bmWidth * bitmap.bmHeight * sizeof( DWORD ) ); ZeroMemory( &infoheader, sizeof( BITMAPINFO ) ); ZeroMemory( &fileheader, sizeof( BITMAPFILEHEADER ) );

GetDIBits( hdc, bmp, 0, height, ( LPVOID )dwpBits, &infoheader, DIB_RGB_COLORS );

HANDLE file = CreateFile( path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); WriteFile( file, &fileheader, sizeof( BITMAPFILEHEADER ), &wb, NULL ); WriteFile( file, &infoheader.bmiHeader, sizeof( infoheader.bmiHeader ), &wb, NULL ); WriteFile( file, dwpBits, bitmap.bmWidth * bitmap.bmHeight * 4, &wb, NULL ); CloseHandle( file );

delete [] dwpBits;

```   }

HDC getDC() const     { return hdc; }
int getWidth() const  { return width; }
int getHeight() const { return height; }

```

private:

```   void createPen()
{
```

if( pen ) DeleteObject( pen ); pen = CreatePen( PS_SOLID, wid, clr ); SelectObject( hdc, pen );

```   }

HBITMAP bmp;
HDC     hdc;
HPEN    pen;
HBRUSH  brush;
void    *pBits;
int     width, height, wid;
DWORD   clr;
```

}; //-------------------------------------------------------------------------------------------------- class mSquares { public:

```   mSquares()
{
bmp.create( BMP_SIZE, BMP_SIZE );
createPallete();
}
```
```   void draw()
{
```

HDC dc = bmp.getDC(); for( int y = 0; y < BMP_SIZE; y++ ) for( int x = 0; x < BMP_SIZE; x++ ) { int c = ( x ^ y ) % 256; SetPixel( dc, x, y, clrs[c] ); }

BitBlt( GetDC( GetConsoleWindow() ), 30, 30, BMP_SIZE, BMP_SIZE, dc, 0, 0, SRCCOPY ); //bmp.saveBitmap( "f:\\rc\\msquares_cpp.bmp" );

```   }
```

private:

```   void createPallete()
{
```

for( int x = 0; x < 256; x++ ) clrs[x] = RGB( x<<1, x, x<<2 );//rand() % 180 + 50, rand() % 200 + 50, rand() % 180 + 50 );

```   }
```
```   unsigned int clrs[256];
myBitmap bmp;
```

}; //-------------------------------------------------------------------------------------------------- int main( int argc, char* argv[] ) {

```   ShowWindow( GetConsoleWindow(), SW_MAXIMIZE );
srand( GetTickCount() );
mSquares s; s.draw();
return system( "pause" );
```

} //-------------------------------------------------------------------------------------------------- </lang>

## C#

<lang csharp>using System.Drawing; using System.Drawing.Imaging; using System.Linq;

class XORPattern {

```   static void Main()
{
var size = 0x100;
var black = Color.Black.ToArgb();
var palette = Enumerable.Range(black, size).Select(Color.FromArgb).ToArray();
using (var image = new Bitmap(size, size))
{
for (var x = 0; x < size; x++)
{
for (var y = 0; y < size; y++)
{
image.SetPixel(x, y, palette[x ^ y]);
}
}
image.Save("XORPatternCSharp.png", ImageFormat.Png);
}
}
```

}</lang>

Output:

## D

<lang d>void main() {

```   import std.stdio;
```
```   enum width = 512, height = 512;
```
```   auto f = File("xor_pattern.ppm", "wb");
f.writefln("P6\n%d %d\n255", width, height);
foreach (immutable y; 0 .. height)
foreach (immutable x; 0 .. width) {
immutable c = (x ^ y) & ubyte.max;
immutable ubyte[3] u3 = [255 - c, c / 2, c];
f.rawWrite(u3);
}
```

}</lang>

## 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 . <lang scheme> (lib 'types) (lib 'plot) (plot-size 512 512) ;; for example

use m = 16, 32, 44, .. to change the definition (number of losanges)

(define (plot-munch (m 256)) (define PIX (pixels->int32-vector)) ;; get canvas image (define (pcolor x y) ;; color at (x,y) (hsv->rgb (// (bitwise-xor (modulo x m) (modulo y m)) m) 0.9 0.9)) (pixels-map pcolor PIX) (vector->pixels PIX)) ;; draw canvas image

(plot-much) ;; ESC to see tge drawing </lang>

## FreeBASIC

<lang freebasic>' version 03-11-2016 ' compile with: fbc -s gui

Dim As ULong x, y, r, w = 256

ScreenRes w, w, 32

For x = 0 To w -1

```   For y = 0 To w -1
r =(x Xor y) And 255
PSet(x, y), RGB(r, r , r)         ' gray scale
' PSet(x, y), RGB(r, 255 - r, 0)  ' red + green
' PSet(x, y), RGB(r, 0, 0)        ' red
Next
```

Next

' empty keyboard buffer While Inkey <> "" : Wend WindowTitle "Close window or hit any key to end program" Sleep End</lang>

## GLSL

This is an example that will work directly on shadertoy.com, Example [1] <lang GLSL>vec3 color; float c,p; vec2 b;

void main(void) { vec2 uv = gl_FragCoord.xy / iResolution.xy; float scale = iResolution.x / iResolution.y; uv = uv-0.5; uv.y/=scale;

b = uv*256.0+256.0; c = 0.0;

for(float i=16.0;i>=1.0;i-=1.0) { p = pow(2.0,i);

if((p < b.x) ^^ (p < b.y)) { c += p; }

if(p < b.x) { b.x -= p; }

if(p < b.y) { b.y -= p; }

}

c=mod(c/128.0,1.0);

color = vec3(sin(c+uv.x*cos(uv.y*1.2)), tan(c+uv.y-0.3)*1.1, cos(c-uv.y+0.9));

gl_FragColor = vec4(color,1.0); }</lang>

## Gnuplot

<lang gnuplot>set pm3d map set size square set isosamples 255,255 splot [0:255][0:255]-(floor(x)^floor(y))</lang>

Output:

<lang haskell>import qualified Data.ByteString as BY (writeFile, pack)

import Data.Bits (xor)

main :: IO () main =

``` BY.writeFile
"out.pgm"
(BY.pack
(fmap (fromIntegral . fromEnum) "P5\n256 256\n256\n" ++
[ x `xor` y
| x <- [0 .. 255]
, y <- [0 .. 255] ]))</lang>
```

## Go

<lang go>package main

import (

```   "image"
"image/png"
"os"
```

)

func main() {

```   g := image.NewGray(image.Rect(0, 0, 256, 256))
for i := range g.Pix {
g.Pix[i] = uint8(i>>8 ^ i)
}
f, _ := os.Create("xor.png")
png.Encode(f, g)
f.Close()
```

}</lang>

## Icon and Unicon

procedure main(A) #: XOR graphic

```  wsize := 512
cmax  := 32768
wparms := ["Xmas Xor Graphic","g",sprintf("size=%d,%d",wsize),"bg=black"]
&window := open!wparms | stop("Unable to open window")

every y := 0 to wsize - 1 do
every x := 0 to wsize - 1 do {
c := cmax/wsize * iand(wsize-1,ixor(x,y))
Fg(sprintf("%d,%d,%d",c,cmax-c,0))
DrawPoint(x,y)
}

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

end</lang>

## J

<lang J> require 'viewmat'

```  viewmat ~:"1/&.#: ~ i.256</lang>
```

## Java

Library: Swing

This example will repeat the pattern if you expand the window. <lang java>import java.awt.Color; import java.awt.Graphics;

import javax.swing.JFrame; import javax.swing.JPanel;

public class XorPattern extends JFrame{

```   private JPanel xorPanel;
```
```   public XorPattern(){
xorPanel = new JPanel(){
@Override
public void paint(Graphics g) {
for(int y = 0; y < getHeight();y++){
for(int x = 0; x < getWidth();x++){
g.setColor(new Color(0, (x ^ y) % 256, 0));
g.drawLine(x, y, x, y);
}
}
}
};
setSize(300, 300);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
```
```   public static void main(String[] args){
new XorPattern();
}
```

}</lang>

## jq

Works with: jq version 1.4

The following is an adaptation of the Ruby entry, but generates an SVG image file: <lang sh>jq -n -r -f Munching_squares.jq > Munching_squares.svg</lang> Part 1: Infrastructure <lang jq># Convert the input integer to an array of bits with lsb first def integer_to_lsb:

``` [recurse(if . > 0 then ./2|floor else empty end) | . % 2] ;
```
1. input array of bits (with lsb first) is converted to an integer

def lsb_to_integer:

``` reduce .[] as \$bit
# state: [power, ans]
([1,0]; (.[0] * 2) as \$b | [\$b, .[1] + (.[0] * \$bit)])
| .[1];
```

def xor(x;y):

```  def lxor(a;b):  # a and/or b may be null
if a == 1 then if b==1 then 0 else 1 end
elif b==1 then if a==1 then 0 else 1 end
else 0
end;
(x|integer_to_lsb) as \$s
| (y|integer_to_lsb) as \$t
| ([\$s|length, \$t|length] | max) as \$length
| reduce range(0;\$length) as \$i
([]; . + [ lxor(\$s[\$i]; \$t[\$i]) ] )
| lsb_to_integer;</lang>
```

Part 2: SVG <lang jq>def rgb2rgb:

``` def p: (. + 0.5) | floor;  # to nearest integer
"rgb(\(.red|p),\(.green|p),\(.blue|p))";
```

def svg(width; height):

``` "<svg width='\(width // "100%")' height='\(height // "100%")'
xmlns='http://www.w3.org/2000/svg'>";
```

def pixel(x; y; color):

``` (color | if type == "string" then . else rgb2rgb end) as \$c
| "<circle r='1' cx='\(x)' cy='\(y)' fill='\(\$c)' />";</lang>
```

Part 3: xor pattern <lang jq># rgb is a JSON object: { "red": _, "green": _, "blue": _}

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

```   # create colour table
256 as \$size
| (reduce range(0;\$size) as \$i
([]; . + [
{"red":   (rgb1.red + (rgb2.red - rgb1.red) * \$i / \$size),
"green": (rgb1.green + (rgb2.green - rgb1.green) * \$i / \$size),
"blue":  (rgb1.blue + (rgb2.blue - rgb1.blue) * \$i / \$size) }])
)  as \$colours
# create the image
| svg(width; height),
( (range(0;width) as \$x
| range(0;height) as \$y
|   pixel(\$x; \$y; \$colours[ xor(\$x; \$y) % \$size] ) ) ),
"</svg>" ;</lang>
```

Part 4: Example <lang jq>def black: { "red": 0, "green": 0, "blue": 0}; def red: black + { "red": 255 }; def yellow: red + { "green": 255 };

xor_pattern(384; 384; red; yellow)</lang>

## Kotlin

<lang scala>// version 1.1.4-3

import javax.swing.JFrame import javax.swing.JPanel import java.awt.Graphics import java.awt.Graphics2D import java.awt.Color import java.awt.Dimension import java.awt.BorderLayout import java.awt.RenderingHints import javax.swing.SwingUtilities

class XorPattern : JPanel() {

```   init {
preferredSize = Dimension(256, 256)
background = Color.white
}
```
```   override fun paint(gg: Graphics) {
super.paintComponent(gg)
val g = gg as Graphics2D
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON)
for (y in 0 until width) {
for (x in 0 until height) {
g.color = Color(0, (x xor y) % 256, 255)
g.drawLine(x, y, x, y)
}
}
}
```

}

fun main(args: Array<String>) {

```   SwingUtilities.invokeLater {
val f = JFrame()
with (f) {
defaultCloseOperation = JFrame.EXIT_ON_CLOSE
title = "Munching squares"
isResizable = false
pack()
setLocationRelativeTo(null)
isVisible = true
}
}
```

}</lang>

## Liberty BASIC

<lang lb>

```   nomainwin
```
```   w =512
'   allow for title bar and window border
WindowWidth  =w +2
WindowHeight =w +34
```
```   open "XOR Pattern" for graphics_nsb_nf as #w
```
```   #w "trapclose quit"
```
```   #w "down"
```
```   for x =0 to w -1
for y =0 to w -1
b =( x xor y) and 255
print b
#w "color "; 255 -b; " "; b /2; " "; b
#w "set "; x; " "; w -y -1
scan
next y
next x
```
```   #w "flush"
```
```   wait
```
```   sub quit j\$
close #w
end
end sub
```

</lang> Image available at [[2]]

## Lua

Needs LÖVE 2D Engine <lang lua> local clr = {} function drawMSquares()

```   local pts = {}
for j = 0, hei - 1 do
for i = 0, wid - 1 do
idx = bit.bxor( i, j ) % 256
pts[1] = { i, j, clr[idx][1], clr[idx][2], clr[idx][3], 255 }
love.graphics.points( pts )
end
end
```

end function createPalette()

```   for i = 0, 255 do
clr[i] = { bit.band( i * 2.8, 255 ), bit.band( i * 3.2, 255 ), bit.band( i * 1.5, 255 ) }
end
```

```   wid, hei = love.graphics.getWidth(), love.graphics.getHeight()
canvas = love.graphics.newCanvas( wid, hei )
love.graphics.setCanvas( canvas ); love.graphics.clear()
love.graphics.setColor( 255, 255, 255 )
createPalette(); drawMSquares();
love.graphics.setCanvas()
```

end function love.draw()

```   love.graphics.draw( canvas )
```

end </lang>

## Mathematica

<lang Mathematica>ListDensityPlot[

```Table[Table[
FromDigits[BitXor[IntegerDigits[x, 2, 8], IntegerDigits[y, 2, 8]],
2], {x, 0, 255}], {y, 0, 255}]]</lang>
```
Output #1:

<lang Mathematica>ArrayPlot[Array[BitXor, {511, 511}]]</lang>

Output #2:

## MATLAB

<lang matlab>size = 256; [x,y] = meshgrid([0:size-1]);

c = bitxor(x,y);

colormap bone(size); image(c); axis equal;</lang>

Output:

## OCaml

<lang ocaml>open Graphics

let () =

``` open_graph "";
resize_window 256 256;
for y = 0 to pred (size_y()) do
for x = 0 to pred (size_x()) do
let v = (x lxor y) land 0xFF in
set_color (rgb v (255 - v) 0);
plot x y
done;
done;
```

Run with:

```\$ ocaml graphics.cma xor_pattern.ml
```
Output:

## Octave

<lang Octave>size = 256; [x,y] = meshgrid([0:size-1]);

c = bitxor(x,y);

colormap(jet(size)); image(c); axis equal;</lang>

Output:

## Perl

<lang perl>use GD;

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

for my \$y(0..255) {

```       for my \$x(0..255) {
my \$color = \$img->colorAllocate( abs(255 - \$x - \$y),  (255-\$x) ^ \$y , \$x ^ (255-\$y));
\$img->setPixel(\$x, \$y, \$color);
}
```

}

print \$img->png</lang>

Output:

## Perl 6

Here's one simple way:

<lang perl6>my \$ppm = open("munching.ppm", :w) or

``` die "Can't create munching.ppm: \$!";
```

\$ppm.print(q :to 'EOT'); P3 256 256 255 EOT

for 0 .. 255 -> \$row {

```   for 0 .. 255 -> \$col {
my \$color = \$row +^ \$col;
\$ppm.print("0 \$color 0 ");
}
\$ppm.say();
```

}

\$ppm.close(); </lang>

Another way:

<lang perl6>my @colors = map -> \$r, \$g, \$b { Buf.new: \$r, \$g, \$b }, map -> \$x { floor (\$x/256) ** 3 * 256 }, (flat (0...255) Z (255...0) Z flat (0,2...254),(254,252...0));

my \$PPM = open "munching.ppm", :w or die "Can't create munching.ppm: \$!";

\$PPM.print: qq:to/EOH/;

```   P6
# munching.pgm
256 256
255
EOH
```

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

\$PPM.close;</lang>

## PHP

\$w = 256; \$h = 256;

\$im = imagecreate(\$w, \$h)

```   or die("Cannot Initialize new GD image stream");
```

\$color = array(); for(\$i=0;\$i<256;\$i++) {

```       array_push(\$color,imagecolorallocate(\$im,sin((\$i)*(2*3.14/256))*128+128,\$i/2,\$i));
```

}

for(\$i=0;\$i<\$w;\$i++) {

```       for(\$j=0;\$j<\$h;\$j++)
{
imagesetpixel(\$im,\$i,\$j,\$color[\$i^\$j]);
}
```

}

imagepng(\$im); imagedestroy(\$im);</lang>

Output:

## PL/I

<lang PL/I>munch: procedure options (main); /* 21 May 2014 */

```  declare screen (0:255, 0:255) bit(24) aligned;
declare b bit(8) aligned;
declare (x, y) unsigned fixed binary (8);
```
```  do x = 0 upthru hbound(screen,2);
do y = 0 upthru hbound(screen,1);
b = unspec(x) ^ unspec(y);
screen(x,y) = b;
end;
end;
call writeppm(screen);
```

end munch;</lang>

## Prolog

Works with SWI-Prolog and his GUI XPCE. <lang Prolog>xor_pattern :- new(D, window('XOR Pattern')), send(D, size, size(512,512)), new(Img, image(@nil, width := 512, height := 512 , kind := pixmap)),

forall(between(0,511, I), ( forall(between(0,511, J), ( V is I xor J, R is (V * 1024) mod 65536, G is (65536 - V * 1024) mod 65536, ( V mod 2 =:= 0 -> B is (V * 4096) mod 65536  ; B is (65536 - (V * 4096)) mod 65536), send(Img, pixel(I, J, colour(@default, R, G, B))))))),

new(Bmp, bitmap(Img)), send(D, display, Bmp, point(0,0)), send(D, open). </lang>

## PureBasic

<lang purebasic>#palletteSize = 128 Procedure.f XorPattern(x, y) ;compute the gradient value from the pixel values

``` Protected result = x ! y
ProcedureReturn Mod(result, #palletteSize) / #palletteSize
```

EndProcedure

Procedure drawPattern()

``` StartDrawing(ImageOutput(0))
;specify a gradient pallette from which only specific indexes will be used
For i = 1 To #palletteSize
Next
Box(0, 0, ImageWidth(0), ImageHeight(0))
StopDrawing()
```

EndProcedure

If OpenWindow(0, 0, 0, 128, 128, "XOR Pattern", #PB_Window_SystemMenu)

``` CreateImage(0, WindowWidth(0), WindowHeight(0))
drawPattern()
ImageGadget(0, 0, 0, ImageWidth(0), ImageHeight(0), ImageID(0))
Repeat
event = WaitWindowEvent(20)
Until event = #PB_Event_CloseWindow
```

EndIf</lang>

## Python

Library: PIL

<lang Python>import Image, ImageDraw

image = Image.new("RGB", (256, 256)) drawingTool = ImageDraw.Draw(image)

for x in range(256):

```   for y in range(256):
drawingTool.point((x, y), (0, x^y, 0))
```

del drawingTool image.save("xorpic.png", "PNG")</lang>

## Racket

<lang racket>

1. lang racket

(require racket/draw) (define palette (for/vector ([x 256]) (make-object color% 0 0 x))) (define bm (make-object bitmap% 256 256)) (define dc (new bitmap-dc% [bitmap bm])) (for* ([x 256] [y 256])

``` (define c (vector-ref palette (bitwise-xor x y)))
(send dc set-pixel x y c))
```

bm </lang>

## Ring

<lang ring>

1. Project : Munching squares
2. Date  : 2018/01/13
3. Author : Gal Zsolt (~ CalmoSoft ~)
4. Email  : <calmosoft@gmail.com>

paint = null

new qapp

```       {
win1 = new qwidget() {
setwindowtitle("Archimedean spiral")
setgeometry(100,100,500,600)
label1 = new qlabel(win1) {
setgeometry(10,10,400,400)
settext("")
}
new qpushbutton(win1) {
setgeometry(150,500,100,30)
settext("draw")
setclickevent("draw()")
}
show()
}
exec()
}
```

func draw

```       p1 = new qpicture()
color = new qcolor() {
setrgb(0,0,255,255)
}
pen = new qpen() {
setcolor(color)
setwidth(1)
}
paint = new qpainter() {
begin(p1)
setpen(pen)
```
```       w = 100
for x = 0 to w
for y = 0 to w
b = (x ^ y)
color = new qcolor()
color.setrgb(255 -b,b /2,b,255)
pen.setcolor(color)
setpen(pen)
drawpoint(x,w -y -1)
next
next
```
```       endpaint()
}
label1 { setpicture(p1) show() }
return
```

</lang> Output:

## Ruby

class Pixmap

``` def self.xor_pattern(width, height, rgb1, rgb2)
# create colour table
size = 256
colours = Array.new(size) do |i|
RGBColour.new(
(rgb1.red + (rgb2.red - rgb1.red) * i / size),
(rgb1.green + (rgb2.green - rgb1.green) * i / size),
(rgb1.blue + (rgb2.blue - rgb1.blue) * i / size),
)
end
```
```   # create the image
pixmap = new(width, height)
pixmap.each_pixel do |x, y|
pixmap[x,y] = colours[(x^y)%size]
end
pixmap
end
```

end

img = Pixmap.xor_pattern(384, 384, RGBColour::RED, RGBColour::YELLOW) img.save_as_png('xorpattern.png')</lang>

## Run BASIC

<lang runbasic>w = 100 graphic #g, w,w for x = 0 to w

``` for y = 0 to w
b = (x xor y) and 255
#g color(255 -b,b /2,b)
#g "set "; x; " "; w -y -1
next y
```

next x render #g

1. g "flush"</lang>

## Rust

<lang rust>extern crate image;

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

fn main() {

```   let mut img = ImageBuffer::new(256, 256);
```
```   for x in 0..256 {
for y in 0..256 {
let pixel = Rgb::from_channels(0, x as u8 ^ y as u8, 0, 0);
img.put_pixel(x, y, pixel);
}
}
```
```   let _ = img.save("output.png");
```

}</lang>

## Scala

Library: Scala

<lang Scala>import scala.swing.Swing.pair2Dimension import scala.swing.{ Color, Graphics2D, MainFrame, Panel, SimpleSwingApplication }

object XorPattern extends SimpleSwingApplication {

``` val ui = new Panel {
```
```   override def paintComponent(g: Graphics2D) = {
super.paintComponent(g)
for {
y <- 0 until size.getHeight().toInt
x <- 0 until size.getWidth().toInt
} {
g.setColor(new Color(0, (x ^ y) % 256, 0))
g.drawLine(x, y, x, y)
}
}
}
```
``` def top = new MainFrame {
preferredSize = (300, 300)
title = "Rosetta Code >>> Task: Munching squares | Language: Scala"
contents = ui
centerOnScreen()
}
```

}</lang>

## Sidef

Translation of: Perl

<lang ruby>require('Imager')

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

for x,y in (^256 ~X ^256) {

```   var rgb = [(255 - x - y).abs, (255-x)^y, x^(255-y)]
img.setpixel(x => x, y => y, color => rgb)
```

}

img.write(file => 'xor.png')</lang>

## Tcl

Library: Tk
<lang tcl>package require Tk

proc xorImage {img table} {

```   set data {}
set h [image height \$img]
set w [image width \$img]
for {set y 0} {\$y < \$h} {incr y} {
```

set row {} for {set x 0} {\$x < \$w} {incr x} { lappend row [lindex \$table [expr {(\$x^\$y) % [llength \$table]}]] } lappend data \$row

```   }
\$img put \$data
```

} proc inRange {i f t} {expr {\$f + (\$t-\$f)*\$i/255}} proc mkTable {rf rt gf gt bf bt} {

```   for {set i 0} {\$i < 256} {incr i} {
```

lappend tbl [format "#%02x%02x%02x" \ [inRange \$i \$rf \$rt] [inRange \$i \$gf \$gt] [inRange \$i \$bf \$bt]]

```   }
return \$tbl
```

}

set img [image create photo -width 512 -height 512] xorImage \$img [mkTable 0 255 64 192 255 0] pack [label .l -image \$img]</lang>

## TI-83 BASIC

Due to the TI-83's 1 bit black and white display, this program uses the home screen and a gradient of characters. Since the TI-83 does not use a standard encoding, the first Sto→ to Str1 may be subjectively interpreted.

<lang ti-83b>PROGRAM:XORPATT " •.-,+-°-1+o*:πOX"→Str1

ClrHome

{0,0,0,0}→L1 {0,0,0,0)→L2

For(I,1,8,1) For(J,1,16,1) J→A I→B

If A>8 Then A-8→A 1→L1(1) Else 0→L1(1) End

If A>4 Then A-4→A 1→L1(2) Else 0→L1(2) End

If A>2 Then A-2→A 1→L1(3) Else 0→L1(3) End

If A>1 Then 1→L1(4) Else 0→L1(4) End

0→L2(1)

If B>4 Then B-4→B 1→L2(2) Else 0→L2(2) End

If B>2 Then B-2→B 1→L2(3) Else 0→L2(3) End

If B>1 Then 1→L2(4) Else 0→L2(4) End

L1≠L2→L3 8L3(1)+4L3(2)+2L3(3)+L3(4)→C Output(I,J,sub(Str1,C+1,1))

End End Pause </lang>

## XPL0

<lang XPL0>include c:\cxpl\codes; \intrinsic 'code' declarations int X, Y; [SetVid(\$101); \set 640x480 graphics with 8-bit color port(\$3C8):= 0; \set color registers with beautiful shades for X:= 0 to 256-1 do

```       [port(\$3C9):= X>>1;     \red
port(\$3C9):= X>>3;     \green
port(\$3C9):= X;        \blue
];
```

for Y:= 0 to 256-1 do \"color table" is array of 256 registers

```   for X:= 0 to 256-1 do
Point(X, Y, X|Y);       \"|" = XOR, not OR which is "!"
```

X:= ChIn(1); \wait for keystroke SetVid(3); \restore normal text mode ]</lang>

Output:

## zkl

Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

Translation of: XPL0

For a kaleidoscopic image, play with coolness. <lang zkl>fcn muncher{

```  bitmap:=PPM(256,256);
coolness:=(1).random(0x10000);  // 55379, 18180, 40, 51950, 57619, 43514, 65465
foreach y,x in ([0 .. 255],[0 .. 255]){
```

// rgb:=b*coolness; // kaleidoscopic image // rgb:=(b*coolness + b)*coolness + b; // more coolness

```     rgb:=(b*0x10000 + b)*0x10000 + b;  // copy ADA image
bitmap[x,y]=rgb;
}
bitmap.write(File("foo.ppm","wb"));
```

}();</lang> For a cheap slide show (on Linux): <lang zkl>while(1){ muncher(); Atomic.sleep(3); }</lang> run ImageViewer on foo.ppm and watch it [auto] update as the image changes.

Output: