How to use max method of diff Package

...60	switch {61	case opts.VerbosityLevel < 0:62		return 063	case opts.VerbosityLevel > 16:64		return 16 // some reasonable maximum to avoid shift overflow65	default:66		return uint(opts.VerbosityLevel)67	}68}69const maxVerbosityPreset = 670// verbosityPreset modifies the verbosity settings given an index71// between 0 and maxVerbosityPreset, inclusive.72func verbosityPreset(opts formatOptions, i int) formatOptions {73	opts.VerbosityLevel = int(opts.verbosity()) + 2*i74	if i > 0 {75		opts.AvoidStringer = true76	}77	if i >= maxVerbosityPreset {78		opts.PrintAddresses = true79		opts.QualifiedNames = true80	}81	return opts82}83// FormatDiff converts a valueNode tree into a textNode tree, where the later84// is a textual representation of the differences detected in the former.85func (opts formatOptions) FormatDiff(v *valueNode, ptrs *pointerReferences) (out textNode) {86	if opts.DiffMode == diffIdentical {87		opts = opts.WithVerbosity(1)88	} else if opts.verbosity() < 3 {89		opts = opts.WithVerbosity(3)90	}91	// Check whether we have specialized formatting for this node.92	// This is not necessary, but helpful for producing more readable outputs.93	if opts.CanFormatDiffSlice(v) {94		return opts.FormatDiffSlice(v)95	}96	var parentKind reflect.Kind97	if v.parent != nil && v.parent.TransformerName == "" {98		parentKind = v.parent.Type.Kind()99	}100	// For leaf nodes, format the value based on the reflect.Values alone.101	if v.MaxDepth == 0 {102		switch opts.DiffMode {103		case diffUnknown, diffIdentical:104			// Format Equal.105			if v.NumDiff == 0 {106				outx := opts.FormatValue(v.ValueX, parentKind, ptrs)107				outy := opts.FormatValue(v.ValueY, parentKind, ptrs)108				if v.NumIgnored > 0 && v.NumSame == 0 {109					return textEllipsis110				} else if outx.Len() < outy.Len() {111					return outx112				} else {113					return outy114				}115			}116			// Format unequal.117			assert(opts.DiffMode == diffUnknown)118			var list textList119			outx := opts.WithTypeMode(elideType).FormatValue(v.ValueX, parentKind, ptrs)120			outy := opts.WithTypeMode(elideType).FormatValue(v.ValueY, parentKind, ptrs)121			for i := 0; i <= maxVerbosityPreset && outx != nil && outy != nil && outx.Equal(outy); i++ {122				opts2 := verbosityPreset(opts, i).WithTypeMode(elideType)123				outx = opts2.FormatValue(v.ValueX, parentKind, ptrs)124				outy = opts2.FormatValue(v.ValueY, parentKind, ptrs)125			}126			if outx != nil {127				list = append(list, textRecord{Diff: '-', Value: outx})128			}129			if outy != nil {130				list = append(list, textRecord{Diff: '+', Value: outy})131			}132			return opts.WithTypeMode(emitType).FormatType(v.Type, list)133		case diffRemoved:134			return opts.FormatValue(v.ValueX, parentKind, ptrs)135		case diffInserted:136			return opts.FormatValue(v.ValueY, parentKind, ptrs)137		default:138			panic("invalid diff mode")139		}140	}141	// Register slice element to support cycle detection.142	if parentKind == reflect.Slice {143		ptrRefs := ptrs.PushPair(v.ValueX, v.ValueY, opts.DiffMode, true)144		defer ptrs.Pop()145		defer func() { out = wrapTrunkReferences(ptrRefs, out) }()146	}147	// Descend into the child value node.148	if v.TransformerName != "" {149		out := opts.WithTypeMode(emitType).FormatDiff(v.Value, ptrs)150		out = &textWrap{Prefix: "Inverse(" + v.TransformerName + ", ", Value: out, Suffix: ")"}151		return opts.FormatType(v.Type, out)152	} else {153		switch k := v.Type.Kind(); k {154		case reflect.Struct, reflect.Array, reflect.Slice:155			out = opts.formatDiffList(v.Records, k, ptrs)156			out = opts.FormatType(v.Type, out)157		case reflect.Map:158			// Register map to support cycle detection.159			ptrRefs := ptrs.PushPair(v.ValueX, v.ValueY, opts.DiffMode, false)160			defer ptrs.Pop()161			out = opts.formatDiffList(v.Records, k, ptrs)162			out = wrapTrunkReferences(ptrRefs, out)163			out = opts.FormatType(v.Type, out)164		case reflect.Ptr:165			// Register pointer to support cycle detection.166			ptrRefs := ptrs.PushPair(v.ValueX, v.ValueY, opts.DiffMode, false)167			defer ptrs.Pop()168			out = opts.FormatDiff(v.Value, ptrs)169			out = wrapTrunkReferences(ptrRefs, out)170			out = &textWrap{Prefix: "&", Value: out}171		case reflect.Interface:172			out = opts.WithTypeMode(emitType).FormatDiff(v.Value, ptrs)173		default:174			panic(fmt.Sprintf("%v cannot have children", k))175		}176		return out177	}178}179func (opts formatOptions) formatDiffList(recs []reportRecord, k reflect.Kind, ptrs *pointerReferences) textNode {180	// Derive record name based on the data structure kind.181	var name string182	var formatKey func(reflect.Value) string183	switch k {184	case reflect.Struct:185		name = "field"186		opts = opts.WithTypeMode(autoType)187		formatKey = func(v reflect.Value) string { return v.String() }188	case reflect.Slice, reflect.Array:189		name = "element"190		opts = opts.WithTypeMode(elideType)191		formatKey = func(reflect.Value) string { return "" }192	case reflect.Map:193		name = "entry"194		opts = opts.WithTypeMode(elideType)195		formatKey = func(v reflect.Value) string { return formatMapKey(v, false, ptrs) }196	}197	maxLen := -1198	if opts.LimitVerbosity {199		if opts.DiffMode == diffIdentical {200			maxLen = ((1 << opts.verbosity()) >> 1) << 2 // 0, 4, 8, 16, 32, etc...201		} else {202			maxLen = (1 << opts.verbosity()) << 1 // 2, 4, 8, 16, 32, 64, etc...203		}204		opts.VerbosityLevel--205	}206	// Handle unification.207	switch opts.DiffMode {208	case diffIdentical, diffRemoved, diffInserted:209		var list textList210		var deferredEllipsis bool // Add final "..." to indicate records were dropped211		for _, r := range recs {212			if len(list) == maxLen {213				deferredEllipsis = true214				break215			}216			// Elide struct fields that are zero value.217			if k == reflect.Struct {218				var isZero bool219				switch opts.DiffMode {220				case diffIdentical:221					isZero = value.IsZero(r.Value.ValueX) || value.IsZero(r.Value.ValueY)222				case diffRemoved:223					isZero = value.IsZero(r.Value.ValueX)224				case diffInserted:225					isZero = value.IsZero(r.Value.ValueY)226				}227				if isZero {228					continue229				}230			}231			// Elide ignored nodes.232			if r.Value.NumIgnored > 0 && r.Value.NumSame+r.Value.NumDiff == 0 {233				deferredEllipsis = !(k == reflect.Slice || k == reflect.Array)234				if !deferredEllipsis {235					list.AppendEllipsis(diffStats{})236				}237				continue238			}239			if out := opts.FormatDiff(r.Value, ptrs); out != nil {240				list = append(list, textRecord{Key: formatKey(r.Key), Value: out})241			}242		}243		if deferredEllipsis {244			list.AppendEllipsis(diffStats{})245		}246		return &textWrap{Prefix: "{", Value: list, Suffix: "}"}247	case diffUnknown:248	default:249		panic("invalid diff mode")250	}251	// Handle differencing.252	var numDiffs int253	var list textList254	var keys []reflect.Value // invariant: len(list) == len(keys)255	groups := coalesceAdjacentRecords(name, recs)256	maxGroup := diffStats{Name: name}257	for i, ds := range groups {258		if maxLen >= 0 && numDiffs >= maxLen {259			maxGroup = maxGroup.Append(ds)260			continue261		}262		// Handle equal records.263		if ds.NumDiff() == 0 {264			// Compute the number of leading and trailing records to print.265			var numLo, numHi int266			numEqual := ds.NumIgnored + ds.NumIdentical267			for numLo < numContextRecords && numLo+numHi < numEqual && i != 0 {268				if r := recs[numLo].Value; r.NumIgnored > 0 && r.NumSame+r.NumDiff == 0 {269					break270				}271				numLo++272			}273			for numHi < numContextRecords && numLo+numHi < numEqual && i != len(groups)-1 {274				if r := recs[numEqual-numHi-1].Value; r.NumIgnored > 0 && r.NumSame+r.NumDiff == 0 {275					break276				}277				numHi++278			}279			if numEqual-(numLo+numHi) == 1 && ds.NumIgnored == 0 {280				numHi++ // Avoid pointless coalescing of a single equal record281			}282			// Format the equal values.283			for _, r := range recs[:numLo] {284				out := opts.WithDiffMode(diffIdentical).FormatDiff(r.Value, ptrs)285				list = append(list, textRecord{Key: formatKey(r.Key), Value: out})286				keys = append(keys, r.Key)287			}288			if numEqual > numLo+numHi {289				ds.NumIdentical -= numLo + numHi290				list.AppendEllipsis(ds)291				for len(keys) < len(list) {292					keys = append(keys, reflect.Value{})293				}294			}295			for _, r := range recs[numEqual-numHi : numEqual] {296				out := opts.WithDiffMode(diffIdentical).FormatDiff(r.Value, ptrs)297				list = append(list, textRecord{Key: formatKey(r.Key), Value: out})298				keys = append(keys, r.Key)299			}300			recs = recs[numEqual:]301			continue302		}303		// Handle unequal records.304		for _, r := range recs[:ds.NumDiff()] {305			switch {306			case opts.CanFormatDiffSlice(r.Value):307				out := opts.FormatDiffSlice(r.Value)308				list = append(list, textRecord{Key: formatKey(r.Key), Value: out})309				keys = append(keys, r.Key)310			case r.Value.NumChildren == r.Value.MaxDepth:311				outx := opts.WithDiffMode(diffRemoved).FormatDiff(r.Value, ptrs)312				outy := opts.WithDiffMode(diffInserted).FormatDiff(r.Value, ptrs)313				for i := 0; i <= maxVerbosityPreset && outx != nil && outy != nil && outx.Equal(outy); i++ {314					opts2 := verbosityPreset(opts, i)315					outx = opts2.WithDiffMode(diffRemoved).FormatDiff(r.Value, ptrs)316					outy = opts2.WithDiffMode(diffInserted).FormatDiff(r.Value, ptrs)317				}318				if outx != nil {319					list = append(list, textRecord{Diff: diffRemoved, Key: formatKey(r.Key), Value: outx})320					keys = append(keys, r.Key)321				}322				if outy != nil {323					list = append(list, textRecord{Diff: diffInserted, Key: formatKey(r.Key), Value: outy})324					keys = append(keys, r.Key)325				}326			default:327				out := opts.FormatDiff(r.Value, ptrs)328				list = append(list, textRecord{Key: formatKey(r.Key), Value: out})329				keys = append(keys, r.Key)330			}331		}332		recs = recs[ds.NumDiff():]333		numDiffs += ds.NumDiff()334	}335	if maxGroup.IsZero() {336		assert(len(recs) == 0)337	} else {338		list.AppendEllipsis(maxGroup)339		for len(keys) < len(list) {340			keys = append(keys, reflect.Value{})341		}342	}343	assert(len(list) == len(keys))344	// For maps, the default formatting logic uses fmt.Stringer which may345	// produce ambiguous output. Avoid calling String to disambiguate.346	if k == reflect.Map {347		var ambiguous bool348		seenKeys := map[string]reflect.Value{}349		for i, currKey := range keys {350			if currKey.IsValid() {351				strKey := list[i].Key352				prevKey, seen := seenKeys[strKey]...

...7 *     Left *TreeNode8 *     Right *TreeNode9 * }10 */11func maxAncestorDiff(root *TreeNode) int {12	_, _, ans := maxAncestorDiffHelper(root)13	return ans14}15func maxAncestorDiffHelper(node *TreeNode) (minVal, maxVal, maxDiff int) {16	if node == nil {17		minVal = 1e5 + 1018		maxVal = -119		maxDiff = 020		return21	}22	lMinVal, lMaxVal, lMaxDiff := maxAncestorDiffHelper(node.Left)23	rMinVal, rMaxVal, rMaxDiff := maxAncestorDiffHelper(node.Right)24	minVal = minInt(lMinVal, rMinVal)25	maxVal = maxInt(lMaxVal, rMaxVal)26	if minVal == 1e5+10 {27		// current node is a leaf28		minVal = node.Val29		maxVal = node.Val30		maxDiff = 031		return32	} else {33		maxDiff = maxInt(lMaxDiff, rMaxDiff)34		maxDiff = maxInt(maxDiff, int(math.Abs(float64(node.Val-minVal))))35		maxDiff = maxInt(maxDiff, int(math.Abs(float64(maxVal-node.Val))))36		minVal = minInt(minVal, node.Val)37		maxVal = maxInt(maxVal, node.Val)38		return39	}40}...

1import (2func main() {3	fmt.Println(test.Max(1, 2))4}5func Max(a, b int) int {6	if a > b {7	}8}9You can also import a package with a different name. For example, if you want to import the test package with the name t, you can do the following:10import t "test"11import (12func main() {13	fmt.Println(m.Max(1, 2))14}15func Max(a, b int) int {16	if a > b {17	}18}19func Max(a, b int) int {20	if a > b {21	}22}

1import "fmt"2import "math"3func main() {4  fmt.Println(math.Max(2, 3))5}6import "fmt"7import "math"8func main() {9  fmt.Println(math.Max(2, 3))10}11import "fmt"12import "math"13func main() {14  fmt.Println(math.Max(2, 3))15}16import "fmt"17import "math"18func main() {19  fmt.Println(math.Max(2, 3))20}21import "fmt"22import "math"23func main() {24  fmt.Println(math.Max(2, 3))25}26import "fmt"27import "math"28func main() {29  fmt.Println(math.Max(2, 3))30}31import "fmt"32import "math"33func main() {34  fmt.Println(math.Max(2, 3))35}36import "fmt"37import "math"38func main() {39  fmt.Println(math.Max(2, 3))40}41import "fmt"42import "math"43func main() {44  fmt.Println(math.Max(2, 3))45}46import "fmt"47import "math"48func main() {49  fmt.Println(math.Max(2, 3))50}51import "fmt"52import "math"53func main() {54  fmt.Println(math.Max(2, 3))55}56import "fmt"57import "math"58func main()

1import "fmt"2import "math"3func main() {4fmt.Println(math.Max(5, 10))5}6import "fmt"7import "math"8func main() {9fmt.Println(math.Max(10, 5))10}11import "fmt"12import "math"13func main() {14fmt.Println(math.Max(5, 10))15}16import "fmt"17import "math"18func main() {19fmt.Println(math.Max(10, 5))20}21import "fmt"22import "math"23func main() {24fmt.Println(math.Max(5, 10))25}26import "fmt"27import "math"28func main() {29fmt.Println(math.Max(10, 5))30}31import "fmt"32import "math"33func main() {34fmt.Println(math.Max(5, 10))35}36import "fmt"37import "math"38func main() {39fmt.Println(math.Max(10, 5))40}41import "fmt"42import "math"43func main() {44fmt.Println(math.Max(5, 10))45}46import "fmt"47import "math"48func main() {49fmt.Println(math.Max(10, 5))50}51import "fmt"52import "math"53func main() {54fmt.Println(math.Max(5, 10))55}56import "fmt"57import "math"58func main() {59fmt.Println(math.Max(10, 5))

1import (2func main() {3	fmt.Println("Max(1,2)=", max.Max(1, 2))4}5func Max(a, b int) int {6	if a > b {7	}8}9import (10func TestMaxBasic(t *testing.T) {11	if Max(1, 2) != 2 {12		t.Error("Max(1,2) failed. Got 1, expected 2")13	}14}15func TestMaxTable(t *testing.T) {16	var tests = []struct {17	}{18		{1, 2, 2},19		{2, 1, 2},20		{2, 2, 2},21		{-1, 2, 2},22		{-1, -2, -1},23		{0, 0, 0},24	}25	for _, e := range tests {26		g := Max(e.a, e.b)27		if g != e.n {28			t.Errorf("Max(%d,%d) failed. Got %d, expected %d", e.a, e.b, g, e.n)29		}30	}31}32import "testing"33func BenchmarkMax(b *testing.B) {34	for i := 0; i < b.N; i++ {35		Max(1, 2)36	}37}38import (39func ExampleMax() {40	fmt.Println(max.Max(1, 2))41}42import (43func ExampleMax() {44	fmt.Println(max.Max(1, 2))45}46import (47func ExampleMax() {48	fmt.Println(max.Max(1, 2))49}50import (

1import (2func main() {3    fmt.Println(math.Max(1, 2))4}5import (6func main() {7    fmt.Println(m.Max(1, 2))8}9import (10func main() {11    fmt.Println(math.Max(1, 2))12}13import (14func main() {15    fmt.Println(math.Max(1, 2))16}17import (18func main() {19    fmt.Println(math.Max(1, 2))20}21import (22func main() {23    fmt.Println(math.Max(1, 2))24}25import (26func main() {

1import (2func main() {3	fmt.Println("Hello, playground")4	fmt.Println("Max is ", diff.Max(2, 3))5}6func Max(a, b int) int {7	if a > b {8	}9}

1import "fmt"2import "github.com/udaygandhi/myfirstgo/uday"3func main() {4    fmt.Println("Max value is ",uday.Max(10,20))5}6import "fmt"7import "github.com/udaygandhi/myfirstgo/uday"8func main() {9    fmt.Println("Max value is ",uday.Max(10,20))10    fmt.Println("Min value is ",uday.Min(10,20))11}12import "fmt"13import "github.com/udaygandhi/myfirstgo/uday"14func main() {15    fmt.Println("Max value is ",uday.Max(10,20))16    fmt.Println("Min value is ",uday.Min(10,20))17    fmt.Println("Add value is ",uday.Add(10,20))18}19import "fmt"20import "github.com/udaygandhi/myfirstgo/uday"21func main() {22    fmt.Println("Max value is ",uday.Max(10,20))23    fmt.Println("Min value is ",uday.Min(10,20))24    fmt.Println("Add value is ",uday.Add(10,20))25}26import "fmt"27import "github.com/udaygandhi/myfirstgo/uday"28func main() {29    fmt.Println("Max value is ",uday.Max(10,20))30    fmt.Println("Min value is ",uday.Min(10,20))31    fmt.Println("Add value is ",uday.Add(10,20))32    fmt.Println("Sub value is ",uday.Sub(10,20))33}34import "fmt"35import "github.com/udayg