第四章 迴圈

第四章 迴圈

4.1 while 迴圈

while 迴圈

下面是我們用 if 陳述式來解「d068. 該減肥了！」這一題的程式碼：

//d068: 該減肥了！ by Snail

#include <iostream>

using namespace std;

int main() {

    int w;

    cin >> w;              //輸入體重

    if (w > 50)             //如果體重 > 50

        w -= 1;         //體重減1

    cout << w;              //輸出體重

}

當所輸入的 w 大於 50，w 的值便會減 1，但是如果 w <= 50，便會維持原狀。

同樣這個程式，如果我們只改一個字，就是把關鍵字 if 改成 while，其他都維持不變，如下：

//d068. 該減肥了！ by Snail

#include <iostream>

using namespace std;

int main() {

    int w;

    cin >> w;               //輸入體重

    while (w > 50)          //如果體重 > 50

        w -= 1;         //體重減1

    cout << w;              //輸出體重

}

執行這個程式，輸入 60，執行結果卻輸岀 50。

while 在語法上和 if 極其相似，差別只在於 while 沒有 else 這個選擇性片語。其語法如下：

    while ( E ) S

和 if 陳述式不一樣的是，當 E 的回傳值不為 0 時 (true)，while 陳述式會重覆執行 S，直到 E 為 0 (false) 為止。

為了讓你瞭解 if 敘述和 while 敘述的差異，我們把它們執行的過程式以流程圖表示如：

在 if 陳述式的流程圖中，S 執行過後，會往下執行 if 陳述式的下一個陳述式。但是在 while 陳述式的流程圖中，S 執行過後，卻會回到上面重新求 E 的回傳值以決定要不要再執行一次。由於這個回頭的動作，讓流程圖中的執行路徑產生了一個迴路 (如下圖)，因此像 while 陳述式這種可以讓程式重覆執行的結構我們稱之為「迴圈 (Loop)」。迴圈會一直重覆地執行 S，直到 E 的回傳值變 0 為止。

由於 while 和 if 在語法上相似的特性，我們可以直接以 while 來取代 if 而不會產生任何的語法錯誤。但是他們的執行結果卻差很多，用 if 指令只減了 1 公斤，可是用 while 卻可以重覆地減 1 公斤，直到 w 不再大於 50 為止。

d498. 我不說髒話

題意很單純，就是要我們輸出 n 次「I don't say swear words!」，我們可以用 while 迴圈，並直接用 n 來記錄還剩幾次：

//d498. 我不說髒話by Snail

#include <iostream>

using namespace std;

int main () {

    int n;

    cin >> n;

    while (n > 0) {                         //若剩餘次數 > 0 則繼續輸出

        cout << "I don't say swear words!";

        n -= 1;                             //剩餘次數減 1

    }

}

這樣程式就會不斷地輸出「I don't say swear words!」，直到 n (剩下的次數) 等於 0 為止。

換行字元

如果你把上面的程式上傳，你會得到 NA，10 個測試點只有一個測試點通過，其它的都是 WA。原因是題目要求每個「I don't say swear words!」都要單獨在一行，因此輸出一次之後就要換行。但是我們要如何在螢幕上換行呢？查一下附錄 E 的 ASCII 字碼表，有一個編號為 10 的字碼代表「new line」，意思就是「換行」，你只要輸出這個字元，游標就會跑到下一行的開頭，接下來的文字就會輸出在這裡了。問題是這個字元要如何打在字串裡呢？C++ 為了方便某些特殊字碼的輸入，定義了一些「逸出順序」(附錄 F)。所謂「逸出順序」，是以一個特殊字元作為記號，其後的字元就被賦予特別的作用，而不再是它原本的意義了。C++ 用倒斜線「\」(backslash) 來作為「逸出字元」，當編譯器看到了「\」時，便會根據附錄 F 的表格來詮釋其後的字元。例如 "n" 就是一個小寫字母 n，但是 "\n" 就代表一個換行字元了。要注意是，雖然 "\n" 在程式碼中是兩個字元，可是存在記憶體中時只有一個「換行」字元。

因此，上面的程式只要在所要輸出的字串尾端加上一個 \n，那麼每個字串輸出完畢之後就會自動換到下一行了：

        cout << "I don't say swear words!\n";

