Tahinli/banker-algorithm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

style: 🎨 cargo fmt

Browse source
This commit is contained in:
Ahmet Kaan GÜMÜŞ 2024-08-12 00:10:29 +03:00
parent 7e2f12bea6
commit a2d3b7b607
1 changed files with 269 additions and 342 deletions
Download patch file Download diff file Expand all files Collapse all files

315
src/main.rs
View file

@ -1,129 +1,101 @@
use std::io;
use rand::Rng; use rand::Rng;
use std::io;
const PROCESS_COUNT:usize = 5; const PROCESS_COUNT: usize = 5;
const RESOURCE_COUNT:usize = 3; const RESOURCE_COUNT: usize = 3;
fn main() { fn main() {
println!("Hello, world!"); println!("Hello, world!");
let mut restart:bool = true; let mut restart: bool = true;
while restart while restart {
{
println!("Max A Resource"); println!("Max A Resource");
let a:u8; let a: u8;
let b:u8; let b: u8;
let c:u8; let c: u8;
let mut resource_input:String = String::new(); let mut resource_input: String = String::new();
if let Err(err_val) = io::stdin().read_line(&mut resource_input) if let Err(err_val) = io::stdin().read_line(&mut resource_input) {
{
println!("Failed to Read: {}", err_val); println!("Failed to Read: {}", err_val);
return; return;
} }
match resource_input.trim().parse::<u8>() match resource_input.trim().parse::<u8>() {
{ Ok(value) => {
Ok(value) =>
{
a = value; a = value;
} }
Err(err_val) => Err(err_val) => {
{
println!("Failed to Convert: {}", err_val); println!("Failed to Convert: {}", err_val);
return; return;
} }
} }
println!("Max B Resource"); println!("Max B Resource");
let mut resource_input:String = String::new(); let mut resource_input: String = String::new();
if let Err(err_val) = io::stdin().read_line(&mut resource_input) if let Err(err_val) = io::stdin().read_line(&mut resource_input) {
{
println!("Failed to Read: {}", err_val); println!("Failed to Read: {}", err_val);
return; return;
} }
match resource_input.trim().parse::<u8>() match resource_input.trim().parse::<u8>() {
{ Ok(value) => {
Ok(value) =>
{
b = value; b = value;
} }
Err(err_val) => Err(err_val) => {
{
println!("Failed to Convert: {}", err_val); println!("Failed to Convert: {}", err_val);
return; return;
} }
} }
println!("Max C Resource"); println!("Max C Resource");
let mut resource_input:String = String::new(); let mut resource_input: String = String::new();
if let Err(err_val) = io::stdin().read_line(&mut resource_input) if let Err(err_val) = io::stdin().read_line(&mut resource_input) {
{
println!("Failed to Read: {}", err_val); println!("Failed to Read: {}", err_val);
return; return;
} }
match resource_input.trim().parse::<u8>() match resource_input.trim().parse::<u8>() {
{ Ok(value) => {
Ok(value) =>
{
c = value; c = value;
} }
Err(err_val) => Err(err_val) => {
{
println!("Failed to Convert: {}", err_val); println!("Failed to Convert: {}", err_val);
return; return;
} }
} }
println!("\n\tA = {}\n\tB = {}\n\tC = {}", a, b, c);
println!("\n\tA = {}\n\tB = {}\n\tC = {}", a,b,c); if a == 0 || b == 0 || c == 0 {
if a == 0 || b == 0 || c == 0
{
println!("Exit: Zero as a Input Invalid"); println!("Exit: Zero as a Input Invalid");
return; return;
} }
let mut max_needs_matrix = [[0_u8;RESOURCE_COUNT];PROCESS_COUNT]; let mut max_needs_matrix = [[0_u8; RESOURCE_COUNT]; PROCESS_COUNT];
let mut assigned_resources_matrix = [[0_u8;RESOURCE_COUNT];PROCESS_COUNT]; let mut assigned_resources_matrix = [[0_u8; RESOURCE_COUNT]; PROCESS_COUNT];
let mut info:(bool, Vec<u8>) = (false, Vec::with_capacity(PROCESS_COUNT)); let mut info: (bool, Vec<u8>) = (false, Vec::with_capacity(PROCESS_COUNT));
while !info.0 while !info.0 {
{ for i in 0..PROCESS_COUNT {
for i in 0..PROCESS_COUNT
{
let mut rng = rand::thread_rng(); let mut rng = rand::thread_rng();
let random = rng.gen_range(0..a); let random = rng.gen_range(0..a);
max_needs_matrix[i][0] = random; max_needs_matrix[i][0] = random;
if random != 0 if random != 0 {
{
assigned_resources_matrix[i][0] = rng.gen_range(0..random); assigned_resources_matrix[i][0] = rng.gen_range(0..random);
} } else {
else
{
assigned_resources_matrix[i][0] = 0; assigned_resources_matrix[i][0] = 0;
} }
} }
for i in 0..PROCESS_COUNT for i in 0..PROCESS_COUNT {
{
let mut rng = rand::thread_rng(); let mut rng = rand::thread_rng();
let random = rng.gen_range(0..b); let random = rng.gen_range(0..b);
max_needs_matrix[i][1] = random; max_needs_matrix[i][1] = random;
if random != 0 if random != 0 {
{
assigned_resources_matrix[i][1] = rng.gen_range(0..random); assigned_resources_matrix[i][1] = rng.gen_range(0..random);
} } else {
else
{
assigned_resources_matrix[i][1] = 0; assigned_resources_matrix[i][1] = 0;
} }
} }
for i in 0..PROCESS_COUNT for i in 0..PROCESS_COUNT {
{
let mut rng = rand::thread_rng(); let mut rng = rand::thread_rng();
let random = rng.gen_range(0..c); let random = rng.gen_range(0..c);
max_needs_matrix[i][2] = random; max_needs_matrix[i][2] = random;
if random != 0 if random != 0 {
{
assigned_resources_matrix[i][2] = rng.gen_range(0..random); assigned_resources_matrix[i][2] = rng.gen_range(0..random);
} } else {
else
{
assigned_resources_matrix[i][2] = 0; assigned_resources_matrix[i][2] = 0;
} }
} }
@ -133,122 +105,98 @@ fn main() {
print_matrix(max_needs_matrix); print_matrix(max_needs_matrix);
println!("Assigned Resources Matrix"); println!("Assigned Resources Matrix");
print_matrix(assigned_resources_matrix); print_matrix(assigned_resources_matrix);
let mut answers:[u8;PROCESS_COUNT] = [0;PROCESS_COUNT]; let mut answers: [u8; PROCESS_COUNT] = [0; PROCESS_COUNT];
for i in 0..PROCESS_COUNT for i in 0..PROCESS_COUNT {
{
println!("Which Process Should be Done Now ?"); println!("Which Process Should be Done Now ?");
let mut input = String::new(); let mut input = String::new();
io::stdin().read_line(&mut input).unwrap(); io::stdin().read_line(&mut input).unwrap();
let input:u8 = input.trim().parse().unwrap(); let input: u8 = input.trim().parse().unwrap();
answers[i] = input; answers[i] = input;
if info.1[i] == input if info.1[i] == input {
{
println!("Correct"); println!("Correct");
} } else {
else
{
println!("Wrong it should be = {}", info.1[i]); println!("Wrong it should be = {}", info.1[i]);
} }
} }
println!("Your Answers"); println!("Your Answers");
for i in 0..PROCESS_COUNT for i in 0..PROCESS_COUNT {
{
println!("P{}", answers[i]); println!("P{}", answers[i]);
} }
println!("Correct Answers"); println!("Correct Answers");
for i in 0..PROCESS_COUNT for i in 0..PROCESS_COUNT {
{
println!("P{}", info.1[i]); println!("P{}", info.1[i]);
} }
let mut resource_input: String = String::new();
let mut resource_input:String = String::new();
println!("Press 'r' to Restart"); println!("Press 'r' to Restart");
if let Err(err_val) = io::stdin().read_line(&mut resource_input) if let Err(err_val) = io::stdin().read_line(&mut resource_input) {
{
println!("Failed to Read: {}", err_val); println!("Failed to Read: {}", err_val);
return; return;
} }
resource_input = resource_input.trim().to_string(); resource_input = resource_input.trim().to_string();
match resource_input.as_str() match resource_input.as_str() {
{ "r" => {
"r" =>
{
restart = true; restart = true;
println!("-------------------------------"); println!("-------------------------------");
} }
_ => _ => {
{
return; return;
} }
} }
} }
} }
fn print_matrix(matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT]) fn print_matrix(matrix: [[u8; RESOURCE_COUNT]; PROCESS_COUNT]) {
{ for i in 0..5 {
for i in 0..5
{
print!("\n\t Process {}: ", i); print!("\n\t Process {}: ", i);
for j in 0..3 for j in 0..3 {
{ if matrix[i][j] > 99 {
if matrix[i][j] > 99
{
print!(" "); print!(" ");
} } else if matrix[i][j] > 9 {
else if matrix[i][j] > 9
{
print!(" "); print!(" ");
} } else {
else
{
print!(" "); print!(" ");
} }
print!("{}", matrix[i][j]); print!("{}", matrix[i][j]);
} }
println!(); println!();
} }
} }
fn banker(a:u8, b:u8, c:u8, max_needs_matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT], assigned_resources_matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT]) -> (bool, Vec<u8>) fn banker(
{ a: u8,
let mut a_remaing:u8 = 0; b: u8,
let mut b_remaing:u8 = 0; c: u8,
let mut c_remaing:u8 = 0; max_needs_matrix: [[u8; RESOURCE_COUNT]; PROCESS_COUNT],
let mut remaining_needs_matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT] = [[0;RESOURCE_COUNT];PROCESS_COUNT]; assigned_resources_matrix: [[u8; RESOURCE_COUNT]; PROCESS_COUNT],
for i in 0..PROCESS_COUNT ) -> (bool, Vec<u8>) {
{ let mut a_remaing: u8 = 0;
match a_remaing.checked_add(assigned_resources_matrix[i][0]) let mut b_remaing: u8 = 0;
{ let mut c_remaing: u8 = 0;
Some(result) => let mut remaining_needs_matrix: [[u8; RESOURCE_COUNT]; PROCESS_COUNT] =
{ [[0; RESOURCE_COUNT]; PROCESS_COUNT];
for i in 0..PROCESS_COUNT {
match a_remaing.checked_add(assigned_resources_matrix[i][0]) {
Some(result) => {
a_remaing = result; a_remaing = result;
} }
None => None => {
{
return (false, vec![]); return (false, vec![]);
} }
} }
match b_remaing.checked_add(assigned_resources_matrix[i][1]) match b_remaing.checked_add(assigned_resources_matrix[i][1]) {
{ Some(result) => {
Some(result) =>
{
b_remaing = result; b_remaing = result;
} }
None => None => {
{
return (false, vec![]); return (false, vec![]);
} }
} }
match c_remaing.checked_add(assigned_resources_matrix[i][2]) match c_remaing.checked_add(assigned_resources_matrix[i][2]) {
{ Some(result) => {
Some(result) =>
{
c_remaing = result; c_remaing = result;
} }
None => None => {
{
return (false, vec![]); return (false, vec![]);
} }
} }
@ -256,89 +204,69 @@ fn banker(a:u8, b:u8, c:u8, max_needs_matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT]
remaining_needs_matrix[i][1] = max_needs_matrix[i][1] - assigned_resources_matrix[i][1]; remaining_needs_matrix[i][1] = max_needs_matrix[i][1] - assigned_resources_matrix[i][1];
remaining_needs_matrix[i][2] = max_needs_matrix[i][2] - assigned_resources_matrix[i][2]; remaining_needs_matrix[i][2] = max_needs_matrix[i][2] - assigned_resources_matrix[i][2];
} }
if a_remaing > a || b_remaing > b || c_remaing > c if a_remaing > a || b_remaing > b || c_remaing > c {
{
return (false, vec![]); return (false, vec![]);
} }
a_remaing = a - a_remaing; a_remaing = a - a_remaing;
b_remaing = b - b_remaing; b_remaing = b - b_remaing;
c_remaing = c - c_remaing; c_remaing = c - c_remaing;
let mut infinite_detection:u8 = 2; let mut infinite_detection: u8 = 2;
let mut done:[bool;PROCESS_COUNT] = [false;PROCESS_COUNT]; let mut done: [bool; PROCESS_COUNT] = [false; PROCESS_COUNT];
let mut q:Vec<u8> = Vec::with_capacity(PROCESS_COUNT); let mut q: Vec<u8> = Vec::with_capacity(PROCESS_COUNT);
while !done[0] || !done[1] || !done[2] || !done[3] || !done[4] while !done[0] || !done[1] || !done[2] || !done[3] || !done[4] {
{
infinite_detection -= 1; infinite_detection -= 1;
for i in 0..PROCESS_COUNT for i in 0..PROCESS_COUNT {
{ if !done[i] {
if !done[i] if a_remaing >= remaining_needs_matrix[i][0]
{ && b_remaing >= remaining_needs_matrix[i][1]
if a_remaing >= remaining_needs_matrix[i][0] && b_remaing >= remaining_needs_matrix[i][1] && c_remaing >= remaining_needs_matrix[i][2] && c_remaing >= remaining_needs_matrix[i][2]
{
match a_remaing.checked_sub(remaining_needs_matrix[i][0])
{
Some(result) =>
{ {
match a_remaing.checked_sub(remaining_needs_matrix[i][0]) {
Some(result) => {
a_remaing = result; a_remaing = result;
} }
None => None => {
{
return (false , vec![]);
}
}
match a_remaing.checked_add(max_needs_matrix[i][0])
{
Some(result) =>
{
a_remaing = result;
}
None =>
{
return (false, vec![]); return (false, vec![]);
} }
} }
match b_remaing.checked_sub(remaining_needs_matrix[i][1]) match a_remaing.checked_add(max_needs_matrix[i][0]) {
{ Some(result) => {
Some(result) => a_remaing = result;
{
b_remaing = result;
} }
None => None => {
{
return (false , vec![]);
}
}
match b_remaing.checked_add(max_needs_matrix[i][1])
{
Some(result) =>
{
b_remaing = result;
}
None =>
{
return (false, vec![]); return (false, vec![]);
} }
} }
match c_remaing.checked_sub(remaining_needs_matrix[i][2]) match b_remaing.checked_sub(remaining_needs_matrix[i][1]) {
{ Some(result) => {
Some(result) => b_remaing = result;
{ }
None => {
return (false, vec![]);
}
}
match b_remaing.checked_add(max_needs_matrix[i][1]) {
Some(result) => {
b_remaing = result;
}
None => {
return (false, vec![]);
}
}
match c_remaing.checked_sub(remaining_needs_matrix[i][2]) {
Some(result) => {
c_remaing = result; c_remaing = result;
} }
None => None => {
{ return (false, vec![]);
return (false , vec![]);
} }
} }
match c_remaing.checked_add(max_needs_matrix[i][2]) match c_remaing.checked_add(max_needs_matrix[i][2]) {
{ Some(result) => {
Some(result) =>
{
c_remaing = result; c_remaing = result;
} }
None => None => {
{
return (false, vec![]); return (false, vec![]);
} }
} }
@ -348,10 +276,9 @@ fn banker(a:u8, b:u8, c:u8, max_needs_matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT]
} }
} }
} }
if infinite_detection == 0 if infinite_detection == 0 {
{
return (false, q); return (false, q);
} }
} }
(true, q) (true, q)
} }