hogwarts/courselist.go

@@ -2,39 +2,6 @@
 
 package hogwarts
 
-import (
-	"log"
-	"slices"
-)
-
-func singleCourseList(
-	course string, prereqs map[string][]string, list []string, traversed []string,
-) []string {
-	if slices.Contains(traversed, course) {
-		log.Panic("Recursive prereqs, aborting...")
-	}
-	traversed = append(traversed, course)
-	for _, prereqCourse := range prereqs[course] {
-		if !slices.Contains(list, prereqCourse) {
-			i := slices.Index(list, course)
-			if i == -1 {
-				list = append(list, prereqCourse)
-			} else {
-				list = slices.Insert(list, i, prereqCourse)
-			}
-		}
-		list = singleCourseList(prereqCourse, prereqs, list, traversed)
-	}
-	return list
-}
-
 func GetCourseList(prereqs map[string][]string) []string {
-	list := make([]string, 0)
-	for course := range prereqs {
-		if !slices.Contains(list, course) {
-			list = append(list, course)
-		}
-		list = singleCourseList(course, prereqs, list, []string{})
-	}
-	return list
+	return []string{}
 }

hotelbusiness/hotels.go

@@ -2,8 +2,6 @@
 
 package hotelbusiness
 
-import "math"
-
 type Guest struct {
 	CheckInDate  int
 	CheckOutDate int
@@ -15,30 +13,5 @@ type Load struct {
 }
 
 func ComputeLoad(guests []Guest) []Load {
-	if len(guests) == 0 {
-		return []Load{}
-	}
-	minDate, maxDate := math.MaxInt, math.MinInt
-	loadsNoEmptyDays := make(map[int]int)
-	for _, guest := range guests {
-		if guest.CheckInDate < minDate {
-			minDate = guest.CheckInDate
-		}
-		if guest.CheckOutDate > maxDate {
-			maxDate = guest.CheckOutDate
-		}
-		for i := guest.CheckInDate; i < guest.CheckOutDate; i++ {
-			loadsNoEmptyDays[i]++
-		}
-	}
-	loads, prevGuestCount := make([]Load, 0), 0
-	for i := minDate; i <= maxDate; i++ {
-		guestCount := loadsNoEmptyDays[i]
-		if prevGuestCount == guestCount {
-			continue
-		}
-		loads = append(loads, Load{i, guestCount})
-		prevGuestCount = guestCount
-	}
-	return loads
+	return []Load{}
 }

utf8/reverse/reverse.go

@@ -2,32 +2,6 @@
 
 package reverse
 
-import (
-	"strings"
-	"unicode/utf8"
-)
-
-// inplace []rune reverse with 2 allocations
-// first for runes slice and second for output
-// func Reverse(input string) string {
-// 	runes := []rune(input)
-// 	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
-// 		runes[i], runes[j] = runes[j], runes[i]
-// 	}
-// 	return string(runes)
-// }
-
-// string.Builder and utf8 decoding magic = 1 allocation
-// overall more iterations but each one is faster,
-// so its as fast as the inplace []rune reverse
 func Reverse(input string) string {
-	output := strings.Builder{}
-	output.Grow(len(input))
-	end := len(input)
-	for end > 0 {
-		r, n := utf8.DecodeLastRuneInString(input[:end])
-		end -= n
-		output.WriteRune(r)
-	}
-	return output.String()
+	return ""
 }

utf8/spacecollapse/collapse.go

@@ -2,44 +2,6 @@
 
 package spacecollapse
 
-import (
-	"strings"
-	"unicode"
-)
-
-// 1 alloc/op, best ns/op but more iterations overall
 func CollapseSpaces(input string) string {
-	output := strings.Builder{}
-	output.Grow(len(input))
-	writeSpace := true
-	for _, r := range input {
-		if unicode.IsSpace(r) {
-			if writeSpace {
-				output.WriteRune(' ')
-			}
-			writeSpace = false
-		} else {
-			output.WriteRune(r)
-			writeSpace = true
-		}
-	}
-	return output.String()
+	return ""
 }
-
-// 3 allocs/op for runes slice, output slice and output string
-// func CollapseSpaces(input string) string {
-// 	runes := []rune(input)
-// 	output, writeSpace := make([]rune, 0, len(runes)), true
-// 	for _, r := range input {
-// 		if unicode.IsSpace(r) {
-// 			if writeSpace {
-// 				output = append(output, ' ')
-// 			}
-// 			writeSpace = false
-// 		} else {
-// 			output = append(output, r)
-// 			writeSpace = true
-// 		}
-// 	}
-// 	return string(output)
-// }