Merge pull request #210 from 0xff-dev/master

Add solution and test-cases for problem 729

Author: Cori1109

leetcode/101-200/0155.Min-Stack/Solution.go

@@ -1,5 +1,81 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+const (
+	push   = "push"
+	pop    = "pop"
+	top    = "top"
+	getMin = "getMIn"
+)
+
+type MinStack struct {
+	data, min []int
+}
+
+func Constructor4() MinStack {
+	return MinStack{
+		data: make([]int, 0),
+		min:  make([]int, 0),
+	}
+}
+
+func (this *MinStack) Push(val int) {
+	if len(this.data) == 0 {
+		this.data = append(this.data, val)
+		this.min = append(this.min, val)
+		return
+	}
+
+	top := this.min[len(this.min)-1]
+	this.data = append(this.data, val)
+	if top > val {
+		top = val
+	}
+
+	this.min = append(this.min, top)
+}
+
+func (this *MinStack) Pop() {
+	if len(this.data) > 0 {
+		l := len(this.data)
+		this.data = this.data[:l-1]
+		this.min = this.min[:l-1]
+	}
+}
+
+func (this *MinStack) Top() int {
+	if len(this.data) > 0 {
+		return this.data[len(this.data)-1]
+	}
+
+	return -1
+}
+
+func (this *MinStack) GetMin() int {
+	return this.min[len(this.min)-1]
+}
+
+// action, push, pop, top, getMin
+func Solution(actions []string, vals []int) []int {
+	o := Constructor4()
+	expect := make([]int, 0)
+	for idx, act := range actions {
+		if act == push {
+			o.Push(vals[idx])
+			continue
+		}
+		if act == pop {
+			o.Pop()
+			continue
+		}
+
+		if act == top {
+			top := o.Top()
+			expect = append(expect, top)
+			continue
+		}
+
+		m := o.GetMin()
+		expect = append(expect, m)
+	}
+	return expect
 }

leetcode/101-200/0155.Min-Stack/Solution_test.go

@@ -9,22 +9,22 @@ import (
 func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
-		name   string
-		inputs bool
-		expect bool
+		name    string
+		actions []string
+		inputs  []int
+		expect  []int
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", []string{push, push, push, getMin, pop, top, getMin}, []int{-2, 0, -3, 0, 0, 0, 0}, []int{-3, 0, -2}},
+		{"TestCase2", []string{push, push, getMin, top, pop, push, getMin, top}, []int{1, 2, 0, 0, 0, -2, 0, 0}, []int{1, 2, -2, -2}},
 	}
 
 	//	开始测试
 	for i, c := range cases {
 		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := Solution(c.inputs)
+			got := Solution(c.actions, c.inputs)
 			if !reflect.DeepEqual(got, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, got, c.inputs)
+				t.Fatalf("expected: %v, but got: %v, with input-actions: %v, input-inputs: %v",
+					c.expect, got, c.actions, c.inputs)
 			}
 		})
 	}

leetcode/301-400/0341.Flatten-Nested-List-Iterator/README.md

@@ -1,26 +1,36 @@
 # [341.Flatten Nested List Iterator][title]
 
-> [!WARNING|style:flat]
-> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
-
 ## Description
+You are given a nested list of integers `nestedList`. Each element is either an integer or a list whose elements may also be integers or other lists. Implement an iterator to flatten it.
 
-**Example 1:**
+Implement the `NestedIterator` class:
 
+- `NestedIterator(List<NestedInteger> nestedList)` Initializes the iterator with the nested list `nestedList`.
+- `int next()` Returns the next integer in the nested list.
+- `boolean hasNext()` Returns `true` if there are still some integers in the nested list and `false` otherwise.
+Your code will be tested with the following pseudocode:
 ```
-Input: a = "11", b = "1"
-Output: "100"
+initialize iterator with nestedList
+res = []
+while iterator.hasNext()
+    append iterator.next() to the end of res
+return res
 ```
