程序虽小，智慧并存

Posted 2022-02-02 hsiang

概述

在IT行业中，通常被人称为：码农，程序猿。在日常开发中，我们不能满足于代码的搬运，不能只会百度搜索，Copy和Paste。犹记春节假期，走亲访友，觥筹交错，席间有一位长辈问:你现在做什么工作呀?我很骄傲地说:我目前是系统架构师，主要负责系统的优化与重构。可是他却愣了很久，但当表妹在旁边补上一句“码农“时，长辈瞬间秒懂，笑呵呵的说道：不错不错。却留我受伤的心在风中凌乱。

为了避免成为码农，我们必须对编码保持热情，并持续学习；必须保持好奇心，乐于探求事物本质；必须对所做的工作及时总结，主动优化代码，让系统变得更加有机；必须主动尝试更好的开发方式、更先进的工具，来提升开发效率，并想办法避免重复性的工作；必须不断改进设计，将编程变成创造性的工作。

以下以一些简单的小例子，介绍C#基础内容，抛砖引玉，共同进步，如有不足之处，还请指正。

给定一个不超过5位数的正整数，判断是几位数，并逐行打印个位，十位，百位，千位，万位上的值

通过分析，此处主要有两个功能：

1. 判断是几位数
2. 打印每一个位上的值

以下有几种方案计算位数（孰优孰劣，欢迎点评）：

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. 第一行与最后一行，第一列与最后一列，都是*号，其他都是空格；
2. 最后一列需要换行

 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*）。

通过分析发现：

1. 第0项是0，第1项是第一个1。
2. 这个数列从第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!”因为那承载着程序员最初的梦想：改变世界。

虽然我们不一定能成为大师，但从不甘心做一个码农，程序员不是码农，码农也不是真正的程序员。

我们可以自谦，可以自嘲，但不能自我定位于码农，止步于码农。