An answer of the exercise: Slices on a tour of Go

answer_pic.go

package main

import "code.google.com/p/go-tour/pic"

func Pic(dx, dy int) [][]uint8 {
	// Allocate two-dimensioanl array.
	a := make([][]uint8, dy)
	for i := 0; i < dy; i++ {
		a[i] = make([]uint8, dx)
	}
	
	// Do something.
	for i := 0; i < dy; i++ {
		for j := 0; j < dx; j++ {
			switch {
			case j % 15 == 0:
				a[i][j] = 240
			case j % 3 == 0:
				a[i][j] = 120
			case j % 5 == 0:
				a[i][j] = 150
			default:
				a[i][j] = 100
			}
		}
	}	
	return a
}

func main() {
	pic.Show(Pic)
}

package main

import "golang.org/x/tour/pic"

func Pic(dx, dy int) [][]uint8 {
img := make([][]uint8, dy)
for y := range img {
img[y] = make([]uint8, dx)
for x := range img[y] {
i := uint8(y)
j := uint8(x)

	    value := (i + j)
		
		if value < 125{
			img[i][j] = j * j
		} else{
			img[i][j] = i * i
		}
	}
}
return img

}

func main() {
pic.Show(Pic)
}

Mandelbrot set

package main

import (
	"golang.org/x/tour/pic"
)

const (
	maxIter    uint8      = 100
	brightness uint8      = 20
	min        complex128 = -2 + 1.4i
	max        complex128 = 0.8 - 1.4i
)

func Pic(dx, dy int) [][]uint8 {
	picture := make([][]uint8, dy)

	for i := range picture {
		picture[i] = make([]uint8, dx)
	}

	rMin := real(min)
	iMin := imag(max)
	sX := (real(max) - real(min)) / float64(dx-1)
	sY := (imag(min) - imag(max)) / float64(dy-1)

	for y := 0; y < dy; y++ {
		for x := 0; x < dx; x++ {
			realPart := float64(x)*sX + rMin
			imagPart := float64(y)*sY + iMin

			picture[y][x] = Mandelbrot(complex(realPart, imagPart)) * brightness
		}
	}

	return picture
}

func Mandelbrot(c complex128) uint8 {
	z := c

	for it := uint8(0); it < maxIter; it++ {
		z = z*z + c

		if r, i := real(z), imag(z); r*r+i*i > 4 {
			return it
		}
	}

	return maxIter
}

func main() {
	pic.Show(Pic)
}

package main

import (
	"image"

	"github.com/Max95Cohen/gopher"
	"golang.org/x/tour/pic"
)

func Pic(dx, dy int) [][]uint8 {
	var a = make([][]uint8, dy)

	for i := 0; i < dy; i++ {
		a[i] = make([]uint8, dx)
	}

	for i := 0; i < dy; i++ {
		for j := 0; j < dx; j++ {
			a[i][j] = 255
		}
	}

	var p = &a

	return gopher.GetPixels(*p)
}

func show(f func(dx, dy int) [][]uint8) {
	const (
		dx = 256
		dy = 256
	)
	data := f(dx, dy)
	m := image.NewNRGBA(image.Rect(0, 0, dx, dy))
	for y := 0; y < dy; y++ {
		for x := 0; x < dx; x++ {
			v := data[y][x]
			i := y*m.Stride + x*4
			
			var r, g, b uint8
			
			if v == 255 {
				r = 255
				g = 0
				b = 255
			} else {
				r = 0
				g = 255
				b = 0
			}
			
			m.Pix[i] = r
			m.Pix[i+1] = g
			m.Pix[i+2] = b
			m.Pix[i+3] = 255
		}
	}
	pic.ShowImage(m)
}

func main() {
	show(Pic)
}

package main

import (
	"golang.org/x/tour/pic"
)

func Pic(dx, dy int) [][]uint8 {
	s := make([][]uint8, dy)
	for i := range s {
		s[i] = make([]uint8, dx)

		for j := range s[i] {
			s[i][j] = uint8((i + j) / 2 >> 8 + (i + j) / 2 % (i + 2) % (j + 2))
		}
	}
	return s
}

func main() {
	pic.Show(Pic)
}

Very suspicious pattern

package main

import "golang.org/x/tour/pic"

const (
	VAL_MAX uint8 = 255
	AMOG_DX uint8 = 10
	AMOG_DY uint8 = 10
)
// ඞ
var AMOGUS = [AMOG_DY][AMOG_DX]uint8{
	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 2, 2, 2, 0, 0, 0},
	{0, 0, 0, 2, 2, 1, 1, 1, 0, 0},
	{0, 0, 2, 2, 2, 2, 2, 2, 0, 0},
	{0, 0, 2, 2, 2, 2, 2, 2, 0, 0},
	{0, 0, 0, 2, 2, 2, 2, 2, 0, 0},
	{0, 0, 0, 2, 0, 0, 0, 2, 0, 0},
	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
}

func Shader(x, y int) uint8 {
	x_u := uint8(x) % AMOG_DX
	y_u := uint8(y) % AMOG_DY
	return AMOGUS[y_u][x_u]*(VAL_MAX>>1) + 1

}

func Pic(dx, dy int) [][]uint8 {
	buf := make([][]uint8, dy)
	for y := range buf {
		column := make([]uint8, dx)
		for x := range column {
			column[x] = Shader(x, y)
		}
		buf[y] = column
	}
	return buf
}

func main() {
	pic.Show(Pic)
}

package main

import "golang.org/x/tour/pic"
// import "fmt"

func pointValue1(x, y int) uint8 {
	return uint8((x + y) / 2)
}

func pointValue2(x, y int) uint8 {
	return uint8(x * y)
}

func pointValue3(x, y int) uint8 {
	return uint8(x ^ y)
}

func Pic(dx, dy int) [][]uint8 {
	// initialize slice rows with dy length
	var matrix [][]uint8
	
	// initialize the i'th element of rows with dx length slice
	for i := 0; i < dy; i ++ {
		// var array_rows [dx]uint8
		var array_rows []uint8
		// update the value of each point
		for j := 0; j < dx; j ++ {
			// array_rows[j] = pointValue1(i, j)
			array_rows = append(array_rows, pointValue3(i, j))
		}
		// matrix = append(matrix, array_rows[0:])
		matrix = append(matrix, array_rows)
	}
	
	// fmt.Println(matrix)
	return matrix
}

func main() {
	pic.Show(Pic)
}