quinoa 0.0.1

quinoa
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100




/*
	pockets
	role

*/

use super::super::deck;

pub mod different;
pub mod pair;
pub mod team_duet_to_quintet;




// let mut indexes : Vec<i64> = Vec::new ();
fn next (mut indexes : Vec<i64>) -> Vec<i64> {
	indexes [0] = 0;
	indexes [1] = 1;
	indexes [2] = 2;
	indexes [3] = 3;
	indexes [4] = 4;	
	
	return indexes;
}

pub fn check_every (
	achieved : fn (Vec<[&'static str; 2]>) -> i64
) {
	let mut this_deck = deck::make_array ();
	
	let character_card_1 = this_deck.remove (0);
	let character_card_2 = this_deck.remove (12);
	println! ("role: {} {}", character_card_1 [0], character_card_1 [1]);
	println! ("role: {} {}", character_card_2 [0], character_card_2 [1]);
	let character_card_1_level = character_card_1 [0];
	
	
	let mut flop__has : i64 = 0;
	let mut turn__has : i64 = 0;
	let mut rive__has : i64 = 0;	
	
	let mut flops = 0;
	let mut turns = 0;
	let mut rives = 0;
	
	for i1 in 0..=49 { 
		let flop_1 = this_deck [i1];
		
		println! ("flop_1 {:02}: {}{}", i1, flop_1 [0], flop_1[1]);
		
		for i2 in 0..=49 { 
			if (i2 == i1) { continue; }
			let flop_2 = this_deck [i2];
			
			for i3 in 0..=49 { 
				if (i3 == i1 || i3 == i2) { continue; }
				let flop_3 = this_deck [i3];
				
				flop__has += achieved (
					[ flop_1, flop_2, flop_3 ].to_vec ()				
				);
				flops += 1;
				
				continue;
				
				for i4 in 0..=49 { 
					if (i4 == i1 || i4 == i2 || i4 == i3) { continue; }
					let turn = this_deck [i4];
					
					turn__has += achieved (
						[ flop_1, flop_2, flop_3, turn ].to_vec ()				
					);
					turns += 1;
					
					
					for i5 in 0..=49 { 
						if (i5 == i1 || i5 == i2 || i5 == i3 || i5 == i4) { continue; }
						let iver = this_deck [i5];
						
						rive__has += achieved (
							[ flop_1, flop_2, flop_3, turn, iver ].to_vec ()				
						);
						rives += 1;
					}
				}
			}
		}
    }

	let flop_splits : f64 = 1 as f64 / (flop__has as f64 / flops as f64);
	let turn_splits : f64 = 1 as f64 / (turn__has as f64 / turns as f64);
	let rive_splits : f64 = 1 as f64 / (rive__has as f64 / rives as f64);
	println! ("{} Flops", flop_splits);
	println! ("{} Turns", turn_splits);
	println! ("{} Rives", rive_splits);
}