プロジェクトオイラーによって錆を学ぶ（1〜6の質問）

最近MOVEは、それはルーストに書かれて発見され、言語天秤座デジタル通貨を学びたいMOVEのメカニズムの正確な理解のように思える、また、錆の深い理解を持っている必要があり、錆はとてもクイックスタート学習を開始しました。

それはかつて怖がっていたが、後に錆がハスケルやその他の関数型プログラミング言語の利点を生かし、と私は時間の経過後には、具体的にはHaskellを学んできた見つけ、それはかなり急な学習曲線だと言う、錆のについてのオンラインの情報を見て学習ポータルは、私は今、このドア魔法の言語が大好きです。

一緒に「錆例による」ブック学習と組み合わせる私の「言語ザ・ラスト・プログラミング」公式、非常に権威を、取得、効果は非常に良いです。

：スキルの任意の時間をプログラミングを学ぶ、英語を学ぶために、特に、何のフィードバックを恐れないを学ぶ、私たちは学習プログラム「と」非常に便利なウェブサイトを持っている必要があり、それは「プロジェクト・オイラー」、URLで
HTTPS：// projecteuler.net

このサイトでは難しい数学の問題に簡単から数百チャンネルを提供しています、あなたはそれを解決するためにどのような方法を使用することができ、もちろん、プログラミングに依存する必要がありますが、プログラミング言語に限定されないが、Javaの、C＃、PythonやLispの、ハスケルやその他を持っています液の種類、もちろん、無意味に答えを直接使用するGoogle検索。

錆は最高の最初の基本的な構文を学び、機能が再びそれを読んで、その後、あなたは問題解決を開始することができ、および問題解決プロセスを学習、試行錯誤で、学ぶために、進捗状況を学習するプロセスを習得し、統合するために大幅に加速されます。

環境の準備

Windowsのインストール、デフォルトのインストールで直接rustupの公式ウェブサイトの下で。

インストールが完了したら、「錆プログラミング言語」ブックオフラインのHTMLバージョンが存在します、直接コマンドが開きます：

rustup doc --book

貨物：しかし、また、強力なパッケージマネージャを使用します。

他の人がコンパイルし、貨物、建設プロジェクトを使いやすくし、それを実行に使用されていると判断しました。

cargo new euler1
cd euler1
cargo build
cargo run

最初の質問

問題の説明：

1000年以内（1000年を除く）、および3または5で割り切れるすべての整数。

直接の答えに：

let mut sum = 0;
for i in 1..1000 {
    if i % 3 == 0 || i % 5 == 0 {
        sum += i;
    }
}
println!("{}", sum);

MUTキーワード（可変の略）は錆、不変のすべての変数のデフォルトの大きな特徴である、あなたは変数をしたい場合は、キーワードをMUTする必要がある、またはときに私の合計で+ =コンパイルエラーが報告されます。

これはマクロであることを、感嘆符が続く！printlnを、マクロ内の錆は非常に、非常に強力です！今、理解するための時間ではありません。

学んだPythonのリスト内包（リスト理解）構文一行文を取得することができ、この質問を感じ、錆は、フィルタ（）との和（）関数を使用する必要があります。

// 为了阅读，分成多行
println!(
    "{}",
    (1..1000).filter(|x| x % 3 == 0 || x % 5 == 0)
             .sum::<u32>() 
);

。これは、あなたが1000年を含めたい場合は、記述する必要がある、1000年最後の注意を含まないシンタックスシュガーの範囲を表し：（1 .. = 1000）

内部フィルタ| xは|クロージャの機能を閉鎖するだけでなく、複雑なトピックを定義します。

和：： （）は、二つのコロンのこの構文はよく私に合った機能のパラダイムです。

また、あなたは折り畳むことができる（）関数は次のように書かれています：

println!(
    "{}",
    (1..1000)
        .filter(|x| x % 3 == 0 || x % 5 == 0)
        .fold(0, |s, a| s + a)
);

私はこれらの数字のすべてをプリントアウトしたいです：

println!(
    "{:?}",
    (1..1000)
        .filter(|x| x % 3 == 0 || x % 5 == 0)
        .collect::<Vec<u32>>()
);
// [3, 5, 6, 9, 10, 12, ... 999]

2番目の質問

問題の説明：

フィボナッチ数の和の400万内のすべてのも、フィボナッチ。

アルゴリズムは、各番号は前の2つの数字の和である後ろの列の数[1、2]、始まる、困難ではありません。

let mut fib = vec![1, 2];

let mut i = 2; // 已经有2个元素
let mut sum = 2; 
loop {
    let c = fib[i - 1] + fib[i - 2];
    if c >= 4_000_000 {
        break;
    }
    fib.push(c); 
    if c % 2 == 0 {
        sum += c;
    }
    i += 1;
}
println!("{}", sum);

関数型プログラミング、MUTの広範な使用、ループ構文によって、無限ループの使用はありません。

錆がデフォルトの浮動小数点型がF64である、デフォルトの整数タイプがI32で、データタイプの様々な提供整数を表します。

数値型は、型を示すために、接尾辞として、I64および他のタイプを簡単に図の一部を読み取るためになるように、「_」、セパレータとより多くの機能を持つことができますが、また、U32することができます。

