Reorganise string

Author: volodimyr

767.reorganise_string/reorganise.go

@@ -0,0 +1,90 @@
+// 767. Reorganise string
+// Topics: 'Hash Table', 'String', 'Greedy', 'Sorting','Heap (Priority Queue)', 'Counting'
+// Level: 'Medium'
+
+// Given a string s, rearrange the characters of s so that any two adjacent characters are not the same.
+
+// Return any possible rearrangement of s or return "" if not possible.
+
+// Example 1:
+
+// Input: s = "aab"
+// Output: "aba"
+
+// Example 2:
+
+// Input: s = "aaab"
+// Output: ""
+
+// Constraints:
+
+//     1 <= s.length <= 500
+//     s consists of lowercase English letters.
+
+package reorganisestring
+
+import (
+	"container/heap"
+)
+
+func reorganizeString(s string) string {
+	m := map[byte]int{}
+	for i := range s {
+		m[s[i]]++
+	}
+	maxheap := maxheap{}
+	for k, v := range m {
+		heap.Push(&maxheap, symbol{times: v, b: k})
+	}
+
+	var res []byte
+	var prev *symbol
+	for maxheap.Len() > 0 {
+		pop := heap.Pop(&maxheap).(symbol)
+		res = append(res, pop.b)
+		pop.times--
+		if prev != nil && prev.times > 0 {
+			heap.Push(&maxheap, *prev)
+		}
+		if pop.times > 0 {
+			prev = &pop
+		} else {
+			prev = nil
+		}
+	}
+	if len(res) != len(s) {
+		return ""
+	}
+
+	return string(res)
+}
+
+type symbol struct {
+	times int
+	b     byte
+}
+
+type maxheap []symbol
+
+func (m maxheap) Len() int {
+	return len(m)
+}
+
+func (m maxheap) Swap(i, j int) {
+	m[i], m[j] = m[j], m[i]
+}
+
+func (m maxheap) Less(i, j int) bool {
+	return m[i].times > m[j].times
+}
+
+func (m *maxheap) Push(v interface{}) {
+	*m = append(*m, v.(symbol))
+}
+
+func (m *maxheap) Pop() interface{} {
+	old := *m
+	x := old[len(old)-1]
+	*m = old[:len(old)-1]
+	return x
+}

767.reorganise_string/reorganise_test.go

@@ -0,0 +1,164 @@
+package reorganisestring
+
+import "testing"
+
+func TestReorganizeString(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		valid bool
+	}{
+		{
+			name:  "custom",
+			input: "aaabc",
+			valid: true,
+		},
+		{
+			name:  "example 1 - aab",
+			input: "aab",
+			valid: true,
+		},
+		{
+			name:  "example 2 - aaab",
+			input: "aaab",
+			valid: false,
+		},
+		{
+			name:  "single character",
+			input: "a",
+			valid: true,
+		},
+		{
+			name:  "two same characters",
+			input: "aa",
+			valid: false,
+		},
+		{
+			name:  "two different characters",
+			input: "ab",
+			valid: true,
+		},
+		{
+			name:  "all different characters",
+			input: "abcde",
+			valid: true,
+		},
+		{
+			name:  "valid rearrangement possible",
+			input: "aaabbc",
+			valid: true,
+		},
+		{
+			name:  "longer valid string",
+			input: "aabbcc",
+			valid: true,
+		},
+		{
+			name:  "edge case - barely possible",
+			input: "aaab",
+			valid: false,
+		},
+		{
+			name:  "edge case - just possible",
+			input: "aabb",
+			valid: true,
+		},
+		{
+			name:  "multiple different frequencies",
+			input: "aaabbbbccd",
+			valid: true,
+		},
+		{
+			name:  "long string with valid distribution",
+			input: "aaaaabbbbbccccc",
+			valid: true,
+		},
+		{
+			name:  "impossible case - one char dominates",
+			input: "aaaaabbc",
+			valid: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := reorganizeString(tt.input)
+
+			if tt.valid {
+				if result == "" {
+					t.Errorf("Expected valid rearrangement but got empty string")
+					return
+				}
+
+				if len(result) != len(tt.input) {
+					t.Errorf("Result length %d doesn't match input length %d", len(result), len(tt.input))
+					return
+				}
+
+				charCount := make(map[byte]int)
+				for i := range tt.input {
+					charCount[tt.input[i]]++
+				}
+				for i := range result {
+					charCount[result[i]]--
+				}
+				for char, count := range charCount {
+					if count != 0 {
+						t.Errorf("Character %c count mismatch: %d", char, count)
+					}
+				}
+
+				for i := 0; i < len(result)-1; i++ {
+					if result[i] == result[i+1] {
+						t.Errorf("Found adjacent same characters at position %d: %c", i, result[i])
+					}
+				}
+			} else {
+				if result != "" {
+					t.Errorf("Expected empty string but got: %s", result)
+				}
+			}
+		})
+	}
+}
+
+func TestReorganizeStringCharacterFrequency(t *testing.T) {
+	input := "aabbcc"
+	result := reorganizeString(input)
+
+	if result == "" {
+		t.Fatal("Expected non-empty result")
+	}
+
+	freq := make(map[byte]int)
+	for i := range input {
+		freq[input[i]]++
+	}
+
+	for i := range result {
+		freq[result[i]]--
+	}
+
+	for char, count := range freq {
+		if count != 0 {
+			t.Errorf("Character frequency mismatch for %c: %d", char, count)
+		}
+	}
+}
+
+func TestReorganizeStringNoAdjacentDuplicates(t *testing.T) {
+	testCases := []string{"aab", "aabbcc", "aaabbbbccccc"}
+
+	for _, input := range testCases {
+		result := reorganizeString(input)
+		if result == "" {
+			continue
+		}
+
+		for i := 0; i < len(result)-1; i++ {
+			if result[i] == result[i+1] {
+				t.Errorf("Input %s: Found adjacent duplicates in result %s at position %d", input, result, i)
+			}
+		}
+	}
+}