+If `res` matches the expected flattened list, then your code will be judged as correct.
 
-## 题意
-> ...
+**Example 1:**
 
-## 题解
+```
+Input: nestedList = [[1,1],2,[1,1]]
+Output: [1,1,2,1,1]
+Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].
+```
 
-### 思路1
-> ...
-Flatten Nested List Iterator
-```go
+__Example 2:__
+```
+Input: nestedList = [1,[4,[6]]]
+Output: [1,4,6]
+Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].
 ```
 
 

leetcode/301-400/0341.Flatten-Nested-List-Iterator/Solution.go

@@ -1,5 +1,69 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+type NestedInteger struct {
+	Val   int
+	isInt bool
+	list  []*NestedInteger
+}
+
+func (this NestedInteger) IsInteger() bool {
+	return this.isInt
+}
+
+func (this NestedInteger) GetInteger() int {
+	return this.Val
+}
+
+func (this NestedInteger) SetInteger(value int) {
+
+}
+func (this NestedInteger) Add(ele NestedInteger) {
+
+}
+
+func (this NestedInteger) GetList() []*NestedInteger {
+	return this.list
+}
+
+type NestedIterator struct {
+	Raw []*NestedInteger
+	idx int
+}
+
+func Constructor3(nestedList []*NestedInteger) *NestedIterator {
+	raw := make([]*NestedInteger, 0)
+	deepTraverse(nestedList, &raw)
+	return &NestedIterator{
+		Raw: raw,
+		idx: 0,
+	}
+}
+
+func deepTraverse(nestedList []*NestedInteger, raw *[]*NestedInteger) {
+	for idx, ele := range nestedList {
+		if ele.IsInteger() {
+			*raw = append(*raw, nestedList[idx])
+			continue
+		}
+		deepTraverse(ele.GetList(), raw)
+	}
+}
+
+func (this *NestedIterator) Next() int {
+	r := this.Raw[this.idx].GetInteger()
+	this.idx++
+	return r
+}
+
+func (this *NestedIterator) HasNext() bool {
+	return this.idx < len(this.Raw)
+}
+
+func Solution(nestedList []*NestedInteger) []int {
+	o := Constructor3(nestedList)
+	expect := make([]int, 0)
+	for o.HasNext() {
+		expect = append(expect, o.Next())
+	}
+	return expect
 }

leetcode/301-400/0341.Flatten-Nested-List-Iterator/Solution_test.go

@@ -10,12 +10,22 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs []*NestedInteger
+		expect []int
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", []*NestedInteger{{Val: 1, isInt: true}, {isInt: false, list: []*NestedInteger{{Val: 2, isInt: true}, {Val: 3, isInt: true}}}, {Val: 1, isInt: true, list: nil}}, []int{1, 2, 3, 1}},
+		{"TestCase2", []*NestedInteger{{Val: 1, isInt: true}, {Val: 2, isInt: true}, {Val: 3, isInt: true}}, []int{1, 2, 3}},
+		{"TestCase3", []*NestedInteger{
+			{Val: 1, isInt: true},
+			{isInt: false, list: []*NestedInteger{
+				{isInt: false, list: []*NestedInteger{{Val: 2, isInt: true}}},
+				{isInt: false, list: []*NestedInteger{
+					{Val: 3, isInt: true},
+					{Val: 4, isInt: true},
+				}},
+			}},
+			{Val: 5, isInt: true}},
+			[]int{1, 2, 3, 4, 5}},
 	}
 
 	//	开始测试

leetcode/701-800/0729.My-Calendar-I/README.md

@@ -1,26 +1,32 @@
 # [729.My Calendar I][title]
 
-> [!WARNING|style:flat]
-> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
 
 ## Description
+You are implementing a program to use as your calendar. We can add a new event if adding the event will not cause a __double booking__.
 
-**Example 1:**
+A __double booking__ happens when two events have some non-empty intersection (i.e., some moment is common to both events.).
 
-```
-Input: a = "11", b = "1"
-Output: "100"
-```
+The event can be represented as a pair of integers `start` and `end` that represents a booking on the half-open interval `[start, end)`, the range of real numbers `x` such that `start <= x < end`.
 
-## 题意
-> ...
+Implement the `MyCalendar` class:
 
-## 题解
+- `MyCalendar()` Initializes the calendar object.
+- `boolean book(int start, int end)` Returns `true` if the event can be added to the calendar successfully without causing a __double booking__. Otherwise, return `false` and do not add the event to the calendar.
 
-### 思路1
-> ...
-My Calendar I
-```go
+**Example 1:**
+
+```
+Input
+["MyCalendar", "book", "book", "book"]
+[[], [10, 20], [15, 25], [20, 30]]
+Output
+[null, true, false, true]
+
+Explanation
+MyCalendar myCalendar = new MyCalendar();
+myCalendar.book(10, 20); // return True
+myCalendar.book(15, 25); // return False, It can not be booked because time 15 is already booked by another event.
+myCalendar.book(20, 30); // return True, The event can be booked, as the first event takes every time less than 20, but not including 20.
 ```
 
 

