From 31e5669e54ad41fb67e2d5141e7cd8cb85059fc5 Mon Sep 17 00:00:00 2001 From: Chris Date: Sat, 6 Feb 2021 20:16:01 +0000 Subject: [PATCH 01/12] looping extra hints --- subjects/looping/README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/subjects/looping/README.md b/subjects/looping/README.md index 982b05b63..93d71c33b 100644 --- a/subjects/looping/README.md +++ b/subjects/looping/README.md @@ -12,6 +12,11 @@ Riddle: I am the beginning of the end, and the end of time and space. I am essen Answer: The letter e +### Notions + +- [Moduler std::io](https://doc.rust-lang.org/std/io/index.html) +- [loop](https://doc.rust-lang.org/std/keyword.loop.html) + ### Usage ```console From c4c7fabfd042d7f29f45421b0de425c169ed3336 Mon Sep 17 00:00:00 2001 From: Chris Date: Sat, 6 Feb 2021 23:18:11 +0000 Subject: [PATCH 02/12] reformating and notions --- subjects/ownership/README.md | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/subjects/ownership/README.md b/subjects/ownership/README.md index 6a5eda1fa..ec14faf9e 100644 --- a/subjects/ownership/README.md +++ b/subjects/ownership/README.md @@ -2,10 +2,14 @@ ### Instruction -- Create a function that takes ownership of a string and returns the first sub-word in it +- Create a **function** that takes ownership of a string and returns the first sub-word in it - It should work for `camelCase` as well as `snake_case` +### Notions + +- [ownership](https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html) + ### Expected Function ```rust @@ -15,9 +19,11 @@ pub fn first_subword(mut s: String) -> String { ### Usage -Here is a program to test your function +Here is a program to test your function: ```rust +use ownership::first_subword; + fn main() { let s1 = String::from("helloWorld"); let s2 = String::from("snake_case"); @@ -31,7 +37,7 @@ fn main() { } ``` -And its output +And its output: ```console student@ubuntu:~/[[ROOT]]/test$ cargo run From 91fea647f98c5f3cbf13a54fc1ffd0160186b422 Mon Sep 17 00:00:00 2001 From: Chris Date: Sun, 7 Feb 2021 21:49:17 +0000 Subject: [PATCH 03/12] clarifications --- subjects/copy/README.md | 45 +++++++++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 17 deletions(-) diff --git a/subjects/copy/README.md b/subjects/copy/README.md index d35ad9909..0b6f8c4a1 100644 --- a/subjects/copy/README.md +++ b/subjects/copy/README.md @@ -2,17 +2,25 @@ ### Instructions -Your objective is to fix the program so that all functions work. +Your objective is to fix the **functions** work so that the program works. -- `nbr_function`, returns a tuple with the original value, the exponential and logarithm of that value -- `str_function`, returns a tuple with the original value and the exponential of that value as a string -- `vec_function`, returns a tuple with the original value and the logarithm of each value +- `nbr_function` returns a tuple: + - with the `original` value + - the `exponential function` of the value + - and the `natural logarithm` of this `absolute` value +- `str_function` returns a tuple: + - with the `original` value + - and the `exponential function` each value as a string (see the example) +- `vec_function` returns a tuple: + - with the `original` value + - and the `natural logarithm` of each `absolute` value -The objective is to now how ownership works with different types. +The objective is to know how ownership works with different types. ### Notions -- https://doc.rust-lang.org/rust-by-example/scope/move.html +- [scope](https://doc.rust-lang.org/rust-by-example/scope/move.html) +- [Primitive Type f64](https://doc.rust-lang.org/std/primitive.f64.html) ### Expected Functions @@ -32,18 +40,21 @@ pub fn vec_function(b: Vec) -> (Vec, Vec) { Here is a possible program to test your function : ```rust +use copy::*; + fn main() { - let a = String::from("1 2 4 5 6"); - let b = vec![1, 2, 4, 5]; - let c: u32 = 0; - - println!("{:?}", nbr_function(c)); - // output: (12, 162754.79141900392, 2.4849066497880004) - println!("{:?}", vec_function(b)); - // output: ([1, 2, 4], [0.0, 0.6931471805599453, 1.3862943611198906]) - println!("{:?}", str_function(a)); - // output: ("1 2 4", "2.718281828459045 7.38905609893065 54.598150033144236") + let a: u32 = 0; + let b = String::from("1 2 4 5 6"); + let c = vec![1, 2, 4, 5]; + + println!("{:?}", nbr_function(a)); + // output : (0, 1.0, inf) + println!("{:?}", str_function(b)); + // output : ("1 2 4 5 6", "2.718281828459045 7.38905609893065 54.598150033144236 148.4131591025766 403.4287934927351") + println!("{:?}", vec_function(c)); + // output : ([1, 2, 4, 5], [0.0, 0.6931471805599453, 1.3862943611198906, 1.6094379124341003]) } + ``` And its output: @@ -51,7 +62,7 @@ And its output: ```console student@ubuntu:~/[[ROOT]]/test$ cargo run (0, 1.0, inf) -([1, 2, 4, 5], [0.0, 0.6931471805599453, 1.3862943611198906, 1.6094379124341003]) ("1 2 4 5 6", "2.718281828459045 7.38905609893065 54.598150033144236 148.4131591025766 403.4287934927351") +([1, 2, 4, 5], [0.0, 0.6931471805599453, 1.3862943611198906, 1.6094379124341003]) student@ubuntu:~/[[ROOT]]/test$ ``` From c8eaec810012d605978e9b24760626b43875fc71 Mon Sep 17 00:00:00 2001 From: Chris Date: Mon, 8 Feb 2021 01:32:57 +0000 Subject: [PATCH 04/12] added notions --- subjects/borrow/README.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/subjects/borrow/README.md b/subjects/borrow/README.md index 12c24715f..0020d6c03 100644 --- a/subjects/borrow/README.md +++ b/subjects/borrow/README.md @@ -2,14 +2,17 @@ ### Instructions -Complete the signature and the body of the `str_len` that receives a string or a string literal and returns its length without taking ownership of the value (i.e, borrowing the value) +Complete the signature and the body of the `str_len` **function** that receives a string or a string literal and returns its length without taking ownership of the value (i.e, borrowing the value). -### Expected Function +### Expected Function (The signature needs to be completed) ```rust pub fn str_len(s: ) -> usize { } ``` +### Notions + +[Primitive Type str](https://doc.rust-lang.org/std/primitive.str.html) ### Usage From cb8e2ab297189b4f40eb96a036bfa6ca61ad906d Mon Sep 17 00:00:00 2001 From: Chris Date: Mon, 8 Feb 2021 13:51:22 +0000 Subject: [PATCH 05/12] clarifications and notions --- subjects/borrow_me_the_reference/README.md | 6 +++++- subjects/changes/README.md | 13 ++++++++++--- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/subjects/borrow_me_the_reference/README.md b/subjects/borrow_me_the_reference/README.md index 641610522..4edd109e7 100644 --- a/subjects/borrow_me_the_reference/README.md +++ b/subjects/borrow_me_the_reference/README.md @@ -7,7 +7,11 @@ needing garbage collector. Therefore you must understand ownership in rust. Create the following functions : - - `delete_and_backspace`, imagine that `-` represents the backspace key and the `+` represents the delete key, this function must receive a borrowed string and turn this string into the string without the backspaces and the deletes. + - `delete_and_backspace`, imagine that the `-` represents the `backspace key` and the `+` represents the `delete key`, this function must receive a borrowed string and turn this string into the string that applies the `backspaces` and the `deletes`. + - For example: + - "helll-o" turns into "hello" + + - "he+lllo" turns into "hello" - `is_correct` that borrows a Vector of string literals with some correct and incorrect math equations and replaces the correct equations with `✔` and the wrong with `✘` and returns a `usize` with the percentage of correct equations. diff --git a/subjects/changes/README.md b/subjects/changes/README.md index f6f096f25..01c5af92d 100644 --- a/subjects/changes/README.md +++ b/subjects/changes/README.md @@ -2,11 +2,16 @@ ### Instructions -Imagine you are working in a software to control smart lights in a house. You have access to an array of all the lights in a house. +Imagine you are working on a software to control smart lights in a house. You have access to an array of all the lights in a house. -Define the associated function `new` to the data structure `Light` which creates a new light with the alias passed in the arguments and a brightness of 0. +Define the associated **function** `new` to the data structure `Light` which creates a new light with the alias passed in the arguments and a brightness of 0. -Define the function `change_brightness` that receives a Vec of lights, an alias and a u8 value and sets the u8 value as the new brightness of the light identified by the alias in the Vec of lights. +Define the **function** `change_brightness` that receives a `Vec` of lights, an `alias` and a `u8`value. The **function** then sets the `u8` value as the new brightness of the light identified by the alias in the Vec of lights. + +### Notions + +[Example of Structs](https://doc.rust-lang.org/book/ch05-02-example-structs.html) +[Keyword Self](https://doc.rust-lang.org/std/keyword.Self.html) ### Expected Functions and Structure @@ -31,6 +36,8 @@ pub fn change_brightness(lights: &mut Vec, alias: &str, value: u8) { Here is an incomplete program to test your function ```rust +use changes::*; + fn main() { // bedroom let mut lights = vec![ From 62cc3d0eb9b41f11d5112b28611ea5c70940d46e Mon Sep 17 00:00:00 2001 From: Chris Date: Mon, 8 Feb 2021 17:51:44 +0000 Subject: [PATCH 06/12] correction --- subjects/name_initials/README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/subjects/name_initials/README.md b/subjects/name_initials/README.md index e52fb6367..b4f318527 100644 --- a/subjects/name_initials/README.md +++ b/subjects/name_initials/README.md @@ -2,7 +2,7 @@ ### Instructions -Create a function called `initials`, this function will receive a vector of string literals +Create a **function** called `initials`, this function will receive a vector of string literals with names and return a vector of Strings with the initials of each name. > This exercise will test the **heap allocation** of your function! @@ -10,25 +10,25 @@ with names and return a vector of Strings with the initials of each name. ### Notions -- https://doc.rust-lang.org/1.22.0/book/first-edition/the-stack-and-the-heap.html +- [stack and heap](https://doc.rust-lang.org/1.22.0/book/first-edition/the-stack-and-the-heap.html) ### Expected Function ```rust -fn initials(names: &mut Vec<&str>) -> Vec { +pub fn initials(names: &mut Vec<&str>) -> Vec { } ``` ### Usage -Here is a program to test your function +Here is a program to test your function: ```rust use name_initials::initials; fn main() { let names = vec!["Harry Potter", "Someone Else", "J. L.", "Barack Obama"] - println!("{:?}", initials(names)); + println!("{:?}", initials(&mut names)); } ``` From 8002cfd522a6c8f56f21b697a74cb966095110a6 Mon Sep 17 00:00:00 2001 From: Chris Date: Mon, 8 Feb 2021 19:38:13 +0000 Subject: [PATCH 07/12] 1) renaming of string_literal folder with an extra s to fix the fetching problem 2) added notions to arrange_it 3) reorganized tic tac toe --- subjects/arrange_it/README.md | 16 +++++---- subjects/string_literal/README.md | 12 +++---- subjects/string_literals/README.md | 53 ++++++++++++++++++++++++++++++ subjects/tic_tac_toe/README.md | 30 +++++++++++------ 4 files changed, 89 insertions(+), 22 deletions(-) create mode 100644 subjects/string_literals/README.md diff --git a/subjects/arrange_it/README.md b/subjects/arrange_it/README.md index 50a2544c2..6d962c251 100644 --- a/subjects/arrange_it/README.md +++ b/subjects/arrange_it/README.md @@ -2,8 +2,8 @@ ### Instructions -Create a function called `arrange_phrase` that takes a string literal as a phrase and returns it organized -Each word will have a number that indicates the position of that word +Create a **function** called `arrange_phrase` that takes a string literal as a phrase and returns it organized +Each word will have a number that indicates the position of that word. > This exercise will test the **heap allocation** of your function! > So try your best to allocate the minimum data on the heap! @@ -11,22 +11,26 @@ Each word will have a number that indicates the position of that word ### Expected Function ```rust -fn arrange_phrase(phrase: &str) -> String { +pub fn arrange_phrase(phrase: &str) -> String { } ``` ### Notions -- https://doc.rust-lang.org/1.22.0/book/first-edition/the-stack-and-the-heap.html -- https://doc.rust-lang.org/std/primitive.str.html#method.split +- [stack and heap](https://doc.rust-lang.org/1.22.0/book/first-edition/the-stack-and-the-heap.html) +- [str.split](https://doc.rust-lang.org/std/primitive.str.html#method.split) +- [str.matches](https://doc.rust-lang.org/std/primitive.str.html#method.matches) +- [str.replace](https://doc.rust-lang.org/std/primitive.str.html#method.replace) ### Usage Here is a program to test your function ```rust +use arrange_it::*; + fn main() { - println!("{:?}", initials("is2 Thi1s T4est 3a")); + println!("{:?}", arrange_phrase("is2 Thi1s T4est 3a")); } ``` diff --git a/subjects/string_literal/README.md b/subjects/string_literal/README.md index ddbf41f73..9c0bac96a 100644 --- a/subjects/string_literal/README.md +++ b/subjects/string_literal/README.md @@ -2,13 +2,13 @@ ### Instructions -Create the following functions: +Create the following **functions**: -- `is_empty`, that returns true if a string is empty -- `is_ascii`, that returns true if all characters of a given string is in ASCII range -- `contains`, that returns true if the string contains a pattern given -- `split_at`, that divides a string in two returning a tuple -- `find', that returns the index if the first character of a given string that matches the pattern +- `is_empty`, which returns `true` if a string is empty +- `is_ascii`, which returns `true` if all characters of a given string is in ASCII range +- `contains`, which returns `true` if the string contains a given pattern +- `split_at`, which divides a string in two returning a tuple +- `find`, which returns the index if the first character of a given string which matches the pattern > This exercise will test the **heap allocation** of your function! > So try your best to allocate the minimum data on the heap! (hit: &str) diff --git a/subjects/string_literals/README.md b/subjects/string_literals/README.md new file mode 100644 index 000000000..ddbf41f73 --- /dev/null +++ b/subjects/string_literals/README.md @@ -0,0 +1,53 @@ +## string literal + +### Instructions + +Create the following functions: + +- `is_empty`, that returns true if a string is empty +- `is_ascii`, that returns true if all characters of a given string is in ASCII range +- `contains`, that returns true if the string contains a pattern given +- `split_at`, that divides a string in two returning a tuple +- `find', that returns the index if the first character of a given string that matches the pattern + +> This exercise will test the **heap allocation** of your function! +> So try your best to allocate the minimum data on the heap! (hit: &str) + +### Notions + +- https://doc.rust-lang.org/1.22.0/book/first-edition/the-stack-and-the-heap.html +- https://doc.rust-lang.org/rust-by-example/primitives/literals.html + +### Expected Functions + +```rust +fn is_empty(v: &str) -> bool { +} + +fn is_ascii(v: &str) -> bool { +} + +fn contains(v: &str, pat: &str) -> bool { +} + +fn split_at(v: &str, index: usize) -> (&str, &str) { +} + +fn find(v: &str, pat: char) -> usize { +} +``` + +### Usage + +Here is a program to test your function + +```rust + +``` + +And its output + +```console +student@ubuntu:~/[[ROOT]]/test$ cargo run +student@ubuntu:~/[[ROOT]]/test$ +``` diff --git a/subjects/tic_tac_toe/README.md b/subjects/tic_tac_toe/README.md index 5086b6f9c..97d5728cb 100644 --- a/subjects/tic_tac_toe/README.md +++ b/subjects/tic_tac_toe/README.md @@ -2,32 +2,40 @@ ### Instructions -You must create a tic tac toe checker. +You must create a `tic tac toe` checker. Create the following functions: -- `tic_tac_toe` that receives a table of vectors (Vec>) and returns a string : `player O won` or `player X won` or `Tie` -- `diagonals` that will receive a player and a table. It should return a boolean, this must return true if all the diagonals are completed by the player -- `horizontal` that will receive a player and a table. It should return a boolean, this must return true if one of the horizontal lines are completed by the player -- `vertical` that will receive a player and a table. It should return a boolean, this must return true if one of the vertical lines are completed by the player +- `tic_tac_toe` which receives: + - a table of vectors (Vec>). + - It should return a String `player O won` or `player X won` or `Tie`. +- `diagonals` which will receive: + - a player and a table. + - It should return a boolean, this must return `true` if all the diagonals are completed by the player. +- `horizontal` which will receive: + - a player and a table. + - It should return a boolean, this must return `true` if one of the horizontal lines are completed by the player. +- `vertical` which will receive: + - a player and a table. + - It should return a boolean, this must return `true` if one of the vertical lines are completed by the player. ### Notions -- https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html +- [references and borrowing](https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html) ### Expected Functions ```rust -fn tic_tac_toe(table: Vec>) -> String { +pub fn tic_tac_toe(table: Vec>) -> String { } -fn diagonals(player: &str, table: &Vec>) -> bool { +pub fn diagonals(player: &str, table: &Vec>) -> bool { } -fn horizontal(player: &str, table: &Vec>) -> bool { +pub fn horizontal(player: &str, table: &Vec>) -> bool { } -fn vertical(player: &str, table: &Vec>) -> bool { +pub fn vertical(player: &str, table: &Vec>) -> bool { } ``` @@ -36,6 +44,8 @@ fn vertical(player: &str, table: &Vec>) -> bool { Here is a program to test your function ```rust +use tic_tac_toe::*; + fn main() { println!( "{:?}", From 4c94911c4628ec0eb474250739b0e2ad03ea7029 Mon Sep 17 00:00:00 2001 From: Augusto Date: Mon, 8 Feb 2021 20:29:37 +0000 Subject: [PATCH 08/12] Correct subject for doubtful --- subjects/doubtful/README.md | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/subjects/doubtful/README.md b/subjects/doubtful/README.md index fcdae0002..c8c0bb9fe 100644 --- a/subjects/doubtful/README.md +++ b/subjects/doubtful/README.md @@ -2,14 +2,20 @@ ### Instructions -Write a function called `doubtful` that adds to every string passed to it a question mark (?) +Write a function called `doubtful` that adds to every string passed to it a question mark (?). -You have to fix the code to make it compile an for that you can only modify the code where is indicated +You have to complete the signature the functions to make it fit the usage and you also have to modify the usage to be able to do what is expected. + +- Restrictions: + + - `doubtful` cannot return any value. + + - And in the example of the usage you can only modify the argument of the function ### Expected ```rust -pub fn doubtful(s: &mut String) { +pub fn doubtful(s: /*give the correct type*/ ) { } ``` @@ -22,7 +28,9 @@ fn main() { let mut s = String::from("Hello"); println!("Before changing the string: {}", s); - doubtful(&mut s); + + doubtful(/*add your code here*/); + println!("After changing the string: {}", s); } ``` From d9a560c89de9902d080f99d773610d5f4a362166 Mon Sep 17 00:00:00 2001 From: lee Date: Tue, 9 Feb 2021 09:02:44 +0000 Subject: [PATCH 09/12] adding usage to string_literal --- subjects/string_literal/README.md | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/subjects/string_literal/README.md b/subjects/string_literal/README.md index 9c0bac96a..a251b7a1a 100644 --- a/subjects/string_literal/README.md +++ b/subjects/string_literal/README.md @@ -42,12 +42,23 @@ fn find(v: &str, pat: char) -> usize { Here is a program to test your function ```rust - +fn main() { + println!("{}", is_empty("")); + println!("{}", is_ascii("rust")); + println!("{}", contains("rust", "ru")); + println!("{:?}", split_at("rust", 2)); + println!("{}", find("rust", 'u')); +} ``` And its output ```console student@ubuntu:~/[[ROOT]]/test$ cargo run +true +true +true +("ru", "st") +1 student@ubuntu:~/[[ROOT]]/test$ ``` From 510228d8357119c3bc85dcf2d7d07f914a22cf78 Mon Sep 17 00:00:00 2001 From: lee Date: Tue, 9 Feb 2021 09:06:41 +0000 Subject: [PATCH 10/12] adding use --- subjects/string_literal/README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/subjects/string_literal/README.md b/subjects/string_literal/README.md index a251b7a1a..4641a27c1 100644 --- a/subjects/string_literal/README.md +++ b/subjects/string_literal/README.md @@ -42,6 +42,8 @@ fn find(v: &str, pat: char) -> usize { Here is a program to test your function ```rust +use string_literal::*; + fn main() { println!("{}", is_empty("")); println!("{}", is_ascii("rust")); From a1894a816058e978a510429a422050be58af42f1 Mon Sep 17 00:00:00 2001 From: lee Date: Tue, 9 Feb 2021 09:40:40 +0000 Subject: [PATCH 11/12] adding "mut" and removing extra exercise --- subjects/name_initials/README.md | 2 +- subjects/string_literal/README.md | 66 ------------------------------ subjects/string_literals/README.md | 15 ++++++- 3 files changed, 15 insertions(+), 68 deletions(-) delete mode 100644 subjects/string_literal/README.md diff --git a/subjects/name_initials/README.md b/subjects/name_initials/README.md index b4f318527..f4a394519 100644 --- a/subjects/name_initials/README.md +++ b/subjects/name_initials/README.md @@ -27,7 +27,7 @@ Here is a program to test your function: use name_initials::initials; fn main() { - let names = vec!["Harry Potter", "Someone Else", "J. L.", "Barack Obama"] + let mut names = vec!["Harry Potter", "Someone Else", "J. L.", "Barack Obama"] println!("{:?}", initials(&mut names)); } ``` diff --git a/subjects/string_literal/README.md b/subjects/string_literal/README.md deleted file mode 100644 index 4641a27c1..000000000 --- a/subjects/string_literal/README.md +++ /dev/null @@ -1,66 +0,0 @@ -## string literal - -### Instructions - -Create the following **functions**: - -- `is_empty`, which returns `true` if a string is empty -- `is_ascii`, which returns `true` if all characters of a given string is in ASCII range -- `contains`, which returns `true` if the string contains a given pattern -- `split_at`, which divides a string in two returning a tuple -- `find`, which returns the index if the first character of a given string which matches the pattern - -> This exercise will test the **heap allocation** of your function! -> So try your best to allocate the minimum data on the heap! (hit: &str) - -### Notions - -- https://doc.rust-lang.org/1.22.0/book/first-edition/the-stack-and-the-heap.html -- https://doc.rust-lang.org/rust-by-example/primitives/literals.html - -### Expected Functions - -```rust -fn is_empty(v: &str) -> bool { -} - -fn is_ascii(v: &str) -> bool { -} - -fn contains(v: &str, pat: &str) -> bool { -} - -fn split_at(v: &str, index: usize) -> (&str, &str) { -} - -fn find(v: &str, pat: char) -> usize { -} -``` - -### Usage - -Here is a program to test your function - -```rust -use string_literal::*; - -fn main() { - println!("{}", is_empty("")); - println!("{}", is_ascii("rust")); - println!("{}", contains("rust", "ru")); - println!("{:?}", split_at("rust", 2)); - println!("{}", find("rust", 'u')); -} -``` - -And its output - -```console -student@ubuntu:~/[[ROOT]]/test$ cargo run -true -true -true -("ru", "st") -1 -student@ubuntu:~/[[ROOT]]/test$ -``` diff --git a/subjects/string_literals/README.md b/subjects/string_literals/README.md index ddbf41f73..f159e6889 100644 --- a/subjects/string_literals/README.md +++ b/subjects/string_literals/README.md @@ -42,12 +42,25 @@ fn find(v: &str, pat: char) -> usize { Here is a program to test your function ```rust - +use string_literal::*; + +fn main() { + println!("{}", is_empty("")); + println!("{}", is_ascii("rust")); + println!("{}", contains("rust", "ru")); + println!("{:?}", split_at("rust", 2)); + println!("{}", find("rust", 'u')); +} ``` And its output ```console student@ubuntu:~/[[ROOT]]/test$ cargo run +true +true +true +("ru", "st") +1 student@ubuntu:~/[[ROOT]]/test$ ``` From d06d339fe9176e6df9c271469f2d3d91dd8d9c81 Mon Sep 17 00:00:00 2001 From: Augusto Date: Thu, 11 Feb 2021 15:17:22 +0000 Subject: [PATCH 12/12] Delete too detailed links --- subjects/arrange_it/README.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/subjects/arrange_it/README.md b/subjects/arrange_it/README.md index 6d962c251..062d88949 100644 --- a/subjects/arrange_it/README.md +++ b/subjects/arrange_it/README.md @@ -18,9 +18,7 @@ pub fn arrange_phrase(phrase: &str) -> String { ### Notions - [stack and heap](https://doc.rust-lang.org/1.22.0/book/first-edition/the-stack-and-the-heap.html) -- [str.split](https://doc.rust-lang.org/std/primitive.str.html#method.split) -- [str.matches](https://doc.rust-lang.org/std/primitive.str.html#method.matches) -- [str.replace](https://doc.rust-lang.org/std/primitive.str.html#method.replace) +- [str](https://doc.rust-lang.org/std/primitive.str.html) ### Usage