程式雖小，智慧並存

力軟資訊發表於2020-03-09

概述

在IT行業中，通常被人稱為：碼農，程式猿。在日常開發中，我們不能滿足於程式碼的搬運，不能只會百度搜尋，Copy和Paste。猶記春節假期，走親訪友，觥籌交錯，席間有一位長輩問:你現在做什麼工作呀?我很驕傲地說:我目前是系統架構師，主要負責系統的最佳化與重構。可是他卻愣了很久，但當表妹在旁邊補上一句“碼農“時，長輩瞬間秒懂，笑呵呵的說道：不錯不錯。卻留我受傷的心在風中凌亂。


為了避免成為碼農，我們必須對編碼保持熱情，並持續學習；必須保持好奇心，樂於探求事物本質；必須對所做的工作及時總結，主動最佳化程式碼，讓系統變得更加有機；必須主動嘗試更好的開發方式、更先進的工具，來提升開發效率，並想辦法避免重複性的工作；必須不斷改進設計，將程式設計變成創造性的工作。


以下以一些簡單的小例子，介紹C#基礎內容，拋磚引玉，共同進步，如有不足之處，還請指正。

給定一個不超過5位數的正整數，判斷是幾位數，並逐行列印個位，十位，百位，千位，萬位上的值

透過分析，此處主要有兩個功能：
  • 判斷是幾位數
  • 列印每一個位上的值
以下有幾種方案計算位數（孰優孰劣，歡迎點評）：
1. 透過比較法進行判斷，簡單直接有效
  1. /// <summary>
  2.         /// 判斷位數，直接比較
  3.         /// </summary>
  4.         /// <param name="num"></param>
  5.         static int CheckDigit1(int num)
  6.         {
  7.             int digit = 0;
  8.             if (num < 10)
  9.             {
  10.                 digit = 1;
  11.             }
  12.             else if (num < 100)
  13.             {
  14.                 digit = 2;
  15.             }
  16.             else if (num < 1000)
  17.             {
  18.                 digit = 3;
  19.             }
  20.             else if (num < 10000)
  21.             {
  22.                 digit = 4;
  23.             }
  24.             else if (num < 100000)
  25.             {
  26.                 digit = 5;
  27.             }
  28.             else
  29.             {
  30.                 digit = -1;
  31.             }
  32.             Console.WriteLine(digit);
  33.             return digit;
  34.         }
複製程式碼
2. 透過整除法進行判斷
  1. /// <summary>
  2.         /// 判斷位數：引入了不該有的計算
  3.         /// </summary>
  4.         /// <param name="num"></param>
  5.         static int CheckDigit2(int num)
  6.         {
  7.             int digit = 0;
  8.             if (num / 10000 > 0)
  9.             {
  10.                 digit = 5;
  11.             }
  12.             else if (num / 1000 > 0)
  13.             {
  14.                 digit = 4;
  15.             }
  16.             else if (num / 100 > 0)
  17.             {
  18.                 digit = 3;
  19.             }
  20.             else if (num / 10 > 0)
  21.             {
  22.                 digit = 2;
  23.             }
  24.             else {
  25.                 digit = 1;
  26.             }
  27.             Console.WriteLine(digit);
  28.             return digit;
  29.         }
複製程式碼


3. 引入折半思想進行判斷
  1. /// <summary>
  2.         /// 採用折半思想
  3.         /// </summary>
  4.         /// <param name="num"></param>
  5.         static int CheckDigit3(int num)
  6.         {
  7.             int digit = 0;
  8.             if (num >= 100)
  9.             {
  10.                 if (num >= 10000)
  11.                 {
  12.                     digit = 5;
  13.                 }
  14.                 else if (num >= 1000)
  15.                 {
  16.                     digit = 4; ;
  17.                 }
  18.                 else {
  19.                     digit = 3;
  20.                 }
  21.             }
  22.             else {
  23.                 if (num >= 10)
  24.                 {
  25.                     digit = 2;
  26.                 }
  27.                 else {
  28.                     digit = 1;
  29.                 }
  30.             }
  31.             Console.WriteLine(digit);
  32.             return digit;
  33.         }
複製程式碼