改完之後上傳之後就可以 AC 了。

和 if 陳述式一樣，在 while ( ) 後面也只能接一個陳述式。如果你要重覆執行的陳述式有兩個或兩個以上，可以用 { } 把這些陳述式包裝起來，變成一個「複合陳述式」。在上面的程式中，需要重複執行的陳述式有「cout << "I don't say swear words!";」及「n -= 1;」兩個，所以必須在這兩個陳述式的前後加上一對大括號。如果忘了這對大括號，後果就很有趣了。請把下面這個程式貼到 VC++ 裡並執行：

//d498. 我不說髒話by Snail

#include <iostream>

using namespace std;

int main () {

    int n;

    cin >> n;

    while (n > 0)                           //若剩餘次數 > 0 則繼續輸出

        cout << "I don't say swear words!\n";

        n -= 1;                             //剩餘次數減 1

}

隨便輸入一個正整數，比如說 5，然後你會發現程式一直不斷地輸出「I don't say swear wrods!」，永遠停不下來。這時候可以按(全部停止) 讓它停下來。

回到程式，請在「」這行上按滑鼠右鍵、選「執行至游標處」，然後用「不進入函式」來逐行執行，你會發現程式一直在「while (n > 0)」「cout << "I don't say swear words!";」這兩個陳述式跳來跳去，也就是說，由於少了一對大括號，所以 while 陳述式並不包含「n -= 1;」這個陳述式，以至於 n 的值沒有被遞減，永遠都不會變成 0，而迴圈也一直重覆地輸出相同地文字，永遠都跳不出來！如果你把這個程式傳上去，會得到以下的訊息：

如果你按「繼續」繼續執行下去，會得到不可預期的結果：

初始化的動作可以和變數的宣告結合，在宣告變數的時候，順便就指定它的初始值，也就是以下的兩行程式：

    int a, b, c, bonus;

    bonus = 0;                      //加分初始化為0

可以寫成：

    int a, b, c, bonus = 0;         //加分初始化為0

用迴圈簡化

可是程式中我們重覆寫了 5 份一模一樣的以下的程式碼：

    cin >> a >> b >> c;             //星期 x

    if (a<b+c && b<a+c && c<a+b)    //如果是三角形

        bonus++;                    //多加一分

我們可以用 while 迴圈來讓這個兩個陳述式重覆執行 5 次：

//d511. 小明的作業 by Snail

#include <iostream>

using namespace std;

int main () {

    int a, b, c, n, bonus = 0;          //加分初始化為 0

    n = 5;

    while (n--) {                       //重覆執行 n 次

        cin >> a >> b >> c;

        if (a<b+c && b<a+c && c<a+b)    //如果是三角形

            bonus++;                 //多加一分

    }

    cout << bonus;

}

記得，由於要重複執行的陳述式有兩個，所以要用大括號括起來。

d074. 電腦教室

題目大意：給你 n 個正整數，請你求最大值。

這題和「d065. 三人行必有我師」有點像，都是求最大值。但是「d065. 三人行必有我師」固定給你三個整數，「d074. 電腦教室」卻是先給你一個整數 n，然後再給你 n 個整數來求最大值。由於 n 的值要到程式執行時才會給你，這個程式就不能用「暴力法」寫一大堆的程式碼來解決問題，一定要用迴圈了。還好你已經學會如何利用 while 迴圈來讓某一段程式碼重複執行 n 次，因此這題就不難了。

在求最大值時，我們通常會使用一個很簡單的技巧，就是先設一個變數來記錄最大值，比如說 mx (代表 maximum)。一開始時先把它設為一個很小的值，小到我們要處理的資料中沒有任何一個數字比它小。然後我們就把數字一個一個讀入，如果發現所讀入的值比 mx 大，就把這個比較大的值設定給 mx。如此一來，mx 會隨時保持到當時為止的最大值，等到所有的數字都讀完了以後，mx 裡所存的值就是所有數字的最大值了。

//d074. 電腦教室 by Snail

#include <iostream>

using namespace std;

int main() {

    int n, c, mx=0;            //用很小的值來初始化mx

    cin >> n;

    while (n--) {              //重複執行n 遍

        cin >> c;              //c(lass)--班級人數

        if (c > mx)            //如果本班人數大於最大值

            mx = c;         //以本班人數做為最大值

    }

    cout << mx;

}

