tetsuok/answer_pic.go

JPCodaLot · 2022-12-02T20:59:09Z

package main

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

func Pic(dx, dy int) (picture [][]uint8) {
	picture = make([][]uint8, dy)
	for y := range picture {
		picture[y] = make([]uint8, dx)
		for x := range picture[y] {
			if y % 2 == 1 {
				picture[y][x] = uint8((y+x*2)^(y-x*2))
			} else {
				picture[y][x] = uint8((x+y*2)^(x-y*2))
			}
		}
	}
	return picture
}

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

krapie · 2022-12-06T08:15:48Z

package main

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

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

func interpretCoordinate(x, y int) uint8 {
	n := x^y
	
	return uint8(n)
}

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

odashi · 2022-12-08T12:31:50Z

package main

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

func Pic(dx, dy int) [][]uint8 {
	s := make([][]uint8, dy)
	for y := range s {
		s[y] = make([]uint8, dx)
		for x := range s[y] {
			s[y][x] = gopher(x, y)
		}
	}

	return s
}

func gopher(x, y int) uint8 {
    xx := float64(x)
	yy := float64(y)
	
	params := [][6]float64 {
		{180, 50, 3, 3, 0, 255},
		{175, 50, 10, 10, 0, 0},
		{105, 80, 3, 3, 0, 255},
		{100, 80, 10, 10, 0, 0},
		{155, 55, 30, 30, 0, 255},
		{155, 55, 32, 32, 0, 0},
		{80, 85, 30, 30, 0, 255},
		{80, 85, 32, 32, 0, 0},
		{130, 90, 7, 1, 24, 255},
		{125, 95, 13, 8, 24, 0},
		{133, 128, 12, 5, 114, 255},
		{133, 128, 13, 6, 114, 0},
		{143, 124, 12, 5, 116, 255},
		{143, 124, 13, 6, 116, 0},
		{130, 108, 22, 12, 23, 160},
		{130, 108, 24, 14, 23, 0},
		{183, 178, 14, 8, -20, 255},
		{183, 178, 15, 9, -20, 0},
		{131, 108, 96, 100, 0, 220},
		{151, 158, 90, 100, 0, 220},
		{151, 188, 90, 100, 0, 220},
		{243, 148, 14, 8, -20, 255},
		{243, 148, 15, 9, -20, 0},
		{205, 36, 2, 2, 0, 255},
		{203, 42, 10, 10, 0, 0},
		{206, 44, 21, 21, 0, 255},
		{206, 44, 23, 23, 0, 0},
		{33, 102, 10, 10, 0, 0},
		{36, 104, 21, 21, 0, 255},
		{36, 104, 23, 23, 0, 0},
	}
    
	for _, p := range params {
		if judge(xx, yy, p[0], p[1], p[2], p[3], p[4]) {
			return uint8(p[5])
		}
	}
	
	return 255
}

func judge(x, y, cx, cy, a, b, deg float64) bool {
	t := deg * math.Pi / 180
	ct := math.Cos(t)
	st := math.Sin(t)
	x2 := (x - cx)
	y2 := (y - cy)
	x3 := (ct * x2 - st * y2) / a
	y3 := (st * x2 + ct * y2) / b
    return x3 * x3 + y3 * y3 < 1
}

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

nreynis · 2023-03-07T22:02:20Z

package main

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

func Pic(dx, dy int) [][]uint8 {
	bitmap := [][]uint8{}

	for i := 0; i < dy; i++ {
		line := make([]uint8, dx)
		for j := range line {
			line[j] = uint8(i * j % (j + 3))
		}
		bitmap = append(bitmap, line)
	}
	return bitmap
}

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

yongkangc · 2023-04-03T21:56:24Z

package main

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

func Pic(dx, dy int) [][]uint8 {
	pictureArray := make([][]uint8, dy)
	for i := range pictureArray {
		pictureArray[i] = make([]uint8, dx)
		for j := range pictureArray[i] {
			pictureArray[i][j] = uint8((i * j / 4) + (i ^ j + 1))
		}
	}
	return pictureArray
}

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

yongkangc · 2023-04-03T21:57:04Z

package main

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

func Pic(dx, dy int) [][]uint8 {
	s := make([][]uint8, dy)
	for y := range s {
		s[y] = make([]uint8, dx)
		for x := range s[y] {
			s[y][x] = gopher(x, y)
		}
	}

	return s
}

func gopher(x, y int) uint8 {
    xx := float64(x)
	yy := float64(y)
	
	params := [][6]float64 {
		{180, 50, 3, 3, 0, 255},
		{175, 50, 10, 10, 0, 0},
		{105, 80, 3, 3, 0, 255},
		{100, 80, 10, 10, 0, 0},
		{155, 55, 30, 30, 0, 255},
		{155, 55, 32, 32, 0, 0},
		{80, 85, 30, 30, 0, 255},
		{80, 85, 32, 32, 0, 0},
		{130, 90, 7, 1, 24, 255},
		{125, 95, 13, 8, 24, 0},
		{133, 128, 12, 5, 114, 255},
		{133, 128, 13, 6, 114, 0},
		{143, 124, 12, 5, 116, 255},
		{143, 124, 13, 6, 116, 0},
		{130, 108, 22, 12, 23, 160},
		{130, 108, 24, 14, 23, 0},
		{183, 178, 14, 8, -20, 255},
		{183, 178, 15, 9, -20, 0},
		{131, 108, 96, 100, 0, 220},
		{151, 158, 90, 100, 0, 220},
		{151, 188, 90, 100, 0, 220},
		{243, 148, 14, 8, -20, 255},
		{243, 148, 15, 9, -20, 0},
		{205, 36, 2, 2, 0, 255},
		{203, 42, 10, 10, 0, 0},
		{206, 44, 21, 21, 0, 255},
		{206, 44, 23, 23, 0, 0},
		{33, 102, 10, 10, 0, 0},
		{36, 104, 21, 21, 0, 255},
		{36, 104, 23, 23, 0, 0},
	}
    
	for _, p := range params {
		if judge(xx, yy, p[0], p[1], p[2], p[3], p[4]) {
			return uint8(p[5])
		}
	}
	
	return 255
}