4. 透過轉換為字串，判斷字串的長度來確定位數
  1. /// <summary>
  2.         /// 透過字串計算位數
  3.         /// </summary>
  4.         /// <param name="num"></param>
  5.         static int CheckDigit4(int num) {
  6.             string strNum = num.ToString();
  7.             int digit = strNum.Length;
  8.             Console.WriteLine(digit);
  9.             return digit;
  10.         }
複製程式碼


列印每一位上的數字，按照從低位到高位進行列印（透過相減的方式）
  1. /// <summary>
  2.         /// 列印每一位數字,從低到高
  3.         /// </summary>
  4.         /// <param name="num"></param>
  5.         /// <param name="digit"></param>
  6.         static void PrintNumber(int num, int digit) {
  7.             int tmp = num;
  8.             for (int i = 0; i < digit; i++) {
  9.                 int n = tmp / 10;
  10.                 Console.WriteLine(tmp - n * 10);
  11.                 tmp = n;
  12.             }
  13.         }
複製程式碼


另一種方案：列印每一位上的數字，按照從低位到高位進行列印（透過求餘的方式）
  1. /// <summary>
  2.         /// 列印每一位數字，從低到高
  3.         /// </summary>
  4.         /// <param name="num"></param>
  5.         /// <param name="digit"></param>
  6.         static void PrintNumber2(int num, int digit) {
  7.             int tmp = num;
  8.             for (int i = 0; i < digit; i++)
  9.             {
  10.                 int n = tmp / 10;
  11.                 Console.WriteLine(tmp % 10);
  12.                 tmp = n;
  13.             }
  14.         }
複製程式碼


從高位到低位進行列印（For迴圈）
  1. /// <summary>
  2.         /// 從高到低列印
  3.         /// </summary>
  4.         /// <param name="num"></param>
  5.         /// <param name="digit"></param>
  6.         static void PrintNumber3(int num, int digit)
  7.         {
  8.             int tmp = num;
  9.             for (int i = 0; i < digit; i++)
  10.             {
  11.                 int n = tmp / (int)Math.Pow(10, digit - i - 1);
  12.                 Console.WriteLine(n);
  13.                 tmp -= n * (int)Math.Pow(10, digit - i - 1);
  14.             }
  15.         }
複製程式碼


另外一種方案：從高位到低位進行列印，採用while迴圈
  1. static void PrintNumber4(int num, int digit) {
  2.             int tmp = num;
  3.             int div = (int)Math.Pow(10, digit - 1);
  4.             while (tmp > 0) {
  5.                 int n = tmp / div;
  6.                 Console.WriteLine(n);
  7.                 tmp -= n * div;
  8.                 div /= 10;
  9.             }
  10.         }
複製程式碼


列印一個邊長為n的正方形

功能說明：主要是列印一個，長和寬個數相同的*號的形狀。
透過分析，主要有兩點：
  • 第一行與最後一行，第一列與最後一列，都是* 號，其他都是空格；
  • 最後一列需要換行
    1. /// <summary>
    2.         /// 列印一個邊長為n的正方形
    3.         /// </summary>
    4.         /// <param name="n"></param>
    5.         static void PrintSquare1(int n) {
    6.             for (int i = 0; i < n; i++) {
    7.                 for (int j = 0; j < n; j++) {
    8.                     string info = string.Empty;
    9.                     if (i == 0 || i == n - 1 || j == 0 || j == n - 1)
    10.                     {
    11.                         info = "*";
    12.                     }
    13.                     else {
    14.                         info = " ";
    15.                     }
    16.                     if (j == n - 1)
    17.                     {
    18.                         Console.WriteLine(info);
    19.                     }
    20.                     else {
    21.                         Console.Write(info);
    22.                     }
    23.                 }
    24.             }
    25.         }
    複製程式碼

求100以內的奇數和

定義：不能被2整除的整數叫奇數,也叫單數,如1、3、5、7、9、……。
透過分析發現：只要對2求餘，餘數大於0，則為奇數，如下所示：
  1. /// <summary>
  2.         /// 求100以內的奇數的和
  3.         /// </summary>
  4.         static void GetOddSum() {
  5.             int total = 0;
  6.             for (int i = 0; i < 100; i++) {
  7.                 if (i % 2 != 0) {
  8.                     total += i;
  9.                 }
  10.             }
  11.             Console.WriteLine(total);
  12.         }
