Golang Newの例

コード例 #1

ファイル: walk.go プロジェクト: yutakakinjyo/go-learn

func main() {
	if Same(tree.New(1), tree.New(1)) {
		fmt.Println("Same!")
	} else {
		fmt.Println("not Same!")
	}
}

コード例 #2

ファイル: equivalentbinarytrees.go プロジェクト: kgaughan/learning

func main() {
	if Same(tree.New(1), tree.New(2)) {
		fmt.Println("Yay!")
	} else {
		fmt.Println("Nay!")
	}
}

コード例 #3

ファイル: tree.go プロジェクト: simbapeer/study

func main() {
	t1 := tree.New(1)
	t2 := tree.New(1)

	fmt.Println(Same(t1, t2))

}

コード例 #4

ファイル: 70.go プロジェクト: py0n/a_tour_of_go

// C70 ...
func C70(opts Options, args []string) int {
	t1 := tree.New(1)
	t2 := tree.New(1)
	fmt.Println(t1)
	fmt.Println(t2)
	fmt.Println(same(t1, t2))
	return 0
}

コード例 #5

ファイル: 72-binary-tree.go プロジェクト: jabley/gotour

func main() {
	//    ch := make(chan int)
	//    go Walk(tree.New(1), ch)
	//    for i := 0; i < 10; i++ {
	//      fmt.Println(<-ch)
	//    }
	fmt.Println(Same(tree.New(1), tree.New(1)))
	fmt.Println(Same(tree.New(1), tree.New(2)))
}

コード例 #6

ファイル: bin_tree.go プロジェクト: heydabop/go-tour

func main() {
	ch := make(chan int)
	go Walk(tree.New(1), ch)
	for i := range ch {
		fmt.Println(i)
	}
	fmt.Println(Same(tree.New(1), tree.New(1)))
	fmt.Println(Same(tree.New(1), tree.New(2)))
}

コード例 #7

ファイル: exercise_71_test.go プロジェクト: rangilin/go-tour-exercises

func TestSame(t *testing.T) {
	if !Same(tree.New(1), tree.New(1)) {
		t.Errorf("Expect tree.New(1) is the same with tree.New(1)")
	}

	if Same(tree.New(1), tree.New(2)) {
		t.Errorf("Expect tree.New(1) is not the same with tree.New(2)")
	}
}

コード例 #8

ファイル: binarytrees.go プロジェクト: rhcarvalho/gotour-solutions

func main() {
	ch := make(chan int)
	go Walk(tree.New(1), ch)
	for i := 0; i < 10; i++ {
		print(<-ch, " ")
	}
	print("\n")
	println(Same(tree.New(1), tree.New(1)),
		Same(tree.New(2), tree.New(1)))
}

コード例 #9

ファイル: 72.go プロジェクト: EmperorEarth/learnGo

func main() {
	ch := make(chan int)
	go Walk(tree.New(1), ch)
	for i := 0; i < 10; i++ {
		fmt.Println(<-ch)
	}

	fmt.Println(Same(tree.New(1), tree.New(1)))
	fmt.Println(Same(tree.New(1), tree.New(2)))
}

コード例 #10

ファイル: 070.go プロジェクト: takyam-git/tour-of-go

func main() {
	if !Same(tree.New(1), tree.New(1)) {
		fmt.Println("fail!! 1 && 1")
		return
	}
	if Same(tree.New(1), tree.New(2)) {
		fmt.Println("fail!! 1 && 2")
		return
	}
	fmt.Println("all succeed!")
}

コード例 #11

ファイル: tour70.go プロジェクト: raydive/tour_of_go

func main() {
	ch := make(chan int)
	go Walk(tree.New(1), ch)
	for n := range ch {
		print(n, " ")
	}
	println()

	println(Same(tree.New(1), tree.New(1)))
	println(Same(tree.New(1), tree.New(2)))
}

コード例 #12

ファイル: ex69_equivalent_binary_trees.go プロジェクト: schettino72/gotour

func main() {
	t1 := tree.New(1)
	/*
	   ch := make(chan int, 10)
	   go Walk(t1, ch)
	   for val := range(ch){
	       fmt.Println(val)
	   }
	*/
	fmt.Println(Same(t1, tree.New(1)))
	fmt.Println(Same(t1, tree.New(2)))
}

コード例 #13

ファイル: tree.go プロジェクト: jchjjj/learnGo

func main() {
	t := tree.New(1)
	t2 := tree.New(1)
	fmt.Println(t)
	fmt.Println(t2)
	c := make(chan int)
	go Walk(t, c)
	for i := 0; i < 10; i++ {
		fmt.Println(<-c)
	}
	fmt.Println(Same(t, t2))
}

