completed 2225 - find players with zero or one losses in Go

Author: jgndev

go/findPlayersithZeroOrOneLosses/README.md

@@ -0,0 +1,44 @@
+# 2225. Find Players with Zero or One Losses
+
+You are given an integer array matches where matches[i] = [winneri, loseri] indicates that the player winneri defeated player loseri in a match.
+
+Return a list answer of size 2 where:
+
+answer[0] is a list of all players that have not lost any matches.
+answer[1] is a list of all players that have lost exactly one match.
+The values in the two lists should be returned in increasing order.
+
+Note:
+
+You should only consider the players that have played at least one match.
+The testcases will be generated such that no two matches will have the same outcome.
+ 
+
+Example 1:
+
+Input: matches = [[1,3],[2,3],[3,6],[5,6],[5,7],[4,5],[4,8],[4,9],[10,4],[10,9]]  
+Output: [[1,2,10],[4,5,7,8]]  
+Explanation:  
+Players 1, 2, and 10 have not lost any matches.  
+Players 4, 5, 7, and 8 each have lost one match.  
+Players 3, 6, and 9 each have lost two matches.  
+Thus, answer[0] = [1,2,10] and answer[1] = [4,5,7,8].  
+
+
+Example 2:
+
+Input: matches = [[2,3],[1,3],[5,4],[6,4]]  
+Output: [[1,2,5,6],[]]  
+Explanation:  
+Players 1, 2, 5, and 6 have not lost any matches.  
+Players 3 and 4 each have lost two matches.  
+Thus, answer[0] = [1,2,5,6] and answer[1] = [].  
+ 
+
+Constraints:
+
+1 <= matches.length <= 105   
+matches[i].length == 2  
+1 <= winneri, loseri <= 105   
+w inneri != loseri  
+All matches[i] are unique.  

go/findPlayersithZeroOrOneLosses/go.mod

@@ -0,0 +1,3 @@
+module findPlayersWithZeroOrOneLosses
+
+go 1.23.2

go/findPlayersithZeroOrOneLosses/solutio_test.go

@@ -0,0 +1,41 @@
+package solution
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestWinnders(t *testing.T) {
+	t.Run("test case one", func(t *testing.T) {
+		matches := [][]int{{1, 3}, {2, 3}, {3, 6}, {5, 6}, {5, 7}, {4, 5}, {4, 8}, {4, 9}, {10, 4}, {10, 9}}
+		wanted := [][]int{{1, 2, 10}, {4, 5, 7, 8}}
+
+		result := findWinners(matches)
+
+		if !reflect.DeepEqual(result, wanted) {
+			t.Errorf("got %v, wanted %v", result, wanted)
+		}
+	})
+
+	t.Run("test case two", func(t *testing.T) {
+		matches := [][]int{{1, 2}, {1, 3}, {2, 3}, {2, 4}}
+		wanted := [][]int{{1}, {2, 4}}
+
+		result := findWinners(matches)
+
+		if !reflect.DeepEqual(result, wanted) {
+			t.Errorf("got %v, wanted %v", result, wanted)
+		}
+	})
+
+	t.Run("test case three", func(t *testing.T) {
+		matches := [][]int{{1, 2}, {2, 1}, {1, 2}, {2, 1}}
+		wanted := [][]int{{}, {}}
+
+		result := findWinners(matches)
+
+		if !reflect.DeepEqual(result, wanted) {
+			t.Errorf("got %v, wanted %v", result, wanted)
+		}
+	})
+}

go/findPlayersithZeroOrOneLosses/solution.go

@@ -0,0 +1,43 @@
+package solution
+
+import "slices"
+
+func findWinners(matches [][]int) [][]int {
+	losses := make(map[int]int)
+
+	// iterate over each match in matches
+	for _, match := range matches {
+		// take the first element as winner, second as loser
+		winner, loser := match[0], match[1]
+
+		// check if the winner is already in the losses map
+		if _, ok := losses[winner]; !ok {
+			// first time seeing this winner
+			losses[winner] = 0
+		}
+
+		// increment the loss count for the loser
+		losses[loser]++
+	}
+
+	// slice for winners with no losses
+	noLoss := make([]int, 0)
+	// slice for winners with one loss
+	oneLoss := make([]int, 0)
+
+	// categorize players based on their losses
+	for player, lossCount := range losses {
+		if lossCount == 0 {
+			noLoss = append(noLoss, player)
+		} else if lossCount == 1 {
+			oneLoss = append(oneLoss, player)
+		}
+	}
+
+	// sort both slices
+	slices.Sort(noLoss)
+	slices.Sort(oneLoss)
+
+	// return the result as a 2D slice
+	return [][]int{noLoss, oneLoss}
+}