也可以用 ? : 來代替 if 陳述式：

//d074. 電腦教室 by Snail

#include <iostream>

using namespace std;

int main() {

    int n, c, mx=0;            //用很小的值來初始化mx

    cin >> n;

    while (n--) {              //重複執行n 遍

        cin >> c;              //c(lass)--班級人數

        mx = c > mx ? c : mx;  //更新最大值

    }

    cout << mx;

}

? : 運算子的可讀性不佳，筆者比較喜歡用 max () 函式：

//d074. 電腦教室 by Snail

#include <iostream>

using namespace std;

int main() {

    int n, c, mx=0;            //用很小的值來初始化mx

    cin >> n;

    while (n--) {              //重複執行n 遍

        cin >> c;              //c(lass)--班級人數

        mx = max (c, mx);  //更新最大值

    }

    cout << mx;

}

4.2 n 行版

到目前為止，我們所做的題目都是專門為初學者所設計，「輸入只有一行」的特殊題目。但是一般在比賽時，出題者為了更徹底地測試參賽者的程式，會要求程式接受多筆的測試資料，並針對每筆測試資料輸出它的結果。以「文文的求婚--續集」為例，題目會要求你的程式可以輸入很多的西元年份，並判斷每個年份是閏年或是平年。

d069. 文文的求婚--續集 (n 行版)

之前的題目都有很多個「測資點」，意思是它會把你上傳的程式執行很多次，每次都輸入不一樣的值，以驗證你的程式是否正確。但是這個題目卻只有 1 個測資點，也就是它只執行你的程式一次，但是這一次就會輸入很多筆的「測試資料」，你的程式必須一一將這些資料讀入，逐一算出答案並輸出。

程式上傳以後，系統用來驗證你的程式碼的測試資料會比公布在題目中的範例輸入要更多且更嚴苛。以這題來說，題目的範例輸入只有 4 筆資料，然而實際上在驗證時，卻輸入了 380 筆資料。所以有很多時候，儘管你輸入題目上的範例測資可以得到正確的結果，但是上傳之後卻不一定能夠 AC。

既然你已經學了迴圈的結構，應該可以用它來讓程式重覆地輸入西元年份並判斷該年是閏年或是平年。問題是會有幾筆測試資料？迴圈倒底要執行幾次？程式如何知道測試資料已經結束？

在範例輸入中，第一行的 4 代表這題有 4 筆測試資料，接下來的 4 個整數才是你要判斷閏平年的西元年份。就像「d074. 電腦教室」的程式一樣，我們也可以先把 4 輸入到變數 n 裡，然後再利用 while 迴圈，讓迴圈裡的程式執行 n 次。至於迴圈內用以輸入年份並判斷閏平年的程式碼 (8~12 行) 則和「d067. 文文的求婚--續集 (1 行版)」的部份完全相同。

註:y % 4 == 0 && y %100 != 0 || y % 400 == 0可改成(y % 4 == 0)-(y %100 == 0)+(y % 400 == 0)

執行程式時，如果你懶得逐一輸入題目上的範例輸入，你可以把它複製下來，再貼到程式執行的畫面。只是因為它是 DOS 的畫面，貼的時候不能用鍵盤的 Ctrl-V，而是要按視窗的左上角的圖示，然後選「編輯 / 貼上」，但是要記得在程式的尾端加上中斷點，以免程式執行完畢後螢幕直接關閉而看不到結果。

它的執行結果如下：

如果你沒有看到最後一行的「a leap year」，可能是因為你複製時沒有複製到最後一個換行，只要在鍵盤上補按一個「Enter」鍵即可。

你很可能會發現，這樣的結果和題目上所要求的結果不一樣：題目上的輸入資料和輸出資料是分開的，可是我們這個程式的輸入資料和輸出資料卻是交錯的，這個程式上傳以後會 AC 嗎？

其實你不用太擔心。你應該猜得到，當你上傳一個程式到線上裁判時，線上裁判那端並不會有一個人坐在電腦前面幫你執行並用鍵盤輸入測試資料－－這些動作是由電腦自動完成的。但是電腦如何幫你輸入測試資料呢？開外掛嗎？當然不是，它是用輸出入重導向的方式來完成的。

