{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"Week17.ipynb","provenance":[],"collapsed_sections":[],"authorship_tag":"ABX9TyM1LgMuxggA9P4VcgqQWG6W"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["#第十七週上課內容"],"metadata":{"id":"9xoK4OIjIfZA"}},{"cell_type":"markdown","source":["###GitHub 教材參考資料\n","\n","[位元運算、C Structures](https://github.com/htchen/i2p-nthu/tree/master/%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88%E4%B8%80/Supplementary%20Material%202)\n","\n","\n","[Static, Extern, 搜尋](https://github.com/htchen/i2p-nthu/tree/master/%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88%E4%B8%80/Supplementary%20Material%203)\n","\n","[Other Data Structures](https://github.com/htchen/i2p-nthu/tree/master/%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88%E4%B8%80/Supplementary%20Material%204)\n"],"metadata":{"id":"05G1Fqg6GRZX"}},{"cell_type":"markdown","source":["# Example 1\n","## C Structures\n","[The GNU C Programming Tutorial 對於 structures 的解釋](https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html#Structures)  \n","\n","Structures 是可以由使用者自己定義，由其他型別 (甚至是 structure) 的變數所組成的一個資料型別  \n","這樣的方式在使用上較方便，也會讓程式更簡潔易懂  \n","\n","譬如要描述平面上的點座標，可以用  \n","\n","```C\n","int x, y;\n","```\n","\n","若使用 structures 則可以自定一個叫做`t_point`的資料型態  \n","\n","```C\n","struct t_point {\n","   int x;\n","   int y;\n","};\n","```  \n","\n","關鍵字`struct`後面接著的`t_point`是自己替這個型別取的名字  \n","括號中間就是這個 structure 所包含的資料結構，括號後面要記得加上分號做結束  \n","這邊的`x`和`y`稱做`struct t_point`的成員變數 (member)  \n","\n","定義過 structure 之後，可以用它來宣告變數  \n","\n","```C\n","struct t_point pt;\n","```\n","\n","如果不想每次寫的時候都要有`struct`關鍵字，，可以利用下面這種寫法  \n","\n","```C\n","struct t_point {\n","    int x;\n","    int y;\n","};\n","typedef struct t_point Point;\n","\n","Point pt;\n","```\n","\n","或是這種寫法  \n","\n","```C\n","typedef struct {\n","    int x;\n","    int y;\n","} Point;\n","\n","Point pt;\n","```\n","\n","`pt`會包含`x`和`y`兩個 members，要更改 members 的內容，最直接的方式是使用 member operator `.` 來存取  \n","如果是指標變數，則可以透過`->`來存取  \n","\n","```C\n","Point pt = {5, 7};\n","pt.x = 7;\n","\n","Point *pp = &pt;\n","(*pp).x = 10;\n","pp->x = 10;\n","// 上面兩行是等價的\n","```\n","\n","又，已經宣告過的 structure 可以再拿來當成另一個 structure 的 member  \n","然後用它來產生變數，以及存取 members  \n","\n","```C\n","typedef struct {\n","   Point pt1;\n","   Point pt2;\n","} Rect;\n","\n","Rect screen;\n","printf(\"%d %d\\n\", screen.pt1.x, screen.pt1.y);\n","```\n","\n","\n","底下是一個較完整的範例  "],"metadata":{"id":"lxVlwJHZ3hn-"}},{"cell_type":"code","source":["%%writefile E17_01.c\n","#include <stdio.h>\n","#include <stdlib.h>\n","\n","// 定義一個新的型別\n","// 取名叫做 Point\n","// 裡面包含 x 和 y 兩個 members\n","// 定義過之後 Point 可以被拿來當作一般的型別來使用\n","// 包括宣告新的變數或是宣告 function\n","typedef struct {\n","    int x;\n","    int y;\n","} Point;\n","\n","// ones_vec_1 會傳回某個 Point 結構的位址\n","// 這個位址是由 Point 結構組成的陣列的開頭位址\n","Point * ones_vec_1(int length);\n","\n","// 傳入一個指向 Point* 的指標，ones_vec_2 會把 Point* 的值設定成\n","// 由 Point 結構組成的陣列的開頭位址\n","void ones_vec_2(int length, Point **bp);\n","\n","int main(void)\n","{\n","   Point *a, *b;\n","   int i, length;\n","   \n","   printf(\"The size of a Point is %lu bytes.\\n\", sizeof(Point));\n","    \n","   printf(\"vector length: \");\n","   scanf(\"%d\", &length);\n","\n","   // 利用 ones_vec_1 取得一個陣列\n","   // 陣列的每個元素是一個 Point\n","   // 陣列的開頭位址記錄在指標變數 a 裡面\n","   a = ones_vec_1(length);\n","   \n","   // 指標變數 b 同理\n","   ones_vec_2(length, &b);\n","\n","   // a 是個指標變數，它記錄的是某個陣列的開頭位址\n","   // 陣列的每個元素是 a[i] (型別為 Point)\n","   // 所以有兩個 members 分別是 a[i].x 和 a[i].y\n","   for (i=0; i<length; i++) \n","      printf(\"(%d, %d) \", a[i].x, a[i].y);\n","   printf(\"\\n\");\n","   \n","   // 同理\n","   for (i=0; i<length; i++)\n","      printf(\"(%d, %d) \", (b+i)->x, (b+i)->y); // (b+i)->x == (*(b+i)).x == b[i].x\n","   printf(\"\\n\");\n","   \n","   \n","   return 0;\n","}\n","\n","Point * ones_vec_1(int length)\n","{\n","   Point *a;\n","   int i;\n","   a = (Point *) malloc(length * sizeof(Point));\n","   for (i = 0 ; i < length; i++) {\n","      a[i].x = 1;\n","      a[i].y = 1;\n","   } \n","   return a;\n","}\n","\n","void ones_vec_2(int length, Point **bp)  // bp = &b;  *bp == b\n","{\n","   int i;\n","   Point *a;\n","   \n","   a = (Point *) malloc(length * sizeof(Point));\n","   for (i = 0; i < length; i++) {\n","      a[i].x = 1;\n","      async[i].y = 1;      \n","   } \n","   *bp = a;\n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"r8N_QUuG2QfR","executionInfo":{"status":"ok","timestamp":1654575838994,"user_tz":-480,"elapsed":8,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"92967b5e-166d-46de-d63e-af984c6002ec"},"execution_count":1,"outputs":[{"output_type":"stream","name":"stdout","text":["Writing E17_01.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E17_01.c -o E17_01\n","./E17_01"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"io5SL0M_4NhH","executionInfo":{"status":"ok","timestamp":1654575858535,"user_tz":-480,"elapsed":8860,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"e1116497-219b-4ca7-c9dd-22353a25b4a5"},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["The size of a Point is 8 bytes.\n","vector length: 10\n","(1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) \n","(1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) \n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":2}]},{"cell_type":"markdown","source":["# Example 2 \n","\n","## Structures + Functions\n","\n","Structures 可以使用的 operator 只有 `=` `&` `.` `->`，其他的運算則必須自己寫 functions 來達到我們想要的功能  \n","例如，想要比較兩個 structure 變數相不相等，不能直接用`==`或`!=`，相加`+`和相減`–`也不能用  \n","\n","以下是幾個自訂 functions 的例子  \n","\n"],"metadata":{"id":"5et8ZzeO6c7L"}},{"cell_type":"code","source":["%%writefile E17_02.c\n","#include <stdio.h>\n","#include <stdlib.h>\n","typedef struct t_complex {\n","    double r;\n","    double i;\n","} Complex;\n","\n","void add(Complex *a, Complex *b, Complex *t)\n","{\n","    t->r = a->r+b->r;\n","    t->i = a->i+b->i;\n","}\n","void set_complex(Complex *p, double r, double i)\n","{\n","    p->r = r;\n","    p->i = i;\n","}\n","void show_complex(Complex t)\n","{\n","    printf(\"%.2f%+.2fi\\n\", t.r, t.i);\n","}\n","\n","int main(void)\n","{\n","    Complex x, y, z;\n","    set_complex(&x, 1, 2);\n","    set_complex(&y, 2, -3);\n","    add(&x, &y, &z);\n","    show_complex(z);\n","\n","    return 0;\n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"E2TvhOwX6ZdU","executionInfo":{"status":"ok","timestamp":1654599806121,"user_tz":-480,"elapsed":317,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"f52f2594-3cf1-4bc4-855a-1bfd7f88a894"},"execution_count":30,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E17_02.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E17_02.c -o E17_02\n","./E17_02"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"7dsAkCFg6zH0","executionInfo":{"status":"ok","timestamp":1654599819112,"user_tz":-480,"elapsed":303,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"d3860c4c-d0aa-4108-c4dd-233c38625215"},"execution_count":31,"outputs":[{"output_type":"stream","name":"stdout","text":["3.00-1.00i\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":31}]},{"cell_type":"markdown","source":["# Example 3 \n","\n","傳遞 structure 變數到 function，會用 call-by-value 的方式  \n","所以在 function 裡改變 structure 的 members 的值，並不會影響外部的 structure 變數的內容  \n","\n","以`show_complex`為例，會發現這個函式其實只是需要讀取外面變數的值，不需要更改其內容  \n","所以就可以利用 call-by-value 的方式傳入  \n","\n","但以`set_complex`為例，這樣將會是徒勞無功  \n","必須如前文的程式碼，使用指標變數才有辦法更改到外面變數的內容  \n","\n","```C\n","void set_complex(Complex p, double r, double i)\n","{\n","    p.r = r;\n","    p.i = i;\n","    // 這個 p 是複製而來的，並不會改變到外面變數的內容\n","}\n","```\n","\n","> Note:  \n","> 如果是透過 call-by-value，傳遞過程可能需要複製整個變數的內容  \n","> 相較之下效率可能會比較低  \n","\n","底下的程式碼，可以將`DATA`想像成是一個`int`的陣列，並包括長度資訊  \n","其中的`clone_data`是為了實作類似`a = b`的效果，而自己定義出來的 function  \n"],"metadata":{"id":"usMu3U5R69hj"}},{"cell_type":"code","source":["%%writefile E17_03.c\n","\n","#include <stdio.h>\n","#include <stdlib.h>\n","typedef struct t_data {\n","    int size;\n","    int * ptr;\n","} DATA;\n","void create_data(DATA *z, int sz)\n","{\n","    int * t;\n","    int i;\n","    z->size = sz;\n","    z->ptr = (int *) malloc(sz*sizeof(int));\n","    t = z->ptr;\n","    for (i=0; i< sz; i++)  {\n","        t[i] = i;\n","    }\n","}\n","void show_data(DATA d) // d.size = x.size; d.ptr = x.ptr;\n","{\n","    int i;\n","    int *p;\n","    printf(\"%lu\\n\", sizeof(d));\n","    p = d.ptr;\n","    for (i=0; i<d.size; i++) {\n","        printf(\"%d \", p[i]);\n","        if ((i+1)%10 == 0) printf(\"\\n\");\n","    }\n","}\n","void delete_data(DATA *z) \n","{\n","    free(z->ptr);\n","    z->ptr = NULL;\n","    z->size = 0;\n","}\n","DATA clone_data(DATA x)\n","{\n","    int i;\n","    DATA y;\n","    y.size = x.size;\n","    y.ptr = (int *) malloc(y.size*sizeof(int));\n","    for (i=0; i<y.size; i++) {\n","        (y.ptr)[i] = (x.ptr)[i];\n","    }\n","    return y;\n","}\n","\n","int main(void)\n","{\n","    DATA x , x_clone;\n","    create_data(&x, 100); // x.size = 100; x.ptr = 0x12345678;\n","    show_data(x);\n","    //x_clone = x; //x_clone.size = x.size; x_clone.ptr = x.ptr;\n","    x_clone = clone_data(x);\n","    delete_data(&x);\n","    show_data(x_clone);\n","\n","    return 0;\n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"1-SRJh1X7gez","executionInfo":{"status":"ok","timestamp":1654575925168,"user_tz":-480,"elapsed":269,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"525b43a0-9e80-471e-83b0-622f1c7c30be"},"execution_count":4,"outputs":[{"output_type":"stream","name":"stdout","text":["Writing E17_03.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E17_03.c -o E17_03\n","./E17_03"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"FovQk3in7m5P","executionInfo":{"status":"ok","timestamp":1653980742531,"user_tz":-480,"elapsed":325,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"7c0be8af-d063-4811-8476-3f8e735f700f"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["16\n","0 1 2 3 4 5 6 7 8 9 \n","10 11 12 13 14 15 16 17 18 19 \n","20 21 22 23 24 25 26 27 28 29 \n","30 31 32 33 34 35 36 37 38 39 \n","40 41 42 43 44 45 46 47 48 49 \n","50 51 52 53 54 55 56 57 58 59 \n","60 61 62 63 64 65 66 67 68 69 \n","70 71 72 73 74 75 76 77 78 79 \n","80 81 82 83 84 85 86 87 88 89 \n","90 91 92 93 94 95 96 97 98 99 \n","16\n","0 1 2 3 4 5 6 7 8 9 \n","10 11 12 13 14 15 16 17 18 19 \n","20 21 22 23 24 25 26 27 28 29 \n","30 31 32 33 34 35 36 37 38 39 \n","40 41 42 43 44 45 46 47 48 49 \n","50 51 52 53 54 55 56 57 58 59 \n","60 61 62 63 64 65 66 67 68 69 \n","70 71 72 73 74 75 76 77 78 79 \n","80 81 82 83 84 85 86 87 88 89 \n","90 91 92 93 94 95 96 97 98 99 \n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":25}]},{"cell_type":"markdown","source":["# Example 4\n","## 位元運算\n","[C reference 對於算數運算子的說明](http://en.cppreference.com/w/c/language/operator_arithmetic)  \n","\n","C 語言提供了一些 bitwise operators，讓我們能用更低階的方式去存取和修改資料  \n","*   `~` (bitwise NOT)  \n","    將每個 bit 的值反轉  \n","    ```C\n","    unsigned int a = ~0;\n","    // 將 a 用二進位表示出來，會得到所有 bit 都是 1\n","    ```  \n","*   `&` (bitwise AND)  \n","    將兩個 operand 對應的 bit 進行 AND 運算  \n","    ```C\n","    // 假設 char 是 8 bit\n","    unsigned char a = 190; // 1011 1110\n","    unsigned char b = 162; // 1010 0010\n","    unsigned char c = a&b; // 1010 0010 = 162\n","    ```  \n","*   `|` (bitwise OR)  \n","    將兩個 operand 對應的 bit 進行 OR 運算  \n","    ```C\n","    // 假設 char 是 8 bit\n","    unsigned char a = 190; // 1011 1110\n","    unsigned char b = 162; // 1010 0010\n","    unsigned char c = a|b; // 1011 1110 = 190\n","    ```  \n","*   `^` (bitwise XOR)  \n","    將兩個 operand 對應的 bit 進行 XOR 運算  \n","    ```C\n","    // 假設 char 是 8 bit\n","    unsigned char a = 190; // 1011 1110\n","    unsigned char b = 162; // 1010 0010\n","    unsigned char c = a^b; // 0001 1100 = 28\n","    ```  \n","*   `<<` (left shift)  \n","    ```C\n","    // 假設 char 是 8 bit\n","    unsigned char x = 5; // 0000 0101 = 5\n","    unsigned char y = x << 3; // 0010 1000 = 40 = 5 * (2^3)\n","    ```  \n","*   `>>` (right shift)  \n","    ```C\n","    // 假設 char 是 8 bit\n","    unsigned char x = 59; // 0011 1011 = 59\n","    unsigned char y = x >> 1; // 0001 1101 = 29 = 59 / (2^1)\n","    ```  \n","\n","> Note:  \n","> 對於 shift operators 其實要注意 operands 的正負號  \n","> 可以參考開頭的網址了解更多細節，以及整數提升的規則  \n","\n","有時候我們需要儲存的資訊可能只有 0 和 1 兩種值，譬如記錄某種狀態的有或無  \n","當我們需要記錄大量這一類的資料時，若每個狀態都使用`int`來記錄會太浪費空間  \n","這種情況就適合使用位元運算，可以大幅地節省空間  \n","\n","譬如一個集合中包含 100、200、300 三種數字  \n","可以把不同數字的有無當成是一個狀態，藉此總共有 2^3 = 8 種子集合  \n","底下的程式碼可以產生除了空集合以外所有可能的組合  \n","\n","輸入  \n","\n","```\n","3\n","100 200 300\n","```\n","\n","輸出  \n","\n","```\n","100\n","200\n","100 200\n","300\n","100 300\n","200 300\n","100 200 300\n","```\n","\n","程式碼  \n"],"metadata":{"id":"Z29csvXHbXB-"}},{"cell_type":"code","source":["%%writefile E17_04.c\n","#include <stdio.h>\n","\n","int mask[16] = {\n","    0x00001, 0x00002, 0x00004, 0x00008,\n","    0x00010, 0x00020, 0x00040, 0x00080,\n","    0x00100, 0x00200, 0x00400, 0x00800,\n","    0x01000, 0x02000, 0x04000, 0x08000\n","};\n","\n","int main(void)\n","{\n","    int N, i, j, lim;\n","    int num[16];\n","\n","    scanf(\"%d\", &N);\n","    for (i=0; i<N; i++) {\n","        scanf(\"%d\", &num[i]);\n","    }\n","    lim = 1<<N;\n","    for (i=0; i<lim; i++) {\n","        for (j=0; j<N; j++)  {\n","            if ((i&mask[j])!=0) {\n","                printf(\"%d \", num[j]);\n","            }\n","        }\n","        printf(\"\\n\");\n","    }\n","\n","    return 0;\n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"znDP-kIkbocr","executionInfo":{"status":"ok","timestamp":1654602332680,"user_tz":-480,"elapsed":322,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"d0f6aa26-616b-472c-daf7-97681f7db8f9"},"execution_count":32,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E17_04.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E17_04.c -o E17_04\n","./E17_04\n","% 1 3 5 7\n","\n","% 0 0 0 0    0\n","% 0 0 0 1    1\n","% 0 0 1 0    2\n","% 0 0 1 1    3\n","% 0 1 0 0    4\n","% 0 1 0 1    5\n","% 0 1 1 0    6\n","% 0 1 1 1    7\n","% 1 0 0 0    8\n","% 1 0 0 1    9\n","% 1 0 1 0   10\n","% 1 0 1 1   11\n","% 1 1 0 0   12\n","% 1 1 0 1   13\n","% 1 1 1 0   14\n","% 1 1 1 1   15\n","%"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"kbv2jYHVb6Kc","executionInfo":{"status":"ok","timestamp":1654602347162,"user_tz":-480,"elapsed":9136,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"5818f059-4cd1-45b1-caed-5b4bb36fa124"},"execution_count":33,"outputs":[{"output_type":"stream","name":"stdout","text":["4\n","1 3 5 7\n","\n","1 \n","3 \n","1 3 \n","5 \n","1 5 \n","3 5 \n","1 3 5 \n","7 \n","1 7 \n","3 7 \n","1 3 7 \n","5 7 \n","1 5 7 \n","3 5 7 \n","1 3 5 7 \n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":33}]},{"cell_type":"code","source":["%%writefile E17_04.c\n","//可以進一步將`mask`使用`1 << N`的方式動態產生  \n","\n","#include <stdio.h>\n","int main(void)\n","{\n","    int N, i, j, lim;\n","    int num[16];\n","\n","    scanf(\"%d\", &N);\n","    for (i=0; i<N; i++) {\n","        scanf(\"%d\", &num[i]);\n","    }\n","\n","    lim = 1<<N;\n","\n","    for (i=0; i<lim; i++) {\n","        for (j=0; j<N; j++)  {\n","            if ( (i & (1<<j))!= 0 ) {\n","                printf(\"%d \", num[j]);\n","            }\n","        }\n","        printf(\"\\n\");\n","    }\n","    return 0;\n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"qfV8TTbpcPxJ","executionInfo":{"status":"ok","timestamp":1654576480414,"user_tz":-480,"elapsed":318,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"00dbd4e3-a364-44aa-9089-ca5557c9fb85"},"execution_count":7,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E17_04.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E17_04.c -o E17_04\n","./E17_04"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"uu16CCVYcYlC","executionInfo":{"status":"ok","timestamp":1654576494536,"user_tz":-480,"elapsed":7067,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"6e53e797-4e2c-4880-8929-022c6566414e"},"execution_count":8,"outputs":[{"output_type":"stream","name":"stdout","text":["3\n","10 20 30\n","\n","10 \n","20 \n","10 20 \n","30 \n","10 30 \n","20 30 \n","10 20 30 \n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":8}]},{"cell_type":"markdown","source":["# Example 5\n","\n","以下是實務中可能會用到的例子，藉由一個夠大的型別來儲存多種屬性  \n"],"metadata":{"id":"78tEqrVdbzj7"}},{"cell_type":"code","source":["%%writefile 17_05.c\n","\n","#include <stddef.h>\n","#include <stdio.h>\n","#include <stdlib.h>\n","\n","#define BIT(n) (1u<<(n))\n","\n","#define NTHU_STUDENT BIT(0)\n","#define NHCUE_STUDENT BIT(1)\n","#define CS_MAJOR BIT(2)\n","#define FRESHMAN BIT(3)\n","\n","void Print(unsigned int* students, size_t length)\n","{\n","\tsize_t i;\n","\tfor (i = 0; i < length; i++)\n","\t{\n","\t\tprintf(\"Student %zu: \", i);\n","\n","\t\tif (students[i] & NTHU_STUDENT)\n","\t\t\tprintf(\"NTHU \");\n","\n","\t\tif (students[i] & NHCUE_STUDENT)\n","\t\t\tprintf(\"NHCUE \");\n","\n","\t\tif (students[i] & CS_MAJOR)\n","\t\t\tprintf(\"CS \");\n","\n","\t\tif (students[i] & FRESHMAN)\n","\t\t\tprintf(\"Freshman \");\n","\n","\t\tprintf(\"\\n\");\n","\t}\n","}\n","\n","int main()\n","{\n","\tunsigned int a = NTHU_STUDENT | CS_MAJOR | FRESHMAN;\n","\tunsigned int b = NTHU_STUDENT | FRESHMAN;\n","\tunsigned int c = NHCUE_STUDENT | FRESHMAN;;\n","\tunsigned int d = CS_MAJOR;\n","\n","\tunsigned int students[] = { a,b,c,d };\n","\tsize_t length = sizeof(students) / sizeof(students[0]);\n","\tsize_t i;\n","\t\n","\tPrint(students, length);\n","\n","\tprintf(\"\\nAfter one year\\n\\n\");\n","\n","\tfor (i = 0; i < length; i++) {\n","\t\tstudents[i] &= ~FRESHMAN;\n","\t}\n","\n","\tPrint(students, length);\n","\n","\tprintf(\"\\nAfter merging\\n\\n\");\n","\t\n","\tfor (i = 0; i < length; i++) {\n","\t\tif (students[i] & NHCUE_STUDENT) {\n","\t\t\tstudents[i] &= ~NHCUE_STUDENT;\n","\t\t\tstudents[i] |= NTHU_STUDENT;\n","\t\t}\n","\t}\n","\n","\tPrint(students, length);\n","\n","\treturn 0;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"4XsM1uWTchbz","executionInfo":{"status":"ok","timestamp":1654576586845,"user_tz":-480,"elapsed":313,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"803bd409-c4d8-4b2a-f87a-c2a129b79e33"},"execution_count":10,"outputs":[{"output_type":"stream","name":"stdout","text":["Writing 17_05.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc 17_05.c -o 17_05\n","./17_05"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"OVp19-iccyuk","executionInfo":{"status":"ok","timestamp":1654576613429,"user_tz":-480,"elapsed":322,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"4e9d120d-e694-4959-8f31-f8734d3cc659"},"execution_count":11,"outputs":[{"output_type":"stream","name":"stdout","text":["Student 0: NTHU CS Freshman \n","Student 1: NTHU Freshman \n","Student 2: NHCUE Freshman \n","Student 3: CS \n","\n","After one year\n","\n","Student 0: NTHU CS \n","Student 1: NTHU \n","Student 2: NHCUE \n","Student 3: CS \n","\n","After merging\n","\n","Student 0: NTHU CS \n","Student 1: NTHU \n","Student 2: NTHU \n","Student 3: CS \n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":11}]},{"cell_type":"markdown","source":["# Example 6\n","\n","## 更多的位元運算\n","\n","下例的程式碼會回傳從右邊數來第 p 個 bit 開始，取出 n 個 bit  \n","```C\n","unsigned getBits(unsigned x, int p, int n)\n","{\n","   return ( x >> (p-n) ) & ~( ~0 << n );  /* 取出 x 的第 p 位置起 n 個 bits */\n","}\n","```\n","\n","以`getBits(100, 6, 4)`為例，會從右邊數來第 6 個 bit 開始，取出 4 個 bit  \n","十進位 100 用二進位表示為 `0001100100`，粗體是要取出的 bits  \n","0000 0000 0000 0000 0000 0000 01**10** **01**00  \n","\n","```C\n","// 這個結果會用來當作mask\n","~( ~0 << n )\n","```\n","*   `~0` : 1111 1111 1111 1111 1111 1111 1111 1111  \n","*   `<< n` : 1111 1111 1111 1111 1111 1111 1111 0000  \n","*   `~`: 0000 0000 0000 0000 0000 0000 0000 1111  \n","\n","```C\n","// 先把右邊不要的部分透過位移運算移除\n","x >> (p-n)\n","```\n","*   `>> (p-n)` : 0000 0000 0000 0000 0000 0000 0001 **1001**  \n","\n","```C\n","// 最後將兩個結果進行 bitwise AND 運算\n","( x >> (p-n) ) & ~( ~0 << n )\n","```\n","*   0000 0000 0000 0000 0000 0000 0000 1111 &  \n","    0000 0000 0000 0000 0000 0000 0001 **1001** =  \n","    0000 0000 0000 0000 0000 0000 0000 **1001**  \n","\n","下例的程式碼是用來把 x 第 p 位置起 n 個 bits 由 0 變 1，1 則變為 0  \n","```C\n","unsigned invert( unsigned x, int p, int n )\n","{\n","   return  x ^ (~(~0 << n) << (p-n));\n","}\n","```\n","\n","利用 XOR 的運算性質：\n","*   a ^ 0 = a  \n","*   a ^ 1 = ~a  \n","\n","想辦法產生一個 mask，能從 p 位置後接 n 個 1，其餘位置都是零  \n","這樣的 mask 可以用`~(~0 << n) << (p-n)`產生  \n","接著將 mask 和 x 做 bitwise XOR 就可得到`invert`要求的效果  \n","\n","下例的程式碼是用來傳回 x 向右 rotate n bits 之後的結果  \n","\n","```C\n","unsigned rightRotate(unsigned x, int n)\n","{\n","   return ((x & ~(~0 << n)) << (sizeof(x)*8 - n)) | (x >> n) ;\n","}\n","```\n","\n","首先用`(x & ~(~0 << n))`取出最右邊 n 個 bits，然後向左位移`(sizeof(x)*8 - n)`bits  \n","接著`(x >> n)`把 x 向右位移 n  bits，把兩個結果利用 OR 運算就可以做出向右 rotate 的效果  \n","\n","> Note:  \n","> 以上範例均是假設`int`為 32 位元\n","\n","## 在二進位表示法下，找出下一個「位元中具有相同數量的 1 」的數字\n","例如，`00100110` 包含三個 `1`，\n","下一個符合這個條件、也包含三個 `1` 的數字是 `00101001`\n","\n","00100110\n","00100111\n","00101000\n","00101001\n","\n","\n","\n","用下面這段程式碼可以直接算出\n","```C\n","char x, t, y, z;\n","x = 38; // 00100110\n","t = x & -x; // 00100110 & 11011010 -> 00000010 找出最右邊的 1\n","y = t + x;  // 00000010 + 00100110 -> 00101000 設法讓x 最右邊的連續的 1 都變成 0，當作是下一個要考慮的數的起點，y 包含的 1 的數量一定會比 x 還少。接下來只要知道要替 y 補上幾個 1，就可以得到我們要的結果\n","z = y ^ x;  // 00101000 ^ 00100110 -> 00001110 找出上一步哪些地方被改了\n","z = (z/t)>>2; // (00001110 / 00000010) >> 2 -> 00000001 去掉最右邊的 0 然後忽略最左邊和最右邊（總共兩個）1，如此可以得到需要補的 1 有幾個\n","x = y | z; //00101000 | 00000001 -> 00101001 把上缺的 1\n","```"],"metadata":{"id":"twKUKfghcumE"}},{"cell_type":"code","source":["%%writefile E17_06.c\n","#include <stdio.h>\n","int main(void)\n","{\n","  int x, t, y, z;\n","  int N, k, i, j, lim;\n","  int num[16];\n","  scanf(\"%d%d\", &N, &k);\n","  for (i=0; i<N; ++i) {\n","      scanf(\"%d\", &num[i]);\n","  }\n","  lim = 1 << N;\n","  x = 0;\n","  x = ~(~x << k);\n","\n","  for ( ; x<lim; ) {\n","    for (j=N-1; j>=0; --j) {\n","      if ((x &(1<<j)) != 0) {\n","          printf(\"%d \", num[j]);\n","      }\n","    }\n","    t = x & -x; \n","    y = t + x;\n","    z = y ^ x; \n","    z = (z/t)>>2;\n","    x = y | z;\n","\n","    printf(\"\\n\");\n","  }\n","    return 0;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"lFPErJKViMf7","executionInfo":{"status":"ok","timestamp":1654604357625,"user_tz":-480,"elapsed":335,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"d0946f43-2367-44c4-8555-fadbc95989a1"},"execution_count":34,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E17_06.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E17_06.c -o E17_06\n","./E17_06"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"FcGyINB56P1K","executionInfo":{"status":"ok","timestamp":1654604472011,"user_tz":-480,"elapsed":11181,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"726f43f4-6397-443c-8f88-f8c81ddba423"},"execution_count":37,"outputs":[{"output_type":"stream","name":"stdout","text":["8 3\n","1 2 3 4 5 6 7 8\n","3 2 1 \n","4 2 1 \n","4 3 1 \n","4 3 2 \n","5 2 1 \n","5 3 1 \n","5 3 2 \n","5 4 1 \n","5 4 2 \n","5 4 3 \n","6 2 1 \n","6 3 1 \n","6 3 2 \n","6 4 1 \n","6 4 2 \n","6 4 3 \n","6 5 1 \n","6 5 2 \n","6 5 3 \n","6 5 4 \n","7 2 1 \n","7 3 1 \n","7 3 2 \n","7 4 1 \n","7 4 2 \n","7 4 3 \n","7 5 1 \n","7 5 2 \n","7 5 3 \n","7 5 4 \n","7 6 1 \n","7 6 2 \n","7 6 3 \n","7 6 4 \n","7 6 5 \n","8 2 1 \n","8 3 1 \n","8 3 2 \n","8 4 1 \n","8 4 2 \n","8 4 3 \n","8 5 1 \n","8 5 2 \n","8 5 3 \n","8 5 4 \n","8 6 1 \n","8 6 2 \n","8 6 3 \n","8 6 4 \n","8 6 5 \n","8 7 1 \n","8 7 2 \n","8 7 3 \n","8 7 4 \n","8 7 5 \n","8 7 6 \n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":37}]},{"cell_type":"markdown","source":["# Example 7\n","\n","\n","## Linked List\n","\n","linked list 是一種常見的資料結構  \n","\n","array 在存取元素時只需要利用起始位址及位移量，就可以算出要存取的元素在哪裡  \n","但如果想要在 array 中間插入元素或是刪除元素，勢必要挪動一部分的元素以遞補或是騰出空位  \n","當插入的動作相當頻繁時，array 就會花很多時間在資料的複製與搬移  \n","\n","而 linked list 的想法就是，元素不需要是連續地儲存在記憶體  \n","每個元素自己都有個資訊可以記得下一個元素在哪裡，與自己本身要儲存的資料  \n"],"metadata":{"id":"LiJzfOwbAjo9"}},{"cell_type":"markdown","source":["![image.png](data:image/png;base64,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)"],"metadata":{"id":"7qCeHoIjA1GY"}},{"cell_type":"markdown","source":["\n","\n","透過這樣的設計，要插入元素的時候，只需改變幾個元素的「下一個元素的位址」的資訊  \n","這樣就只需要簡單的幾個操作就可以插入元素，並不會因為資料規模變大而使得插入的速度變慢  \n","但與此同時，如果想要從第一個元素走到最後一個，或是想要存取其中某個元素  \n","勢必得從頭開始走訪，沒辦法如同 array 那般快速  \n","\n","```C\n","#include <stdio.h>\n","#include <stdlib.h>\n","typedef struct _node {\n","    int x;\n","    struct _node *next;\n","} Node;\n","\n","int main(void)\n","{\n","    Node head;\n","\n","    head.x = 0;\n","    head.next = NULL;\n","\n","    head.next = (Node *) malloc (sizeof(Node));\n","\n","    (head.next)->x = 1;\n","    (head.next)->next = NULL;\n","\n","    printf(\"%d %d\\n\", head.x, (head.next)->x);\n","\n","    free(head.next);\n","\n","    return 0;\n","}\n","```\n","\n","底下的程式碼利用迴圈來產生 node  \n","\n","\n","\n","\n","\n","\n"],"metadata":{"id":"eiIaLW3NBFVd"}},{"cell_type":"code","source":["%%writefile E17_07.c\n","#include <stdio.h>\n","#include <stdlib.h>\n","typedef struct _node {\n","    int x;\n","    struct _node *next;\n","} Node;\n","\n","/*\n","head[x|next]\n","        |\n","        V\n","        [x|next]\n","             |\n","             V\n","        np-> [x|next]\n","*/\n","\n","int main(void)\n","{\n","    Node head;\n","    Node *np, *nq;\n","    int i;\n","\n","    head.x = 0;\n","    head.next = (Node *) malloc(sizeof(Node));\n","    np = head.next;\n","    i = 1;\n","    while (i < 10) {\n","        np->x = i;\n","        np->next = (Node *) malloc(sizeof(Node));\n","        np = np->next;\n","        i++;\n","    }\n","    np->x = i;\n","    np->next = NULL;\n","    np = head.next;\n","    while (np!=NULL) {\n","        printf(\"%d\\n\", np->x);\n","        np = np->next;\n","    }\n","\n","    np = head.next;\n","    while (np!=NULL) {\n","        nq = np;\n","        np = np->next;\n","        free(nq);\n","    }\n","\n","    return 0;\n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"owudmQwkBWec","executionInfo":{"status":"ok","timestamp":1654586284728,"user_tz":-480,"elapsed":269,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"65171937-7662-4652-ba72-6633bb451b36"},"execution_count":28,"outputs":[{"output_type":"stream","name":"stdout","text":["Writing E17_07.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E17_07.c -o E17_07\n","./E17_07"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"1yiTrw9UBrvx","executionInfo":{"status":"ok","timestamp":1654586288782,"user_tz":-480,"elapsed":282,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"ca580169-711f-4719-d1fd-9632be431039"},"execution_count":29,"outputs":[{"output_type":"stream","name":"stdout","text":["1\n","2\n","3\n","4\n","5\n","6\n","7\n","8\n","9\n","10\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":29}]},{"cell_type":"markdown","source":["\n","透過上面的範例大致理解 linked list 以後  \n","接下來我們希望設計一個 linked list，存的資料順序要由小排到大，為此我們需要解決幾個問題：  \n","1.  如何產生一個 linked list\n","2.  如何在某個位置插入一個 node\n","3.  如何拿掉某個 node\n","\n","故可以設計這些 functions  \n","\n","```C\n","struct t_node* insert(struct t_node *np, int val);\n","struct t_node* delete(struct t_node *np, char val);\n","void dispList(struct t_node *np);\n","```\n","\n","主程式從產生`head`開始  \n","\n","```C\n","struct t_node *head;\n","head = NULL;\n","```\n","\n","呼叫`insert`把某個值加入`head`所指到的 linked list 的適當位置 (node 的 data 值要從小排到大)  \n","\n","```C\n","head = insert(head, 4); /* 經過 insert() 之後， head 可能需要指到不同位址 */\n","head = insert(head, 8); /* 所以要傳回新的位址給 head */\n","head = insert(head, 13);\n","```\n","\n","或是呼叫`delete`把值從`head`所指到的 linked list 中刪除  \n","\n","```C\n","head = delete(head, 13);\n","head = delete(head, 4);\n","head = delete(head, 11);\n","```\n","\n","或是呼叫`dispList`把`head`所指到的 linked list 的內容顯示出來  \n","\n","```C\n","dispList(head);\n","```\n","\n","先來看怎麼寫`dispList`  \n","\n","```C\n","void dispList(struct t_node *np)\n","{ \n","   if ( np == NULL ) {\n","      printf(\"List is empty.\\n\\n\");\n","   }  \n","   else { \n","      printf(\"The list is:\\n\");\n","      while (np != NULL) { \n","         printf(\"%d--> \", np->data);\n","         np = np->nextPtr;   \n","      }\n","      printf(\"NULL\\n\\n\");\n","   }\n","}\n","```\n"],"metadata":{"id":"IiqSkRYoBozc"}},{"cell_type":"markdown","source":["![image.png](data:image/png;base64,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)"],"metadata":{"id":"-8amMXb_B6YV"}},{"cell_type":"markdown","source":["\n","\n","\n","再來看`insert`怎麼寫  \n","\n","```C\n","struct t_node* insert(struct t_node *np, int val)\n","{ \n","   struct t_node *newPtr, *previousPtr, *currentPtr; \n","\n","   newPtr = (struct t_node *)malloc(sizeof(struct t_node)); \n","   if (newPtr != NULL) { \n","      newPtr->data = val; \n","      newPtr->nextPtr = NULL; \n","      previousPtr = NULL;\n","      currentPtr = np;\n","      while (currentPtr!=NULL && val>currentPtr->data) { \n","         previousPtr = currentPtr;    \n","         currentPtr = currentPtr->nextPtr; \n","      }      \n","      if (previousPtr == NULL) { \n","         newPtr->nextPtr = np;\n","         np = newPtr;\n","      }\n","      else {\n","         previousPtr->nextPtr = newPtr;\n","         newPtr->nextPtr = currentPtr;\n","      }   \n","      return np;\n","   }\n","   else {\n","      printf(\"Out of memory\\n\");\n","      return NULL;\n","   }\n","}\n","```\n"],"metadata":{"id":"aIxCDQGECAsC"}},{"cell_type":"markdown","source":["![image.png](data:image/png;base64,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)"],"metadata":{"id":"XrH-SeD_CA27"}},{"cell_type":"markdown","source":["\n","最後看怎麼寫`delete`  \n","\n","```C\n","struct t_node* delete(struct t_node *np, int val)\n","{ \n","   struct t_node *previousPtr, *currentPtr, *tempPtr;    \n","\n","   if (val == np->data) { \n","      tempPtr = np; \n","      np = np->nextPtr; \n","      free( tempPtr ); \n","      return np;\n","   }\n","   else { \n","      previousPtr = np;\n","      currentPtr = np->nextPtr;\n","      while (currentPtr != NULL && \n","                currentPtr->data != val) { \n","         previousPtr = currentPtr;         \n","         currentPtr = currentPtr->nextPtr; \n","      }\n","      if (currentPtr != NULL) { \n","         tempPtr = currentPtr;\n","         previousPtr->nextPtr = currentPtr->nextPtr;\n","         free( tempPtr );\n","         return np;\n","      }     \n","   } \n","   return NULL;\n","}\n","```"],"metadata":{"id":"S9uTqKUYCUts"}},{"cell_type":"markdown","source":["![image.png](data:image/png;base64,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)"],"metadata":{"id":"dyhVRQ-7Ckm9"}},{"cell_type":"markdown","source":["# Supplementary Material 3\n","\n","目錄  \n","*\t[關於 static 與 extern](#關於-static-與-extern)  \n","*\t[資料處理](#資料處理)  \n","*\t[查字典與自動完成](#查字典與自動完成)  \n","*\t[Doubly Linked List](#doubly-linked-list)  \n","\n","## 關於 static 與 extern\n","[Stack Overflow 關於這部分的說明](https://stackoverflow.com/questions/95890/what-is-a-variables-linkage-and-storage-specifier)  \n","\n","*   **static**  \n","    函數或是全域變數前面如果加`static`  \n","    表示這個函數不會被 linker 看到  \n","    因此不會和其他檔案連結  \n","\n","    區域變數前面如果加`static`  \n","    表示這個變數從程式開始執行就會存在  \n","    直到程式結束才會消失  \n","\n","*   **extern**  \n","    只在一個原始碼檔案中定義  \n","    \n","    ```C\n","    int x = 0;\n","    ```\n","    \n","    其他原始碼檔案如果要使用`x`，應該宣告成  \n","    \n","    ```C\n","    extern int x;\n","    ```\n","    \n","    > Note:  \n","    > 可以參考底下的資料，進一步了解對於變數來說甚麼時候需要`extern`  \n","    > [Stack Overflow 關於 Global Variable in Header File 的問答](https://stackoverflow.com/questions/8108634/global-variables-in-header-file)  \n","\n","\n","## 資料處理\n","*   [qsort](http://www.gnu.org/software/libc/manual/html_node/Array-Sort-Function.html#Array-Sort-Function)\n","*   [fgets](http://www.cplusplus.com/reference/cstdio/fgets/)\n","\n","讀取`imdb_top250.txt`檔案，裡面包含了 250 筆電影資料  \n","每一筆資料包含四個項目，分別是平均評分、電影名稱、上映年份、參與評分的網友數目  \n","\n","\n","\n","Download file:\n","[imdb_top250.txt](https://drive.google.com/file/d/15j-pExj6FtuizDIpNewdqcvvfrkPPLSF/view?usp=sharing)\n","\n","\n","\n","輸入中的每一筆資料之間用空行隔開  \n","\n","```\n","9.2\n","The Shawshank Redemption\n","1994\n","885806\n","\n","9.2\n","The Godfather\n","1972\n","641587\n","```\n","\n","並利用底下的 structure 儲存  \n","\n","```C\n","struct t_movie {\n","    double rating;\n","    char name[64];\n","    int year;\n","    int reviews;\n","};\n","typedef struct t_movie Movie;\n","```\n","\n","且產生一個 250 個元素的陣列，儲存 250 筆電影資料  \n","\n","```C\n","Movie top[250];\n","```\n","\n","利用`qsort`將資料以底下的原則重新排列：  \n","1.  依照電影名稱的英文字母順序\n","2.  依照上映年份排序，從早期到近期，如果年份相同，則再依照電影名稱的英文字母順序排序\n","3.  依照平均評分的高低排序，由高到低，如果評分相同，則再依照參與評分的網友數量排序\n","\n","將以上三點的的排序結果分別輸出為`sort1.txt`、`sort2.txt`、`sort3.txt`\n","\n","範例程式碼  \n","\n","```C\n","#include <stdio.h>\n","#include <stdlib.h>\n","#include <string.h>\n","\n","struct t_movie {\n","    double rating;\n","    char name[64];\n","    int year;\n","    int reviews;\n","};\n","typedef struct t_movie Movie;\n","Movie movies[300];\n","\n","int cmp1(const void *a, const void *b)\n","{\n","    Movie *s, *t;\n","    s = (Movie*) a;\n","    t = (Movie*) b;\n","    return strcmp(s->name, t->name);\n","}\n","int cmp2(const void *a, const void *b)\n","{\n","    Movie *s, *t;\n","    s = (Movie*) a;\n","    t = (Movie*) b;\n","    if (s->year > t->year) return 1;\n","    else if (s->year < t->year) return -1;\n","    else\n","         return strcmp(s->name, t->name);\n","}\n","int cmp3(const void *a, const void *b)\n","{\n","    Movie *s, *t;\n","    s = (Movie*) a;\n","    t = (Movie*) b;\n","    if (s->rating > t->rating) return -1;\n","    else if (s->rating < t->rating) return 1;\n","    else {\n","        if (s->reviews > t->reviews) return -1;\n","        else if (s->reviews < t->reviews) return 1;\n","        else return 0;\n","    }\n","}\n","\n","void write(char * fname, Movie *mvs, int NM)\n","{\n","    int i;\n","    FILE *fout;\n","    fout = fopen(fname, \"w\");\n","    for (i=0; i<NM; i++) {\n","        fprintf(fout, \"%3d: %f\\t%s\\t(%d)\\t%d\\n\",\n","               i+1, mvs[i].rating, mvs[i].name, mvs[i].year, mvs[i].reviews);\n","    }\n","    fclose(fout);\n","}\n","\n","int main(void)\n","{\n","    int NM;\n","    FILE *fin;\n","\n","    char line[255];\n","    fin = fopen(\"imdb_top250.txt\", \"r\");\n","\n","    NM = 0;\n","    while (!feof(fin) ) {\n","        if (fgets(line, 255, fin)==NULL) break;\n","        movies[NM].rating = atof(line);\n","        if (fgets(line, 255, fin)==NULL) break;\n","        strcpy(movies[NM].name, line);\n","        if (fgets(line, 255, fin)==NULL) break;\n","        movies[NM].year = atoi(line);\n","        if (fgets(line, 255, fin)==NULL) break;\n","        movies[NM].reviews = atoi(line);\n","        NM++;\n","        if (fgets(line, 255, fin)==NULL) break;\n","    }\n","    fclose(fin);\n","/*\n","    for (i=0; i<NM; i++) {\n","        printf(\"%3d: %f\\t%s\\t(%d)\\t%d\\n\",\n","               i+1, movies[i].rating, movies[i].name, movies[i].year, movies[i].reviews);\n","    }\n","*/\n","    qsort(movies, NM, sizeof(Movie), cmp1);\n","    write(\"sort1.txt\", movies, NM);\n","\n","    qsort(movies, NM, sizeof(Movie), cmp2);\n","    write(\"sort2.txt\", movies, NM);\n","\n","    qsort(movies, NM, sizeof(Movie), cmp3);\n","    write(\"sort3.txt\", movies, NM);\n","\n","\n","    return 0;\n","}\n","```\n","\n","另一種透過指標陣列的寫法  \n","\n","```C\n","#include <stdio.h>\n","#include <stdlib.h>\n","#include <string.h>\n","\n","struct t_movie {\n","    double rating;\n","    char name[64];\n","    int year;\n","    int reviews;\n","};\n","typedef struct t_movie Movie;\n","Movie movies[300];\n","\n","int cmp1(const void *a, const void *b)\n","{\n","    Movie *s, *t;\n","    s = * (Movie**) a;\n","    t = * (Movie**) b;\n","    return strcmp(s->name, t->name);\n","}\n","int cmp2(const void *a, const void *b)\n","{\n","    Movie *s, *t;\n","    s = * (Movie**) a;\n","    t = * (Movie**) b;\n","    if (s->year > t->year) return 1;\n","    else if (s->year < t->year) return -1;\n","    else\n","         return strcmp(s->name, t->name);\n","}\n","int cmp3(const void *a, const void *b)\n","{\n","    Movie *s, *t;\n","    s = * (Movie**) a;\n","    t = * (Movie**) b;\n","    if (s->rating > t->rating) return -1;\n","    else if (s->rating < t->rating) return 1;\n","    else {\n","        if (s->reviews > t->reviews) return -1;\n","        else if (s->reviews < t->reviews) return 1;\n","        else return 0;\n","    }\n","}\n","\n","void write(char * fname, Movie * pmvs[], int NM)\n","{\n","    int i;\n","    FILE *fout;\n","    fout = fopen(fname, \"w\");\n","    for (i=0; i<NM; i++) {\n","        fprintf(fout, \"%3d: %f\\t%s\\t(%d)\\t%d\\n\",\n","               i+1, pmvs[i]->rating, pmvs[i]->name, pmvs[i]->year, pmvs[i]->reviews);\n","    }\n","    fclose(fout);\n","}\n","\n","int main(void)\n","{\n","    int NM;\n","    FILE *fin;\n","\n","    char line[255];\n","    fin = fopen(\"imdb_top250.txt\", \"r\");\n","\n","    Movie *pmovies[300];\n","    int i;\n","    for (i=0; i<300; i++) pmovies[i] = &movies[i];\n","\n","    NM = 0;\n","    while (!feof(fin) ) {\n","        if (fgets(line, 255, fin)==NULL) break;\n","        movies[NM].rating = atof(line);\n","        if (fgets(line, 255, fin)==NULL) break;\n","        line[strlen(line)-1] = '\\0';\n","        strcpy(movies[NM].name, line);\n","        if (fgets(line, 255, fin)==NULL) break;\n","        movies[NM].year = atoi(line);\n","        if (fgets(line, 255, fin)==NULL) break;\n","        movies[NM].reviews = atoi(line);\n","        NM++;\n","        if (fgets(line, 255, fin)==NULL) break;\n","    }\n","    fclose(fin);\n","\n","\n","    qsort(pmovies, NM, sizeof(Movie*), cmp1);\n","    write(\"sort1.txt\", pmovies, NM);\n","\n","    qsort(pmovies, NM, sizeof(Movie*), cmp2);\n","    write(\"sort2.txt\", pmovies, NM);\n","\n","    qsort(pmovies, NM, sizeof(Movie*), cmp3);\n","    write(\"sort3.txt\", pmovies, NM);\n","\n","\n","    return 0;\n","}\n","```\n","\n","## 查字典與自動完成\n","\n","利用附件`words.txt`  \n","\n","Download file:\n","[words.txt](https://drive.google.com/file/d/1CbL7vlZLtuPuOq4Ns9kQjucENs6AvwJc/view?usp=sharing)\n","\n","\n","\n","```C\n","#include <stdio.h>\n","#include <stdlib.h>\n","#include <string.h>\n","enum {\n","    MAX_LEN = 60,\n","    NUM_WORDS = 120000\n","};\n","\n","int lookup(char word[], char *dict[], int nwords);\n","\n","int main(void)\n","{\n","    char **p, buf[MAX_LEN + 1];\n","    int i, j;\n","    FILE *fin;\n","\n","    fin = fopen(\"words.txt\", \"r\");\n","    p = (char **) malloc(sizeof(char *)* NUM_WORDS);\n","    i = 0;\n","    while(i< NUM_WORDS && (fgets(buf, MAX_LEN + 1, fin) != NULL)) {\n","        buf[strlen(buf)-1] =  '\\0';\n","        p[i] = malloc(strlen(buf)+1);\n","        if (p[i] != NULL) {\n","            strcpy(p[i], buf);\n","            i++;\n","        }\n","    }\n","    fclose(fin);\n","\n","    while(fgets(buf, MAX_LEN + 1, stdin) != NULL) {\n","        buf[strlen(buf)-1] = '\\0';\n","        j = lookup(buf, p, i);\n","        while (j>=0) {\n","            if (strncmp(p[j], buf, strlen(buf))!=0) {\n","                j++;\n","                break;\n","            }\n","            j--;\n","        }\n","        if (j<0) j = 0;\n","        while (j<i) {\n","            if (strncmp(p[j], buf, strlen(buf))!=0)\n","                break;\n","            printf(\"%s\\n\", p[j]);\n","            j++;\n","        }\n","    }\n","\n","    for (j=0; j<i; j++) {\n","        free(p[j]);\n","    }\n","    free(p);\n","\n","    return 0;\n","}\n","\n","int lookup(char *word, char *dict[], int nwords)\n","{\n","    int  low, high, mid, cmp;\n","    low = mid = 0;\n","    high = nwords - 1;\n","    while (low <= high) {\n","        mid = low + (high-low)/2;\n","        cmp = strcmp(word, dict[mid]);\n","        if (cmp < 0)\n","            high = mid - 1;\n","        else if (cmp > 0)\n","            low = mid + 1;\n","        else\n","            break;\n","    }\n","    return mid;\n","}\n","```\n","\n","## Doubly Linked List\n","[維基百科對於 doubly linked list 的說明](http://en.wikipedia.org/wiki/Doubly_linked_list)\n","\n","底下是框架，可以試著實作那些尚未被完成的功能  \n","\n","```C\n","##include <stdio.h>\n","#include <stdlib.h>\n","\n","struct dl_node {\n","    int data;\n","    struct dl_node *prev;\n","    struct dl_node *next;\n","};\n","typedef struct dl_node DL_Node;\n","\n","struct dl_list {\n","    DL_Node *firstNode;\n","    DL_Node *lastNode;\n","};\n","typedef struct dl_list DL_List;\n","\n","void insertAfter(DL_List *list, DL_Node *node, DL_Node *newNode)\n","{\n","\n","}\n","\n","void insertBefore(DL_List *list, DL_Node *node, DL_Node *newNode)\n","{\n","\n","}\n","\n","void insertBeginning(DL_List *list, DL_Node *newNode)\n","{\n","\n","}\n","\n","void insertEnd(DL_List *list, DL_Node *newNode)\n","{\n","\n","}\n","\n","DL_Node *createNewNode(int data)\n","{\n","    DL_Node *p;\n","    p = (DL_Node*) malloc(sizeof(DL_Node));\n","    p->data = data;\n","    p->prev = NULL;\n","    p->next = NULL;\n","    return p;\n","}\n","\n","void showList(DL_List *list)\n","{\n","    DL_Node *p = list->firstNode;\n","    while (p != NULL) {\n","        printf(\"%d->\", p->data);\n","        p = p->next;\n","    }\n","    printf(\"NULL\\n\");\n","}\n","void showListReverse(DL_List *list)\n","{\n","\n","}\n","void removeNode(DL_List *list, DL_Node *node)\n","{\n","\n","}\n","void freeList(DL_List *list)\n","{\n","    DL_Node *p = list->firstNode;\n","    while (p != NULL) {\n","        p = p->next;\n","        if (p!=NULL)\n","            free(p->prev);\n","        else\n","            free(list->lastNode);\n","    }\n","    free(list);\n","}\n","int main(void)\n","{\n","    DL_List *dll = NULL;\n","\n","    dll = (DL_List*) malloc(sizeof(DL_List));\n","\n","    dll->firstNode = NULL;\n","    dll->lastNode = NULL;\n","\n","    insertBeginning(dll, createNewNode(14));\n","    insertBeginning(dll, createNewNode(13));\n","    insertBeginning(dll, createNewNode(12));\n","    insertBeginning(dll, createNewNode(11));\n","    insertBeginning(dll, createNewNode(10));\n","\n","    insertEnd(dll, createNewNode(20));\n","    insertEnd(dll, createNewNode(21));\n","    insertEnd(dll, createNewNode(22));\n","    insertEnd(dll, createNewNode(23));\n","    insertEnd(dll, createNewNode(24));\n","\n","    showList(dll);\n","    showListReverse(dll);\n","\n","    removeNode(dll, dll->firstNode);\n","    removeNode(dll, dll->lastNode);\n","    showList(dll);\n","\n","    freeList(dll);\n","\n","    return 0;\n","}\n","```\n","\n","執行之後應該要得到  \n","\n","```\n","10->11->12->13->14->20->21->22->23->24->NULL\n","24->23->22->21->20->14->13->12->11->10->NULL\n","11->12->13->14->20->21->22->23->NULL\n","```\n","\n","圖示搭配程式碼可以參考 `dll.pptx`\n","\n","\n","Download file:\n","[dll.pptx](https://docs.google.com/presentation/d/1joFu5wZdmHfJFTo0robWODhkLCU2mkxk/edit?usp=sharing&ouid=113447873319056546407&rtpof=true&sd=true)\n","\n","\n","\n","底下是完整的程式碼  \n","\n","```C\n","#include <stdio.h>\n","#include <stdlib.h>\n","\n","struct dl_node {\n","    int data;\n","    struct dl_node *prev;\n","    struct dl_node *next;\n","};\n","typedef struct dl_node DL_Node;\n","\n","struct dl_list {\n","    DL_Node *firstNode;\n","    DL_Node *lastNode;\n","};\n","typedef struct dl_list DL_List;\n","\n","void insertAfter(DL_List *list, DL_Node *node, DL_Node *newNode)\n","{\n","    newNode->prev = node;\n","    newNode->next = node->next;\n","    if (node->next == NULL) {\n","        list->lastNode = newNode;\n","    } else {\n","        node->next->prev = newNode;\n","    }\n","    node->next = newNode;\n","}\n","\n","void insertBefore(DL_List *list, DL_Node *node, DL_Node *newNode)\n","{\n","    newNode->prev = node->prev;\n","    newNode->next = node;\n","    if (node->prev == NULL) {\n","        list->firstNode = newNode;\n","    } else {\n","        node->prev->next = newNode;\n","    }\n","    node->prev = newNode;\n","}\n","\n","void insertBeginning(DL_List *list, DL_Node *newNode)\n","{\n","    if (list->firstNode == NULL) {\n","        list->firstNode = newNode;\n","        list->lastNode = newNode;\n","        newNode->prev = NULL;\n","        newNode->next = NULL;\n","    } else {\n","        insertBefore(list, list->firstNode, newNode);\n","    }\n","}\n","\n","void insertEnd(DL_List *list, DL_Node *newNode)\n","{\n","    if (list->lastNode == NULL) {\n","        insertBeginning(list, newNode);\n","    } else {\n","        insertAfter(list, list->lastNode, newNode);\n","    }\n","}\n","\n","DL_Node *createNewNode(int data)\n","{\n","    DL_Node *p;\n","    p = (DL_Node*) malloc(sizeof(DL_Node));\n","    p->data = data;\n","    p->prev = NULL;\n","    p->next = NULL;\n","    return p;\n","}\n","\n","void showList(DL_List *list)\n","{\n","    DL_Node *p = list->firstNode;\n","    while (p != NULL) {\n","        printf(\"%d->\", p->data);\n","        p = p->next;\n","    }\n","    printf(\"NULL\\n\");\n","}\n","\n","void showListReverse(DL_List *list)\n","{\n","    DL_Node *p = list->lastNode;\n","    while (p != NULL) {\n","        printf(\"%d->\", p->data);\n","        p = p->prev;\n","    }\n","    printf(\"NULL\\n\");\n","}\n","\n","void removeNode(DL_List *list, DL_Node *node)\n","{\n","    if (node->prev == NULL) {\n","        list->firstNode = node->next;\n","    } else {\n","        node->prev->next = node->next;\n","    }\n","    if (node->next == NULL) {\n","        list->lastNode = node->prev;\n","    } else {\n","        node->next->prev = node->prev;\n","    }\n","    free(node);\n","}\n","\n","void freeList(DL_List *list)\n","{\n","    DL_Node *p = list->firstNode;\n","    while (p != NULL) {\n","        p = p->next;\n","        if (p!=NULL)\n","            free(p->prev);\n","        else\n","            free(list->lastNode);\n","    }\n","    free(list);\n","}\n","\n","int main(void)\n","{\n","    DL_List *dll = NULL;\n","\n","    dll = (DL_List*) malloc(sizeof(DL_List));\n","\n","    dll->firstNode = NULL;\n","    dll->lastNode = NULL;\n","\n","\n","    insertBeginning(dll, createNewNode(14));\n","    insertBeginning(dll, createNewNode(13));\n","    insertBeginning(dll, createNewNode(12));\n","    insertBeginning(dll, createNewNode(11));\n","    insertBeginning(dll, createNewNode(10));\n","\n","    insertEnd(dll, createNewNode(20));\n","    insertEnd(dll, createNewNode(21));\n","    insertEnd(dll, createNewNode(22));\n","    insertEnd(dll, createNewNode(23));\n","    insertEnd(dll, createNewNode(24));\n","\n","    showList(dll);\n","    showListReverse(dll);\n","\n","    removeNode(dll, dll->firstNode);\n","    removeNode(dll, dll->lastNode);\n","    showList(dll);\n","\n","    freeList(dll);\n","\n","    return 0;\n","}\n","\n","```\n","\n","\n"],"metadata":{"id":"Q0gACdtWClIk"}}]}