add initials exercises/samples

Author: EmanueleC

exercises/transpose_exercise.rs

@@ -0,0 +1,22 @@
+/* Add a transpose function using the reverse function as a template, which accepts a matrix as
+ an argument, and returns a matrix in which two elements have been swapped.
+
+fn reverse(pair: (i32, bool)) -> (bool, i32) {
+ let (integer, boolean) = pair;
+
+ (boolean, integer)
+} */
+
+fn transpose(matrix: Matrix) -> Matrix {
+ Matrix(matrix.0, matrix.2, matrix.1, matrix.3)
+}
+
+#[derive(Debug)]
+struct Matrix(f32, f32, f32, f32);
+
+fn main() {
+ let matrix = Matrix(1.1, 1.2, 2.1, 2.2);
+ println!("{:?}", matrix);
+ println!("---");
+ println!("{:?}", transpose(matrix));
+}

first_steps/array_slices.rs

@@ -0,0 +1,36 @@
+use std::mem;
+
+// This function borrows a slice
+fn analyze_slice(slice: &[i32]) {
+ println!("first element of the slice: {}", slice[0]);
+ println!("the slice has {} elements", slice.len());
+}
+
+fn main() {
+ // Fixed-size array (type signature is superfluous)
+ let xs: [i32; 5] = [1, 2, 3, 4, 5];
+
+ // All elements can be initialized to the same value
+ let ys: [i32; 500] = [0; 500];
+
+ // Indexing starts at 0
+ println!("first element of the array: {}", xs[0]);
+ println!("second element of the array: {}", xs[1]);
+
+ // `len` returns the size of the array
+ println!("array size: {}", xs.len());
+
+ // Arrays are stack allocated
+ println!("array occupies {} bytes", mem::size_of_val(&xs));
+
+ // Arrays can be automatically borrowed as slices
+ println!("borrow the whole array as a slice");
+ analyze_slice(&xs);
+
+ // Slices can point to a section of an array
+ println!("borrow a section of the array as a slice");
+ analyze_slice(&ys[1 .. 4]);
+
+ // Out of bound indexing yields a panic
+ // println!("{}", xs[5]);
+}

first_steps/formatted_print.rs

@@ -0,0 +1,45 @@
+fn main() {
+ // In general, the `{}` will be automatically replaced with any
+ // arguments. These will be stringified.
+ println!("{} days", 31);
+
+ // Without a suffix, 31 becomes an i32. You can change what type 31 is,
+ // with a suffix.
+
+ // There are various optional patterns this works with. Positional
+ // arguments can be used.
+ println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob");
+
+ // As can named arguments.
+ println!("{subject} {verb} {object}",
+ object="the lazy dog",
+ subject="the quick brown fox",
+ verb="jumps over");
+
+ // Special formatting can be specified after a `:`.
+ println!("{} of {:b} people know binary, the other half don't", 1, 2);
+
+ // You can right-align text with a specified width. This will output
+ // " 1". 5 white spaces and a "1".
+ println!("{number:>width$}", number=1, width=6);
+
+ // You can pad numbers with extra zeroes. This will output "000001".
+ println!("{number:>0width$}", number=1, width=6);
+
+ // It will even check to make sure the correct number of arguments are
+ // used.
+ println!("My name is {0}, {1} {0}", "Bond", "James");
+ // FIXME ^ Add the missing argument: "James" OK
+
+ // Create a structure which contains an `i32`. Name it `Structure`.
+ #[allow(dead_code)]
+ struct Structure(i32);
+
+ // However, custom types such as this structure require more complicated
+ // handling. This will not work.
+ // println!("This struct `{}` won't print...", Structure(3));
+ // FIXME ^ Comment out this line OK
+
+ let pi = format!("{:.*}", 3, 3.141592);
+ println!("Pi is roughly {}", pi);
+}

first_steps/hello.rs

@@ -0,0 +1,6 @@
+// This is the main function
+fn main() {
+ // this simply print "Hello World!" to the console
+ println!("Hello World!");
+ println!("I'm a Rustacean!");
+}

first_steps/literals_operators.rs

@@ -0,0 +1,24 @@
+fn main() {
+ // Integer addition
+ println!("1 + 2 = {}", 1u32 + 2);
+
+ // Integer subtraction
+ println!("1 - 2 = {}", 1i32 - 2);
+ // TODO ^ Try changing `1i32` to `1u32` to see why the type is important OK
+ // unsigned 1 causes the warning "attempt to subtract with overflow"
+
+ // Short-circuiting boolean logic
+ println!("true AND false is {}", true && false);
+ println!("true OR false is {}", true || false);
+ println!("NOT true is {}", !true);
+
+ // Bitwise operations
+ println!("0011 AND 0101 is {:04b}", 0b0011u32 & 0b0101);
+ println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101);
+ println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101);
+ println!("1 << 5 is {}", 1u32 << 5);
+ println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2);
+
+ // Use underscores to improve readability!
+ println!("One million is written as {}", 1_000_000u32);
+}

first_steps/tuples.rs

@@ -0,0 +1,48 @@
+// Tuples can be used as function arguments and as return values
+fn reverse(pair: (i32, bool)) -> (bool, i32) {
+ // `let` can be used to bind the members of a tuple to variables
+ let (integer, boolean) = pair; // pattern matching
+
+ (boolean, integer) // return
+}
+
+#[derive(Debug)]
+struct Matrix(f32, f32, f32, f32);
+
+fn main() {
+ // A tuple with a bunch of different types
+ let long_tuple = (1u8, 2u16, 3u32, 4u64,
+ -1i8, -2i16, -3i32, -4i64,
+ 0.1f32, 0.2f64,
+ 'a', true);
+
+ // Values can be extracted from the tuple using tuple indexing
+ println!("long tuple first value: {}", long_tuple.0);
+ println!("long tuple second value: {}", long_tuple.1);
+
+ // Tuples can be tuple members
+ let tuple_of_tuples = ((1u8, 2u16, 2u32), (4u64, -1i8), -2i16);
+
+ // Tuples are printable
+ println!("tuple of tuples: {:?}", tuple_of_tuples);
+
+ let pair = (1, true);
+ println!("pair is {:?}", pair);
+
+ println!("the reversed pair is {:?}", reverse(pair));
+
+ // To create one element tuples, the comma is required to tell them apart
+ // from a literal surrounded by parentheses
+ println!("one element tuple: {:?}", (5u32,));
+ println!("just an integer: {:?}", (5u32));
+
+ //tuples can be destructured to create bindings
+ let tuple = (1, "hello", 4.5, true);
+
+ let (a, b, c, d) = tuple;
+ println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);
+
+ let matrix = Matrix(1.1, 1.2, 2.1, 2.2);
+ println!("{:?}", matrix)
+
+}