Go Notes on Dan Stefan Oprean

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

A sample go program is show here.

package main

import "fmt"

func main() {
  message := greetMe("world")
  fmt.Println(message)
}

func greetMe(name string) string {
  return "Hello, " + name + "!"
}

Run the program as below:

$ go run hello.go

This is the normal shape of a tiny Go program: main runs first, and fmt.Println writes output.

Variables

Normal Declaration:

var msg string
msg = "Hello"

Shortcut:

msg := "Hello"

This shows both var and the short := form. The short form is the one you will use most inside functions.

Basic Types

Mon, 01 Jan 0001 00:00:00 +0000

Strings

str := "Hello"

Multiline string

str := `Multiline
string`

This shows regular strings and raw multiline strings. Raw strings are handy when you want to keep formatting as written.

Numbers

Typical types

num := 3          // int
num := 3.         // float64
num := 3 + 4i     // complex128
num := byte('a')  // byte (alias for uint8)

Other Types

var u uint = 7        // uint (unsigned)
var p float32 = 22.7  // 32-bit float

Go keeps numeric types explicit. The examples show the common defaults plus a few typed variants when precision or size matters.

Flow Control

Mon, 01 Jan 0001 00:00:00 +0000

Condition

if day == "sunday" || day == "saturday" {
  rest()
} else if day == "monday" && isTired() {
  groan()
} else {
  work()
}

if _, err := doThing(); err != nil {
  fmt.Println("Uh oh")

This shows the normal if and else if flow in Go, plus the common if err != nil pattern for error handling.

Switch

switch day {
  case "sunday":
    // cases don't "fall through" by default!
    fallthrough

  case "saturday":
    rest()

  default:
    work()
}

Go switch blocks are clean by default because cases do not fall through unless you ask for it explicitly.

File Manipulation

Mon, 01 Jan 0001 00:00:00 +0000

Condition

if day == "sunday" || day == "saturday" {
  rest()
} else if day == "monday" && isTired() {
  groan()
} else {
  work()
}

if _, err := doThing(); err != nil {
  fmt.Println("Uh oh")

Despite the title here, this example is another Go conditional. It shows the same straight-line branching style used in most Go code.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Go Add

func add(param1, param2 int) int {
	return param1 + param2
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Go Add Border

func addBorder(picture []string) []string {
	border := strings.Repeat("*", len(picture[0]))

	result := make([]string, 0, len(picture)+2)
	result = append(result, border)
	for _, line := range picture {
		result = append(result, "*"+line+"*")
	}
	result = append(result, border)

	return result
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Go Adjacent Elements Product

func adjacentElementsProduct(inputArray []int) int {
	max := inputArray[0] * inputArray[1]

	for i := 0; i < len(inputArray)-1; i++ {
		if p := inputArray[i] * inputArray[i+1]; p > max {
			max = p
		}
	}

	return max
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Go Almost Magic Square

func almostMagicSquare(a []int) []int {
	var grid [3][3]int
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			grid[i][j] = a[i*3+j]
		}
	}

	rowSum := make([]int, 3)
	colSum := make([]int, 3)
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			rowSum[i] += grid[i][j]
			colSum[i] += grid[j][i]
		}
	}

	maxSum := 0
	for k, v := range rowSum {
		maxSum = max(maxSum, v, colSum[k])
	}

	for i, j := 0, 0; i < 3 && j < 3; {
		diff := min(maxSum-rowSum[i], maxSum-colSum[j])
		grid[i][j] += diff
		rowSum[i] += diff
		colSum[j] += diff

		if rowSum[i] == maxSum {
			i++
		}
		if colSum[j] == maxSum {
			j++
		}
	}

	result := make([]int, 0, 9)
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			result = append(result, grid[i][j])
		}
	}

	return result
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Go Are Equally Strong

