rust/okor6: comparison src/main.rs

equal deleted inserted replaced

-:950660fddec0
+:3d9dba5b16e0
 // #[allow(dead_code, unused)]
 // vigyazz6! autplayer
 //
 use core::{fmt, panic};
-use std::{collections::VecDeque, time::Instant, i64::MAX};
+use std::{collections::VecDeque, time::Instant, cmp::Reverse};
 use rand::Rng;
 use std::mem;
 extern crate pretty_env_logger;
 #[macro_use] extern crate log;
 fn len( &self ) -> usize {
 self.content.len()
 }
-fn get_nth( &mut self, n: usize ) -> Card {
+fn _get_nth( &mut self, n: usize ) -> Card {
 if let Some(c) = self.content.remove(n) {
 c
 } else {
 panic!("get_nth: index {} out of bounds ({})!", n, self.content.len());
 }
 self.rows_busted += 1;
 trace!("Player {} got busted, count {}", self.name, &self.rows_busted);
 }
 // ask the player their score
-fn tell_points( self ) -> i32 {
+fn _tell_points( self ) -> i32 {
 self.game_point
 }
 fn inc_wins( &mut self ) {
 self.wins += 1;
 // card too small: pick a row to collect from the rows
 fn pick_row_for_small_card( &self, rows: &Vec<Row>, playercard: &Card ) -> usize {
 trace!("Player {} picking a row for small card, card {:?}, rows {:?}", self.name, playercard, rows);
 // contains the summary point for each row
-let mut row_points = Vec::new();
+let mut row_points = Vec::with_capacity(5);
 // the smallest row score
 let mut smallest = 999;
 // how many rows have the same smallest score
 let mut same_point = 0;
 // the first smallest row_id
 impl Row {
 const MAX_LEN: usize = 5;
 fn new() -> Self {
 Row {
-cards: VecDeque::new(),
+cards: VecDeque::with_capacity(5),
 }
 }
 fn push_or_collect( &mut self, card: Card ) -> Option<VecDeque<Card>> {
 trace!("Called push_or_collect on row {:?}", &self);
 player_id: i32,
 card: Card,
 }
 impl PlayerCard {
-fn get_player(&self) -> i32 {
+fn _get_player(&self) -> i32 {
 self.player_id
 }
 }
 impl PartialEq for PlayerCard {
 player_cards: VecDeque<PlayerCard>, // owned by a player
 }
 impl Table {
 fn new(row_cards: VecDeque<Card>) -> Self {
-let mut rows = Vec::new();
+let mut rows = Vec::with_capacity(5);
 for card in row_cards {
 // create a new row then put a card into it
 let mut row = Row::new();
-if let Some(c) = row.push_or_collect(card) {
+if let Some(_c) = row.push_or_collect(card) {
 panic!("Freshly created row overflowed");
 }
 rows.push( row );
 }
 stats.shuffle_count += 1;
 stats.game_count += 1;
 // dealing
 debug!("Dealing.");
-for i in 1..=10 {
+for _i in 1..=10 {
 for player in 0 .. player_count {
 players[player].get_card( deck.pop().expect("Deck is empty while dealing to players") );
 }
 }
 // we need 5 crds from deck
 debug!("Building the rows.");
 let mut cards = VecDeque::new();
-for i in 1..=5 {
+(1..=5).for_each(|_| {
 cards.push_back( deck.pop().expect("deck empty before starting the game") );
-}
+});
 // println!("We push 5 cards to rows: {:?}\n", cards);
 let mut table = Table::new(cards);
 // DEBUG
 /*         println!("Table: {:?}\n", table);
 let cards = table.take_row(rowid);
 trace!("Took cards: {:?}", cards);
 players[ player_id ].give_pile( cards );
 // put new card in the row
 let overflow = table.put_card_into_row(smallest, rowid);
-if let Some(c) = overflow {
+if let Some(_) = overflow {
 panic!("Player took whole row and it's already full");
 }
 }
 }
 }
 player.close_round();
 });
 */
 }
-println!("Totals (game time {} µs, or {} s), {} games played ({} shuffles):",
+let elapsed_micro: f64 = stats.start_time.elapsed().as_micros() as f64;
+let game_rounds: f64 = GAME_ROUNDS.into();
+let _res: f64 = stats.start_time.elapsed().as_micros() as f64 / <i32 as Into<f64>>::into(GAME_ROUNDS);
+println!("Totals (game time {} µs, or {} s; {} µs/game), {} games played ({} shuffles):",
 stats.start_time.elapsed().as_micros(),
 stats.start_time.elapsed().as_secs(),
+elapsed_micro / game_rounds,
 stats.game_count,
 stats.shuffle_count,
 );
-players.sort_by( |a, b| a.total_point.partial_cmp(&b.total_point).unwrap() );
+// players.sort_by( |a, b| a.total_point.partial_cmp(&b.total_point).unwrap() );    // ASC points
+// players.sort_by( |a, b| b.wins.partial_cmp(&a.wins).unwrap() );                  // DESC wins
+players.sort_by_cached_key( |x| Reverse(x.wins) );                                  // DESC wins (caching is just for the show)
 for i in 0..players.len() {
 let p = &players[i];
 println!("Player {} has wins {}, score {} (busted {} times)", p.name, p.wins, p.total_point, p.rows_busted);
 }
 }
 #[cfg(test)]
 mod tests {
-use core::panic;
+// use core::panic;
 use std::collections::VecDeque;
 use rand::Rng;
 use crate::{Card, Player, Row, Table, PlayerCard};
 #[test]
 fn sort_cards() {
 let mut cards: VecDeque<Card> = VecDeque::new();
 let mut rng = rand::thread_rng();
-for i in 1..50 {
+for _ in 1..50 {
 let n = rng.gen_range(1..104);
 cards.push_back( Card::new(n) );
 }
 cards.make_contiguous().sort();

changeset 3	3d9dba5b16e0
parent 2	950660fddec0
child 4	a2f0cb2b5c13