forked from root/public
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
190 lines
3.4 KiB
190 lines
3.4 KiB
package correct |
|
|
|
import ( |
|
"reflect" |
|
"runtime" |
|
"strconv" |
|
"strings" |
|
|
|
"lib" |
|
) |
|
|
|
func FormatTree(root *TreeNode) string { |
|
if root == nil { |
|
return "" |
|
} |
|
res := root.Data + "\n" |
|
res += formatSubTree(root, "") |
|
return res |
|
} |
|
|
|
func formatSubTree(root *TreeNode, prefix string) string { |
|
if root == nil { |
|
return "" |
|
} |
|
|
|
var res string |
|
|
|
hasLeft := root.Left != nil |
|
hasRight := root.Right != nil |
|
|
|
if !hasLeft && !hasRight { |
|
return res |
|
} |
|
|
|
res += prefix |
|
if hasLeft && hasRight { |
|
res += "├── " |
|
} |
|
|
|
if !hasLeft && hasRight { |
|
res += "└── " |
|
} |
|
|
|
if hasRight { |
|
printStrand := (hasLeft && hasRight && (root.Right.Right != nil || root.Right.Left != nil)) |
|
newPrefix := prefix |
|
if printStrand { |
|
newPrefix += "│ " |
|
} else { |
|
newPrefix += " " |
|
} |
|
res += root.Right.Data + "\n" |
|
res += formatSubTree(root.Right, newPrefix) |
|
} |
|
|
|
if hasLeft { |
|
if hasRight { |
|
res += prefix |
|
} |
|
res += "└── " + root.Left.Data + "\n" |
|
res += formatSubTree(root.Left, prefix+" ") |
|
} |
|
return res |
|
} |
|
|
|
func ParentList(root *TreeNode) string { |
|
if root == nil { |
|
return "" |
|
} |
|
|
|
var parent string |
|
|
|
if root.Parent == nil { |
|
parent = "nil" |
|
} else { |
|
parent = root.Parent.Data |
|
} |
|
|
|
r := "Node: " + root.Data + " Parent: " + parent + "\n" |
|
r += ParentList(root.Left) + ParentList(root.Right) |
|
return r |
|
} |
|
|
|
func ChallengeTree( |
|
name string, |
|
fn1, fn2 interface{}, |
|
arg1 *TreeNode, arg2 interface{}, |
|
args ...interface{}, |
|
) { |
|
args1 := []interface{}{arg1} |
|
args2 := []interface{}{arg2} |
|
|
|
if args != nil { |
|
for _, v := range args { |
|
args1 = append(args1, v) |
|
args2 = append(args2, v) |
|
} |
|
} |
|
st1 := lib.Monitor(fn1, args1) |
|
st2 := lib.Monitor(fn2, args2) |
|
|
|
if st1.Stdout != st2.Stdout { |
|
lib.Fatalf("%s(\n%s)\n prints %s instead of %s\n", |
|
name, |
|
FormatTree(arg1), |
|
lib.Format(st2.Stdout), |
|
lib.Format(st1.Stdout), |
|
) |
|
} |
|
} |
|
|
|
func PrintList(n *NodeI) string { |
|
var res string |
|
it := n |
|
for it != nil { |
|
res += strconv.Itoa(it.Data) + "-> " |
|
it = it.Next |
|
} |
|
res += "<nil>" |
|
return res |
|
} |
|
|
|
func ListToString(n *NodeL) string { |
|
var res string |
|
it := n |
|
for it != nil { |
|
switch it.Data.(type) { |
|
case int: |
|
res += strconv.Itoa(it.Data.(int)) + "-> " |
|
case string: |
|
res += it.Data.(string) + "-> " |
|
} |
|
it = it.Next |
|
} |
|
res += "<nil>" |
|
return res |
|
} |
|
|
|
func ConvertIntToInterface(t []int) []interface{} { |
|
RandLen := lib.RandIntBetween(0, len(t)) |
|
s := make([]interface{}, RandLen) |
|
for j := 0; j < RandLen; j++ { |
|
for i := 0; i < lib.RandIntBetween(1, len(t)); i++ { |
|
s[j] = t[i] |
|
} |
|
} |
|
return s |
|
} |
|
|
|
func ConvertIntToStringface(t []string) []interface{} { |
|
RandLen := lib.RandIntBetween(0, len(t)) |
|
s := make([]interface{}, RandLen) |
|
for j := 0; j < RandLen; j++ { |
|
for i := 0; i < lib.RandIntBetween(1, len(t)); i++ { |
|
s[j] = t[i] |
|
} |
|
} |
|
return s |
|
} |
|
|
|
type NodeTest struct { |
|
Data []interface{} |
|
} |
|
|
|
func ElementsToTest(table []NodeTest) []NodeTest { |
|
table = append(table, |
|
NodeTest{ |
|
Data: []interface{}{}, |
|
}, |
|
) |
|
for i := 0; i < 3; i++ { |
|
val := NodeTest{ |
|
Data: ConvertIntToInterface(lib.MultRandInt()), |
|
} |
|
table = append(table, val) |
|
} |
|
for i := 0; i < 3; i++ { |
|
val := NodeTest{ |
|
Data: ConvertIntToStringface(lib.MultRandWords()), |
|
} |
|
table = append(table, val) |
|
} |
|
return table |
|
} |
|
|
|
// GetName gets the function name |
|
func GetName(f interface{}) string { |
|
pathFuncUsed := strings.Split(runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name(), "/") |
|
return pathFuncUsed[len(pathFuncUsed)-1] |
|
}
|
|
|