Submited code

Author: Bigomby

README.md

@@ -0,0 +1,5 @@
+# Hashcode 2017
+
+This is the code developed for Google Hashcode 2017. The tag 1.0 is the code exactly as it was submited.
+
+The score was **1286849**.

cmd/main.go

@@ -1,13 +1,32 @@
 package main
 
 import (
+	"bytes"
 	"flag"
+	"fmt"
 	"os"
+	"sort"
 
 	log "github.com/Sirupsen/logrus"
 	"github.com/bigomby/hashcode2017/internal/input"
+	"github.com/bigomby/hashcode2017/internal/types"
 )
 
+// Videos is cool
+type Videos []*types.Video
+
+func (slice Videos) Len() int {
+	return len(slice)
+}
+
+func (slice Videos) Less(i, j int) bool {
+	return slice[i].Size < slice[j].Size
+}
+
+func (slice Videos) Swap(i, j int) {
+	slice[i], slice[j] = slice[j], slice[i]
+}
+
 func main() {
 	input.Logger = log.New()
 
@@ -29,5 +48,49 @@ func main() {
 		log.Fatal(err.Error())
 	}
 
-	input.ParseHeader(f)
+	// Sort videos
+	var videos Videos
+	endpoints, videos, servers, _ := input.ParseHeader(f)
+	sort.Sort(videos)
+
+	// Sort every endpoint
+	for _, endpoint := range endpoints {
+		var sortable types.Connections
+		sortable = endpoint.Connections
+		sort.Sort(sortable)
+	}
+
+	for _, video := range videos {
+	serverLoop:
+		for _, server := range servers {
+			if server.Capacity >= video.Size {
+				server.Videos = append(server.Videos, video)
+				server.Capacity -= video.Size
+				break serverLoop
+			}
+		}
+	}
+
+	// The output
+	var usedServersCount int
+	for _, server := range servers {
+		if len(server.Videos) > 0 {
+			usedServersCount++
+		}
+	}
+
+	output := new(bytes.Buffer)
+	fmt.Fprintf(output, "%d\n", usedServersCount)
+
+	for i, server := range servers {
+		fmt.Fprintf(output, "%d", i)
+		for _, video := range server.Videos {
+			fmt.Fprintf(output, " %d", video.ID)
+		}
+
+		fmt.Fprintf(output, "\n")
+	}
+
+	outfile, err := os.Create("output")
+	outfile.Write(output.Bytes())
 }

internal/input/input.go