コード例 #14

ファイル: go_tour.go プロジェクト: xingyuli/godemo

func page68_Exercise_EquivalentBinaryTrees() {
	// test Walk
	/*
		ch := make(chan int)
		go Walk(tree.New(1), ch)
		for i := 0; i < 10; i++ {
			fmt.Println(<-ch)
		}
	*/

	fmt.Println(Same(tree.New(1), tree.New(1)))
	fmt.Println(Same(tree.New(1), tree.New(2)))
}

コード例 #15

ファイル: exercise11.go プロジェクト: jlubawy/gotour

func Exercise11() {
	// Uncomment to test Walk

	// ch := make(chan int)
	// go Walk(tree.New(1), ch)
	//
	// for v := range ch {
	// 	fmt.Printf("%d\n", v)
	// }

	fmt.Printf("tree.New(1) == tree.New(1) is %t\n", Same(tree.New(1), tree.New(1)))
	fmt.Printf("tree.New(1) == tree.New(2) is %t\n", Same(tree.New(1), tree.New(2)))
}

コード例 #16

ファイル: exercise_71.go プロジェクト: rangilin/go-tour-exercises

func main() {
	ch := make(chan int)

	// test Walk
	go Walk(tree.New(1), ch)
	for n := range ch {
		fmt.Print(n)
	}
	fmt.Println()

	// test Same
	fmt.Println(Same(tree.New(1), tree.New(1))) // should be true
	fmt.Println(Same(tree.New(1), tree.New(2))) // should be false
}

コード例 #17

ファイル: bintrees.go プロジェクト: mockturtl/get-going

func main() {
	rand.Seed(time.Now().UTC().UnixNano())
	t1, t2 := tree.New(1), tree.New(2)

	log.Println("t1: ", t1)
	//dump(t1)

	log.Println("t2: ", t2)
	//dump(t2)

	log.Println("t1 == t1? ", Same(t1, t1, 1))
	log.Println("t2 == t2? ", Same(t2, t2, 1))
	log.Println("t1 == t2? ", Same(t1, t2, 2))
}

コード例 #18

ファイル: 70.go プロジェクト: yuta-masano/a_tour_of_go

func main() {
	ch := make(chan int)
	t1 := tree.New(1)
	t2 := tree.New(2)

	// fmt.Println(PyutaWalk(t1))
	// foreachNode(t1)

	go Walk(t1, ch)
	for c := range ch {
		fmt.Println(c)
	}
	fmt.Printf("%v\n", Same(t1, t2))
}

コード例 #19

ファイル: tour71.go プロジェクト: roca/GO

func main() {

	t1 := tree.Tree{
		&tree.Tree{
			&tree.Tree{
				nil,
				1,
				nil,
			},
			1,
			&tree.Tree{
				nil,
				2,
				nil,
			},
		},
		3,
		&tree.Tree{
			&tree.Tree{
				nil,
				5,
				nil,
			},
			8,
			&tree.Tree{
				nil,
				13,
				nil,
			},
		},
	}
	t2 := tree.Tree{
		&tree.Tree{
			&tree.Tree{
				&tree.Tree{nil, 1, nil},
				1,
				&tree.Tree{nil, 2, nil},
			},
			3,
			&tree.Tree{nil, 5, nil},
		},
		8,
		&tree.Tree{nil, 13, nil},
	}

	fmt.Println("Are they the same ?", Same(&t1, &t2))
	fmt.Println("Are they the same ?", Same(tree.New(1), tree.New(1)))
	fmt.Println("Are they the same ?", Same(tree.New(1), tree.New(2)))
}

コード例 #20

ファイル: binarytrees.go プロジェクト: doublek420/go-tour

func main() {
	fmt.Print("tree.New(1) == tree.New(1): ")
	if Same(tree.New(1), tree.New(1)) {
		fmt.Println("PASSED")
	} else {
		fmt.Println("FAILED")
	}

	fmt.Print("tree.New(1) != tree.New(2): ")
	if !Same(tree.New(1), tree.New(2)) {
		fmt.Println("PASSED")
	} else {
		fmt.Println("FAILED")
	}
}

コード例 #21

ファイル: equiv-binary-tree.go プロジェクト: guanqun/gotour-answers

