Solve '139 Word Break'

Author: obalunenko

two-sum/spec.md renamed to 1-two-sum/spec.md

@@ -0,0 +1,34 @@
+# 139. Word Break
+
+<https://leetcode.com/problems/word-break/>
+
+Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words.
+
+Note:
+
+* The same word in the dictionary may be reused multiple times in the segmentation.
+* You may assume the dictionary does not contain duplicate words.
+
+Example 1:
+
+```text
+Input: s = "leetcode", wordDict = ["leet", "code"]
+Output: true
+Explanation: Return true because "leetcode" can be segmented as "leet code".
+```
+
+Example 2:
+
+```text
+Input: s = "applepenapple", wordDict = ["apple", "pen"]
+Output: true
+Explanation: Return true because "applepenapple" can be segmented as "apple pen apple".
+             Note that you are allowed to reuse a dictionary word.
+```
+
+Example 3:
+
+```text
+Input: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
+Output: false
+```

two-sum/sum.go renamed to 1-two-sum/sum.go

@@ -0,0 +1,32 @@
+package wordbreak
+
+func wordBreak(s string, wordDict []string) bool {
+	if s == "" || len(wordDict) == 0 {
+		return false
+	}
+
+	dict := make(map[string]bool, len(wordDict))
+
+	for _, w := range wordDict {
+		dict[w] = true
+	}
+
+	l := len(s)
+	// remember indexes of next after breaks
+	list := make(map[int]bool, l+1)
+	list[0] = true
+
+	for i := 1; i <= l; i++ {
+		for j := 0; j < i; j++ {
+			cur := s[j:i]
+
+			if dict[cur] && list[j] {
+				list[i] = true
+
+				break
+			}
+		}
+	}
+
+	return list[l]
+}

two-sum/sum_test.go renamed to 1-two-sum/sum_test.go

@@ -0,0 +1,84 @@
+package wordbreak
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_wordBreak(t *testing.T) {
+	type args struct {
+		s        string
+		wordDict []string
+	}
+
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: `Return true because "leetcode" can be segmented as "leet code".`,
+			args: args{
+				s:        "leetcode",
+				wordDict: []string{"leet", "code"},
+			},
+			want: true,
+		},
+		{
+			name: `Return true because "applepenapple" can be segmented as "apple pen apple".`,
+			args: args{
+				s:        "applepenapple",
+				wordDict: []string{"apple", "pen"},
+			},
+			want: true,
+		},
+		{
+			name: `Return false cause could not segment`,
+			args: args{
+				s:        "catsandog",
+				wordDict: []string{"cats", "dog", "sand", "and", "cat"},
+			},
+			want: false,
+		},
+		{
+			name: `Return true cause could be segmented, the same letter`,
+			args: args{
+				s:        "aaaaaaa",
+				wordDict: []string{"aaaa", "aaa"},
+			},
+			want: true,
+		},
+		{
+			name: `Return false for empty word`,
+			args: args{
+				s:        "",
+				wordDict: []string{"aaaa", "aaa"},
+			},
+			want: false,
+		},
+		{
+			name: `Return false for empty dict`,
+			args: args{
+				s:        "aasad s",
+				wordDict: nil,
+			},
+			want: false,
+		},
+		{
+			name: `Return true for repeated`,
+			args: args{
+				s:        "goalspecial",
+				wordDict: []string{"go", "goal", "goals", "special"},
+			},
+			want: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := wordBreak(tt.args.s, tt.args.wordDict)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

139-word-break/spec.md

@@ -8,7 +8,8 @@ at which the corresponding bits are different.
 Given two integers x and y, calculate the Hamming distance.
 
 Note:
-`0 ≤ x, y < 231.`
+
+* `0 ≤ x, y < 231.`
 
 Example:
 
@@ -23,5 +24,4 @@ Explanation:
        ↑   ↑
 ```
 
-
 The above arrows point to positions where the corresponding bits are different.

139-word-break/word.go

@@ -11,7 +11,7 @@ For convenience, the full table for the 26 letters of the English alphabet is gi
 [".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
 ```
 
-Now, given a list of words, each word can be written as a concatenation of the Morse code of each letter. 
+Now, given a list of words, each word can be written as a concatenation of the Morse code of each letter.
 For example, `"cab"` can be written as `"-.-.-....-"`, (which is the concatenation `"-.-." + "-..." + ".-"`).
 We'll call such a concatenation, the transformation of a word.