@@ -16,7 +16,7 @@ import (
 var Logger *log.Logger
 
 // ParseHeader parses the fist line of the file
-func ParseHeader(input io.Reader) {
+func ParseHeader(input io.Reader) ([]types.Endpoint, []*types.Video, []*types.CacheServer, []types.RequestDescription) {
 	var videosCount int
 	var endpointsCount int
 	var requestsDescriptionsCount int
@@ -42,32 +42,52 @@ func ParseHeader(input io.Reader) {
 		&capacity,
 	)
 
+	serverTemplate := types.CacheServer{
+		Capacity: capacity,
+	}
+
+	var servers []*types.CacheServer
+	for i := 0; i < cacheServersCount; i++ {
+		serverTemplateCopy := serverTemplate
+		servers = append(servers, &serverTemplateCopy)
+	}
+
+	for _, server := range servers {
+		server = new(types.CacheServer)
+		server.Capacity = capacity
+	}
+
 	scanner.Scan()
 	videos := parseVideos(scanner.Text())
 	parseVideos(scanner.Text())
 
 	for i := 0; i < endpointsCount; i++ {
-		endpoints = append(endpoints, parseEndpoint(scanner))
+		endpoints = append(endpoints, parseEndpoint(scanner, servers))
 	}
 
 	for i := 0; i < requestsDescriptionsCount; i++ {
 		requests = append(requests, parseRequest(scanner, videos, endpoints))
 	}
+
+	return endpoints, videos, servers, requests
 }
 
-func parseVideos(line string) []types.Video {
-	var videos []types.Video
+func parseVideos(line string) []*types.Video {
+	var videos []*types.Video
 	sizes := strings.Split(line, " ")
 
-	for _, size := range sizes {
+	for i, size := range sizes {
 		sizeInt, _ := strconv.ParseInt(size, 10, 32)
-		videos = append(videos, types.Video{Size: int(sizeInt)})
+		videos = append(videos, &types.Video{
+			ID:   i,
+			Size: int(sizeInt),
+		})
 	}
 
 	return videos
 }
 
-func parseEndpoint(scanner *bufio.Scanner) types.Endpoint {
+func parseEndpoint(scanner *bufio.Scanner, servers []*types.CacheServer) types.Endpoint {
 	var connections int
 	var latency int
 
@@ -77,15 +97,17 @@ func parseEndpoint(scanner *bufio.Scanner) types.Endpoint {
 
 	endpoint := types.Endpoint{
 		Latency:     latency,
-		Connections: make([]types.Connection, connections),
+		Connections: make([]types.Connection, 0),
 	}
 
 	for i := 0; i < connections; i++ {
 		connection := types.Connection{}
+		var connectionID int
 
 		scanner.Scan()
 		attributes := scanner.Text()
-		fmt.Sscanf(attributes, "%d %d", &connection.ID, &connection.CacheLatency)
+		fmt.Sscanf(attributes, "%d %d", &connectionID, &connection.CacheLatency)
+		connection.Server = servers[connectionID]
 		endpoint.Connections = append(endpoint.Connections, connection)
 	}
 
@@ -94,7 +116,7 @@ func parseEndpoint(scanner *bufio.Scanner) types.Endpoint {
 
 func parseRequest(
 	scanner *bufio.Scanner,
-	videos []types.Video,
+	videos []*types.Video,
 	endpoints []types.Endpoint,
 ) types.RequestDescription {
 	var videoID int
@@ -104,11 +126,11 @@ func parseRequest(
 	scanner.Scan()
 	line := scanner.Text()
 	fmt.Sscanf(line, "%d %d %d", &videoID, &endpointID, &amount)
-	Logger.Debugf("[REQUEST] Amount: %d | Video: %d | Endpoint: %d", amount, videoID, endpointID)
+	// Logger.Debugf("[REQUEST] Amount: %d | Video: %d | Endpoint: %d", amount, videoID, endpointID)
 
 	return types.RequestDescription{
 		Amount: amount,
-		Video:  &videos[videoID],
+		Video:  videos[videoID],
 		Source: &endpoints[endpointID],
 	}
 }

internal/types/cache_server.go

@@ -3,4 +3,5 @@ package types
 // CacheServer is a server who caches. Really.
 type CacheServer struct {
 	Capacity int
+	Videos   []*Video
 }

internal/types/endpoint.go

@@ -1,5 +1,20 @@
 package types
 
+// Connections does stuff
+type Connections []Connection
+
+func (slice Connections) Len() int {
+	return len(slice)
+}
+
+func (slice Connections) Less(i, j int) bool {
+	return slice[i].CacheLatency < slice[j].CacheLatency
+}
+
+func (slice Connections) Swap(i, j int) {
+	slice[i], slice[j] = slice[j], slice[i]
+}
+
 // Endpoint represents a group of users connecting to the Internet in the same
 // geographical area (for example, a neighborhood in a city). Every endpoint is
 // connected to the data center. Additionally, each endpoint may (but doesn’t
@@ -11,13 +26,12 @@ package types
 // is connected to (how long it takes to serve a video stored in the given cache
 // server to a user in this endpoint).
 type Endpoint struct {
-	Servers     []*CacheServer
-	Latency     int
 	Connections []Connection
+	Latency     int
 }
 
 // Connection is a connection from an endpoint to a Cache Server
 type Connection struct {
-	ID           int
+	Server       *CacheServer
 	CacheLatency int
 }

internal/types/requests.go

@@ -1,5 +1,6 @@
 package types
 
+// RequestDescription hola manu
 type RequestDescription struct {
 	Amount int
 	Video  *Video

internal/types/video.go

@@ -2,5 +2,6 @@ package types
 
 // Video is just a video
 type Video struct {
+	ID   int
 	Size int
 }