func main() {
	// test Walk()
	ch := make(chan int)
	go Walk(tree.New(1), ch)
	for i := 1; i <= 10; i++ {
		ii := <-ch
		if ii != i {
			fmt.Println("Walk Error, doesn't match!")
		}
	}

	// test Same()
	fmt.Println("Same(tree.New(1), tree.New(1)): ", Same(tree.New(1), tree.New(1)))
	fmt.Println("Same(tree.New(1), tree.New(2)): ", Same(tree.New(1), tree.New(2)))
}

コード例 #22

ファイル: main.go プロジェクト: kkdai/Golang

func main() {
	//tt := tree.New(1)
	//fmt.Println("out tree=", tt.String())
	ch := make(chan int)
	go Walk(tree.New(1), ch)
	for v := range ch {
		fmt.Println(v)
	}

	if Same(tree.New(1), tree.New(2)) {
		fmt.Println("is the sam")
	} else {
		fmt.Println("is not the same ")
	}

}

コード例 #23

ファイル: 72-binary-trees.go プロジェクト: kamilsmuga/golang-tour

func main() {
	ch := make(chan int)
	go Walk(tree.New(10), ch)
	for elem := range ch {
		fmt.Println(elem)
	}
}

コード例 #24

ファイル: 72_equivalent_binary_trees.go プロジェクト: hasIan/gotour-exercise-solutions

func main() {
	t1 := tree.New(1)
	t1prime := tree.New(1)
	t2 := tree.New(2)

	if Same(t1, t1prime) {
		fmt.Println("Success: 1-based trees are equal as expected")
	} else {
		fmt.Println("Error: 1-based trees are not equal, but should be")
	}

	if Same(t1, t2) {
		fmt.Println("Error: 1- and 2-based trees are equal, but shouldn't be")
	} else {
		fmt.Println("Success: 1- and 2-based trees are not equal")
	}
}

コード例 #25

ファイル: 67.go プロジェクト: bulkan/learning

func main() {
	// Walk test
	t1 := tree.New(1)

	ch := make(chan int)
	go Walk(t1, ch)

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

	// Same test
	t2 := tree.New(1)
	fmt.Println(Same(t1, t2))
	t3 := tree.New(2)
	fmt.Println(Same(t1, t3))
}

コード例 #26

ファイル: trees.go プロジェクト: pewniak747/go-tour

func main() {
	ch := make(chan int)
	go Walk(tree.New(1), ch)
	for i := 0; i < 10; i++ {
		v := <-ch
		fmt.Println(v)
	}
}

コード例 #27

ファイル: main.go プロジェクト: ptrv/go-tour-exercises

func main() {
	// test Walk()
	t := tree.New(1)
	ch := make(chan int)
	go Walk(t, ch)
	testWalk := true
	for i := 0; i < 10; i++ {
		if i+1 != <-ch {
			testWalk = false
			break
		}
	}
	fmt.Println("Test Walk() passed: ", testWalk)

	fmt.Println("Same(tree.New(1), tree.New(1))", Same(tree.New(1), tree.New(1)))
	fmt.Println("Same(tree.New(1), tree.New(2))", Same(tree.New(1), tree.New(2)))
}

コード例 #28

ファイル: equiv_bin_trees.go プロジェクト: rpeleg1970/golang-tour

func main() {
	// Test the Walk function
	ch := make(chan int)
	go Walk(tree.New(1), ch)
	v, ok := <-ch
	for ok {
		fmt.Printf("%d,", v)
		v, ok = <-ch
		if !ok {
			fmt.Printf("done...\n")
		}
	}

	// Test the Same function:
	fmt.Println(Same(tree.New(1), tree.New(1)))
	fmt.Println(Same(tree.New(1), tree.New(3)))
}

コード例 #29

ファイル: tour68.go プロジェクト: brettanomyces/ici

func main() {
	fmt.Println()
	ch := make(chan int)

	// the channel can not be closed in main so stick it in an anonomous func?
	// This does mean they start traversing straight away...
	go func() {
		Walk(tree.New(1), ch)
		close(ch)
	}()

	for v := range ch {
		fmt.Println(v)
	}

	fmt.Println(Same(tree.New(1), tree.New(1)))
	fmt.Println(Same(tree.New(1), tree.New(2)))

}

コード例 #30

ファイル: 70.go プロジェクト: pankona/tour_of_go_exercises

func main() {
	ch := make(chan int)
	go Walk(tree.New(1), ch)
	for v := range ch {
		fmt.Println(v)
	}

	if Same(tree.New(1), tree.New(1)) {
		fmt.Println("ok")
	} else {
		fmt.Println("ng")
	}

	if !Same(tree.New(1), tree.New(2)) {
		fmt.Println("ok")
	} else {
		fmt.Println("ng")
	}
}