事實上，出題者把要輸入的資料存在一個檔案中並上傳到 Zerojudge，Zerojudge 在執行你的程式時再把它「導入」你的程式中作為 cin 的輸入。我們現在就來模擬這樣的過程。

WINDOWS XP:

• 1. 打開「命令提示字元」。

  2. 輸入以下指令並按 Enter。

  3. copy con in.txt

  4. 用剛才所教的方法把題目的「範例輸入」內容貼上。貼上後如果游標沒有換到下一行，則補按一個 Enter。

  5. 在鍵盤上按 Ctrl-Z 及 Enter。

  6. 這時候你已經在這個位置準備好了一個「輸入檔」，檔名是「in.txt」如果你要驗證這個檔案，可以輸入「notepad in.txt」來查看，看完後關閉記事本並回到「命令提示字元」視窗。

  7. 打開「<專案目錄> / Debug」資料夾，在裡面找到一個 .exe 檔，把它用滑鼠拖到「命令提示字元」視窗裡，它會在「命令提示字元」加上程式的路徑名稱。

我們發現程式的確在遇到檔尾時跳出迴圈了，不過，在 ^Z (按 Ctrl-Z 時畫面會出現 ^Z) 的下面卻又多出了一行「a leap year」。如果你把這個程式上傳，你會得到 OLE (Output Limit Exceeded, 超出輸出限制) 以及下面的說明：

從程式的輸出結果中我們可以看出，前兩次的 bool (cin) 都得到了 1，但是由於第二個 cin >> x; 的讀取動作遇到了檔尾 (Ctrl-Z)，沒有讀成功，接下來的 bool (cin) 就轉成 0 了。由此可知，我們可以用 bool (cin) 來得知前一次的讀取是否成功。那麼之前的程式就可以改成：

//d071. 文文的求婚--續集(EOF 版) by Snail

#include <iostream>

using namespace std;

int main () {

    int y;

    while (1) {                         //重複執行迴圈

        cin >> y;                       //輸入西元年份

        if (!bool (cin)) break;         //輸入不成功則跳出迴圈

        if (y%4 == 0 && y%100 != 0 || y%400 == 0)

            cout << "a leap year\n";    //閏年

     else

            cout << "a normal year\n";  //平年

    }

}

由於放在 if 或 while 後面的 ( ) 內的運算式最後都是會轉成 bool，所以 bool 的型態轉換就可以省下來了，因此

        if (!bool (cin)) break;         //輸入不成功則跳出迴圈

可以寫成

        if (!cin) break;             //輸入不成功則跳出迴圈

還記得 cin >> y 的回傳值就是 cin 嗎？因此，我們也可以直接把 cin >> y 直接代入 if 陳述式之中了：

        cin >> y;                       //輸入西元年份

        if (!cin) break;             //輸入不成功則跳出迴圈

可以寫成

        if (!(cin >> y)) break;         //輸入不成功則跳出迴圈

整個程式就變成了：

//d071. 文文的求婚--續集(EOF 版) by Snail

#include <iostream>

using namespace std;

int main () {

    int y;

    while (1) {                         //重複執行迴圈

        if (!(cin >> y)) break;         //輸入不成功則跳出迴圈

        if (y%4 == 0 && y%100 != 0 || y%400 == 0)

            cout << "a leap year\n";    //閏年

     else

            cout << "a normal year\n";  //平年

    }

}

即然在進入迴圈後的第一個指令就是 if (!(cin >> y)) break;，我們大可以把這個判斷就放在 while 的 ( ) 裡了。而且現在在迴圈裡的只有一個 if 陳述式，所以大括號也可以省了。以下是這題的「終極版」程式碼：

//d071. 文文的求婚--續集(EOF 版) by Snail

#include <iostream>

using namespace std;

int main () {

    int y;

    while (cin >> y)                 //輸入成功時

        if (y%4 == 0 && y%100 != 0 || y%400 == 0)

            cout << "a leap year\n";    //閏年

     else

            cout << "a normal year\n";  //平年

}

比較一下上面這個「eof 版」的程式和下面這個「一行版」的程式有什麼不同？

//d067. 文文的求婚--續集(1 行版) by Snail

#include <iostream>

using namespace std;

