func main() {
	fmt.Println("### Start Slice Exercise ###")

	pic.Show(Pic)

	fmt.Println("### End Slice Exercise ###")
}
示例#2
0
func main() {
	pointer()
	v := Vertex{1, 2}
	v.X = 4
	fmt.Println(v)

	p := &v
	p.X = 1e9
	fmt.Println(v)

	structLiterals()
	array()
	slice()
	tictactoe()
	slicing()

	makeslice()
	zeroSlice()
	appendSlice()
	ranges()

	pic.Show(Pic)

	var vLL = VertexLL{40.68433, -74.39967}
	geography("Bell Labs", vLL)
	fmt.Println(m["Bell Labs"])
	vLL = VertexLL{37.4828, 122.2361}
	geography("Redwood City", vLL)
	fmt.Println(m["Redwood City"])

	fmt.Println(m)

	mutateMap()
	wc.Test(WordCount)

	fmt.Println(hypot(5, 12))

	fmt.Println(compute(hypot))
	fmt.Println(compute(math.Pow))

	exAdder()

	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}

}
示例#3
0
func main() {
	pic.Show(Pic)
}
示例#4
0
func TestExerciseSlices(t *testing.T) {
	pic.Show(Pic)
}
示例#5
0
func main() {
	i, j := 42, 2701

	// pointer to i
	p := &i

	fmt.Println(p, " -> ", *p)

	p = &j
	fmt.Println(p, " -> ", *p)
	*p = i
	fmt.Println(p, " -> ", *p)

	v1 := Vertex{4, 5}
	v2 := Vertex{X: 9, Y: 9}
	v3 := Vertex{X: 9} // Y=0 is implicit

	fmt.Println(v1.X)
	fmt.Println(v2, v3)

	// arrays
	var s1 [2]string

	s1[0] = "hi"
	s1[1] = "there"

	fmt.Println("a[0]: ", s1[0])
	fmt.Println("a: ", s1)

	arr := []int{1, 2, 4, 5, 23, 123, 5, 0}
	fmt.Println("arr ==", arr)

	for i := 0; i < len(arr); i++ {
		fmt.Printf("arr[%d] == %d\n", i, arr[i])
	}
	fmt.Println("arr[:3] == ", arr[:3])
	fmt.Println("arr[2:5] == ", arr[2:5])
	fmt.Println("arr[5:] == ", arr[5:])
	fmt.Println("arr[:] == ", arr[:])

	a := make([]int, 5)
	printSlice("a", a)
	b := make([]int, 0, 5)
	printSlice("b", b)
	c := b[:2]
	printSlice("c", c)
	d := c[2:5]
	printSlice("d", d)

	var z []int

	// zero value for empty array is nil
	if z == nil {

		fmt.Println("nil,", z)

	}

	printSlice("z", z)
	z = append(z, 1)
	z = append(z, 2)
	z = append(z, 4)
	var z2 []int = append(z, 3, 5, 6)
	printSlice("z", z)
	printSlice("z", z2)

	for i, v := range pow {
		fmt.Printf("2^%d = %d\n", i, v)
	}

	pwrs := make([]int, 10)
	for i := range pwrs {
		pwrs[i] = 1 << uint(i)
	}
	for _, val := range pwrs {
		fmt.Println(val)
	}
	pic.Show(Pic)

	var m map[string]Vertex

	m = make(map[string]Vertex)

	m["Bell labs"] = Vertex{342, 4532}

	var m2 = map[string]Vertex{
		"Google":           {33, 44},
		"General Electric": {54322, 3423},
		"deleteme":         {},
	}

	delete(m2, "deleteme")

	fmt.Println(m, m2)

	// functions

	hypnot := func(x, y float64) float64 {
		return math.Sqrt(x*x + y*y)
	}
	fmt.Println(hypnot(4.0, 3.0))

	adder := closureAdder()
	for i := 0; i < 10; i++ {
		fmt.Printf(" %d ", adder(i))
	}
	fmt.Printf("\n")

}
示例#6
0
////Learning material used from
//https://tour.golang.org/moretypes/15
//GoTour needs to be installed locally
func main() {
	rand.Seed(time.Now().UTC().UnixNano())
	pic.Show(Pic)
}
示例#7
0
func main() {
	pic.Show(Pic)
	fmt.Println("hello, world")
}
示例#8
0
func showPic() {
	pic.Show(Pic)
}
示例#9
0
func main() {
	//pic.Show(Pic(2,2))
	pic.Show(Pic)
}
示例#10
0
文件: sandbox.go 项目: trsathya/go
func main() {
	fmt.Println("Welcome to the playground!")
	fmt.Println("The time is", time.Now())
	fmt.Println("My favorite number is", rand.Intn(10))
	fmt.Printf("Now you have %g problems.", math.Nextafter(2, 3))
	fmt.Println(math.Pi)
	fmt.Println(add1(42, 13))
	fmt.Println(add2(42, 13))
	a, b := swap("hello", "world")
	fmt.Println(a, b)
	fmt.Println(split(17))

	//1
	var i1 int
	fmt.Println(i1, c1, python1, java1)
	//2
	var c2, python2, java2 = true, false, "no!"
	fmt.Println(i2, j2, c2, python2, java2)

	//3
	var i3, j3 int = 1, 2
	k3 := 3
	c3, python3, java3 := true, false, "no!"

	fmt.Println(i3, j3, k3, c3, python3, java3)

	const f4 = "%T(%v)\n"
	fmt.Printf(f4, ToBe, ToBe)
	fmt.Printf(f4, MaxInt, MaxInt)
	fmt.Printf(f4, z4, z4)

	// data types
	// bool

	// string

	// int  int8  int16  int32  int64
	// uint uint8 uint16 uint32 uint64 uintptr

	// byte // alias for uint8

	// rune // alias for int32
	//      // represents a Unicode code point

	// float32 float64

	// complex64 complex128

	// default value
	var i5 int
	var f5 float64
	var b5 bool
	var s5 string
	fmt.Printf("%v %v %v %q\n", i5, f5, b5, s5)

	var x6, y6 int = 3, 4
	var f6 float64 = math.Sqrt(float64(x6*x6 + y6*y6))
	var z6 int = int(f6)
	fmt.Println(x6, y6, z6)

	v2 := 1.3 // change me!
	fmt.Printf("v is of type %T\n", v2)

	const World = "世界"
	fmt.Println("Hello", World)
	fmt.Println("Happy", Pi, "Day")

	const Truth = true
	fmt.Println("Go rules?", Truth)

	fmt.Println(needInt(Small))
	fmt.Println(needFloat(Small))
	fmt.Println(needFloat(Big))

	sum1 := 0
	for i := 0; i < 10; i++ {
		sum1 += i
	}
	fmt.Println(sum1)

	sum2 := 1
	for sum2 < 1000 {
		sum2 += sum2
	}
	fmt.Println(sum2)

	// For is Go's "while"
	sum3 := 1
	for sum3 < 1000 {
		sum3 += sum3
	}
	fmt.Println(sum3)

	fmt.Println(sqrt(2), sqrt(-4))

	fmt.Println(
		pow1(3, 2, 10),
		pow1(3, 3, 20),
	)

	//switch
	switch os := runtime.GOOS; os {
	case "darwin":
		fmt.Println("OS X.")
	case "linux":
		fmt.Println("Linux.")
	default:
		// freebsd, openbsd,
		// plan9, windows...
		fmt.Printf("%s.", os)
	}

	fmt.Println("When's Saturday?")
	today := time.Now().Weekday()
	fmt.Println(today, time.Saturday)
	switch time.Saturday {
	case today + 0:
		fmt.Println("Today.")
	case today + 1:
		fmt.Println("Tomorrow.")
	case today + 2:
		fmt.Println("In two days.")
	default:
		fmt.Println("Too far away.")
	}

	t := time.Now()
	switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	case t.Hour() < 17:
		fmt.Println("Good afternoon.")
	default:
		fmt.Println("Good evening.")
	}

	DeferFunc()
	// end of flow control statements

	// pointers
	fmt.Println("Pointers ---")
	i, j := 42, 2701
	var p *int      // declaring a pointer to an int.
	p = &i          // point to i
	fmt.Println(*p) // read i through the pointer. This is known as "dereferencing" or "indirecting".
	*p = 21         // set i through the pointer. This is known as "dereferencing" or "indirecting".
	fmt.Println(i)  // see the new value of i

	p = &j         // point to j.
	*p = *p / 37   // divide j through the pointer. This is known as "dereferencing" or "indirecting".
	fmt.Println(j) // see the new value of j
	fmt.Println("Pointers ---")

	// Structs
	fmt.Println(Vertex{1, 2})

	v1 := Vertex{1, 2}
	v1.X = 4
	fmt.Println(v1.X)
	p1 := &v1
	p1.X = 1e9
	fmt.Println(v1)

	fmt.Println(v3, p2, v4, v5)

	//arrays
	var array [2]string
	array[0] = "Hello"
	array[1] = "World"
	fmt.Println(array[0], array[1])
	fmt.Println(array)

	s := []int{2, 3, 5, 7, 11, 13}
	fmt.Println("s ==", s)

	for i := 0; i < len(s); i++ {
		fmt.Printf("s[%d] == %d\n", i, s[i])
	}

	// slicing
	fmt.Println("s[1:4] ==", s[1:4])

	// missing low index implies 0
	fmt.Println("s[:3] ==", s[:3])

	// missing high index implies len(s)
	fmt.Println("s[4:] ==", s[4:])

	a1 := make([]int, 5)
	printSlice("a1", a1)
	b1 := make([]int, 0, 5)
	printSlice("b1", b1)
	c1 := b1[:2]
	printSlice("c1", c1)
	d1 := c1[2:5]
	printSlice("d1", d1)
	//Nil slices
	var zNil []int
	fmt.Println(zNil, len(zNil), cap(zNil))
	if zNil == nil {
		fmt.Println("nil!")
	}

	var a2 []int
	printSlice("a2", a2)

	// append works on nil slices.
	a2 = append(a2, 0)
	printSlice("a2", a2)

	// the slice grows as needed.
	a2 = append(a2, 1)
	printSlice("a2", a2)

	// we can add more than one element at a time.
	a2 = append(a2, 2, 3, 4)
	printSlice("a2", a2)

	// range
	for i, v := range pow2 {
		fmt.Printf("2**%d = %d\n", i, v)
	}

	pow3 := make([]int, 10)
	for i := range pow3 {
		pow3[i] = 1 << uint(i)
	}
	for _, value := range pow3 {
		fmt.Printf("%d\n", value)
	}

	pic.Show(Pic)

	// Maps
	map1 = make(map[string]LocationCoordinate)
	map1["Bell Labs"] = LocationCoordinate{
		40.68433, -74.39967,
	}
	fmt.Println(map1["Bell Labs"])
	fmt.Println(map1)

	fmt.Println(map2)

	//Mutating Maps
	map3 := make(map[string]int)

	map3["Answer"] = 42
	fmt.Println("The value:", map3["Answer"])

	v6, ok1 := map3["Answer"]
	fmt.Println("The value:", v6, "Present?", ok1)

	map3["Answer"] = 48
	fmt.Println("The value:", map3["Answer"])

	delete(map3, "Answer")
	fmt.Println("The value:", map3["Answer"])

	v6, ok2 := map3["Answer"]
	fmt.Println("The value:", v6, "Present?", ok2)

	// map exercise
	wc.Test(WordCount)

	//functions arevalues too
	hypot := func(x, y float64) float64 {
		return math.Sqrt(x*x + y*y)
	}

	fmt.Println(hypot(3, 4))

	pos, neg := adder(), adder()
	for i := 0; i < 10; i++ {
		fmt.Println(
			pos(i),
			neg(-2*i),
		)
	}

	fib := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(fib())
	}

	v7 := &FloatVertex{3, 4}
	fmt.Println("FloatVertex", v7.Abs())

	f1 := MyFloat(-math.Sqrt2)
	fmt.Println(f1.Abs())

	v8 := &FloatVertex{3, 4}
	v8.Scale(5)
	fmt.Println(v8, v8.Abs())

	runInterface()
	runImplicitInterface()
	runStringer()
	runErrors()

	go say("world")
	say("hello")
	runGoRoutine()
	runBufferedChannel()
	runRangeAndClose()
	runFibonacci3()
	runDefaultSelection()
}
示例#11
0
文件: pic.go 项目: svr93/go_examples
func main() {

	pic.Show(Pic) // base64
}
示例#12
0
文件: main.go 项目: iplog/gotour
func main() {
	pic.Show(Pic)
	pic.Show(PicRange)
}
示例#13
0
func testPic() {
	pic.Show(Pic)
}
示例#14
0
// 参考 https://tour.go-zh.org/moretypes/15
func main() {
	// nice choice (x+y)/2、x*y 和 x^y
	pic.Show(Pic)
}
示例#15
0
文件: slice.go 项目: yu81/go-sandbox
func ExecPic() {
	pic.Show(Pic)
}