在傳統的磁碟管理方式中，通常使用固定大小的磁碟分割（partitions）來配置空間。缺點在於一旦磁碟分割完成，要擴充空間或搬移資料都會變得困難甚至需要停機，缺乏彈性，而 LVM（邏輯卷管理器）為了解決這種問題應運而生。
邏輯卷管理器（LVM） 是一種儲存虛擬化軟體，旨在提升對實體儲存裝置的管理能力與彈性。它透過對底層硬體的抽象，允許你動態地建立、調整大小與刪除虛擬儲存設備。 在 LVM 的架構中：
嘗試將包在 docker 內的 app 和 redis container 一起用 docker-compose 啟動並連接的時候，發現 app 一直連不上，而且會顯示錯誤：
[ioredis] Unhandled error event: Error: connect ECONNREFUSED 127.0.0.1:6379
at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1085:14)
const redisClient1 = new Redis({
host: 'redis1',
port: 6379
});
這個解法來自這篇
Leetcode Top Interview 150 的其中一題
Given a 1-indexed array of integers numbers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number. Let these two numbers be numbers[index1] and numbers[index2] where 1 <= index1 < index2 <= numbers.length.
Return the indices of the two numbers, index1 and index2, added by one as an integer array [index1, index2] of length 2.
The tests are generated such that there is exactly one solution. You may not use the same element twice.
Your solution must use only constant extra space.
Input: numbers = [2,7,11,15], target = 9
Output: [1,2]
Explanation: The sum of 2 and 7 is 9. Therefore, index1 = 1, index2 = 2. We return [1, 2].
Input: numbers = [2,3,4], target = 6
Output: [1,3]
Explanation: The sum of 2 and 4 is 6. Therefore index1 = 1, index2 = 3. We return [1, 3].
這題另一種解法是一邊用 map 紀錄目前有的數值，每次都檢查 target-numbers[i] 這個值是否已經存在。但由於題目規定只能使用 constant extra space，所以以下解法使用雙指針。
func twoSum(numbers []int, target int) []int {
left := 0
right := len(numbers) - 1
for left < right {
// 如果相加等於 target，回傳答案
if numbers[left] + numbers[right] == target {
return []int{left+1, right+1}
}
// 如果相加比 target 大，代表其中一個數字應該更小，將右指針左移
if numbers[left] + numbers[right] > target {
right--
}
// 如果相加比 target 小，代表其中一個數字應該更大，將左指針右移
if numbers[left] + numbers[right] < target {
left++
}
}
return []int{1, 2}
}
Time complexity : O(n) Space complexity : O(1)
Leetcode Top Interview 150 的其中一題
You are given a 0-indexed array of integers nums of length n. You are initially positioned at nums[0].
Each elementnums[i] represents the maximum length of a forward jump from index i. In other words, if you are at nums[i], you can jump to any nums[i + j] where:
0 <= j <= nums[i] andi + j < n
Return the minimum number of jumps to reach nums[n - 1]. The test cases are generated such that you can reach nums[n - 1].Input: nums = [2,3,1,1,4]
Output: 2
Explanation: The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index.
Input: nums = [2,3,0,1,4]
Output: 2
思路：記錄從我們每一步可以到達的地方中，找出最遠下一步可以到哪 例如範例一 index 0 可以到 index 1, index 2
func jump(nums []int) int {
res := 0
currFarest := 0
start := 0
for currFarest < len(nums)-1 {
farest := 0
for i := start; i <= currFarest; i++ {
farest = max(farest, i + nums[i])
}
start = currFarest + 1
currFarest = farest
res++
}
return res
}
func max(a, b int) int {
if a > b { return a }
return b
}
Time complexity : O(n^2) Space complexity : O(1)
Leetcode Top Interview 150 的其中一題
You are given an integer array nums. You are initially positioned at the array’s first index, and each element in the array represents your maximum jump length at that position.
Return true if you can reach the last index, or false otherwise.
Input: nums = [2,3,1,1,4]
Output: true
Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.
Input: nums = [3,2,1,0,4]
Output: false
Explanation: You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.
專注於我們目前能到達的最遠 index 。從前面哪個 index 到這個最遠的index並不重要。
從 index 0 開始遍歷 nums，使用 canArrive 變數來記錄我們能到達的最遠 index。如果 i + nums[i] > canArrive，這表示我們可以到達更遠的 index，更新canArrive的值。如果 i < canArrive，這表示我們無法抵達剩餘的index，返回 false。
func maximumGain(s string, x int, y int) int {
remove := func(str string, removestr string, val int) int {
count := 0
stack := make([]byte, 0)
for i:=0; i<len(str); i++ {
stack = append(stack, str[i])
l := len(stack)
if l >= 2 && stack[l-1]==removestr[1] && stack[l-2]==removestr[0] {
count += val
stack = stack[:l-2]
}
}
s = string(stack)
return count
}
if x > y {
return remove(s, "ab", x) + remove(s, "ba", y)
} else {
return remove(s, "ba", y) + remove(s, "ab", x)
}
return 0
}
Time complexity : O(n) Space complexity : O(1)