int main () {

    int y;

    cin >> y;                    //輸入西元年份

    if (y%4 == 0 && y%100 != 0 || y%400 == 0)

        cout << "a leap year\n";    //閏年

    else

        cout << "a normal year\n";  //平年

}

辨識 eof 版的題目

在所有的測試資料輸入模式中，「EOF 版」算是用得最多的了。有的時候題目對此也交待得不是很清楚，常常以「輸入含有多筆測資」就帶過了。因此如果輸入說明中，沒有清楚地交待一共有幾筆測試資料 (n 行版)，或是測試資料以特殊的結作為結束 (下一節的 0 尾版)，那麼這題就應該以「EOF 版」來處理了。學會了「EOF 版」的處理方式之後，現在你能做的題目就多很多了。事實上，所有由 Zerojudge 的站長 Jiangsir 所出的基礎題，全部都是「EOF 版」的。同學們，殺啊！

a004. 文文的求婚

這題算是這一系列劇情的「首部曲」了。題目的要求和「d071. 文文的求婚--續集 (EOF 版)」其實是一模一樣的，差別只是這題用中文的「閏年」及「平年」作為輸出。同學們，再 AC 一題吧！

a002. 簡易加法

題目大意：這樣的題目還要大意啊？自己看吧！超級秒殺題。

在 while 的 ( ) 也可以輸入兩個變數，如 while (cin >> a >> b) ...，反正最後傳回的 cin 轉成 bool 都會是 0 (false)。

a003. 兩光法師占卜術

這題再寫不出來，你也很兩光哦！

 更多「EOF 版」的題目：

d053 10970 - Big Chocolate

題目大意：給你一塊長寬為 m 與 n 的巧克力，至少要切幾刀才能把它切成 m×n 塊。

根據題意，你不可以把好幾塊併在一起或疊在一起切，一次只能切一塊。那麼這題就和「d461. 班際籃球賽」很像了，每切一刀就會多一塊，那麼要切成 n 塊就得切 n - 1 刀了。

d126. 一、牧场围栏

這題是大陸的題目，所以是簡體字。有兩個原因讓 Zerojudge 也很受大陸同胞的歡迎。首先，它提供用 Pascal 語言解題。在大陸的中學生當中，Pascal 是很受歡迎的電腦語言。再者，這個網站提供了簡繁轉換的功能。台灣同胞要看大陸的題目，只要在「内容 ：」右邊的「简体->正體 」上點兩次，它就會變成繁體的了。

題目大意：給你矩形的長寬，求周長。

4.4 0 尾版

d070. 文文的求婚--續集 (0 尾版)

講完了「n 行版」和「EOF  版」，現在我們來看看第三種給測資的方式——「0 尾版」。這題的題目內容「 文文的求婚--續集」系列一模一樣，差別只在於給資料的方式。「n 行版」是一開始就告訴你底下會有多少筆的資料，「EOF 版」則是跟本不告訴你有幾筆資料，你自己讀到沒有資料為止。而在處理「0 尾版」的題目感覺上像「EOF 版」，只是它不是以 eof 作為結束，而是在資料的最後加上一筆不可能的資料來作為結束的記號。以這題的範例輸入來說，前四行是你要處理的資料，而最後一行的 0 則是結束的記號。這個結束的記號必須是不可能出現在測試資料之中的，以免造成混淆。題目中已經說明西元年份 y 為一個「正整數」，所以可以用 0 來做為資料的結束。

我們直接用「EOF 版」的程式加上一個 if ... break; 述敘就可以 AC 這題了：

//d070. 文文的求婚--續集(0 尾版) by Snail

#include <iostream>

using namespace std;

int main () {

    int y;

    while (cin >> y) {               //輸入成功時

        if (y == 0) break;          //輸入為 0 則跳出迴圈

        if (y%4 == 0 && y%100 != 0 || y%400 == 0)

            cout << "a leap year\n";    //閏年

     else

            cout << "a normal year\n";  //平年}

    }

}

, 運算子

C++ 至少定義了 44 個運算子，各式各樣、琳琅滿目，在各主要的程式語言之中，算是最多的了。其中有很多運算子的功能有點奇怪，初學者很難看出它倒底是要做什麼的，逗號運算子就是其中的一個。

