quinnwencn
commented
1 month ago 我的第一版解法是：
/// Check a Luhn checksum.
pub fn is_valid(code: &str) -> bool {
if !code.chars().all(|c| c.is_ascii_digit() || c.is_whitespace()) {
return false;
}
let mut count = 0;
let mut sum: u32 = 0;
code.chars()
.rev()
.filter(|x| x.is_ascii_digit())
.for_each(|x| {
count += 1;
if count % 2 != 0 {
sum += x.to_digit(10).unwrap();
} else {
let val = x.to_digit(10).unwrap() * 2;
match val.cmp(&10) {
std::cmp::Ordering::Less => sum += val,
_ => sum += val - 9,
};
}
});
count > 1 && sum % 10 == 0
}
這雖然能解決問題，但是存在兩次迭代；此外，還額外控制了count和sum這兩個變量的更新，其實這都可以通過迭代器來完成，我們看看社區內其他人的優秀解法：
/// Check a Luhn checksum.
pub fn is_valid(code: &str) -> bool {
code.chars()
.rev()
.filter(|c| !c.is_whitespace())
.try_fold((0, 0), |(sum, count), val| {
val.to_digit(10)
.map(|num| if count % 2 == 1 { num * 2 } else { num })
.map(|num| if num > 9 { num - 9 } else { num })
.map(|num| (num + sum, count + 1))
}).map_or(false, |(sum, count)| sum % 10 == 0 && count > 1)
}這個解法來自[JaneL's solution，這裏主要用了try_fold和map_or來解決我的解法中兩次迭代的問題。try_fold實際上是fold的變種，fold始終成功，而try_fold則可能會失敗，因此要配合map_or來使用。 我們先來看fold的定義：
fn fold<B, F>(self, init: B, f: F) -> B where Self: Sized, F: FnMut(B, Self::Item) -> B, Folds every element into an accumulator by applying an operation, returning the final result. fold() takes two arguments: an initial value, and a closure with two arguments: an ‘accumulator’, and an element. The closure returns the value that the accumulator should have for the next iteration. The initial value is the value the accumulator will have on the first call. After applying this closure to every element of the iterator, fold() returns the accumulator.
fold的輸入是兩個參數：
- 初始值
- 閉包，閉包是兩個參數，第一個是累加的值，第二個是處理的入參
比如:
let a = [1, 2, 3];
// the sum of all of the elements of the array let sum = a.iter().fold(0, |acc, x| acc + x);
assert_eq!(sum, 6);
try_fold就是比fold多了一個失敗機制：
> fn [try_fold](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.try_fold)<B, F, R>(&mut self, init: B, f: F) -> R
where
Self: [Sized](https://doc.rust-lang.org/std/marker/trait.Sized.html),
F: [FnMut](https://doc.rust-lang.org/std/ops/trait.FnMut.html)(B, Self::[Item](https://doc.rust-lang.org/std/iter/trait.Iterator.html#associatedtype.Item)) -> R,
R: [Try](https://doc.rust-lang.org/std/ops/trait.Try.html)<Output = B>,
An iterator method that applies a function as long as it returns successfully, producing a single, final value.
try_fold() takes two arguments: an initial value, and a closure with two arguments: an ‘accumulator’, and an element. The closure either returns successfully, with the value that the accumulator should have for the next iteration, or it returns failure, with an error value that is propagated back to the caller immediately (short-circuiting).
因為try_fold返回的是一個Option，因此如果沒有迭代器處理的話，就需要用Some來取值：let a = [1, 2, 3];
// the checked sum of all of the elements of the array let sum = a.iter().try_fold(0i8, |acc, &x| acc.checked_add(x));
assert_eq!(sum, Some(6));
如果用迭代器，則需要用帶有or的迭代器，表示可能會失敗。題解中的map_or就是這麼用的：
> pub fn [map_or](https://doc.rust-lang.org/std/option/enum.Option.html#method.map_or)<U, F>(self, default: U, f: F) -> U
where
F: [FnOnce](https://doc.rust-lang.org/std/ops/trait.FnOnce.html)(T) -> U,
Returns the provided default result (if none), or applies a function to the contained value (if any).
Arguments passed to map_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use [map_or_else](https://doc.rust-lang.org/std/option/enum.Option.html#method.map_or_else), which is lazily evaluated.
第一個參數是失敗時返回的值，第二個閉包則是成功時需要進行的處理。
題解中，如果失敗，代表有字符無法轉換成digit，也就是非數字字符，因此直接返回false，如果是數字字符，則根據Luhn的算法進行處理。
不得不說，這個解法真的很棒！
Rust中的迭代器功能非常強大，但是掌握並熟悉使用迭代器是一個漫長的過程，尤其是對熟悉了C++再學習的人，會經常以C++的方式寫一些循環代碼。這裏我藉著Exercism上的一道題，來熟悉迭代器的使用，後續如果有新的迭代器不熟悉的，也在這個issue上補充。迭代器的官方文檔也是非常有用的手冊！ 這次的Exorcism的題目是Luhn， 判斷一串數字是否滿足Luhn算法的要求，銀行卡、社保號碼等都滿足Luhn算法的要求。 Luhn算法可以參考維基百科的介紹，要求簡單概括為以下：