diff --git a/subjects/arrange_it/README.md b/subjects/arrange_it/README.md index 50a2544c2..062d88949 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,24 @@ 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](https://doc.rust-lang.org/std/primitive.str.html) ### 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/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 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![ 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$ ``` 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); } ``` 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 diff --git a/subjects/name_initials/README.md b/subjects/name_initials/README.md index e52fb6367..f4a394519 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)); + let mut names = vec!["Harry Potter", "Someone Else", "J. L.", "Barack Obama"] + println!("{:?}", initials(&mut names)); } ``` 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 diff --git a/subjects/string_literal/README.md b/subjects/string_literals/README.md similarity index 81% rename from subjects/string_literal/README.md rename to subjects/string_literals/README.md index ddbf41f73..f159e6889 100644 --- a/subjects/string_literal/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$ ``` 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!( "{:?}",