割り当てと他の言語が同じでない、あなたがそのタイプを変更することができることができます、この機能が隠されたシャドウイングです。

let x = 500u16;
let x = x + 1;
let x = 4_000_000_u64;
let x = "slb";

FIBは、ベクトルである配列リスト内の他の言語と同じです。VEC！マクロは、タスクを初期化することができます。
この行：

let mut fib = vec![1, 2];

これは、次の3行に相当します。

let mut fib = Vec::new();
fib.push(1);
fib.push(2);

プッシュ（）関数は、リストに要素を追加するために使用されます。

3番目の質問

問題の説明：
整数600851475143の最大の素因数を見つけます。

1は素数であり、それ自体は分割することができ、最初の素数かどうかを決定するための、（）関数is_primeを定義します。

fn is_prime(num: u64) -> bool {
    for i in 2..(num / 2 + 1) {
        if num % i == 0 {
            return false;
        }
    }
    true
}

錆が強く型付けされた言語である、の関数定義を参照 - >ブール値を、Haskellの構文のことを思い出します。

本当の最後の行のみ機能、無セミコロンは、人々は非常に奇妙な感じ。錆が表現ベースの言語であり、最後のブロックは、式文は、あるのも当然使用することリターンはtrue。

あなたは今、最大の素因数を見つけることができます。

let big_num = 600851475143;
for i in (2..=big_num).rev() {
    if big_num % i == 0 && is_prime(i) {
        println!("{}", i);
        break;
    }
}

600851、結果のうち、1秒未満では、効率がプログラムのが悪い、主に判定素数の多くを必要とすることに表示されます。結果を実行しても問題はなく、数分をコンパイルしていない、などの小さな数字は、ことを強調してみました最適化するために必要な計算量。

多数の素因数分解を実行しようとすると、比較のために記録された素因数、効率は、実質的に1秒未満結果を増加させました。

let mut big_num = 600851475143;
let mut max_prime_factor = 2;

while big_num >= 2 {
    for i in 2..=big_num {
        if big_num % i == 0 && is_prime(i) {
            big_num /= i;
            if i > max_prime_factor  {
                max_prime_factor = i;
                break;
            }
        }
    }
}
println!("{}", max_prime_factor);

第四に質問

問題の説明：

2の製品を求めている3桁の回文数の最大値。

いわゆるパリンドロームは、両側に読み出され、例えば同じ数である：698 896。

回文数を決定するために関数を記述するには：

fn is_palindromic(n: u64) -> bool {
    let s = n.to_string();
    s.chars().rev().collect::<String>() == s
}

元の文字列が回文であるかのように私は、逆の順序で、文字列に、文字列を数字を置きます。

操作の逆の順序で錆の文字列はとても奇妙ですが、それは（s.revではありません）、私はGoogleのコードスニペットことがわかりました。

残りのロジックはすぐに得ることができ、二重ループで、複雑ではありません。

let mut max = 0;
for x in 100..=999 {
    for y in 100..=999 {
        let prod = x * y;
        if is_palindromic(prod) && prod > max {
            max = prod;
            // println!("{} x {} = {}", x, y, prod);
        }
    }
}
println!("{}", max);

私はこの問題は、それをどこにあるか、あなたが見つけることができた最大数、限り逆順検索など迅速な答えを見つけることができることを考え始めではなく？しかし、このエラーコードから、私は外側のループ、ダブルループ構文の外にジャンプする方法を学びました。ホワイトは本当に回り道をしませんでした。

// 错误代码
'outer: for x in (100..=999).rev() {
    for y in (100..=999).rev() {
        let prod = x * y;
        if is_palindromic(prod) {
            println!("{} x {} = {}", x, y, prod);
            break 'outer;
        }
    }
}

第五質問

問題の説明：

1、2、3、...、20割り切れるの整数を見つけるために最小化することができます。

コードのロジックは、最も外側のループの外に発見した後、割り切れ試して非常に簡単です。

let mut x = 2 * 3 * 5 * 7;
'outer: loop {
    for f in 2..=20 {
        if x % f != 0 {break;}
        if f == 20 {
            println!("{}", x);
            break 'outer;
        }
    }
    x += 2;
}

あなたは、プログラムが効率が十分に高くない実行されていると感じた場合は、実行するには、次のコマンドラインを使用することができ、その差は非常に大きく、Cプログラムに匹敵する効率の気持ち：

cargo run --release

質問6

問題の説明：
1〜100「と四角」と「二乗和」貧しい人々の自然数を見つけます。

通常の手続き型プログラミングは、この質問はあまりにも簡単ですが、関数型プログラミングのアイデアを試すために、コードは非常に簡単にすることができます。

let sum_of_squares = (1..=100).map(|x| x*x).sum::<u32>();
let sum = (1..=100).sum::<u32>();
println!("{}", sum * sum - sum_of_squares);

書き込みの使用倍（）関数もあり、それらのいくつかを理解することはより困難です。

let sum_of_squares = (1..=100).fold(0, |s, n| s + n * n);
let sum = (1..=100).fold(0, |s, n| s + n);
println!("{}", sum * sum - sum_of_squares);