add more details about performance and complexity to strings

Author: spring1843

array/README.md

@@ -6,7 +6,7 @@ To provide a real-world analogy, consider an array of athletes preparing for a s
 
 ## Implementation
 
-In the Go programming language, arrays are considered values rather than pointers and represent the entirety of the array. Whenever an array is passed to a function, a copy is created, resulting in additional memory usage. To avoid this, it is possible to pass a pointer to an array, or use slices instead. The size of the array is constant and it must be known at compile time, and there is no need to use the built-in `make` function when defining arrays.
+In the Go programming language, (arrays)[https://go.dev/blog/slices] are considered values rather than pointers and represent the entirety of the array. Whenever an array is passed to a function, a copy is created, resulting in additional memory usage. To avoid this, it is possible to pass a pointer to an array, or use slices instead. The size of the array is constant and it must be known at compile time, and there is no need to use the built-in `make` function when defining arrays.
 
 ```Go
 package main

strings/README.md

@@ -1,10 +1,12 @@
 # String
 
-A string is a ubiquitous data structure, typically a built-in data type in programming languages. However, beneath the surface, strings are essentially arrays of characters that enable textual data storage and manipulation.
+A string is a ubiquitous data structure, typically a built-in data type in programming languages. However, beneath the surface, strings are essentially [slices](../array/) of characters that enable textual data storage and manipulation.
 
 ## Implementation
 
-In Go, strings are a data type. Behind the scenes strings are a slice of bytes. The `strings` package provides several useful convenience functions. Examples include:
+In Go, [strings](https://go.dev/blog/strings) are a data type. Behind the scenes strings are an immutable slice of bytes. Since Go is a UTF-8 compliant language, each character in Go can take up to 4 bytes of storage.
+
+The `strings` package provides several useful convenience functions. Examples include:
 
 * [Index](https://golang.org/pkg/strings/#Index), [Contains](https://golang.org/pkg/strings/#Contains), [HasPrefix](https://golang.org/pkg/strings/#HasPrefix), [HasSuffix](https://golang.org/pkg/strings/#HasSuffix)
 * [Split](https://golang.org/pkg/strings/#Split), [Fields](https://golang.org/pkg/strings/#Split), [Join](https://golang.org/pkg/strings/#Join)
@@ -13,27 +15,96 @@ In Go, strings are a data type. Behind the scenes strings are a slice of bytes.
 * [Title](https://golang.org/pkg/strings/#Title), [ToLower](https://golang.org/pkg/strings/#ToLower), [ToUpper](https://golang.org/pkg/strings/#ToUpper)
 * [Trim](https://golang.org/pkg/strings/#Trim), [TrimSpace](https://golang.org/pkg/strings/#TrimSpace), [TrimSuffix](https://golang.org/pkg/strings/#TrimSuffix), [TrimPrefix](https://golang.org/pkg/strings/#TrimPrefix)
 
-When a string is iterated in Go using the `range` keyword, every element becomes a [rune](https://blog.golang.org/strings#TOC_5.) which is an alias for the type `int32`. If the code being written works with many single-character strings, it is better to define variables and function parameters as `rune`. The following code shows how to iterate through a string.
+When a iterating every character in a string in Go using the `range` keyword, every element becomes a [rune](https://blog.golang.org/strings#TOC_5.) which is an alias for the type `int32`. If the code being written works with many single-character strings, it is better to define variables and function parameters as `rune` rather than convert them many times. The following code shows how to iterate through a string.
+
+```Go
+package main
+
+import "fmt"
+
+/*
+ main outputs the rune (int32) value of each character:
+
+ Char #0 "a" has value 97
+ Char #1 "A" has value 65
+ Char #2 "和" has value 21644
+ Char #5 "平" has value 24179
+ Char #8 "😊" has value 128522
+*/
+func main() {
+	for i, r := range "aA𓅚😊" {
+		fmt.Printf("Char #%d %q has value %d\n", i, string(r), r)
+	}
+}
+```
+
+A very common tool to use for manipulating strings in Go is the `fmt.Sprtinf` function. This is specially useful when converting many values into a string.
 
 ```Go
 package main
 
+import "fmt"
+
+func main() {
+	number := 1
+	value := 1.1
+	name := "foo"
+
+	output := fmt.Sprintf("%d %f %s", number, value, name)
+	fmt.Println(output) // 1 1.100000 foo
+}
+```
+
+### Regular Expressions
+
+Unlike many other programming languages, in Go [regular expressions](https://golang.org/pkg/regexp/) are [guaranteed](https://swtch.com/~rsc/regexp/regexp1.html) to have O(n) time complexity where n is the length of the input, making them a viable and practical option for pattern matching in a string.
+
+Here is an example of how you can find a pattern using regular expressions in Go. Given a string return the string if it contains a fish word. A fish word is a word that starts with `fi` optionally followed by other character(s) and ends with `sh`. Examples include {`fish`, `finish`}.
+
+```GO
+package main
+
 import (
 	"fmt"
+	"regexp"
 )
 
+var fishPattern = regexp.MustCompile(`(?i).*fi\w*sh\b`)
+
+// main outputs [selfish][shellfish][fish][finish][Finnish]
 func main() {
-	for i, r := range "abcd" {
-		fmt.Printf("Char #%d %q has value %d\n", i, string(r), r)
+	inputs := []string{"shift", "selfish", "shellfish", "fish dish", "finish", "Finnish"}
+
+	for _, input := range inputs {
+		matches := fishPattern.FindAllString(input, -1)
+		if len(matches) > 0 {
+			fmt.Print(matches)
+		}
 	}
 }
 ```
 
 ## Complexity
 
-Strings have the same complexity as [arrays](../array/) and slices in Go.
+Since strings are slices of bytes, the time complexity of string operations should be similar to [arrays](../array/). Reading a character at a given index is O(1), but since strings are immutable modifying them involves creating a new string making it a O(n) operation. Go standard library includes `strings.Builder` for more efficient string building.
+
+The space complexity to store a string depends on the type of characters. This following example shows how we can index a string and print the hexadecimal value of every byte in it.
+
+```GO
+package main
+
+import "fmt"
+
+// main Outputs 41 f0 93 85 9a f0 9f 98 8a.
+func main() {
+	input := "A𓅚😊"
+	for i := 0; i < len(input); i++ {
+		fmt.Printf("%x ", input[i])
+	}
+}
+```
 
-Unlike many other programming languages, [regular expressions](https://golang.org/pkg/regexp/) are guaranteed to have O(n) time complexity in Go, allowing efficient string pattern matching.
+The output of the above code indicates that 9 bytes are used to store the 3 input characters. 1 byte for the first character and 4 bytes for each of the remaining two.
 
 ## Application