Day 1 Morning Exercises

Arrays and for Loops

(back to exercise)

  1. // Copyright 2022 Google LLC
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. //      http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  15. // ANCHOR: transpose
  16. fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {
  17.     // ANCHOR_END: transpose
  18.     let mut result = [[0; 3]; 3];
  19.     for i in 0..3 {
  20.         for j in 0..3 {
  21.             result[j][i] = matrix[i][j];
  22.         }
  23.     }
  24.     return result;
  25. }
  27. // ANCHOR: pretty_print
  28. fn pretty_print(matrix: &[[i32; 3]; 3]) {
  29.     // ANCHOR_END: pretty_print
  30.     for row in matrix {
  31.         println!("{row:?}");
  32.     }
  33. }
  35. // ANCHOR: tests
  36. #[test]
  37. fn test_transpose() {
  38.     let matrix = [
  39.         [101, 102, 103], //
  40.         [201, 202, 203],
  41.         [301, 302, 303],
  42.     ];
  43.     let transposed = transpose(matrix);
  44.     assert_eq!(
  45.         transposed,
  46.         [
  47.             [101, 201, 301], //
  48.             [102, 202, 302],
  49.             [103, 203, 303],
  50.         ]
  51.     );
  52. }
  53. // ANCHOR_END: tests
  55. // ANCHOR: main
  56. fn main() {
  57.     let matrix = [
  58.         [101, 102, 103], // <-- the comment makes rustfmt add a newline
  59.         [201, 202, 203],
  60.         [301, 302, 303],
  61.     ];
  63.     println!("matrix:");
  64.     pretty_print(&matrix);
  66.     let transposed = transpose(matrix);
  67.     println!("transposed:");
  68.     pretty_print(&transposed);
  69. }

Bonus question

It requires more advanced concepts. It might seem that we could use a slice-of-slices (&[&[i32]]) as the input type to transpose and thus make our function handle any size of matrix. However, this quickly breaks down: the return type cannot be &[&[i32]] since it needs to own the data you return.

You can attempt to use something like Vec<Vec<i32>>, but this doesn’t work out-of-the-box either: it’s hard to convert from Vec<Vec<i32>> to &[&[i32]] so now you cannot easily use pretty_print either.

Once we get to traits and generics, we’ll be able to use the std::convert::AsRef trait to abstract over anything that can be referenced as a slice.

  1. use std::convert::AsRef;
  2. use std::fmt::Debug;
  4. fn pretty_print<T, Line, Matrix>(matrix: Matrix)
  5. where
  6.     T: Debug,
  7.     // A line references a slice of items
  8.     Line: AsRef<[T]>,
  9.     // A matrix references a slice of lines
  10.     Matrix: AsRef<[Line]>
  11. {
  12.     for row in matrix.as_ref() {
  13.         println!("{:?}", row.as_ref());
  14.     }
  15. }
  17. fn main() {
  18.     // &[&[i32]]
  19.     pretty_print(&[&[1, 2, 3], &[4, 5, 6], &[7, 8, 9]]);
  20.     // [[&str; 2]; 2]
  21.     pretty_print([["a", "b"], ["c", "d"]]);
  22.     // Vec<Vec<i32>>
  23.     pretty_print(vec![vec![1, 2], vec![3, 4]]);
  24. }

In addition, the type itself would not enforce that the child slices are of the same length, so such variable could contain an invalid matrix.