依 C++ 的定義，逗號運算子像大多數其它的運算子一樣，也是一個二元運算子，在它的前後各有一個運算元。它會先對其左側的運算元求值，然後將回傳值捨棄，接下來再對其右側的運算元求值，並以右側運算元的回傳值作為逗號運算子的回傳值。以下面這個陳述式為例：

    a = (1 + 2, 4 * 5);

程式會先求出 1 + 2 的結果為 3，然後把 3 丟棄，接下來再求 4 * 5 的結果為 20，並把這個 20 透過 = 運算子指定給變數 a。

既然早知它的回傳值要丟棄，那還寫它做什麼？沒錯，上面的這個陳述式其實就等於

    a = 4 * 5;

那逗號運算子的存在就是很多餘的一件事了不是嗎？其實不然，看看下面這個陳述式：

    a = (cin >> a, a * 2);

這個陳述式會先輸入 a，然後立刻將 a * 2 再回存到 a。如果輸入 3，a 就會變 6；如果輸入 7，a 就會變 14。

重點是，逗號運算子的左側運算元一定必須是一個有「副作用」的運算式。a = (1 + 2, 4 * 5); 就等於 a = 4 * 5;，因為 1 + 2 的運算沒有「副作用」，而它的回傳值又被捨棄了。但是 cin >> a 卻是有「副作用」的，雖然它的回傳值 cin 被捨棄了，但是求值完後 a 的值已經變成了我們所輸入的值了。

逗號運算子常被有經驗的程式師用來讓程式碼更簡潔。參考下面的程式片段：

    a = 3;

    b = 5;

    t = a;

    a = b;

    b = t;

這段程式的作用是先設定變數 a 和 b 的值，然後把它們的值交換，(我知道，這個例子很無聊)。因為每個陳述式都很短，所以你可能會想把它們合併一下，變成：

    a = 3; b = 5;

    t = a; a = b; b = t;

但是這樣的程式看起來「不舒服」，因為有太多的「;」所以看起來有點支離破碎。我們可以模枋英文，用逗號把若干個「子句」連接成「複合句」，而不是一大堆的「簡單句」：

    a = 3, b = 5;

    t = a, a = b, b = t;

這樣的程式碼看起來比較優雅。(什麼？還要有「連接詞」！你是英文老師派來這裡亂的嗎？)

