completed 1189. maximum number of balloons in go, python and rust

Author: jgndev

go/maximumNumberOfBallons/README.md

@@ -0,0 +1,30 @@
+# 1189. Maximum Number of Balloons
+
+Given a string text, you want to use the characters of text to form as many instances of the word "balloon" as possible.
+
+You can use each character in text at most once. Return the maximum number of instances that can be formed.
+
+
+
+Example 1:
+
+Input: text = "nlaebolko"  
+Output: 1  
+
+
+Example 2:
+
+Input: text = "loonbalxballpoon"  
+Output: 2  
+
+
+Example 3:
+
+Input: text = "leetcode"  
+Output: 0  
+
+
+Constraints:
+
+1 <= text.length <= 104  
+text consists of lower case English letters only.  

go/maximumNumberOfBallons/go.mod

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

go/maximumNumberOfBallons/solution.go

@@ -0,0 +1,17 @@
+package solution
+
+func maxNumberOfBalloons(text string) int {
+	counts := make(map[rune]int)
+
+	for _, r := range text {
+		counts[r]++
+	}
+
+	count := counts['b']
+	count = min(count, counts['a'])
+	count = min(count, counts['n'])
+	count = min(count, counts['l']/2)
+	count = min(count, counts['o']/2)
+
+	return count
+}

go/maximumNumberOfBallons/solution_test.go

@@ -0,0 +1,37 @@
+package solution
+
+import "testing"
+
+func TestMaxNumberOfBalloons(t *testing.T) {
+	testCases := []struct {
+		name string
+		text string
+		want int
+	}{
+		{
+			name: "test case one",
+			text: "nlaebolko",
+			want: 1,
+		},
+		{
+			name: "test case two",
+			text: "loonbalxballpoon",
+			want: 2,
+		},
+		{
+			name: "test case three",
+			text: "leetcode",
+			want: 0,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := maxNumberOfBalloons(tc.text)
+
+			if got != tc.want {
+				t.Errorf("got %d, wanted %d", got, tc.want)
+			}
+		})
+	}
+}

py/maximum_number_of_balloons/solution.py

@@ -0,0 +1,14 @@
+class Solution:
+    def maxNumberOfBalloons(self, text: str) -> int:
+        counts = {}
+
+        for char in text:
+            counts[char] = counts.get(char, 0) + 1
+
+        count = counts.get('b', 0)
+        count = min(count, counts.get('a', 0))
+        count = min(count, counts.get('n', 0))
+        count = min(count, counts.get('l', 0) // 2)
+        count = min(count, counts.get('o', 0) // 2)
+
+        return count

py/maximum_number_of_balloons/solution_test.py

@@ -0,0 +1,23 @@
+import unittest
+from solution import Solution
+
+class TestMaxNumberOfBalloons(unittest.TestCase):
+    solution = Solution()
+
+    def test_case_one(self):
+        text = "nlaebolko"
+        expected = 1
+        result = self.solution.maxNumberOfBalloons(text)
+        self.assertEqual(result, expected)
+
+    def test_case_two(self):
+        text = "loonbalxballpoon"
+        expected = 2
+        result = self.solution.maxNumberOfBalloons(text)
+        self.assertEqual(result, expected)
+
+    def test_case_three(self):
+        text = "leetcode"
+        expected = 0
+        result = self.solution.maxNumberOfBalloons(text)
+        self.assertEqual(result, expected)

rs/max_number_of_balloons/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "max_number_of_balloons"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

rs/max_number_of_balloons/src/lib.rs

@@ -0,0 +1,50 @@
+use std::collections::HashMap;
+
+struct Solution {}
+
+impl Solution {
+    pub fn max_number_of_balloons(text: String) -> i32 {
+        let mut counts = HashMap::new();
+
+        for c in text.chars() {
+            *counts.entry(c).or_insert(0) += 1;
+        }
+
+        let mut count = *counts.get(&'b').unwrap_or(&0);
+        count = count.min(*counts.get(&'a').unwrap_or(&0));
+        count = count.min(*counts.get(&'n').unwrap_or(&0));
+        count = count.min(*counts.get(&'l').unwrap_or(&0) / 2);
+        count = count.min(*counts.get(&'o').unwrap_or(&0) / 2 );
+
+        count
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_case_one() {
+        let expected = 1;
+        let text = String::from("nlaebolko");
+        let result = Solution::max_number_of_balloons(text);
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_case_two() {
+        let expected = 2;
+        let text = String::from("loonbalxballpoon");
+        let result = Solution::max_number_of_balloons(text);
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_case_three() {
+        let expected = 0;
+        let text = String::from("leetcode");
+        let result = Solution::max_number_of_balloons(text);
+        assert_eq!(result, expected);
+    }
+}