[RUBY] Ein Versuch, "Mathe-Rätsel, die das Rust-Gehirn mehr trainieren".

Ich dachte, dass das Umschreiben von "Mathe-Rätseln, die das Gehirn des Programmierers mehr trainieren" mit Rust genau richtig sein könnte, um Unschärfe zu verhindern.

S.13 Beispiel 1: Auswendiglernen und dynamische Planung

Original Ruby Code (S.015).

pre1_2.rb

M, N = 10, 100

@memo = {}
def check(remain, pre)
    return @memo[[remain, pre]] if @memo[[remain,pre]]

    return 0 if remain < 0
    return 1 if remain == 0

    cnt = 0
    pre.upto(M) do |i|
        cnt += check(remain - i, i)
    end
    @memo[[remain, pre]] = cnt
end

puts check(N, 2)

Rost feste Transplantation.

main.rs

use std::collections::HashMap;

fn main() {
    let mut memo: HashMap<(i64, i64), i64> = HashMap::new();
    println!("{}", check(&mut memo, 10, 100, 2));
}

fn check(
    memo: &mut HashMap<(i64, i64), i64>,
    max_seat_at_one_table: i64,
    remain: i64,
    pre: i64,
) -> i64 {
    match memo.get(&(remain, pre)) {
        Some(cnt) => return *cnt,
        _ => {
            if remain < 0 {
                return 0;
            } else if remain == 0 {
                return 1;
            } else {
                let mut count = 0;
                for i in pre..=max_seat_at_one_table {
                    count += check(memo, max_seat_at_one_table, remain - i, i);
                }
                memo.insert((remain, pre), count);
                return count;
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_check() {
        let max_seat_at_one_table = 10;
        let number_of_people = 100;
        let mut memo: HashMap<(i64, i64), i64> = HashMap::new();
        assert_eq!(
            check(&mut memo, max_seat_at_one_table, number_of_people, 2),
            437_420
        );
    }
}

Um Rusts "für" dazu zu bringen, dasselbe wie Rubys "bis" zu tun, müssen Sie +1. Wenn Sie denken, hat @scivola darauf hingewiesen. Vielen Dank!

Es ist eine globale Variable, die ich in Rubys Kurzcode nicht denke, aber ich trage sie herum, weil ich nicht weiß, wie ich es mit Rust machen soll. Obwohl es auch in der Buchbesprechung von Amazon war, wird es unverständlich sein, wenn Sie die Variable wie Mathematik weglassen, so dass ich sie nur im schrecklichen Teil zu einem langen Namen gemacht habe.

Wieder einmal spüre ich die Leichtigkeit von Ruby (= Vertrauen in den Programmierer) bei der Verarbeitung der bedingten Verzweigung. Rost ist kompakt, lässt sich aber nicht ablösen, aber das ist ein gutes Gefühl.

Nachtrag 2020/09/29

Wird erneut implementiert, nachdem auf den Umgang mit globalen Variablen hingewiesen wurde. Ein Plan zur Realisierung globaler Variablen als "Struktur". Dies ist bereits ein Fuß im Entwurfsmuster.

main.rs

use std::collections::HashMap;

struct Checker {
    memo: HashMap<(i64, i64), i64>,
    max_seat_at_one_table: i64,
}

impl Checker {
    pub fn check(&mut self, remain: i64, pre: i64) -> i64 {
        match &self.memo.get(&(remain, pre)) {
            Some(cnt) => return **cnt,
            _ => {
                if remain < 0 {
                    return 0;
                } else if remain == 0 {
                    return 1;
                } else {
                    let mut count = 0;
                    for i in pre..=self.max_seat_at_one_table {
                        count += self.check(remain - i, i);
                    }
                    &self.memo.insert((remain, pre), count);
                    return count;
                }
            }
        }
    }
}

fn main() {
    let mut chk = Checker {
        memo: HashMap::new(),
        max_seat_at_one_table: 10,
    };
    println!("{}", chk.check(100, 2));
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_check() {
        let number_of_people = 100;
        let mut chk = Checker {
            memo: HashMap::new(),
            max_seat_at_one_table: 10,
        };
        assert_eq!(chk.check(number_of_people, 2), 437_420);
    }
}