回到我們的「0 尾版」程式，while (cin >> y) 也可以用逗號運算子把下一行的 if 陳述式合併進來：

    while (cin >> y) {               //輸入成功時

        if (y == 0) break;          //輸入為 0 則跳出迴圈

就變成了：

    while (cin >> y, y != 0) {          //輸入不為 0 時

程式會先輸入 y，再根據 y 的值來判斷是否要繼續執行迴圈。while 的 ( ) 裡的 != 0 是可以省略的，而且迴圈內部也只剩一個 if 指令了，所以大括號也可以省略。最後整個程式最後就變成了：

//d070. 文文的求婚--續集(0 尾版) by Snail

#include <iostream>

using namespace std;

int main () {

    int y;

    while (cin >> y, y)             //輸入不為 0 時

        if (y%4 == 0 && y%100 != 0 || y%400 == 0)

            cout << "a leap year\n";    //閏年

     else

            cout << "a normal year\n";  //平年

}

三種版本的整理

當你做題目時，在看完題目準備開始寫程式的時候，第一個工作就是要看「輸入說明」及「範例輸入」來判斷它的測試資料是屬於哪一種型式。大部分的題目都是這三種版本其中的一種，也有一些是其中一中的「變體」，或是兩種版本的「組合」。只要你把基本的型式弄熟了，其他的變化就不是問題了。

1. 「n 行版」：先告訴你有幾筆資料。

    cin >> t;

    while (t--) {                    //剩餘次數不為 0 時

        //你的程式

    }

2. 「eof 版」：用檔案結束 (EOF) 來表示結束。

    while (cin >> n) {               //輸入成功時

        //你的程式

    }

3. 「0 尾版」：資料結尾用 0 或其他特別的值來標示。

    while (cin >> n, n) {            //輸入不為 0 時

        //你的程式

    }

這三種型式中，「eof 版」是最熱門的。對出題者來說，如果要在輸入檔中增加一筆測試資料，「n 行版」需要回去修改一開始的 n 值，但是「eof 版」就不需要了。對答題者來說，測試「n 行版」的程式時需要在程式的最後加上中斷點，或是把一開始的 n 值換成一個較大的值，否則程式一執行完畫面就關掉了。但是「eof 版」的程式就不需要加中斷點，你只要在看完結果後按 Ctrl-Z 和 Enter 就可以了。

「0 尾版」和「eof 版」有點相似，只要在複製範例輸入時不要複製最後的 0，等看完結果後再按 0 和 Enter 就可以了。「0 尾版」的一個缺點是真正的測試資料中不能再有 0 存在，否則會被誤為測試資料的結束。如果測試資料中會出現 0 的話，可以改用 -1 作為結束，如果測試資料也包含負數的話，那就只能改用「n 行版」或「eof 版」了。那是為什麼在這三種型式中，「0 尾版」是最少見的一種的原因了。

c006. Combination Lock 

d057. 11494 - Queen 

4.5 for 迴圈

d532. 文文的求婚 (三)

題目大意：求西元 a 年與 b 年之間一共有多少個閏年。

我們已經知道如何去判斷閏年和平年了，我們只要想辦法用一個迴圈讓它重複執行 b - a + 1 次，迴圈中的 y 則從 a 變到 b。在迴圈中如果發現 y 是閏年數的話，就把閏年數加 1，迴圈結束後我們就可以知道一共有幾個閏年了。

//d532. 文文的求婚(三) by Snail

#include <iostream>

using namespace std;

int main () {

    int a, b, y, leap=0;                    //閏年數先設為 0

    cin >> a >> b;

    y = a;                                  //一開始設 y 為a

    while (y <= b) {                        //y 還 <= b 時

        if (y % 4 == 0 && y %100 != 0 || y % 400 == 0)

            leap++;                         //加一個閏年

        y++;                                //y 加 1

    }

    cout << leap << endl;

}

上面這個程式是可以 AC 的。不過，在 C++ 有另外一個 for 陳述式可以用來簡化這樣的迴圈。for 陳述式的語法如下：

    for ( E1 ; E2 ; E3 ) S

    E1: 初始部

    E2: 條件部

    E3: 更新部

其流程圖如下：

上面的 for 陳述式也可以用下面的 while 陳述式來完成，其作用是一樣的：

    E1;

    while ( E2 ) {

        S

        E3;

    }

一個迴圈的形成，一般來說有三個重要部份。在進入迴圈之前，我們要先設定它的初始狀態，這個部份我們稱為「初始部」(Initialization)，也就是語法裡的 E1。以上面的程式為例，在迴圈開始之前，我們要先把 y 設為 a，這就是初始部。每執行完一次迴圈中的動作，我們需要更新控制變數，讓它準備好進行下一個回合，這個部份我們稱為「更新部」(Update)，上面的程式中，每次在判斷完 y 是不是閏年後，我們就把 y 加 1，準備好去做下一個判斷，這就是更新部。你也需要為迴圈設定一個條件，用以判斷迴圈是否繼續，這就是「條件部」(Condition)，範例程式中 的 y 如果仍小於或等於 b 時，我們就繼續判斷 y 是否閏年，一旦 y 大於 b 時，迴圈就會跳出來了，這就是條件部。

用 while 陳述式來做迴圈時，這三個部份會分散在三個地方，一來程式較為冗長，而且閱讀起來較為吃力。for 陳述式把控制迴圈的這三個部份集中在一起，讓程式看起來較為簡潔，也比較容易閱讀。上面範例程式的迴圈部份：

    y = a;             //E1 (y=a)--初始部

    while (y <= b) {   //E2 (y <= b)--條件部

        if (y % 4 == 0 && y %100 != 0 || y % 400 == 0)

            leap++;

        y++;           //E3 (y++)--更新部

    }

以 for 陳述式來改寫如下：

    for (y = a; y <= b; y++)                //y 從 a 變到 b

        if (y % 4 == 0 && y %100 != 0 || y % 400 == 0)

            leap++;                         //加一個閏年

在這個迴圈中，y 的角色稱為「控制變數」(Control Variable)，程式中利用它的變化來控制迴圈執行的次數。for 迴圈可以把這些迴圈控制的動作完全集中在 for 後面的 ( ) 中，只要看完 for (y = a; y <= b; y++) 這一行，你就可以知道迴圈一共會執行 b-a+1 次，迴圈中的 y 會從 a 開始依次遞增到 b。 

使用 for 陳述式時要注意，在 ( ) 中是用兩個分號來隔開三個「運算式」E1, E2 及 E3。

d072. 文文的求婚--續集 (Case 版)

這題的測試資料型式其實是「n 行版」，你可以發現它的輸入資料和「n 行版」完全相同，只是輸出變得比較麻煩，在「a leap year」及「a normal year」之前，我們得先輸出這是第幾筆測試資料。即然輸入旳部份與「n 行版」完全相同，你可能會認為直接用之前的「n 行版」的程式改一下輸出就好了。這題需要輸出這是第幾筆測試資料，這個數字從 1 開始，由小到大，可是 n 的變化卻是由大到小，所以...(敬請期待)

b146. NOIP2004 1.不高兴的津津

題目大意：給你 7 組數字，每組兩個整數，求第幾組的和最大，但是若最大的和不大於 8 則輸出 0，若有好幾組並列最大，輸出最小的組別。

這題你可以用以下的「暴力法」來解題：

//b146. NOIP2004 1.不高兴的津津 by Snail

#include <iostream>

using namespace std;

int main () {

    int a, b, mx=8, mxi=0;

    cin >> a >> b;             //第 1 組

    if (a + b > mx) {

        mx = a + b;

        mxi = 1;

    }

    cin >> a >> b;             //第 2 組

    if (a + b > mx) {

        mx = a + b;

        mxi = 2;

    }

    cin >> a >> b;             //第 3 組

    if (a + b > mx) {

        mx = a + b;

        mxi = 3;

    }

    cin >> a >> b;             //第 4 組

    if (a + b > mx) {

        mx = a + b;

        mxi = 4;

    }

    cin >> a >> b;             //第 5 組

    if (a + b > mx) {

        mx = a + b;

        mxi = 5;

    }

    cin >> a >> b;             //第 6 組

    if (a + b > mx) {

        mx = a + b;

        mxi = 6;

    }

    cin >> a >> b;             //第 7 組

    if (a + b > mx) {

        mx = a + b;

        mxi = 7;

    }

    cout << mxi << endl;

}

還記得「d511. 小明的作業」這題嗎？那個程式的「暴力解」有五段一模一樣的程式碼，我們用 while 陳述式將其中的一段程式碼重複執行五次，其他四段就可以刪掉了。可是如果你仔細看，上面的程式雖然有 7 段幾乎一模一樣的程式碼，但是每一段卻仍有一個陳述式不太一樣 (紅色部份)，這樣我們還能用迴圈來簡化這個程式嗎？答案當然是肯定的，只是我們需要另外設一個變數，讓它在迴圈執行的過程中，它的值會從 1 依次遞增到 7，然後再用它來取代程式中紅色的部份就行了。你當然也是可以用 while 陳述式來完成這個工作，但是即然學了 for 陳述式，就要善用它為我們所帶來的便利。

//b146. NOIP2004 1.不高兴的津津by Snail

#include <iostream>

using namespace std;

int main () {

    int a, b, i, mx=8, mxi=0;

    for (i=1; i<=7; i++) {          //迴圈重複執行 7 次

        cin >> a >> b;

        if (a + b > mx) {

            mx = a + b;

            mxi = i;            //i 的值從 1 依次遞增到 7

        }

    }

    cout << mxi << endl;

}

程式中的變數 i 除了用來取代原來的 1 到 7 的值以外，也用來作為迴圈的控制變數，一舉兩得。變數 mx (maximum) 用以儲存最大的上課時數，所用的技巧和「d074. 電腦教室」求最大班級人數的方法是一樣的。但是我們一開始的時候把 mx 設為 8，那麼如果沒有任何一天的上課時數大於 8 時，變數 mxi 的值就會維持最初設定的 0 了。

4.6 巢狀迴圈

a147 Print it all (0尾版 + 迴圈解題)

d040 11207 - The easiest way (0 尾版 + n 行版)

4.7 更多簡單問題

a042. 平面圓形切割 (EOF 版) (數學歸納法求公式)

b127. 會議中心（Room）(費氏數列)