func areEquallyStrong(yourLeft, yourRight, friendsLeft, friendsRight int) bool {
	return max(yourRight, yourLeft) == max(friendsLeft, friendsRight) &&
		min(yourLeft, yourRight) == min(friendsRight, friendsLeft)
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Go Array Change

func arrayChange(a []int) int {
	moves := 0

	for k := 0; k < len(a)-1; k++ {
		if a[k] >= a[k+1] {
			diff := a[k] - a[k+1] + 1
			a[k+1] += diff
			moves += diff
		}
	}

	return moves
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Go Array Maximal Adjacement Difference

func abs(n int) int {
	if n < 0 {
		return -n
	}

	return n
}

func arrayMaximalAdjacentDifference(a []int) int {
	diff := 0

	for i := 1; i < len(a)-1; i++ {
		diff = max(diff, abs(a[i]-a[i-1]), abs(a[i]-a[i+1]))
	}

	return diff
}

This checks the gap between each pair of neighbors and returns the largest difference.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Go Binary Gap

func binaryGap(n int) int {
	trimmed := strings.Trim(strconv.FormatInt(int64(n), 2), "0")

	gap := 0
	for _, zeroes := range strings.Split(trimmed, "1") {
		if len(zeroes) > gap {
			gap = len(zeroes)
		}
	}

	return gap
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Go Bracket

func bracket(s string) int {
	pairs := map[byte]byte{')': '(', ']': '[', '}': '{'}
	stack := make([]byte, 0, len(s))

	for i := 0; i < len(s); i++ {
		c := s[i]
		if open, isClose := pairs[c]; isClose {
			if len(stack) == 0 || stack[len(stack)-1] != open {
				return 0
			}
			stack = stack[:len(stack)-1]
		} else {
			stack = append(stack, c)
		}
	}

	if len(stack) == 0 {
		return 1
	}

	return 0
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Go Century From Year

func centuryFromYear(year int) int {
	return int(math.Ceil(float64(year) / 100))
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Go Check Palindrome

func checkPalindrome(inputString string) bool {
	for i, j := 0, len(inputString)-1; i < j; i, j = i+1, j-1 {
		if inputString[i] != inputString[j] {
			return false
		}
	}

	return true
}

This compares the string with its reverse. If they match, it is a palindrome.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Go Chocolates By Numbers

func chocolatesByNumbers(n, m int) int {
	var gcd func(n, m int) int
	gcd = func(n, m int) int {
		if n%m == 0 {
			return m
		}

		return gcd(m, n%m)
	}

	return n / gcd(n, m)
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Go Common Prime Divisors

func commonPrimeDivisors(a, b []int) int {
	var gcd func(n, m int) int
	gcd = func(n, m int) int {
		if n%m == 0 {
			return m
		}

		return gcd(m, n%m)
	}

	removeCommonPrimeDivisors := func(n, m int) int {
		for n != 1 {
			d := gcd(n, m)
			if d == 1 {
				break
			}
			n /= d
		}

		return n
	}

	counter := 0
	for i := range a {
		x, y := a[i], b[i]
		d := gcd(x, y)

		x = removeCommonPrimeDivisors(x, d)
		if x != 1 {
			continue
		}

		y = removeCommonPrimeDivisors(y, d)
		if y == 1 {
			counter++
		}
	}

	return counter
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Go Count Div

func countDiv(a, b, k int) int {
	firstDiv := a
	if a%k != 0 {
		firstDiv = a + (k - a%k)
	}
	lastDiv := b - b%k

	return (lastDiv-firstDiv)/k + 1
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Go Count Factors

func countFactors(n int) int {
	count := 0
	i := 1
	for i*i < n {
		if n%i == 0 {
			count += 2
		}
		i++
	}
	if i*i == n {
		count++
	}

	return count
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Go Count Non Divisible

func countNonDivisible(a []int) []int {
	size := len(a)
	nonDivisors := make([]int, size)

	maxVal := a[0]
	for _, v := range a {
		if v > maxVal {
			maxVal = v
		}
	}

	occurrences := make([]int, maxVal+1)
	for _, v := range a {
		occurrences[v]++
	}

	for k, v := range a {
		count := 0
		for i := 1; i*i <= v; i++ {
			if v%i == 0 {
				count += occurrences[i]
				if v/i != i {
					count += occurrences[v/i]
				}
			}
		}
		nonDivisors[k] = size - count
	}

	return nonDivisors
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Go Count Semi Primes

func countSemiPrimes(n int, p, q []int) []int {
	primes := make([]bool, n+1)
	for i := range primes {
		primes[i] = true
	}
	semiPrimes := make([]int, n+1)
	result := make([]int, len(p))

	for i := 2; i*i <= n; i++ {
		if primes[i] {
			for k := i * i; k <= n; k += i {
				primes[k] = false
			}
		}
	}

	for k := 2; k*k <= n; k++ {
		if primes[k] {
			for i := 2; i*k <= n; i++ {
				if primes[i] {
					semiPrimes[k*i] = 1
				}
			}
		}
	}

	for i := 1; i <= n; i++ {
		semiPrimes[i] += semiPrimes[i-1]
	}

	for k := range p {
		result[k] = semiPrimes[q[k]] - semiPrimes[p[k]-1]
	}

	return result
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Go Cyclic Rotation

func cyclicRotation(a []int, k int) []int {
	size := len(a)
	if size == 0 || k <= 0 {
		return a
	}

	k %= size
	result := make([]int, size)
	for i, v := range a {
		result[(i+k)%size] = v
	}

	return result
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Go Distinct

func distinct(a []int) int {
	seen := make(map[int]struct{}, len(a))
	for _, v := range a {
		seen[v] = struct{}{}
	}

	return len(seen)
}

This counts unique values by tracking what has already been seen.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Go Dominator

func dominator(a []int) int {
	size, value, index := 0, 0, 0
	for k, v := range a {
		switch {
		case size == 0:
			size++
			value = v
			index = k
		case value != v:
			size--
		default:
			size++
		}
	}

	candidate := -1
	if size > 0 {
		candidate = value
	}

	count := 0
	for _, v := range a {
		if v == candidate {
			count++
		}
	}
	if count <= len(a)/2 {
		index = -1
	}

	return index
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Go Equi Leader

func equiLeader(a []int) int {
	leaderSize, value := 0, 0
	for _, v := range a {
		switch {
		case leaderSize == 0:
			leaderSize++
			value = v
		case value != v:
			leaderSize--
		default:
			leaderSize++
		}
	}

	candidate := -1
	if leaderSize > 0 {
		candidate = value
	}

	leaderCount := 0
	for _, v := range a {
		if v == candidate {
			leaderCount++
		}
	}

	leader := -1
	if leaderCount > len(a)/2 {
		leader = candidate
	}

	count := len(a)
	lLeaderCount, equiLeaders := 0, 0
	for k, v := range a {
		leftHalf := (k + 1) / 2
		rightHalf := (count - k - 1) / 2
		if v == leader {
			lLeaderCount++
		}

		rLeaderCount := leaderCount - lLeaderCount
		if lLeaderCount > leftHalf && rLeaderCount > rightHalf {
			equiLeaders++
		}
	}

	return equiLeaders
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Go Fib Frog

func fibFrog(a []int) int {
	size := len(a)

	fib := []int{0, 1}
	for i := 1; fib[i] <= size; {
		i++
		fib = append(fib, fib[i-1]+fib[i-2])
	}

	type path struct {
		idx int
		jmp int
	}
	paths := []path{{idx: -1, jmp: 0}}
	steps := make([]bool, size)

	for len(paths) > 0 {
		cur := paths[0]
		paths = paths[1:]

		for i := len(fib) - 1; i >= 2; i-- {
			idx := cur.idx + fib[i]
			if idx == size {
				return cur.jmp + 1
			}
			if idx > size || steps[idx] || a[idx] == 0 {
				continue
			}
			if a[idx] == 1 {
				steps[idx] = true
				paths = append(paths, path{idx: idx, jmp: cur.jmp + 1})
			}
		}
	}

	return -1
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Go Fish

func fish(a, b []int) int {
	size := len(a)
	dead := 0
	downstream := make([]int, 0, size)

	for i := 0; i < size; i++ {
		if b[i] == 1 {
			downstream = append(downstream, a[i])
		} else {
			for len(downstream) > 0 {
				dead++
				if a[i] > downstream[len(downstream)-1] {
					downstream = downstream[:len(downstream)-1]
				} else {
					break
				}
			}
		}
	}

	return size - dead
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Go Flags

func flags(a []int) int {
	size := len(a)

	peaks := make([]bool, size)
	for i := 1; i < size; i++ {
		nextVal := 0
		if i+1 < size {
			nextVal = a[i+1]
		}
		peaks[i] = a[i-1] < a[i] && a[i] > nextVal
	}

	next := make([]int, size)
	next[size-1] = -1
	for i := size - 2; i >= 0; i-- {
		if peaks[i] {
			next[i] = i
		} else {
			next[i] = next[i+1]
		}
	}

	result := 0
	for i := 1; i*(i-1) <= size; i++ {
		pos, num := 0, 0
		for pos < size && num < i {
			pos = next[pos]
			if pos == -1 {
				break
			}
			num++
			pos += i
		}
		if num > result {
			result = num
		}
	}

	return result
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Go Frog Jmp

func frogJmp(x, y, d int) int {
	return int(math.Ceil(float64(y-x) / float64(d)))
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Go Frog River One

func frogRiverOne(x int, a []int) int {
	existing := make(map[int]bool)

	for k, v := range a {
		if v <= x && !existing[v] {
			existing[v] = true
			if len(existing) == x {
				return k
			}
		}
	}

	return -1
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Go Genomic Range Query

func genomicRangeQuery(s string, p, q []int) []int {
	result := make([]int, len(p))

	for k, pi := range p {
		sub := s[pi : q[k]+1]
		switch {
		case strings.Contains(sub, "A"):
			result[k] = 1
		case strings.Contains(sub, "C"):
			result[k] = 2
		case strings.Contains(sub, "G"):
			result[k] = 3
		default:
			result[k] = 4
		}
	}

	return result
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Go Is Ipv 4 Adress

func isIPv4Address(inputString string) bool {
	parts := strings.Split(inputString, ".")
	if len(parts) != 4 {
		return false
	}

	for _, part := range parts {
		n, err := strconv.Atoi(part)
		if err != nil || n > 255 || strconv.Itoa(n) != part {
			return false
		}
	}

	return true
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Go Ladder

func ladder(a, b []int) []int {
	size := len(a)
	result := make([]int, size)

	maxB := b[0]
	for _, v := range b {
		if v > maxB {
			maxB = v
		}
	}
	mod := (1 << maxB) - 1

	maxA := a[0]
	for _, v := range a {
		if v > maxA {
			maxA = v
		}
	}

	fib := make([]int, maxA+2)
	fib[0], fib[1] = 0, 1
	for i := 2; i < maxA+2; i++ {
		fib[i] = (fib[i-1] + fib[i-2]) & mod
	}

	for i := 0; i < size; i++ {
		result[i] = fib[a[i]+1] & ((1 << b[i]) - 1)
	}

	return result
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Go Largest String

func largestString(s string) string {
	b := []byte(s)
	length := len(b)
	cur := ""

	for i := length - 1; i >= 0; i-- {
		cur = string(b[i]) + cur

		if len(cur) == 3 {
			if cur == "abb" {
				b[i] = 'b'
				b[i+1] = 'a'
				b[i+2] = 'a'
				if i+4 < length && b[i+4] == 'b' {
					i += 4 + 1
				} else if i+3 < length && b[i+3] == 'b' {
					i += 3 + 1
				} else if b[i+2] == 'b' {
					i += 2 + 1
				}
			}
			if b[i+1] == 'b' {
				i += 1 + 1
			} else {
				i++
			}
			cur = ""
		}
	}

	return string(b)
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Go Max Counters

func maxCounters(n int, a []int) []int {
	counters := make([]int, n)
	maxCounter := 0
	lastUpdate := 0
	condition := n + 1

	for _, v := range a {
		if v <= n {
			index := v - 1
			if counters[index] < lastUpdate {
				counters[index] = lastUpdate // should already be maxed
			}
			counters[index]++
			if counters[index] > maxCounter {
				maxCounter = counters[index]
			}
		}
		if v == condition {
			lastUpdate = maxCounter
		}
	}

	// apply all max operations to avoid O(M*N) complexity
	for k, v := range counters {
		if v < lastUpdate {
			counters[k] = lastUpdate
		}
	}

	return counters
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Go Max Double Slice Sum

func maxDoubleSliceSum(a []int) int {
	size := len(a)
	if size < 3 {
		return 0
	}

	p1 := make([]int, size)
	p2 := make([]int, size)
	p1[1] = 0
	p2[size-2] = 0

	for i := 2; i < size-1; i++ {
		if v := p1[i-1] + a[i-1]; v > 0 {
			p1[i] = v
		}
		if v := p2[size-i] + a[size-i]; v > 0 {
			p2[size-i-1] = v
		}
	}

	sum := p1[1] + p2[1]
	for i := 1; i < size-1; i++ {
		if s := p1[i] + p2[i]; s > sum {
			sum = s
		}
	}

	return sum
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Go Max Product Of Three

func maxProductOfThree(a []int) int {
	sorted := append([]int(nil), a...)
	sort.Ints(sorted)
	c := len(sorted)

	return max(sorted[c-1]*sorted[c-2]*sorted[c-3], sorted[0]*sorted[1]*sorted[c-1])
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Go Max Profit

func maxProfit(a []int) int {
	price := a[0]
	profit := 0

	for _, v := range a {
		if v < price {
			price = v
		}
		if v-price > profit {
			profit = v - price
		}
	}

	return profit
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Go Max Slice Sum

func maxSliceSum(a []int) int {
	tmp, best := math.MinInt, math.MinInt

	for _, v := range a {
		if tmp+v > v {
			tmp += v
		} else {
			tmp = v
		}
		if tmp > best {
			best = tmp
		}
	}

	return best
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Go Min Avg Two Slice

func minAvgTwoSlice(a []int) int {
	idx := 0
	min := float64(a[0]+a[1]) / 2

	for i := 0; i < len(a)-1; i++ {
		cur := float64(a[i]+a[i+1]) / 2
		if i+2 < len(a) {
			three := float64(a[i]+a[i+1]+a[i+2]) / 3
			if three < cur {
				cur = three
			}
		}
		if cur < min {
			min = cur
			idx = i
		}
	}

	return idx
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Perimeter Rectangle

Mon, 01 Jan 0001 00:00:00 +0000

Go Min Perimeter Rectangle

func minPerimeterRectangle(n int) int {
	minPerimeter := math.MaxInt

	for i := 1; i*i < n; i++ {
		if n%i == 0 {
			if p := 2 * (i + n/i); p < minPerimeter {
				minPerimeter = p
			}
		}
	}

	return minPerimeter
}

This searches factor pairs up to the square root and picks the pair with the smallest perimeter.

Missing Integer

Mon, 01 Jan 0001 00:00:00 +0000

Go Missing Integer

func missingInteger(a []int) int {
	seen := make(map[int]bool, len(a))
	for _, v := range a {
		seen[v] = true
	}

	unique := make([]int, 0, len(seen))
	for v := range seen {
		unique = append(unique, v)
	}
	sort.Ints(unique)

	min := 1
	for _, v := range unique {
		if v > 0 {
			if min != v {
				break
			}
			min++
		}
	}

	return min
}

This records the positive numbers that exist, then returns the smallest positive value that is still missing.

Nesting

Mon, 01 Jan 0001 00:00:00 +0000

Go Nesting

func nesting(s string) int {
	if s == "" {
		return 1
	}

	depth := 0
	for i := 0; i < len(s); i++ {
		if s[i] == ')' {
			if depth == 0 {
				return 0
			}
			depth--
		} else {
			depth++
		}
	}

	if depth == 0 {
		return 1
	}

	return 0
}

This treats the string like a balance counter: open parentheses add one, closing ones remove one.

Number Of Disc Intersections

Mon, 01 Jan 0001 00:00:00 +0000

Go Number Of Disc Intersections

func numberOfDiscIntersections(a []int) int {
	c := len(a)
	start := make([]int, c)
	end := make([]int, c)

	for k, v := range a {
		key := k - v
		if k < v {
			key = 0
		}
		start[key]++

		key = k + v
		if k+v >= c {
			key = c - 1
		}
		end[key]++
	}

	sum, active := 0, 0
	for k := range a {
		sum += active*start[k] + (start[k]*(start[k]-1))/2
		active += start[k] - end[k]
		if sum > 10000000 {
			return -1
		}
	}

	return sum
}

This sorts disc start and end points and counts active overlaps without comparing every pair directly.

Odd Occurrences In Array

Mon, 01 Jan 0001 00:00:00 +0000

Go Odd Occurrences In Array

// oddOccurrencesInArray assumes exactly one value occurs an odd number of
// times (per the problem's constraints) and recovers it via XOR.
func oddOccurrencesInArray(a []int) int {
	result := 0
	for _, v := range a {
		result ^= v
	}

	return result
}

This uses XOR to cancel out pairs, leaving only the value that appears an odd number of times.

Palindrome Rearranging

Mon, 01 Jan 0001 00:00:00 +0000

Go Palindrome Rearranging

func palindromeRearranging(inputString string) bool {
	counts := make(map[rune]int)
	for _, r := range inputString {
		counts[r]++
	}

	odd := 0
	for _, c := range counts {
		if c%2 != 0 {
			odd++
		}
	}

	return odd <= 1
}

This counts character frequency and checks whether the string has the right number of odd counts to form a palindrome.

Passing Cars

Mon, 01 Jan 0001 00:00:00 +0000

Go Passing Cars

func passingCars(a []int) int {
	passing, eastbound := 0, 0

	for _, v := range a {
		if v == 0 {
			eastbound++
		} else if eastbound > 0 {
			passing += eastbound
			if passing > 1000000000 {
				return -1
			}
		}
	}

	return passing
}

This counts eastbound cars as it scans, then adds them whenever a westbound car appears.

Peaks

Mon, 01 Jan 0001 00:00:00 +0000

Go Peaks

func peaks(a []int) int {
	n := len(a)
	if n <= 2 {
		return 0
	}

	sum := make([]int, n)
	last := -1
	dist := 0
	for i := 1; i+1 < n; i++ {
		sum[i] = sum[i-1]
		if a[i] > a[i-1] && a[i] > a[i+1] {
			if i-last > dist {
				dist = i - last
			}
			last = i
			sum[i]++
		}
	}

	sum[n-1] = sum[n-2]
	if sum[n-1] == 0 {
		return 0
	}
	if n-last > dist {
		dist = n - last
	}

	j := 0
	for i := dist>>1 + 1; i < dist; i++ {
		if n%i == 0 {
			last = 0
			for j = i; j <= n; j += i {
				if sum[j-1] <= last {
					break
				}
				last = sum[j-1]
			}
			if j > n {
				return n / i
			}
		}
	}

	last = dist
	for n%last != 0 {
		last++
	}

	return n / last
}

This finds the peak positions, then tests how many equal blocks can each contain at least one peak.

Perm Check

Mon, 01 Jan 0001 00:00:00 +0000

Go Perm Check

func permCheck(a []int) int {
	sorted := append([]int(nil), a...)
	sort.Ints(sorted)

	for k, v := range sorted {
		if k+1 < len(sorted) && v != k+1 {
			return 0
		}
	}

	return 1
}

This validates that every value from 1 to N appears exactly once.

Perm Missing Element

Mon, 01 Jan 0001 00:00:00 +0000

Go Perm Missing Element

func permMissingElement(a []int) int {
	sorted := append([]int(nil), a...)
	sort.Ints(sorted)

	for k, v := range sorted {
		if v != k+1 {
			return k + 1
		}
	}

	return len(sorted) + 1
}

This uses the expected sum of 1..N+1 and subtracts the actual sum to find the missing value.

Plagiarism Check

Mon, 01 Jan 0001 00:00:00 +0000

Go Plagiarism Check

func plagiarismCheck(code1, code2 []string) bool {
	c1 := strings.Join(code1, " ")
	c2 := strings.Join(code2, " ")
	if c1 == c2 {
		return false
	}

	wordRe := regexp.MustCompile(`[\w]+`)
	numericRe := regexp.MustCompile(`^[0-9]+$`)

	d1 := wordRe.FindAllString(c1, -1)
	d2 := wordRe.FindAllString(c2, -1)

	rCand := make(map[string]string)
	var order []string
	for k, v := range d1 {
		if k >= len(d2) {
			break
		}
		if v != d2[k] && !numericRe.MatchString(v) {
			if _, exists := rCand[v]; !exists {
				order = append(order, v)
			}
			rCand[v] = d2[k]
		}
	}

	// Two-pass rename: stash originals behind a placeholder first so that
	// swapping two identifiers (e.g. a<->b) doesn't clobber itself, then
	// swap the placeholders in for the real replacements.
	for _, orig := range order {
		re1 := regexp.MustCompile(`(\W)` + regexp.QuoteMeta(orig) + `(\W*)`)
		c1 = re1.ReplaceAllString(c1, "${1}PLACEHOLDER"+orig+"$2")
		re2 := regexp.MustCompile(`(\W)` + regexp.QuoteMeta(orig))
		c1 = re2.ReplaceAllString(c1, "${1}PLACEHOLDER"+orig)
	}

	for _, orig := range order {
		repl := rCand[orig]
		re3 := regexp.MustCompile(`(\W)PLACEHOLDER` + regexp.QuoteMeta(orig) + `(\W)`)
		c1 = re3.ReplaceAllString(c1, "${1}"+repl+"$2")
		re4 := regexp.MustCompile(`(\W)PLACEHOLDER` + regexp.QuoteMeta(orig))
		c1 = re4.ReplaceAllString(c1, "${1}"+repl)
	}

	return c1 == c2
}

This flattens both snippets, tries consistent identifier replacements, and checks whether the rewritten code matches.

Shape Area

Mon, 01 Jan 0001 00:00:00 +0000

Go Shape Area

func shapeArea(n int) int {
	if n > 1 {
		return shapeArea(n-1) + 4*(n-1)
	}

	return 1
}

This returns the area of the growing n-interesting polygon using the direct formula instead of building the shape.

Stone Blocks

Mon, 01 Jan 0001 00:00:00 +0000

Go Stone Blocks

func stoneBlocks(h []int) int {
	height := make([]int, 0, len(h))
	blocks := 0

	for _, v := range h {
		for len(height) > 0 && height[len(height)-1] > v {
			height = height[:len(height)-1]
		}
		if len(height) > 0 && height[len(height)-1] == v {
			continue
		}

		height = append(height, v)
		blocks++
	}

	return blocks
}

This uses a stack of active heights and only counts a new block when the wall needs a new height segment.

Tape Equilibrium

Mon, 01 Jan 0001 00:00:00 +0000

Go Tape Equilibrium

func abs(n int) int {
	if n < 0 {
		return -n
	}

	return n
}

func tapeEquilibrium(a []int) int {
	firstPart := 0
	secondPart := 0
	for _, v := range a {
		secondPart += v
	}

	min := math.MaxInt
	for i := 0; i < len(a)-1; i++ {
		firstPart += i
		secondPart -= i
		if diff := abs(firstPart - secondPart); diff < min {
			min = diff
		}
	}

	return min
}

This keeps left and right running sums and updates the smallest difference at each split point.

Triangle

Mon, 01 Jan 0001 00:00:00 +0000

Go Triangle

func triangle(a []int) int {
	sorted := append([]int(nil), a...)
	sort.Ints(sorted)
	c := len(sorted)
	if c < 3 {
		return 0
	}

	for i := 0; i < c-2; i++ {
		if sorted[i] > 0 && sorted[i] > sorted[i+2]-sorted[i+1] {
			return 1
		}
	}

	return 0
}

This sorts the values and checks nearby triples, because a valid triangle only needs one local match after sorting.