func judge(x, y, cx, cy, a, b, deg float64) bool {
	t := deg * math.Pi / 180
	ct := math.Cos(t)
	st := math.Sin(t)
	x2 := (x - cx)
	y2 := (y - cy)
	x3 := (ct * x2 - st * y2) / a
	y3 := (st * x2 + ct * y2) / b
    return x3 * x3 + y3 * y3 < 1
}

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

this is amazing!

19valentin99 · 2023-05-12T15:15:42Z

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)
}

Rivgad · 2023-05-13T21:08:01Z

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)
}

Max95Cohen · 2023-09-15T04:06:57Z

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)
}

bryceleue · 2023-09-16T00:11:29Z

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)
}

mikurei · 2023-10-12T21:31:46Z

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)
}

hello2333 · 2024-02-10T11:05:22Z

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)
}

masiunas · 2024-06-14T18:00:52Z

package main

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

func Pic(dx, dy int) [][]uint8 {
	result := make([][]uint8, dy)
	for y := range result {
		result[y] = make([]uint8, dx)
		for x := range result[y] {
			result[y][x] = uint8((x + y) / 2)
		}
	}
	return result
}

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

joksdz · 2024-06-26T09:52:32Z

package main

import (
	"math"

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

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

	for y := range pic {
		pic[y] = make([]uint8, dx)

		for x := range pic[y] {
			pic[y][x] = uint8(float64(x^y-y^x) / math.Pi)
		}
	}

	return pic
}

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

joksdz · 2024-06-26T09:57:01Z

package main

import (
	"math"

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

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

		for x := range pic[y] {

			i++
			pic[y][x] = uint8(float64((x+y)*i) / math.Pi)
		}
	}

	return pic
}

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

sturmenta · 2024-07-16T04:44:42Z

package main

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

func Pic(dx, dy int) [][]uint8 {
	var image [][]uint8

	for y := 0; y < dy; y++ {
		var row []uint8

		for x := 0; x < dx; x++ {
			row = append(row, uint8(x*10 + y*100))
		}

		image = append(image, row)
	}

	return image
}

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

Anastasiais · 2024-07-31T08:18:34Z

 package main

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

 func Pic(dx, dy int) [][]uint8 {

 slice:= make([][]uint8, dy, dy)
 for y, _ := range slice {
	slice[y] = make([]uint8, dx)
	for x:= range slice {
		i := uint8(y)
		j := uint8(x)
		slice[i][j] = (j * j * 100) + (i * i * 100)
	}
}
 return slice
} 
func main() {
      pic.Show(Pic)
}

light-traveller · 2024-12-24T13:04:01Z

package main

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

func Pic(dx, dy int) [][]uint8 {
    bitmap := make([][]uint8, dy)
    
    for i := 0; i < dy; i++ {
	bitmap[i] = make([]uint8, dx)
    }
	
    for i := 0; i < dy; i++ {
	for j := 0; j < dx; j++ {
	    bitmap[i][j] = uint8(math.Sqrt(float64(i)) * .01 * float64(i * j)) >> 2
	}
    }
	
    return bitmap
}

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

	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)
	}

tetsuok/answer_pic.go

JPCodaLot commented Dec 2, 2022

krapie commented Dec 6, 2022

odashi commented Dec 8, 2022

nreynis commented Mar 7, 2023

yongkangc commented Apr 3, 2023

yongkangc commented Apr 3, 2023

19valentin99 commented May 12, 2023

Rivgad commented May 13, 2023

Max95Cohen commented Sep 15, 2023

bryceleue commented Sep 16, 2023

mikurei commented Oct 12, 2023

hello2333 commented Feb 10, 2024

masiunas commented Jun 14, 2024 •

edited

Loading

joksdz commented Jun 26, 2024

joksdz commented Jun 26, 2024

sturmenta commented Jul 16, 2024

Anastasiais commented Jul 31, 2024 •

edited

Loading

light-traveller commented Dec 24, 2024

tetsuok/answer_pic.go

JPCodaLot commented Dec 2, 2022

krapie commented Dec 6, 2022

odashi commented Dec 8, 2022

nreynis commented Mar 7, 2023

yongkangc commented Apr 3, 2023

yongkangc commented Apr 3, 2023

19valentin99 commented May 12, 2023

Rivgad commented May 13, 2023

Max95Cohen commented Sep 15, 2023

bryceleue commented Sep 16, 2023

mikurei commented Oct 12, 2023

hello2333 commented Feb 10, 2024

masiunas commented Jun 14, 2024 • edited Loading

joksdz commented Jun 26, 2024

joksdz commented Jun 26, 2024

sturmenta commented Jul 16, 2024

Anastasiais commented Jul 31, 2024 • edited Loading

light-traveller commented Dec 24, 2024

masiunas commented Jun 14, 2024 •

edited

Loading

Anastasiais commented Jul 31, 2024 •

edited

Loading