複製程式碼


另外一種方案：奇數與偶數是交替出現的，如第一個數是奇數，則加2還是奇數，如下所示：
  1. /// <summary>
  2.         /// 求100以內的奇數的和
  3.         /// </summary>
  4.         static void GetOddSum2()
  5.         {
  6.             int total = 0;
  7.             for (int i = 1; i < 100; i += 2)
  8.             {
  9.                 total += i;
  10.             }
  11.             Console.WriteLine(total);
  12.         }
複製程式碼


列印九九乘法表

正向九九乘法表，透過分析發現，第一個乘數（j）小於等於第二個乘數（i），如下所示：
  1. /// <summary>
  2.         /// 列印九九乘法表
  3.         /// </summary>
  4.         static void PrintMultiplicationTable() {
  5.             for (int i = 0; i < 9; i++) {
  6.                 for (int j = 0; j < 9; j++)
  7.                 {
  8.                     if (i > j)
  9.                     {
  10.                         Console.Write("{0}*{1}={2} ", j + 1, i + 1, (i + 1) * (j + 1));
  11.                     }
  12.                     if (i == j) {
  13.                         Console.WriteLine("{0}*{1}={2} ", j + 1, i + 1, (i + 1) * (j + 1));
  14.                     }
  15.                 }
  16.             }
  17.         }
複製程式碼


另外一種方案：倒打九九乘法表，透過分析發現，第一個乘數（j）大於等於第二個乘數（i），如下所示：
  1. /// <summary>
  2.         /// 倒打九九乘法表
  3.         /// </summary>
  4.         static void PrintMultiplicationTable2()
  5.         {
  6.             for (int i = 0; i < 9; i++)
  7.             {
  8.                 for (int j = 0; j < 9; j++)
  9.                 {
  10.                     if (i < 9 - j - 1)
  11.                     {
  12.                         Console.Write("{0}*{1}={2} ", j + 1, 9 - i, (9 - i) * (j + 1));
  13.                     }
  14.                     else if (i == 9 - j - 1)
  15.                     {
  16.                         Console.WriteLine("{0}*{1}={2} ", j + 1, 9 - i, (9 - i) * (j + 1));
  17.                     }
  18.                 }
  19.             }
  20.         }
複製程式碼


斐波那契數列

定義：斐波那契數列，又稱黃金分割數列，指的是這樣一個數列：0、1、1、2、3、5、8、13、21、34、……在數學上，斐波納契數列以如下被以遞迴的方法定義：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）。
透過分析發現：
  • 第0 項是 0 ，第 1 項是第一個 1 。
  • 這個數列從第3 項開始，每一項都等於前兩項之和。
    1. /// <summary>
    2.         /// 列印斐波那契數列，10以內
    3.         /// </summary>
    4.         static void PrintFibonacci() {
    5.             int cur = 0;
    6.             int pre1 = 0;
    7.             int pre2 = 0;
    8.             for (int i = 0; i < 30; i++) {
    9.                 if (i == 0)
    10.                 {
    11.                     pre2 = 0;
    12.                     pre1 = 0;
    13.                     cur = 0;
    14.                 }
    15.                 else if (i == 1)
    16.                 {
    17.                     pre2 = 0;
    18.                     pre1 = 0;
    19.                     cur = 1;
    20.                 }
    21.                 else if (i == 2) {
    22.                     pre2 = pre1;
    23.                     pre1 = 1;
    24.                     cur = 1;
    25.                 }
    26.                 else {
    27.                     pre2 = pre1;
    28.                     pre1 = cur;
    29.                     cur = pre1 + pre2;
    30.                 }
    31.                 Console.WriteLine(cur);
    32.             }
    33.         }
    複製程式碼

備註

我們永遠不會忘記寫的第一個程式--“Hello，World!”因為那承載著程式設計師最初的夢想：改變世界。
雖然我們不一定能成為大師，但從不甘心做一個碼農，程式設計師不是碼農，碼農也不是真正的程式設計師。
我們可以自謙，可以自嘲，但不能自我定位於碼農，止步於碼農。


來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/69965343/viewspace-2679239/，如需轉載，請註明出處，否則將追究法律責任。

相關文章