diff --git a/65_Nim/rust/Cargo.toml b/65_Nim/rust/Cargo.toml new file mode 100644 index 00000000..4032c364 --- /dev/null +++ b/65_Nim/rust/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "nim" +version = "1.0.0" +edition = "2021" + +[dependencies] +text_io = "0.1.10" +nanorand = "0.6.1" \ No newline at end of file diff --git a/65_Nim/rust/src/main.rs b/65_Nim/rust/src/main.rs new file mode 100644 index 00000000..3d4dc304 --- /dev/null +++ b/65_Nim/rust/src/main.rs @@ -0,0 +1,297 @@ +use std::{io::{self, Write}}; +use nanorand::{tls::TlsWyRand, Rng}; +use text_io::{read, try_read}; + +/// Play Nim on the command line! +fn main() { + let mut rng = nanorand::tls_rng(); + println!("{:>37}","NIM"); //100 + println!("{:>15}{}","","CREATIVE COMPUTING MORRISTOWN, NEW JERSEY"); //110 + println!();println!();println!(); //120 + let mut piles = [0.0;100]; let mut b_piles = [[0.0;100];11]; let mut ix_do= [0usize;3]; //210 + println!("THIS IS THE GAME OF NIM."); //220 + //230 + loop{ + let instuct_me=input("DO YOU WANT INSTRUCTIONS"); //240 + if instuct_me=="NO" || instuct_me=="no" { break } //440 //260 + if instuct_me=="YES" || instuct_me=="yes" { instructions(); break }//310 //280 + println!("PLEASE ANSWER YES OR NO"); //290 + } //300 + 'play_again: loop { + println!(); //440 + let winner_take_last:bool = + loop { + let choice= input_int("ENTER WIN OPTION - 1 TO TAKE LAST, 2 TO AVOID LAST"); //460 + if (1..=2).contains(&choice) { break choice==1 } //490 //470 + }; + let np= + loop { //490 + let choice = input_int("ENTER NUMBER OF PILES"); //500 + if choice<=100 && choice>=1 { break choice }//490 //510 + //490 //520 + //490 //530 + }; + println!("ENTER PILE SIZES"); //540 + for ix in 0..np as usize { //550 + piles[ix] = + loop { + let choice = input_int(&(ix+1).to_string()); //570 + if choice<=2000 && choice>=1 && choice>=1 { break choice as f64 }//560 //580 + //560 //600 + } + } //610 + let human_first = + loop {//620 + let choice = input("DO YOU WANT TO MOVE FIRST"); //630 + let choice = choice.to_lowercase(); + if choice=="yes" { break true } //1450 //650 + if choice=="no" { break false }//700 //670 + println!("PLEASE ANSWER YES OR NO."); //680 + }; //690 + + let mut winner = WinState::GameOn; + if human_first {winner = human_turn(winner_take_last, np, &mut piles);}; + //### main game loop + if winner.is_game_on() { + winner = + loop { + // break on winner returning from here: + let win = machines_turn(&mut rng, winner_take_last, np, &mut piles, &mut ix_do, &mut b_piles); + if ! win.is_game_on() { + break win; + }; //starts at 700 + + println!("PILE SIZE"); //1380 + for ix in 0..np as usize { //1390 + println!("{} {}",ix+1,piles[ix]); //1400 + }// NEXT ix //1410 + + // break on winner returning from here: + let win = human_turn(winner_take_last, np, &mut piles); + if ! win.is_game_on() { + break win; + }; + // GOTO 700 //1560 + }; + } + println!("MACHINE {}", if winner==WinState::ComputerWins{"WINS"}else{"LOSES"}); + loop { + // Game over //1640 + let choice = input("do you want to play another game"); //1650 + match choice.to_ascii_lowercase().as_str() { + "yes" => { break }, //1720 //1660 + "no" => { break 'play_again },//1730 //1680 + _ => println!("PLEASE. YES OR NO."), //1700 + } // GOTO 1650 //1710 + } // GOTO 440 //1720 + } // END //1730 +} + +#[derive(PartialEq)] +enum WinState { + GameOn, + ComputerWins, + HumanWins +} + +impl WinState { + /// Returns `true` if the win state is [`GameOn`]. + /// + /// [`GameOn`]: WinState::GameOn + fn is_game_on(&self) -> bool { + matches!(self, Self::GameOn) + } +} + + +/// Computer's turn +fn machines_turn(rng:&mut TlsWyRand, winner_take_last: bool, np: i32, piles: &mut [f64; 100], ix_do: &mut [usize; 3], b_piles: &mut [[f64;100];11] ) -> WinState { + if ! winner_take_last { //940 //700 + //### Loser takes last, check for winner + let mut count=0; //710 + 'wayout: loop { + 'outer: loop { + for ix in 0..np as usize { //720 + if piles[ix]==0.0 { continue } //730 + count+=1; //740 + if count==3 { break 'outer }//840 //750 + ix_do[count]=ix; //760 + } //770 + // exactly two piles remain + if count==2 { + // println!("Only two piles remain : unused0={} pile1={} pile2={}",ix_do[0]+1,ix_do[1]+1,ix_do[2]+1); //diagnostic + if piles[ix_do[1]]==1.0 || piles[ix_do[2]]==1.0 { //920 + return WinState::ComputerWins; + }//820 //930 + break 'wayout; + } //920 //780 + // exactly one pile remains, loser takes last, and before machine's turn + // println!("Only one pile remains : pile={}",ix_do[1]); //diagnostic + assert!(piles[ix_do[1]] > 0.0 ); + if piles[ix_do[1]] == 1.0 { //820 //790 + return WinState::HumanWins; //800 + // GOTO 1640 //810 + } else { + return WinState::ComputerWins; //820 + // GOTO 1640 //830 + } + } + count=0 ; //840 + let mut is_all_ones=true; + for ix in 0..np as usize {// FOR ix=1 TO N //850 + if piles[ix]>1.0 { is_all_ones=false; break }//940 //860 + if piles[ix]!=0.0 { //890 //870 + count=count+1 ; //880 + } + }// NEXT ix //890 + if is_all_ones && count%2 != 0 { //800 //900 + return WinState::HumanWins; + } + break; // GOTO 940 //910 + } + } + //### winner take last (or first?) -- check for winner + for ix in 0..np as usize { //940 + let mut sticks=piles[ix]; //950 + for jx in 0..=10 { //960 + let half=sticks/2.0; //970 + b_piles[ix][jx]=2.0*(half-half.trunc()) ; //980 + sticks=half.trunc(); //990 + }// NEXT J //1000 + }// NEXT I //1010 + + let mut is_odd = false; + let mut ix_max_pile = usize::MAX; // make sure this fails if ever used. + for jx in (0..=10).rev() { //1020 + let mut count=0; //1030 + let mut highest=0.0; //1040 + for ix in 0..np as usize { //1050 + if b_piles[ix][jx]==0.0 { continue }; //1110 //1060 + count=count+1; //1070 + if piles[ix]<=highest as f64 { continue }; //1110 //1080 + highest = piles[ix]; //1090 + ix_max_pile=ix; //1100 + } //NEXT I //1110 + // println!("if none are odd, use random: count={} odd={}", count,count%2!=0); //diagnostic + if count%2!=0 { is_odd=true ; break } // C/2<>INT(C/2) //1190 //1120 + }// NEXT J //1130 + if ! is_odd { + let mut ix_random; + loop { + ix_random= rng.generate_range(0..np as usize); //(N*RND(1)+1).trunc(); //1140 + if piles[ix_random] != 0.0 { break } //1140 //1150 + } + let remove_random= rng.generate_range(1..=piles[ix_random] as i32); // INT(A[E]*RND(1)+1) //1160 + piles[ix_random] = piles[ix_random] - remove_random as f64; //1170 + // println!("I choose random: pile={} removed={}",ix_random+1,remove_random) //diagnostic + // GOTO 1380 //1180 + } else { + // println!("max pile: pile={}, was={} setting to 0. Expect add back.",ix_max_pile+1,piles[ix_max_pile]); //diagnostic + piles[ix_max_pile] = 0.0; //1190 + for jx in 0..=10 { //1200 + b_piles[ix_max_pile][jx]=0.0; //1210 + let mut countum=0; //1220 + for ix in 0..np as usize { //1230 + if b_piles[ix][jx]==0.0 { continue }//1260 //1240 + countum+=1; // count non-empty //1250 + }// NEXT ix //1260 + piles[ix_max_pile] = piles[ix_max_pile] + ((countum%2)*2usize.pow(jx as u32)) as f64; //1270 + // println!("I choose max pile : pile={}, add back=odd?2^{}:0={}",ix_max_pile+1,jx,((countum%2)*2usize.pow(jx as u32))); //diagnostic + }// NEXT J //1280 + + 'done: loop { + if ! winner_take_last { //1380 //1290 + let mut counter=0; //1300 + for ix in 0..np as usize { //1310 + if piles[ix]>1.0 { break 'done } //1380 //1320 + if piles[ix]!=0.0 { //1350 //1330 + counter+=1; //1340 + } + }// NEXT ix //1350 + // done if C is odd + if counter%2!=0 { break } //1380 //1360 + // println!("max pile if even: 1 - pile : pile={}, before 1-p = {}",ix_max_pile+1,piles[ix_max_pile]); //diagnostic + piles[ix_max_pile] = 1.0 - piles[ix_max_pile]; //1370 + } + break; + } + } + return WinState::GameOn; //1380 is after this +} + +/// Human decide what you want to do and see if there is a winner +fn human_turn(winner_take_last: bool, np: i32, piles: &mut [f64; 100], ) -> WinState { + if winner_take_last { //1450 //1420 + let is_all_empty=one_if_all_zero(np, &piles);// GOSUB 1570 //1430 + if is_all_empty==1 { return WinState::ComputerWins }//820 //1440 //### machine wins + } + //### many things go here + loop {//1450 + let (pile_choice, remove_choice) = input_2int("YOUR MOVE - PILE, NUMBER TO BE REMOVED"); //1460 + if pile_choice>np || pile_choice<1 { continue } //1450 //1480 + let ix_choice= (pile_choice - 1) as usize; + if remove_choice<1 || remove_choice as f64 > piles[ix_choice] { continue }; //1450 //1500 + // remove the humans choice: + piles[ix_choice] = piles[ix_choice]-remove_choice as f64 ; //1530 + break; + } + if one_if_all_zero(np, &piles)==1 // GOSUB 1570 //1540 + { return WinState::HumanWins }//800 //1550 //### machine loses! + return WinState::GameOn; +} + +/// returns 0 if all A are 0, otherwise 1 +fn one_if_all_zero(np:i32, piles: &[f64; 100]) -> i32 { // sets Z to the return value + //1570 + for ix in 0..np as usize { //1580 + if piles[ix]!=0.0 {return 0} //1610 //1590 + //1600 + } //1610 + return 1; //1620 +} //1630 + +fn instructions() { + println!("THE GAME IS PLAYED WITH A NUMBER OF PILES OF OBJECTS."); + println!("ANY NUMBER OF OBJECTS ARE REMOVED FROM ONE PILE BY YOU AND"); + println!("THE MACHINE ALTERNATELY. ON YOUR TURN, YOU MAY TAKE"); + println!("ALL THE OBJECTS THAT REMAIN IN ANY PILE, BUT YOU MUST"); + println!("TAKE AT LEAST ONE OBJECT, AND YOU MAY TAKE OBJECTS FROM"); + println!("ONLY ONE PILE ON A SINGLE TURN. YOU MUST SPECIFY WHETHER"); + println!("WINNING IS DEFINED AS TAKING OR NOT TAKING THE LAST OBJECT,"); + println!("THE NUMBER OF PILES IN THE GAME, AND HOW MANY OBJECTS ARE"); + println!("ORIGINALLY IN EACH PILE. EACH PILE MAY CONTAIN A"); + println!("DIFFERENT NUMBER OF OBJECTS."); + println!("THE MACHINE WILL SHOW ITS MOVE BY LISTING EACH PILE AND THE"); + println!("NUMBER OF OBJECTS REMAINING IN THE PILES AFTER EACH OF ITS"); + println!("MOVES."); + +} + +/// print the prompt, wait for a number and newline. Loop if invalid. +fn input(prompt:&str) -> String { + loop { + print!("{} ? ",prompt);io::stdout().flush().unwrap(); + // TODO: asks twice on win10, not linux. \r vs \n? + let innn:String=read!("{}\n"); + let out:String = innn.trim().to_string(); + if out!="" {return out} + } +} +fn input_int(prompt:&str) -> i32 { + loop { + print!("{} ? ",prompt);io::stdout().flush().unwrap(); + match try_read!() { + Ok(n) => return n, + Err(_) => {}, + } + } +} + +fn input_2int(prompt:&str) -> (i32,i32) { + loop { + let inp = input(prompt); + let nums:Vec = inp.split(",").filter_map(|c| c.parse::().ok()).collect(); + if nums.len()!=2 {println!("Enter two numbers like: 9,9",);continue} + return (nums[0], nums[1]) + } +}