Question improvements

Author: postrational

questions/q027.yaml

@@ -1,34 +1,33 @@
 question: |-
   ```rust
-  use std::rc::Rc;
-  use std::sync::Arc;
-  use std::thread;
+    use std::rc::Rc;
+    use std::sync::Arc;
+    use std::thread;
 
-  // Version A
-  fn version_a() {
-      let data = Rc::new(vec![1, 2, 3]);
-      let data_clone = Rc::clone(&data);
-      
-      thread::spawn(move || {
-          println!("{:?}", data_clone);
-      });
-  }
+    // Version A
+    fn version_a() {
+        let data = Rc::new(vec![1, 2, 3]);
+        let data_clone = Rc::clone(&data);
+        
+        thread::spawn(move || {
+            println!("{:?}", data_clone);
+        }).join();
+    }
 
-  // Version B  
-  fn version_b() {
-      let data = Arc::new(vec![1, 2, 3]);
-      let data_clone = Arc::clone(&data);
-      
-      thread::spawn(move || {
-          println!("{:?}", data_clone);
-      });
-  }
+    // Version B  
+    fn version_b() {
+        let data = Arc::new(vec![1, 2, 3]);
+        let data_clone = Arc::clone(&data);
+        
+        thread::spawn(move || {
+            println!("{:?}", data_clone);
+        }).join();
+    }
 
-  fn main() {
-      // Uncommenting version_a() would cause a compilation error
-      version_a();
-      // version_b();
-  }
+    fn main() {
+        version_a();
+        version_b();
+    }
   ```
 
   Which code compiles?

questions/q038.yaml

@@ -1,5 +1,13 @@
 question: |-
   ```rust
+  fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
+      if x.len() > y.len() {
+          x
+      } else {
+          y
+      }
+  }
+  
   fn main() {
       let string1 = String::from("long string");
       let result;
@@ -9,14 +17,6 @@ question: |-
       }
       println!("{}", result);
   }
-
-  fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
-      if x.len() > y.len() {
-          x
-      } else {
-          y
-      }
-  }
   ```
 
   What happens when this code runs?

questions/q064.yaml

@@ -64,12 +64,15 @@ explanation: |-
 
   ```rust
   trait Plugin: Any {
-      fn name(&self) -> &str;
-      fn execute(&self);
-      
-      fn as_any(&self) -> &dyn Any {
-          self
-      }
+      fn as_any(&self) -> &dyn Any;
+  }
+
+  impl Plugin for AudioPlugin {
+      fn as_any(&self) -> &dyn Any { self }
+  }
+
+  impl Plugin for VideoPlugin {
+      fn as_any(&self) -> &dyn Any { self }
   }
   ```
 

questions/q073.yaml

@@ -21,7 +21,7 @@ question: |-
   What happens when you try to compile this code?
 answers:
 - The code compiles and runs successfully
-- 'Compilation error: the trait `MyTrait` is not dyn compatible because method `method` references the `Self` type in its return type'
+- 'Compilation error: the trait `MyTrait` is not dyn compatible
 - 'Compilation error: `MyStruct` does not implement `MyTrait`'
 - Runtime panic occurs when creating the trait object
 correct_answer: 1

questions/q078.yaml

@@ -0,0 +1,44 @@
+question: |-
+  ```rust
+  fn main() {
+      let mut s = String::from("hello");
+      let r1 = &s;
+      let r2 = &s;
+      drop(r1);
+      drop(r2);
+      println!("{} {}", r1, r2);
+  }
+  ```
+
+  What happens when you run this code?
+answers:
+- Prints "hello hello"
+- 'Compilation error: borrow of moved value'
+- 'Runtime panic: use after drop'
+- 'Compilation error: cannot drop a reference'
+correct_answer: 0
+expected_output:
+- 'hello hello'
+explanation: |-
+  This question tests understanding of reference semantics and the `drop()` function
+  in Rust. The key misconception is thinking that calling `drop()` on a reference
+  will invalidate it or move it, making it unusable afterward.
+  
+  In reality, references are `Copy` types, meaning they are copied (not moved) when
+  passed to functions. When `drop(r1)` is called, a copy of the reference is passed
+  to the `drop()` function, and that copy is dropped. The original binding `r1`
+  remains valid and unchanged. The same applies to `r2`.
+  
+  After both `drop()` calls, `r1` and `r2` are still valid references pointing to
+  the string `s`, so `println!("{} {}", r1, r2)` successfully prints `hello hello`.
+  
+  Calling `drop()` on a reference is effectively a no-op—it drops a copy of the
+  reference, not the referenced data itself. This is fundamentally different from
+  calling `drop()` on an owned value, which would move the value and make it
+  inaccessible.
+  
+  The key takeaway is that references implement `Copy`, so passing them to functions
+  (including `drop()`) creates copies rather than moves. Dropping a reference has no
+  effect on either the reference binding or the underlying data. To actually
+  invalidate references, you would need to drop or mutate the owned value they refer
+  to, not the references themselves.