diff --git a/16-slices/exercises/22-adv-ops-practice/main.go b/16-slices/exercises/22-adv-ops-practice/main.go new file mode 100644 index 0000000..563058e --- /dev/null +++ b/16-slices/exercises/22-adv-ops-practice/main.go @@ -0,0 +1,143 @@ +package main + +import ( + s "github.com/inancgumus/prettyslice" +) + +// --------------------------------------------------------- +// EXERCISE: Practice advanced slice operations +// +// This exercise's intention is warm you up and reinforce +// your memory for the advanced slice operations. +// +// Please follow the directions in the following code. +// +// To see the expected output, please run: +// +// go run solution/main.go +// +// --------------------------------------------------------- + +func main() { + // + // Use the prettyslice package for printing the slices, + // or do it with your own Printf that matches the output + // of the prettyslice package. + // + + // This allows you to see the backing array of the slices. + s.PrintBacking = true + // Shows 10 slice elements per line + s.MaxPerLine = 10 + // Prints 60 character per line + s.Width = 60 + + // ######################################################## + // + // #1: Create a string slice with a length and capacity + // of 5. Call the slice: `names` and print it. + // + + // ... + // s.Show("1st step", names) + + // ######################################################## + // + // #2: Append the following names to the names slice: + // + // "einstein", "tesla", "aristo" + // + // Print the names slice. + // + // Observe how the slice and its backing array change. + // + + // ... + // s.Show("2nd step", names) + + // ######################################################## + // + // #3: Fix the append problem by reinitializing the + // names slice below (currently the previous code + // appends after 5 elements). + // + // Append the new elements to the head of the names + // slice instead. + // + // Print the names slice. + // + // HINT: + // + // The problem is in the `make` function. + // + + // ... + // s.Show("3rd step", names) + + // ######################################################## + // + // #4: Copy elements from an array to the `names` slice. + // + // Currently, `cap(names)` is 5. So, copy only + // the first two elements of the following array + // to the last two elements of the `names` slice. + // + // Print the names slice (do not forget extending it). + // You should print 5 elements. + // + // Observe how the backing array stays the same. + // + + // Array (uncomment): + // moreNames := [...]string{"plato", "khayyam", "ptolemy"} + + // ... + + // s.Show("4th step", names) + + // ######################################################## + // + // #5: Clone the `names` slice to the `clone` slice. + // + // But only clone (copy) the last 3 elements of the + // `names` slice. + // + // Then, append the first two elements of the `names` + // slice to the `clone` slice. + // + // Ensure that after appending no new backing array + // allocations occur for the `clone` slice. + // + // Print the clone slice before and after the append. + // + + // ... + // s.Show("5th step (before append)", clone) + + // ... + // s.Show("5th step (after append)", clone) + + // ######################################################## + // + // #6: Slice the `clone` slice between 2nd and 4th + // elements. + // + // Put the sliced slice into a variable named: + // `sliced`. + // + // Append "hypatia" to the `sliced` slice. + // + // Ensure that new backing array allocation "happens". + // + // Change the 3rd element of the `clone` slice + // to "elder". + // + // Doing so should not change any elements of + // the `sliced` slice. + // + // Print the `clone` and `sliced` slices. + // + + // ... + // s.Show("6th step", clone, sliced) +} diff --git a/16-slices/exercises/22-adv-ops-practice/solution/main.go b/16-slices/exercises/22-adv-ops-practice/solution/main.go new file mode 100644 index 0000000..6df898e --- /dev/null +++ b/16-slices/exercises/22-adv-ops-practice/solution/main.go @@ -0,0 +1,71 @@ +// For more tutorials: https://blog.learngoprogramming.com +// +// Copyright © 2018 Inanc Gumus +// Learn Go Programming Course +// License: https://creativecommons.org/licenses/by-nc-sa/4.0/ +// + +package main + +import ( + s "github.com/inancgumus/prettyslice" +) + +func main() { + s.PrintBacking = true + s.MaxPerLine = 10 + s.Width = 60 + + // + // #1 + // + + names := make([]string, 5) + s.Show("1st step", names) + + // + // #2 + // + + names = append(names, "einstein", "tesla", "aristo") + s.Show("2nd step", names) + + // + // #3 + // + names = make([]string, 0, 5) + names = append(names, "einstein", "tesla", "aristo") + s.Show("3rd step", names) + + // + // #4 + // + + moreNames := [...]string{"plato", "khayyam", "ptolemy"} + copy(names[3:5], moreNames[:2]) + names = names[:cap(names)] + + s.Show("4th step", names) + + // + // #5 + // + + clone := make([]string, 3, 5) + copy(clone, names[len(names)-3:]) + s.Show("5th step (before append)", clone) + + clone = append(clone, names[:2]...) + s.Show("5th step (after append)", clone) + + // + // #6 + // + + sliced := clone[1:4:4] + sliced = append(sliced, "hypatia") + + clone[2] = "elder" + + s.Show("6th step", clone, sliced) +} diff --git a/x-tba/slices/exercises/fix-xx-limit-the-backing-array-sharing/api/api.go b/16-slices/exercises/23-limit-the-backing-array-sharing/api/api.go similarity index 100% rename from x-tba/slices/exercises/fix-xx-limit-the-backing-array-sharing/api/api.go rename to 16-slices/exercises/23-limit-the-backing-array-sharing/api/api.go diff --git a/x-tba/slices/exercises/fix-xx-limit-the-backing-array-sharing/main.go b/16-slices/exercises/23-limit-the-backing-array-sharing/main.go similarity index 96% rename from x-tba/slices/exercises/fix-xx-limit-the-backing-array-sharing/main.go rename to 16-slices/exercises/23-limit-the-backing-array-sharing/main.go index e99522c..22570f7 100644 --- a/x-tba/slices/exercises/fix-xx-limit-the-backing-array-sharing/main.go +++ b/16-slices/exercises/23-limit-the-backing-array-sharing/main.go @@ -10,7 +10,7 @@ package main import ( "fmt" - "github.com/inancgumus/learngo/16-slices/exercises/19-limit-the-backing-array-sharing/api" + "github.com/inancgumus/learngo/16-slices/exercises/23-limit-the-backing-array-sharing/api" ) // --------------------------------------------------------- diff --git a/x-tba/slices/exercises/fix-xx-limit-the-backing-array-sharing/solution/api/api.go b/16-slices/exercises/23-limit-the-backing-array-sharing/solution/api/api.go similarity index 100% rename from x-tba/slices/exercises/fix-xx-limit-the-backing-array-sharing/solution/api/api.go rename to 16-slices/exercises/23-limit-the-backing-array-sharing/solution/api/api.go diff --git a/x-tba/slices/exercises/fix-xx-limit-the-backing-array-sharing/solution/main.go b/16-slices/exercises/23-limit-the-backing-array-sharing/solution/main.go similarity index 86% rename from x-tba/slices/exercises/fix-xx-limit-the-backing-array-sharing/solution/main.go rename to 16-slices/exercises/23-limit-the-backing-array-sharing/solution/main.go index 1a9a645..8b7e4df 100644 --- a/x-tba/slices/exercises/fix-xx-limit-the-backing-array-sharing/solution/main.go +++ b/16-slices/exercises/23-limit-the-backing-array-sharing/solution/main.go @@ -10,12 +10,11 @@ package main import ( "fmt" - "github.com/inancgumus/learngo/16-slices/exercises/19-limit-the-backing-array-sharing/solution/api" + "github.com/inancgumus/learngo/16-slices/exercises/23-limit-the-backing-array-sharing/solution/api" ) func main() { temps := api.Read(0, 3) - temps = append(temps, []int{1, 3}...) fmt.Println("API's readings:", api.All()) diff --git a/16-slices/exercises/24-fix-the-memory-leak/api/api.go b/16-slices/exercises/24-fix-the-memory-leak/api/api.go new file mode 100644 index 0000000..aa715e0 --- /dev/null +++ b/16-slices/exercises/24-fix-the-memory-leak/api/api.go @@ -0,0 +1,24 @@ +package api + +import ( + "fmt" + "math/rand" + "runtime" +) + +// DO NOT TOUCH THE FOLLOWING CODE +// THIS IS THE API +// YOU CANNOT CONTROL IT! :) + +// Read returns a huge slice (allocates ~65 MB of memory) +func Read() []int { + return rand.Perm(2 << 22) +} + +// Report cleans the memory and prints the current memory usage +func Report() { + var m runtime.MemStats + runtime.GC() + runtime.ReadMemStats(&m) + fmt.Printf(" > Memory Usage: %v KB\n", m.Alloc/1024) +} diff --git a/16-slices/exercises/24-fix-the-memory-leak/main.go b/16-slices/exercises/24-fix-the-memory-leak/main.go new file mode 100644 index 0000000..d763679 --- /dev/null +++ b/16-slices/exercises/24-fix-the-memory-leak/main.go @@ -0,0 +1,67 @@ +// For more tutorials: https://blog.learngoprogramming.com +// +// Copyright © 2018 Inanc Gumus +// Learn Go Programming Course +// License: https://creativecommons.org/licenses/by-nc-sa/4.0/ +// + +package main + +import ( + "fmt" + "io/ioutil" + + "github.com/inancgumus/learngo/16-slices/exercises/24-fix-the-memory-leak/api" +) + +// --------------------------------------------------------- +// EXERCISE: Fix the memory leak +// +// You're receiving millions of temperature data points from +// an API, but you only need the last 10 data points. +// +// Currently, there is a memory leak in your program. +// Find the leak and fix it. +// +// +// EXPECTED OUTPUT +// +// > Memory Usage: 116 KB +// > Memory Usage: 118 KB +// +// +// EXPECTED OUTPUT EXPLANATION +// +// Your output will be different. Your goal is to reduce the +// difference between the two measurements of the memory usage. +// +// For the expected output above: +// +// 118 KB - 116 KB = Only 2 KB so that's OK. +// +// However, in the current program, because of the memory leak, +// the difference is huge: about ~60 MB. Run the program and, +// see yourself. +// +// --------------------------------------------------------- + +func main() { + // reports the initial memory usage + api.Report() + + // reads 65 MB of temperature data into the memory! + temps := api.Read() + + // ----------------------------------------------------- + // ✪ ONLY ADD YOUR CODE INSIDE THIS BOX ✪ + // + + // + // ✪ ONLY ADD YOUR CODE INSIDE THIS BOX ✪ + // ----------------------------------------------------- + + // fix the problem so that the memory usage stays low + // dont touch this code + api.Report() + fmt.Fprintln(ioutil.Discard, temps[0]) +} diff --git a/16-slices/exercises/24-fix-the-memory-leak/solution/api/api.go b/16-slices/exercises/24-fix-the-memory-leak/solution/api/api.go new file mode 100644 index 0000000..aa715e0 --- /dev/null +++ b/16-slices/exercises/24-fix-the-memory-leak/solution/api/api.go @@ -0,0 +1,24 @@ +package api + +import ( + "fmt" + "math/rand" + "runtime" +) + +// DO NOT TOUCH THE FOLLOWING CODE +// THIS IS THE API +// YOU CANNOT CONTROL IT! :) + +// Read returns a huge slice (allocates ~65 MB of memory) +func Read() []int { + return rand.Perm(2 << 22) +} + +// Report cleans the memory and prints the current memory usage +func Report() { + var m runtime.MemStats + runtime.GC() + runtime.ReadMemStats(&m) + fmt.Printf(" > Memory Usage: %v KB\n", m.Alloc/1024) +} diff --git a/16-slices/exercises/24-fix-the-memory-leak/solution/main.go b/16-slices/exercises/24-fix-the-memory-leak/solution/main.go new file mode 100644 index 0000000..c2885af --- /dev/null +++ b/16-slices/exercises/24-fix-the-memory-leak/solution/main.go @@ -0,0 +1,45 @@ +// For more tutorials: https://blog.learngoprogramming.com +// +// Copyright © 2018 Inanc Gumus +// Learn Go Programming Course +// License: https://creativecommons.org/licenses/by-nc-sa/4.0/ +// + +package main + +import ( + "fmt" + "io/ioutil" + + "github.com/inancgumus/learngo/16-slices/exercises/24-fix-the-memory-leak/solution/api" +) + +func main() { + // reports the initial memory usage + api.Report() + + // reads 65 MB of temperature data into the memory! + temps := api.Read() + + // + // SOLUTION #1: + // + + // clone the last 10 elements of the returned temperatures + // into a new slice + need := make([]int, 10) + copy(need, temps[len(temps)-10:]) + // make the temp slice lose reference to its backing array + // so that it can be cleaned from the memory + temps = need + + // + // SOLUTION #2: + // + + // The code below does the same thing like the code above but in one line. + // temps = append([]int(nil), temps[len(temps)-10:]...) + + api.Report() + fmt.Fprintln(ioutil.Discard, temps[0]) +} diff --git a/16-slices/exercises/25-add-lines/main.go b/16-slices/exercises/25-add-lines/main.go new file mode 100644 index 0000000..a6188c2 --- /dev/null +++ b/16-slices/exercises/25-add-lines/main.go @@ -0,0 +1,119 @@ +package main + +import ( + s "github.com/inancgumus/prettyslice" +) + +// --------------------------------------------------------- +// EXERCISE: Add newlines to the lyric sentences +// +// You have a slice of lyrics data of Beatles' awesome +// song: Yesterday. Your goal is adding newlines after +// each sentence of the lyric. +// +// Your goal is creating a new slice, then copying +// each sentence of the lyric to the new buffer, then +// after each sentence adding a newline character. +// +// You cannot guess how many times you will get across +// something like this. Believe me, learning this will +// make you a better Gopher. +// +// +// RESTRICTIONS +// +// . For warming-up, in this exercise, never use the `append()` func. +// +// . Instead, only use the `copy()` func. +// +// . You cannot use slicing for printing the sentences. +// +// . Instead, use slicing to fill the new buffer, then print it. +// +// +// STEPS +// +// . Follow the instructions inside the code. +// +// +// EXPECTED OUTPUT +// +// yesterday all my troubles seemed so far away +// now it looks as though they are here to stay +// oh i believe in yesterday +// +// --------------------------------------------------------- + +func main() { + // + // YOU DON'T NEED TO TOUCH THIS + // + // This inits some options for the prettyslice package. + // You can change the options if you want. + // + // s.Colors(false) // if your editor is light colored then enable this + s.PrintBacking = true // prints the backing arrays + s.MaxPerLine = 15 // prints max 15 elements per line + s.SpaceCharacter = "*" // print this instead of printing a newline (for debugging) + + // + // UNCOMMENT THE VARIABLE BELOW THEN START! + // + + // lyric := strings.Fields(`yesterday all my troubles seemed so far away now it looks as though they are here to stay oh i believe in yesterday`) + + // + // RESTRICTION EXPLANATION: + // + // Don't do something like this: + // (Do not use slicing for printing the sentences) + // + + // fmt.Println(lyric[:8]) + // fmt.Println(lyric[8:18]) + // fmt.Println(lyric[18:23]) + + // ======================================================================== + // + // #1: CREATE A LARGE ENOUGH BUFFER (A NEW SLICE) + // + // You need to put each lyric sentence + a newline into this buffer + // + + // I name the buffer: `fix`, you can name it however you want + // fix := make(...) + + // ======================================================================== + // + // #2: CALCULATE THE CUT POINTS + // + // You want to put newlines after each sentence. So you may want to put + // these index positions into a slice. Then you can use them to cut the + // lyric slice. + // + + // cutpoints := []int{...} + + // ======================================================================== + // + // #3: CREATE A LOOP AND COPY THE SENTENCES INTO THE BUFFER + // + + // for ... { + // Use the `copy` function to copy from the `lyric` slice to the buffer. + // + // Copy a newline character (in a string) to the buffer after each sentence. + // + // You can use slicing here for filling the new buffer. + // + // Uncomment this to aid debugging (to see how the fix slice changes) + // s.Show("fix slice", fix) + // } + + // ======================================================================== + // + // #4: PRINT THE BUFFER + // + + // ... +} diff --git a/16-slices/exercises/25-add-lines/solution/main.go b/16-slices/exercises/25-add-lines/solution/main.go new file mode 100644 index 0000000..815a74d --- /dev/null +++ b/16-slices/exercises/25-add-lines/solution/main.go @@ -0,0 +1,93 @@ +// For more tutorials: https://blog.learngoprogramming.com +// +// Copyright © 2018 Inanc Gumus +// Learn Go Programming Course +// License: https://creativecommons.org/licenses/by-nc-sa/4.0/ +// + +package main + +import ( + "fmt" + "strings" + + s "github.com/inancgumus/prettyslice" +) + +func main() { + // + // YOU DON'T NEED TO TOUCH THIS + // + // This inits some options for the prettyslice package. + // You can change the options if you want. + // + // s.Colors(false) // if your editor is light colored then enable this + s.PrintBacking = true // prints the backing arrays + s.MaxPerLine = 15 // prints max 15 elements per line + s.SpaceCharacter = "*" // print this instead of printing a newline (for debugging) + + lyric := strings.Fields(`yesterday all my troubles seemed so far away now it looks as though they are here to stay oh i believe in yesterday`) + + // CREATE A LARGE ENOUGH BUFFER + // `+3` because we're going to add 3 newline characters + fix := make([]string, len(lyric)+3) + + // CALCULATE THE CUT POINTS + // + // + The first sentence has 8 words so its cutpoint is 8. + // + // + The second one has 10 words so its cutpoint is 10. + // + // + The third one has 5 words so its cutpoint is 5. + // + // + // yesterday all my troubles seemed so far away now it looks as though they are here to stay + // | + // v + // cutpoint: 8 + // + // ... now it looks as though they are here to stay oh i believe in yesterday + // | + // v + // 10 + // + // ... now it looks as though they are here to stay oh i believe in yesterday + // | + // v + // 5 + cutpoints := []int{8, 10, 5} + + // `n` tracks how much we've moved inside the `lyric` slice + // `i` tracks the sentence that we're on + for i, n := 0, 0; n < len(lyric); i++ { + // + // copy to `fix` from the `lyric` + // + // destination: + // fix[n+i] because we don't want to delete the previous copy. + // it moves sentence by sentence, using the cutpoints. + // + // source: + // lyric[n:n+cutpoints[i]] because we want copy the next sentence + // beginning from the number of the last copied elements to the + // n+next cutpoint (the next sentence). + // + n += copy(fix[n+i:], lyric[n:n+cutpoints[i]]) + + // add a newline after the number of copied elements + // notice that the '\n' position slides as we move over + // that's why n+i + fix[n+i] = "\n" + + // uncomment this to aid debugging (to see how the fix slice changes) + // s.Show("fix slice", fix) + } + + // print the fix slice + for _, w := range fix { + fmt.Print(w) + if w != "\n" { + fmt.Print(" ") + } + } +} diff --git a/16-slices/exercises/26-print-daily-requests/main.go b/16-slices/exercises/26-print-daily-requests/main.go new file mode 100644 index 0000000..b608b1b --- /dev/null +++ b/16-slices/exercises/26-print-daily-requests/main.go @@ -0,0 +1,104 @@ +package main + +// --------------------------------------------------------- +// EXERCISE: Print daily requests +// +// You've got a requests log for a system in a slice: `reqs`. +// The log contains the total requests counts per 8 hours. +// +// The reqs slice is a single-dimensional slice but you need +// to group the daily into a slice named: `daily`. +// +// Please follow the instructions inside the code to solve +// the exercise. +// +// +// EXPECTED OUTPUT +// +// Please run `solution/main.go` to see the expected +// output. +// +// go run solution/main.go +// +// --------------------------------------------------------- + +func main() { + // + // #1: DAILY REQUESTS DATA + // + // . The system collects and groups the requests per 8 hours + // + // . So there are 3 requests totals per day + // + // . Your code should be robust enough to work with + // insufficient data. For example, in the last day + // there are only two request totals: 100 and 150. + // + // So, don't forget to handle that edge case as well. + // + // . Uncomment the code below and start + // + + // reqs := []int{ + // 500, 600, 250, + // 200, 400, 50, + // 900, 800, 600, + // 750, 250, 100, + // 100, 150, + // } + + // + // #2: Group the `reqs` per day into a slice named: `daily` + // + // . Create the daily slice using the `make` function + // + // . Anticipate the length argument to the make function using this data: + // + // + The length of the reqs slice + // + There are 3 requests totals per day + // + There are residual elements (the last day) + // + // ! So, do not blindly allocate a slice. + // + // ! Allocate the slice efficiently with the exact size needed. + // + // . Then append to it the daily requests in a "loop" + // + + // + // #3: Print the header: + // + // Day Requests + // ==================== + // + + // + // #4: Print the data per day along with the totals: + // + // 1 500 + // 1 600 + // 1 250 + // -------------------- + // 1350 --> Print the daily total requests + // + // 2 200 + // 2 400 + // 2 50 + // -------------------- + // 650 + // + // 2000 --> Also print the grand total + + // ------------------------------------------------------------------------ + // + // ❤️ NOTE ❤️ + // + // If you could't solve this challenge. Please do not get discouraged. + // + // Look at the solution, then try to solve it again. This is valuable too. + // + // Then ️change the request data, the number of requests per day (now it's 3), etc + // and then try to solve it again. + // + // ------------------------------------------------------------------------ +} diff --git a/16-slices/exercises/26-print-daily-requests/solution/main.go b/16-slices/exercises/26-print-daily-requests/solution/main.go new file mode 100644 index 0000000..778cda8 --- /dev/null +++ b/16-slices/exercises/26-print-daily-requests/solution/main.go @@ -0,0 +1,81 @@ +// For more tutorials: https://blog.learngoprogramming.com +// +// Copyright © 2018 Inanc Gumus +// Learn Go Programming Course +// License: https://creativecommons.org/licenses/by-nc-sa/4.0/ +// + +package main + +import ( + "fmt" + "strings" +) + +func main() { + // + // DAILY REQUESTS DATA + // + reqs := []int{ + 500, 600, 250, + 200, 400, 50, + 900, 800, 600, + 750, 250, 100, + 100, 150, + } + + // + // There are 3 requests per day + // + const N = 3 + + // + // Allocate the slice efficiently with the exact size needed + // + l := len(reqs) + size := l / N + if l%N != 0 { + size++ + } + daily := make([][]int, 0, size) + + // + // Group the `reqs` per day into a slice named: `daily` + // + for N < len(reqs) { + daily = append(daily, reqs[:N]) // add the current batch of nums to the `groups` + reqs = reqs[N:] // move the slice pointer for the next batch + } + + // + // Add the residual elements to the group (len(reqs) % N) + // + daily = append(daily, reqs) + + // + // Print the header: + // + fmt.Printf("%-10s%-10s\n", "Day", "Requests") + fmt.Println(strings.Repeat("=", 20)) + + // + // Print the data per day along with the totals: + // + var grand int + + for i, d := range daily { + var sum int + + for _, q := range d { + sum += q + fmt.Printf("%-10d%-10d\n", i+1, q) + } + + fmt.Println(strings.Repeat("-", 20)) + fmt.Printf("%10s%-10d\n\n", "", sum) + + grand += sum + } + + fmt.Printf("%10s%-10d\n", "", grand) +} diff --git a/16-slices/exercises/README.md b/16-slices/exercises/README.md index 50abb57..3fa6bf5 100644 --- a/16-slices/exercises/README.md +++ b/16-slices/exercises/README.md @@ -2,7 +2,7 @@ ## Exercises Level I - Basics — Warm-Up -These are warm-up exercises that will reinforce your knowledge of slices. +Let's reinforce your basic knowledge of slices. 1. **[Declare nil slices](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/01-declare-nil)** @@ -20,6 +20,8 @@ These are warm-up exercises that will reinforce your knowledge of slices. ## Exercises Level II - Appending +Discover the power of the append function. + 1. **[Append #1 — Append and compare byte slices](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/07-append)** 2. **[Append #2 — Append to a nil slice](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/08-append-2)** @@ -37,6 +39,8 @@ These are warm-up exercises that will reinforce your knowledge of slices. ## Exercises Level III - Slicing +Discover the power of slicing. + 1. **[Slice the numbers](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/13-slicing-basics)** 2. **[Slicing by arguments](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/14-slicing-by-args)** @@ -47,6 +51,8 @@ These are warm-up exercises that will reinforce your knowledge of slices. ## Exercises Level IV - Internals +Peek into the internals of the slices and gain more insight. This is necessary for complete command of the slices. + 1. **[Fix the backing array problems](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/16-internals-backing-array-fix)** 2. **[Sort the backing array](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/17-internals-backing-array-sort)** @@ -57,4 +63,30 @@ These are warm-up exercises that will reinforce your knowledge of slices. 5. **[Observe the capacity growth](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/20-observe-the-cap-growth)** -6. **[Correct the lyric](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/21-correct-the-lyric)** \ No newline at end of file +6. **[Correct the lyric](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/21-correct-the-lyric)** + +--- + +## Exercises Level V - Advanced Operations + +Commonly used and more advanced operations are available to slices. Now, it's time to test yourself and fix some common problems. + +1. **[Practice Advanced Slice Operations](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/22-adv-ops-practice)** + + Let's warm you up for the advanced slice operations, and reinforce your neurons. + +2. **[Limit the backing array sharing](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/23-limit-the-backing-array-sharing)** + + Your API does not control the slices that it share with the outside world. You need to fix it. + +3. **[Fix the Memory Leak](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/25-fix-the-memory-leak)** + + A slice retrieved from an API causes a memory leak in your program. You need to fix it. + +4. **[Add newlines to the lyric sentences](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/25-add-lines)** + + Use the power of the `copy()` function and add newlines into a new buffer from a string slice. This exercise is more tricky than you might think. + +5. **[Print Daily Requests](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/26-print-daily-requests)** + + Group the requests log into a multi-dimensional from a single-dimensional slice. Allocate a slice with the exact size needed by doing some wizardary calculations. And lastly, pretty print the result. diff --git a/x-tba/slices/20-png-parser-project/main.go b/x-tba/slices/20-png-parser-project/main.go index ce91f6c..3430406 100644 --- a/x-tba/slices/20-png-parser-project/main.go +++ b/x-tba/slices/20-png-parser-project/main.go @@ -25,8 +25,10 @@ func main() { return } + report() img = append([]byte(nil), img[:24]...) - img = img[:24:24] + // img = img[:24:24] // unnecessary + report() // s.PrintBacking = true // s.MaxPerLine = 8 diff --git a/x-tba/slices/exercises/README.md b/x-tba/slices/exercises/README.md deleted file mode 100644 index 3cdf5ff..0000000 --- a/x-tba/slices/exercises/README.md +++ /dev/null @@ -1,68 +0,0 @@ -# Slice Exercises - ---- - -# ANNOUNCEMENT - -I teach you what the other courses don't even care to teach. - -**What's new?** -* New Section: Advanced Slice Operations -* New Exercises for the Slice Internals -* New Exercises for the Slices: Advanced Operations - -**What are you going to learn?** -* Full Slice Expressions: Limiting access to the backing array -* Make(): Preallocation -* Copy(): Efficiently and safely copy elements without using a loop -* Multi-Dimensional Slices - -**What's coming next?** -* Empty Filer Finder: Your first taste of file operations. -* Bouncing Ball: Create a bouncing ball animation on a 2D surface. -* Png Parser: Parse a PNG file by hand and tell its dimensions. - -These lectures will be added in the next 3 weeks. - -**Statistics:** -* +1 hour of additional content! -* +5 new lectures -* +20 new questions -* 3 + ? new exercises - -**Total content in the slices section:** -* ? hours -* ? lectures -* ? questions -* ? exercises - ---- - -## Full Slice Exp + Make + Copy + Multi-Dim Slices - -# FIX THIS -1. **[Limit the backing array sharing](https://github.com/inancgumus/learngo/tree/master/16-slices/exercises/??-limit-the-backing-array-sharing)** - -* fix the excess memory allocation - * return a huge slice from a func, ask the student fix it -* full slice exp: https://play.golang.org/p/SPrLspRBXdI -* copy: https://play.golang.org/p/SPrLspRBXdI - * + put \n for the beatles exercise using copy - ```go - s = append(s, 0 /* use the zero value of the element type */) - copy(s[i+1:], s[i:]) - s[i] = x - ``` - - -* multi dim slices batches -```go -actions := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} -batchSize := 3 -var batches [][]int - -for batchSize < len(actions) { - actions, batches = actions[batchSize:], append(batches, actions[0:batchSize:batchSize]) -} -batches = append(batches, actions) -``` \ No newline at end of file diff --git a/x-tba/slices/exercises/_template/main.go b/x-tba/slices/exercises/_template/main.go deleted file mode 100644 index f7bc9c3..0000000 --- a/x-tba/slices/exercises/_template/main.go +++ /dev/null @@ -1,14 +0,0 @@ -package main - -// --------------------------------------------------------- -// EXERCISE: ? -// -// -// -// EXPECTED OUTPUT -// -// -// --------------------------------------------------------- - -func main() { -} diff --git a/x-tba/slices/exercises/_template/solution/main.go b/x-tba/slices/exercises/_template/solution/main.go deleted file mode 100644 index b5e729e..0000000 --- a/x-tba/slices/exercises/_template/solution/main.go +++ /dev/null @@ -1,11 +0,0 @@ -// For more tutorials: https://blog.learngoprogramming.com -// -// Copyright © 2018 Inanc Gumus -// Learn Go Programming Course -// License: https://creativecommons.org/licenses/by-nc-sa/4.0/ -// - -package main - -func main() { -}