Решение на Домашно 1 - търсене на съкровища от Илиян Гаврилов

Обратно към всички решения

Към профила на Илиян Гаврилов

Код

use std::sync::{mpsc, Arc, Mutex};

use std::thread;

#[derive(Debug, Clone, PartialEq, Eq)]

pub struct TreasureLoc {

pub lane_index: usize,

pub cell_coord: usize,

pub value: i32,

}

#[derive(Debug, PartialEq, Eq)]

pub enum FoundTreasures {

Big(TreasureLoc),

Small(Vec<TreasureLoc>),

Nothing,

}

pub struct Scan<'a> {

pub start_coord: usize,

pub cells: &'a [i32],

}

#[derive(Debug)]

enum DroneMessage {

Treasure(TreasureLoc),

Done,

}

const fn assert_send_static<T: Send + 'static>() {}

const _: () = assert_send_static::<DroneController>();

const _: () = assert_send_static::<Drone>();

pub struct DroneController {

state: Arc<Mutex<(usize, mpsc::Receiver<DroneMessage>)>>,

Няма нужда от Arc<Mutex<_>> - състоянието не се споделя никъде. Може да са обикновнни полета на структурата.
Методите create_drone и run няма как да се извикат едновременно един с друг, защото всичките приемат ексклузивна референция &mut self.

Никола коментира преди около 1 месеца

sender: mpsc::Sender<DroneMessage>,

}

impl DroneController {

pub fn new() -> Self {

let (sender, receiver) = mpsc::channel();

DroneController {

state: Arc::new(Mutex::new((0, receiver))),

sender: sender.clone(),

}

}

pub fn create_drone(&mut self, lane_index: usize) -> Drone {

let mut state = self.state.lock().unwrap();

state.0 += 1;

Drone {

lane_index,

sender: self.sender.clone(),

}

}

pub fn run(&mut self) -> FoundTreasures {

let (num_drones, receiver) = {

let mut state = self.state.lock().unwrap();

let num_drones = state.0;

let receiver = std::mem::replace(&mut state.1, mpsc::channel().1);

(num_drones, receiver)

};

let mut treasures_by_lane: Vec<TreasureLoc> = Vec::new();

let mut current_sum: i32 = 0;

let mut completed_drones: usize = 0;

for msg in receiver.iter() {

match msg {

DroneMessage::Treasure(t) => {

if t.value >= 999 {

return FoundTreasures::Big(t);

}

if let Some(existing) = treasures_by_lane.iter_mut().find(|x| x.lane_index == t.lane_index) {

if t.value > existing.value {

current_sum -= existing.value;

current_sum += t.value;

*existing = t;

}

} else {

current_sum += t.value;

treasures_by_lane.push(t);

}

if current_sum >= 300 {

return FoundTreasures::Small(treasures_by_lane);

}

}

DroneMessage::Done => {

completed_drones += 1;

if completed_drones == num_drones {

return FoundTreasures::Nothing;

}

}

}

}

FoundTreasures::Nothing

}

}

pub struct Drone {

lane_index: usize,

sender: mpsc::Sender<DroneMessage>,

}

impl Drone {

pub fn explore(&mut self, scanner: &mut dyn Iterator<Item = Scan<'_>>) {

for scan in scanner {

for (cell_offset, &value) in scan.cells.iter().enumerate() {

if value > 0 {

let treasure = TreasureLoc {

lane_index: self.lane_index,

cell_coord: scan.start_coord + cell_offset,

value,

};

if self.sender.send(DroneMessage::Treasure(treasure)).is_err() {

return;

}

}

}

}

let _ = self.sender.send(DroneMessage::Done);

}

}

fn main() {}

Лог от изпълнението

Updating crates.io index
     Locking 46 packages to latest compatible versions
   Compiling proc-macro2 v1.0.104
   Compiling libc v0.2.178
   Compiling unicode-ident v1.0.22
   Compiling quote v1.0.42
   Compiling syn v2.0.111
   Compiling futures-core v0.3.31
   Compiling futures-sink v0.3.31
   Compiling parking_lot_core v0.9.12
   Compiling pin-project-lite v0.2.16
   Compiling futures-channel v0.3.31
   Compiling memchr v2.7.6
   Compiling cfg-if v1.0.4
   Compiling slab v0.4.11
   Compiling futures-task v0.3.31
   Compiling smallvec v1.15.1
   Compiling futures-io v0.3.31
   Compiling pin-utils v0.1.0
   Compiling scopeguard v1.2.0
   Compiling lock_api v0.4.14
   Compiling errno v0.3.14
   Compiling signal-hook-registry v1.4.8
   Compiling parking_lot v0.12.5
   Compiling mio v1.1.1
   Compiling futures-macro v0.3.31
   Compiling tokio-macros v2.6.0
   Compiling socket2 v0.6.1
   Compiling futures-util v0.3.31
   Compiling bytes v1.11.0
   Compiling tokio v1.48.0
   Compiling futures-executor v0.3.31
   Compiling futures v0.3.31
   Compiling solution v0.1.0 (/tmp/d20251229-4108951-15d8cxx/solution)
warning: unused import: `std::thread`
 --> src/lib.rs:2:5
  |
2 | use std::thread;
  |     ^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: function `assert_send_static` is never used
  --> src/lib.rs:29:10
   |
29 | const fn assert_send_static<T: Send + 'static>() {}
   |          ^^^^^^^^^^^^^^^^^^
   |
   = note: `#[warn(dead_code)]` on by default

warning: function `main` is never used
   --> src/lib.rs:131:4
    |
131 | fn main() {}
    |    ^^^^

warning: `solution` (lib) generated 3 warnings (run `cargo fix --lib -p solution` to apply 1 suggestion)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 18.01s
     Running tests/solution_test.rs (target/debug/deps/solution_test-f512224d9fb3caf8)

running 5 tests
test solution_test::test_nothing ... ok
test solution_test::test_big_treasure ... ok
test solution_test::test_small_treasure ... ok
test solution_test::test_small_treasure_2 ... ok
test solution_test::test_return_immediately_when_found ... FAILED

failures:

---- solution_test::test_return_immediately_when_found stdout ----
thread 'solution_test::test_return_immediately_when_found' panicked at tests/solution_test.rs:234:60:
test timeout
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    solution_test::test_return_immediately_when_found

test result: FAILED. 4 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 3.00s

error: test failed, to rerun pass `--test solution_test`

История (1 версия и 1 коментар)