leetcode/701-800/0729.My-Calendar-I/Solution.go

@@ -1,5 +1,65 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+type seg struct {
+	start, end int
+}
+
+type MyCalendar struct {
+	books []seg
+}
+
+func Constructor() MyCalendar {
+	return MyCalendar{
+		books: make([]seg, 0),
+	}
+}
+
+func (this *MyCalendar) Book(start, end int) bool {
+	s := seg{start, end}
+	if len(this.books) == 0 {
+		this.books = append(this.books, s)
+		return true
+	}
+
+	idx := len(this.books) - 1
+	breakPoint := false
+	for ; idx >= 0; idx-- {
+		if s.end >= this.books[idx].end && s.start >= this.books[idx].end {
+			breakPoint = true
+			break
+		}
+		if (s.start >= this.books[idx].start && s.start < this.books[idx].end) || (s.end > this.books[idx].start && s.end < this.books[idx].end) || (s.end >= this.books[idx].end && s.start <= this.books[idx].start) {
+			return false
+		}
+		if idx == 0 {
+			breakPoint = true
+		}
+	}
+	if breakPoint {
+		if idx < 0 {
+			this.books = append([]seg{s}, this.books...)
+		} else {
+			tmp := make([]seg, 0)
+			tmp = append(tmp, this.books[:idx+1]...)
+			tmp = append(tmp, s)
+			tmp = append(tmp, this.books[idx+1:]...)
+			this.books = tmp
+		}
+	}
+
+	return breakPoint
+}
+
+func Solution(segs []seg, res []bool) bool {
+	if len(segs) != len(res) {
+		return false
+	}
+	c := Constructor()
+
+	for idx := 0; idx < len(segs); idx++ {
+		if res[idx] != c.Book(segs[idx].start, segs[idx].end) {
+			return false
+		}
+	}
+	return true
 }

leetcode/701-800/0729.My-Calendar-I/Solution_test.go

@@ -10,21 +10,22 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
+		segs   []seg
+		res    []bool
 		expect bool
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", []seg{{2, 6}, {12, 15}, {8, 9}, {9, 10}}, []bool{true, true, true, true}, true},
+		{"TestCase2", []seg{{10, 20}, {15, 25}, {20, 30}}, []bool{true, false, true}, true},
+		{"TestCase3", []seg{{37, 50}, {33, 50}, {4, 17}, {35, 48}, {8, 25}}, []bool{true, false, true, false, false}, true},
 	}
 
 	//	开始测试
 	for i, c := range cases {
 		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := Solution(c.inputs)
+			got := Solution(c.segs, c.res)
 			if !reflect.DeepEqual(got, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, got, c.inputs)
+				t.Fatalf("expected: %v, but got: %v, with input-segs: %v, input-res: %v",
+					c.expect, got, c.segs, c.res)
 			}
 		})
 	}