其他路径：
CSDN: https://blog.csdn.net/wodehao0808
微信公众号：程序喵星人
更多资源和视频教程，QQ：1902686547
5 变量的更多内容
5.1 类型转换
5.1.1 隐式转换
当小盒子可以放入大盒子时，系统可以自动隐式转换；
例如：
byte byt = 6;
int i = byt; // int 类型范围比 byte 大，所以可以隐式转换，系统自动将 byt 的值转换为 int 类型存储在 i 中
2.子类型赋值给基类（父类）
5.1.2 显示转换
显示转换，也叫强制转换。
当将大盒子放入小盒子时，可能会放不下，编译器不允许这样操作，这时需要显示转换（相当于告诉编译器，我知道自己在做这件事，有问题自己承担。）。
例如：
int i = 12;
// byte byt = i; // 编译器会报错，不允许
byte byt = (byte)i; // 使用 (byte) 明确的告诉编译器，我要将 int 类型的 i值 转换为 byte 类型的值存储到 byt 中。
为什么编译器会不允许小盒子放入大盒子呢？举个例子：
int i = 2566;
byte byt = i; // i 超出了byte取值范围，导致 byt 值 可能不是用户想要存储的值，导致未知错误；所以编译器，不允许这样操作！除非用户自己知道并愿意承担强制转换的后果，就使用显示转换。
5.1.3 使用Convert转换
使用之一：如果要把一个数字字符串转换成一个数字类型（整形或者浮点型），就要用到Convert里面的方法。
int类型：Convert.ToInt32。
float类型：Convert.ToSingle。
double类型：Convert.ToDouble。
string类型：Convert.ToString。
......
5.1.4 Example:类型转换
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 类型转换
namespace Lesson_4_1
{
class Program
{
static void Main(string[] args)
{
// 隐式转换
byte byt = 10;
int i = byt; // 隐式转换
Console.WriteLine("隐式转换i = " + i);
// 显示转换
int iNum = 10;
// byte bytNum = iNum; // 大盒子放入小盒子中，不能隐式转换
byte bytNum = (byte)iNum; // 显示转换
Console.WriteLine("显示转换 iNum = " + iNum);
// Convert转换
string str = "123.36";
float f = Convert.ToSingle(str);
double d = Convert.ToDouble(str);
// int intN = Convert.ToInt32(str); // 抛出异常错误，小数不能转换成整数
// Console.WriteLine("Convert转换 intN = " + intN);
Console.WriteLine("Convert转换 f = " + f);
Console.WriteLine("Convert转换 d = " + d);
Console.ReadKey();
}
}
}
5.2 枚举
枚举是一组命名的整型常量。枚举类型使用 enum 关键字声明。
枚举定义：
enum <typeName>
{
<value1>,
<value2>,
<value3>,
...
}
枚举类型中的每一个值，其实都是一个整数，默认为int类型。
默认情况下，枚举中的值从 0 开始，其后面的值是前一个值+1。
例如：
enum EState
{
start, // 默认为 0
end, // 1
win, // 2
fail, // 3
}
enum EState2
{
start = 100, // 自定义值 100
end, // 101
win, // 102
fail, // 103
}
enum EState3
{
start = 100, // 自定义值 100
end, // 101
win = 695, // 自定义值695
fail, // 696
}
枚举也可以设置枚举的类型，例如
enum EState: byte
{
start, // 默认为 0
end, // 1
win, // 2
fail, // 3
}
如果在明确枚举类型范围最大值时，尽可能的使用小的类型存储，这样能节约内存开销。
5.2.1 Example: 枚举
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 枚举
namespace Lesson_4_2
{
enum EGameState // 默认枚举存储类型是 int
{
Start, // 默认值 0
End, // 前一个值自动 +1, 1
Win, // 前一个值自动 +1, 2
Fail // 前一个值自动 +1, 3
}
enum EGameState2
{
Start, // 默认值 0
End = 10, // 自定义值 10
Win, // 前一个值自动 +1, 11
Fail // 前一个值自动 +1, 12
}
enum EGameState3
{
Start = 10, // 自定义值 10
End, // 前一个值自动 +1, 11
Win = 30, // 自定义值 30
Fail // 前一个值自动 +1, 31
}
// 如果在明确枚举值范围情况下，尽可能的使用小的枚举存储类型，这样能节省内存开销
enum EGameState4 : byte // 重新定义枚举存储类型，byte
{
Start, // 默认值 0
End, // 前一个值自动 +1, 1
Win, // 前一个值自动 +1, 2
Fail // 前一个值自动 +1, 3
}
class Program
{
static void Main(string[] args)
{
// EGameState
EGameState t_eState = EGameState.Fail;
if (EGameState.Fail == t_eState)
{
Console.WriteLine("当前状态时失败");
}
Console.WriteLine("EGameState 是 t_eState = " + t_eState);
Console.WriteLine("EGameState 是 int e = " + (int)t_eState);
// EGameState2
EGameState2 t_eState2 = EGameState2.Fail;
if (EGameState2.Fail == t_eState2)
{
Console.WriteLine("当前状态时失败");
}
Console.WriteLine("EGameState2 是 t_eState2 = " + t_eState2);
Console.WriteLine("EGameState2 是 int e = " + (int)t_eState2);
// EGameState3
EGameState3 t_eState3 = EGameState3.Fail;
if (EGameState3.Fail == t_eState3)
{
Console.WriteLine("当前状态时失败");
}
Console.WriteLine("EGameState3 是 t_eState3 = " + t_eState3);
Console.WriteLine("EGameState3 是 int e = " + (int)t_eState3);
// EGameState4
EGameState4 t_eState4 = EGameState4.Fail;
if (EGameState4.Fail == t_eState4)
{
Console.WriteLine("当前状态时失败");
}
Console.WriteLine("EGameState4 是 t_eState4 = " + t_eState4);
Console.WriteLine("EGameState4 是 byte e = " + (int)t_eState4);
Console.ReadKey();
}
}
}
5.3 结构
结构，可以看成是一组数据和操作的集合。
定义：
struct <typeName>
{
// ...
}
例如：
// 定义了位置信息的结构
struct Postion
{
public float x;
public float y;
public float z;
}
Position pos1, pos2;
pos1.x = 1;
pos1.y = 1;
pos1.z = 1;
pos2.x = 20;
pos2.y = 20;
pos2.z = 20;
5.3.1 Example:结构
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 结构
namespace Lesson_4_3
{
// 位置
struct Position
{
public float x;
public float y;
public float z;
}
// 方向
enum EDir
{
West,
North,
South,
East
}
struct Direction
{
public EDir eDir;
public float distance;
}
class Program
{
static void Main(string[] args)
{
// 不使用结构，定义两个位置
float x1 = 1;
float y1 = 1;
float z1 = 1;
float x2 = 1;
float y2 = 1;
float z2 = 1;
// 使用结构，定义两个位置
Position pos1, pos2;
pos1.x = 1;
pos1.y = 1;
pos1.z = 1;
pos2.x = 1;
pos2.y = 1;
pos2.z = 1;
// 方向
Direction dir;
dir.eDir = EDir.North;
dir.distance = 1000;
}
}
}
5.4 数组
数组存储一个大小固定的顺序集合中相同类型的元素。数组用于存储数据的集合，我们通常认为数组是一个存储在连续的内存位置的相同类型的集合。
数组特性：
1.所有元素是同一类型；
2.数组定义后大小固定，不能增删；
3.通常认为数组是一个存储在连续的内存位置。
5.4.1 数组的定义
数组声明：
<Type>[] <varName>;
数组是一个变量的索引列表，这个索引是一个整数，第一个条目的索引是0，第二个是1，以此类推。
比如：
int[] scores = { 1, 2, 3 };
// 取值
int i0 = scores[0]; // 1
int i1 = scores[1]; // 2
int i2 = scores[2]; // 3
// 赋值
scores[0] = 100;
scores[1] = 101;
scores[2] = 102;
会发现，索引从0开始，最大索引值是数组长度减1（Length - 1）。
数组长度获取方法，.Length，例如：scores.Length;
int[] scores;
第一种定义方式：
scores = { 16, 8, 9, 86, 102 };
第二种定义方式：
scores = new int[10]; // 10个元素的数组，每个元素是该类型的默认值
第三种定义方式：
scores = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
第四中定义方式：
scores = new int[] { 1, 2, 3, 4 }; // new int[] 中没有指定元素数目，而是根据后面的{}中的元素个数推导出来数组长度；
5.4.1.1 Example:数组的定义
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 数组的定义
namespace Lesson_4_4
{
class Program
{
static void Main(string[] args)
{
// 第一种定义方式
int[] scores = { 12, 65, 89, 89, 98, 65 };
Console.WriteLine("第一种定义方式，scores[0] = ：" + scores[0]);
Console.WriteLine("第一种定义方式，长度：" + scores.Length);
// 第二种定义方式
int[] scores2 = new int[10];
scores2[0] = 100;
scores2[1] = 31;
Console.WriteLine("第二种定义方式，scores2[0] = ：" + scores2[0]);
Console.WriteLine("第二种定义方式，scores2[1] = ：" + scores2[1]);
Console.WriteLine("第二种定义方式，scores2[2] = ：" + scores2[2]);
Console.WriteLine("第二种定义方式，长度：" + scores2.Length);
// 第三种定义方式
int[] scores3 = new int[5] { 5, 55, 65, 75, 85 };
Console.WriteLine("第三种定义方式，scores3[0] = ：" + scores3[0]);
Console.WriteLine("第三种定义方式，scores3[1] = ：" + scores3[1]);
Console.WriteLine("第三种定义方式，scores3[2] = ：" + scores3[2]);
Console.WriteLine("第三种定义方式，长度：" + scores3.Length);
// 第四种定义方式
int[] scores4 = new int[] { 4, 41, 43, 23 };
Console.WriteLine("第四种定义方式，scores4[0] = ：" + scores4[0]);
Console.WriteLine("第四种定义方式，scores4[1] = ：" + scores4[1]);
Console.WriteLine("第四种定义方式，scores4[2] = ：" + scores4[2]);
Console.WriteLine("第四种定义方式，scores4[3] = ：" + scores4[3]);
Console.WriteLine("第三种定义方式，长度：" + scores4.Length);
Console.ReadKey();
}
}
}
5.4.2 数组的遍历
5.4.2.1 Example:数组的遍历
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 数组的遍历
namespace Lesson_4_5
{
class Program
{
static void Main(string[] args)
{
int[] scores = { 2, 98, 87, 56, 32 };
// 使用for遍历
for (int i = 0; i < scores.Length; ++i)
{
Console.WriteLine("for 循环遍历数组，元素 {0} 的值是 = {1}", i, scores[i]);
}
Console.WriteLine("for循环遍历数组结束--------------------------------");
// 使用while遍历
int i2 = 0;
while (i2 < scores.Length)
{
Console.WriteLine("while 循环遍历数组，元素 {0} 的值是 = {1}", i2, scores[i2]);
++i2;
}
Console.WriteLine("while循环遍历数组结束--------------------------------");
// 使用foreach遍历
foreach (int value in scores) // 无法取得元素的索引值
{
Console.WriteLine("foreach 循环遍历数组，元素的值是 = {0}", value);
}
Console.WriteLine("foreach循环遍历数组结束--------------------------------");
Console.ReadKey();
}
}
}
5.5 字符串的处理
字符串的一些常用处理方法：
* 通过索引，获得指定的字符串的指定位置的字符；索引从 0 开始。例如：
string str = "Hello";
char ch = str[0]; // 'H'
char ch2 = str[2]; // 'l'
* 字符串长度，.Length；例如：
string str = "12345";
int len = str.Length; // 5
* ToLower()方法：将字符串中的字母，全部转换为小写字母；返回一个副本，原字符串不会改变；
* ToUpper()方法：将字符串中的字母，全部转换为大写字母；返回一个副本，原字符串不会改变；
* Trim()方法：将字符串，首尾两端的空格删除；返回一个副本，原字符串不会改变；
* TrimStart()方法：将字符串，首端的空格删除；返回一个副本，原字符串不会改变；
* TrimEnd()方法：将字符串，尾段的空格删除；返回一个副本，原字符串不会改变；
* Split()方法：将字符串，按照指定的 字符（参数传递进入）进行分割，返回的结果是数组（类型是string）；原字符串不会改变；
5.5.1 Example:字符串的处理
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 字符串的处理
namespace Lesson_4_6
{
class Program
{
static void Main(string[] args)
{
string str = " My N a.m.e is CShape ";
// 索引
char ch = str[5];
Console.WriteLine("索引，ch = " + ch);
Console.WriteLine("索引结束--------------------------------");
// 长度
int t_len = str.Length;
Console.WriteLine("长度，length = " + t_len);
Console.WriteLine("长度结束--------------------------------");
// ToLower
string strLower = str.ToLower();
Console.WriteLine("ToLower 原字符串不会改变，str = " + str);
Console.WriteLine("ToLower 结果是：" + strLower);
Console.WriteLine("ToLower 结束--------------------------------");
// ToUpper
string strUpper = str.ToUpper();
Console.WriteLine("ToUpper 原字符串不会改变，str = " + str);
Console.WriteLine("ToUpper 结果是：" + strUpper);
Console.WriteLine("ToUpper 结束--------------------------------");
// Trim
string strTrim = str.Trim();
Console.WriteLine("Trim 原字符串不会改变，str = " + str + "!"); // 加上一个 ! 是为了方便查看 去除空格的效果
Console.WriteLine("Trim 结果是：" + strTrim + "!");
Console.WriteLine("Trim 结束--------------------------------");
// TrimStart
string strTrimStart = str.TrimStart();
Console.WriteLine("TrimStart 原字符串不会改变，str = " + str + "!"); // 加上一个 ! 是为了方便查看 去除空格的效果
Console.WriteLine("TrimStart 结果是：" + strTrimStart + "!");
Console.WriteLine("TrimStart 结束--------------------------------");
// TrimEnd
string strTrimEnd = str.TrimEnd();
Console.WriteLine("TrimEnd 原字符串不会改变，str = " + str + "!"); // 加上一个 ! 是为了方便查看 去除空格的效果
Console.WriteLine("TrimEnd 结果是：" + strTrimEnd + "!");
Console.WriteLine("TrimEnd 结束--------------------------------");
// split
string[] strArray = str.Split('.');
for (int i = 0; i < strArray.Length; ++i)
{
Console.WriteLine("Split 分割后的字符串数组时，元素 {0} 的值是 = {1}", i, strArray[i]);
}
Console.WriteLine("Split 结束--------------------------------");
Console.ReadKey();
}
}
}
5.6 练习
练习1.
找出100到999之间的水仙花数；"153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3"
练习2.
3个可乐瓶可以换一瓶可乐，现在有364瓶可乐。问一共可以喝多少瓶可乐，剩下几个空瓶！
练习3.
猜数字游戏，我有一个数，请您猜猜是多少？
//请您输入一个0-50之间的数：20（用户输入数字）
//您猜小了，这个数字比20大：30
//您猜大了，这个数字比30小：25
//恭喜您猜对了，这个数字为：25
用户猜错了就继续猜，猜对了就停止游戏。
练习4.
编写一个应用程序用来输入的字符串进行加密，对于字母字符串加密规则如下：
‘a’→’d’ ‘b’→’e’ ‘w’→’z’ …… ‘x’→’a’ ‘y’→’b’ ‘z’→’c’‘A’→’D’ ‘B’→’E’ ‘W’→’Z’ …… ‘X’→’A’ ‘Y’→’B’ ‘Z’→’C’?对于其他字符，不进行加密。
练习5.
编写一个控制台程序，要求用户输入一组数字用空格间隔，对用户输入的数字从小到大输出。(Array.Sort方法和冒泡排序)
练习6.
喜欢西游记的同学肯定都知道悟空偷吃蟠桃的故事，你们一定都觉得这猴子太闹腾了，其实你们是有所不知：悟空是在研究一个数学问题！
当时的情况是这样的：
第一天悟空吃掉桃子总数一半多一个，第二天又将剩下的桃子吃掉一半多一个，以后每天吃掉前一天剩下的一半多一个，到第n天准备吃的时候只剩下一个桃子。聪明的你，请帮悟空算一下，他第一天开始吃的时候桃子一共有多少个呢？
用户输入n的值，计算出来他第一天吃的时候桃子是多少个?
练习7.
输入n(n<100)个数，找出其中最小的数，将它与最前面的数交换后输出这些数。
练习8.
有n(n<=100)个整数，已经按照从小到大顺序排列好，现在另外给一个整数x，请将该数插入到序列中，并使新的序列仍然有序。
输出新的序列
练习9.
问题：如果工资额都知道，最少需要准备多少张人民币，才能在给每位发工资的时候都不用找零呢？
这里假设工资都是正整数，单位元，人民币一共有100元、50元、10元、5元、2元和1元六种。
练习10.
输入一个字符串，判断其是否是C#的合法标识符。
练习11.
“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。请写一个程序判断读入的字符串是否是“回文”。
练习12.
网上流传一句话:"常在网上飘啊，哪能不挨刀啊～"。其实要想能安安心心地上网其实也不难，学点安全知识就可以。
首先，我们就要设置一个安全的密码。那什么样的密码才叫安全的呢？一般来说一个比较安全的密码至少应该满足下面两个条件：
(1).密码长度大于等于8，且不要超过16。
(2).密码中的字符应该来自下面“字符类别”中四组中的至少三组。、
这四个字符类别分别为：
1.大写字母：A,B,C...Z;
2.小写字母：a,b,c...z;
3.数字：0,1,2...9;
4.特殊符号：~,!,@,#,$,%,^;
给你一个密码，你的任务就是判断它是不是一个安全的密码。
5.6.1 Example:练习1、2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 练习1、2
namespace Lesson_4_7
{
class Program
{
static void Main(string[] args)
{
// example_1: 找出100到999之间的水仙花数；"153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3"
for (int i = 100; i < 1000; ++i)
{
int t_bai = i / 100; // 百位
int t_shi = (i / 10) % 10; // 十位
int t_ge = i % 10; // 个位
int result = t_ge * t_ge * t_ge + t_shi * t_shi * t_shi + t_bai * t_bai * t_bai;
if (result == i)
{
Console.WriteLine("水仙花数是：" + i);
}
}
Console.WriteLine("example_1 finish ----------------------------------- ");
// example_2: 3个可乐瓶可以换一瓶可乐，现在有364瓶可乐。问一共可以喝多少瓶可乐，剩下几个空瓶！
int iCount = 364;
int iEmptyCount = 364;
while (iEmptyCount >= 3)
{
int iNewCount = iEmptyCount / 3;
iEmptyCount %= 3;
iCount += iNewCount;
iEmptyCount += iNewCount;
}
Console.WriteLine("一共可以喝 {0} 瓶可乐，剩下 {1} 个空瓶", iCount, iEmptyCount);
Console.WriteLine("example_2 finish ----------------------------------- ");
}
}
}
5.6.2 Example:练习3、4
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 练习3、4
namespace Lesson_4_8
{
class Program
{
static void Main(string[] args)
{
// example_3:
/*
猜数字游戏，我有一个数，请您猜猜是多少？
//请您输入一个0-50之间的数：20（用户输入数字）
//您猜小了，这个数字比20大：30
//您猜大了，这个数字比30小：25
//恭喜您猜对了，这个数字为：25
用户猜错了就继续猜，猜对了就停止游戏。
*/
int iCount = new Random().Next(0, 51);
Console.WriteLine("请输入一个数字：");
while (true)
{
int i = Convert.ToInt32(Console.ReadLine());
if (i > iCount)
{
Console.WriteLine("您猜大了，这个数字比 {0} 小。请继续输入数字猜：", i);
}
else if (i < iCount)
{
Console.WriteLine("您猜小了，这个数字比 {0} 大。请继续输入数字猜：", i);
}
else
{
Console.WriteLine("恭喜您猜对了，游戏结束。");
break;
}
}
Console.WriteLine("example_3 finish -------------------------------- ");
// example_4:
/*
编写一个应用程序用来输入的字符串进行加密，对于字母字符串加密规则如下：
‘a’→’d’ ‘b’→’e’ ‘w’→’z’ …… ‘x’→’a’ ‘y’→’b’ ‘z’→’c’
‘A’→’D’ ‘B’→’E’ ‘W’→’Z’ …… ‘X’→’A’ ‘Y’→’B’ ‘Z’→’C’
对于其他字符，不进行加密。
*/
Console.WriteLine("请输入一个字符串：");
string str = Console.ReadLine();
string strTmp = "";
for (int i = 0; i < str.Length; ++i)
{
char tmp = str[i];
if (tmp >= 'a' && tmp <= 'z')
{
int iNum = (int)tmp;
iNum += 3;
tmp = (char)iNum;
if (tmp > 'z')
{
tmp = (char)(tmp - 'z' + 'a' - 1);
}
strTmp += tmp;
}
else if (tmp >= 'A' && tmp <= 'Z')
{
int iNum = (int)tmp;
iNum += 3;
tmp = (char)iNum;
if (tmp > 'Z')
{
tmp = (char)(tmp - 'Z' + 'A' - 1);
}
strTmp += tmp;
}
}
Console.WriteLine("加密后的字符串是：" + strTmp);
Console.WriteLine("example_4 finish ---------------------------------------- ");
Console.ReadKey();
}
}
}
5.6.3 Example:练习5
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 练习5
namespace Lesson_4_9
{
class Program
{
static void Main(string[] args)
{
// example_5: 编写一个控制台程序，要求用户输入一组数字用空格间隔，对用户输入的数字从小到大输出。(Array.Sort方法和冒泡排序)
Console.WriteLine("请输入一组数字（数字直接用一个空格间隔）：");
string str = Console.ReadLine();
string[] strArray = str.Split(' ');
int[] intArray = new int[strArray.Length];
for (int i = 0; i < strArray.Length; ++i)
{
intArray[i] = Convert.ToInt32(strArray[i]);
}
//// 直接使用CLR（公共语言运行库）提供的排序功能，采用的是快速排序法
//Array.Sort(intArray);
//for (int i = 0; i < intArray.Length; ++i)
//{
// Console.WriteLine("sort方法排序后的输出是：" + intArray[i]);
//}
// 使用冒泡排序
for (int i = 1; i < intArray.Length; ++i)
{
for (int j = 0; j < intArray.Length - i; ++j)
{
if (intArray[j] > intArray[j + 1])
{
int tmp = intArray[j];
intArray[j] = intArray[j + 1];
intArray[j + 1] = tmp;
}
}
}
for (int i = 1; i < intArray.Length; ++i)
{
Console.WriteLine("冒泡排序后的输出是：" + intArray[i]);
}
Console.WriteLine("example_5 finish ------------------------------------ ");
Console.ReadKey();
}
}
}
5.6.4 Example:练习6、7
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 练习6、7
namespace Lesson_4_10
{
class Program
{
static void Main(string[] args)
{
// example_6:
/*
喜欢西游记的同学肯定都知道悟空偷吃蟠桃的故事，你们一定都觉得这猴子太闹腾了，其实你们是有所不知：悟空是在研究一个数学问题！
什么问题？他研究的问题是蟠桃一共有多少个！
不过，到最后，他还是没能解决这个难题
当时的情况是这样的：
第一天悟空吃掉桃子总数一半多一个，第二天又将剩下的桃子吃掉一半多一个，以后每天吃掉前一天剩下的一半多一个，到第n天准备吃的时候只剩下一个桃子。聪明的你，请帮悟空算一下，他第一天开始吃的时候桃子一共有多少个呢？
用户输入n的值(n为最后一天的天数)，计算出来他第一天吃的时候桃子是多少个
*/
Console.WriteLine("请输入一共吃了多少天：");
int n = Convert.ToInt32(Console.ReadLine());
int iCount = 1; // 最后一天拥有的桃子数
for (int i = n - 1; i > 0; --i)
{
// 规律是：
// 第 n 天剩余数目 = （ 第 n - 1 天的数目 ）/ 2 - 1;
// 所以得到：第 n-1 天的数目 = (第 n 天剩余数目 + 1 ) * 2;
iCount = (iCount + 1) * 2; // 第 i 天拥有的桃子数
}
Console.WriteLine("第一天吃的桃子数是：" + iCount);
Console.WriteLine("example_6 finish --------------------------------");
// example_7: 输入n(n<100)个数，找出其中最小的数，将它与最前面的数交换后输出这些数。
Console.WriteLine("请输入一组整数（整数之前使用一个空格间隔）：");
string str = Console.ReadLine();
string[] strArray = str.Split(' ');
int[] intArray = new int[strArray.Length];
for (int i = 0; i < intArray.Length; ++i)
{
intArray[i] = Convert.ToInt32(strArray[i]);
}
int iIndex = 0, iMin = intArray[0];
for (int i = 1; i < intArray.Length; ++i)
{
if (iMin > intArray[i])
{
iMin = intArray[i];
iIndex = i;
}
}
int tmp = intArray[0];
intArray[0] = iMin;
intArray[iIndex] = tmp;
for (int i = 0; i < intArray.Length; ++i)
{
Console.WriteLine("交换后的数组顺序是：" + intArray[i]);
}
Console.WriteLine("example_7 finish --------------------------------");
Console.ReadKey();
}
}
}
5.6.5 Example:练习8
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 练习8
namespace Lesson_4_11
{
class Program
{
static void Main(string[] args)
{
// example_8:
// 有n(n<=100)个整数，已经按照从小到大顺序排列好，现在另外给一个整数x，请将该数插入到序列中，并使新的序列仍然有序。
// 输出新的序列
int[] intArray = { 1, 2, 3, 4, 5, 6 }; // 已经排序好的
Console.WriteLine("请输入一个插入的整数：");
int iNum = Convert.ToInt32(Console.ReadLine());
int[] intNewArray = new int[intArray.Length + 1];
int iIndex = -1;
bool isInsert = false;
for (int i = 0; i < intArray.Length; ++i)
{
++iIndex;
intNewArray[iIndex] = intArray[i];
if (intArray[i] > iNum && !isInsert)
{
isInsert = true;
intNewArray[iIndex] = iNum;
++iIndex;
intNewArray[iIndex] = intArray[i];
}
}
if (!isInsert)
{
isInsert = true;
++iIndex;
intNewArray[iIndex] = iNum;
}
for (int i = 0; i < intNewArray.Length; ++i)
{
Console.WriteLine("新的数组顺序是：" + intNewArray[i]);
}
Console.WriteLine("example_8 finish --------------------------------");
Console.ReadKey();
}
}
}
5.6.6 Example:练习9、10
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 练习9、10
namespace Lesson_4_12
{
class Program
{
static void Main(string[] args)
{
// example_9:
// 问题：如果工资额都知道，最少需要准备多少张人民币，才能在给每位发工资的时候都不用找零呢？
// 这里假设工资都是正整数，单位元，人民币一共有100元、50元、10元、5元、2元和1元六种。
Console.WriteLine("请输入薪资：");
int iMoney = Convert.ToInt32(Console.ReadLine());
int iCount100 = iMoney / 100; // 100元张数
int iRemain = iMoney % 100;
int iCount50 = iRemain / 50; // 50元张数
iRemain %= 50;
int iCount10 = iRemain / 10; // 10元张数
iRemain %= 10;
int iCount5 = iRemain / 5; // 5元张数
iRemain %= 5;
int iCount2 = iRemain / 2; // 2元张数
iRemain %= 2; // 1元张数
Console.WriteLine("需要准备 100元{0}张 50元{1}张 10元{2}张 5元{3}张 2元{4}张 1元{5}张", iCount100, iCount50, iCount10, iCount5, iCount2, iRemain);
Console.WriteLine("example_9 finish ------------------------------");
// example_10: 输入一个字符串，判断其是否是C#的合法标识符。
Console.WriteLine("请输入一个字符串：");
string str = Console.ReadLine();
bool isOk = true;
char ch = str[0];
// 首位判断
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_' || ch == '@')
{
// 首位合法
}
else
{
isOk = false;
}
if (isOk)
{
for (int i = 1; i < str.Length; ++i)
{
ch = str[i];
// 其他位
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_')
{
// 合法
}
else
{
isOk = false;
break;
}
}
}
if (isOk)
{
Console.WriteLine("标识符合法");
}
else
{
Console.WriteLine("标识符不合法");
}
Console.WriteLine("example_10 finish ----------------------------------");
Console.ReadKey();
}
}
}
5.6.7 Example:练习11、12
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 练习11、12
namespace Lesson_4_13
{
class Program
{
static void Main(string[] args)
{
// example_11: “回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。请写一个程序判断读入的字符串是否是“回文”。
Console.WriteLine("请输入一个字符串：");
string str = Console.ReadLine();
bool bIsHui = true;
for (int i = 0; i < str.Length / 2; ++i)
{
if (str[i] != str[str.Length - 1 - i])
{
bIsHui = false;
break;
}
}
if (bIsHui)
{
Console.WriteLine("是回文串");
}
else
{
Console.WriteLine("不是回文串");
}
Console.WriteLine("example_11 finish------------------------------------");
// example_12:
/*
安全的密码至少应该满足下面两个条件：
(1).密码长度大于等于8，且不要超过16。
(2).密码中的字符应该来自下面“字符类别”中四组中的至少三组。
这四个字符类别分别为：
1.大写字母：A,B,C...Z;
2.小写字母：a,b,c...z;
3.数字：0,1,2...9;
4.特殊符号：~,!,@,#,$,%,^;
给你一个密码，你的任务就是判断它是不是一个安全的密码。
*/
Console.WriteLine("请设置一个密码(8~16位)：");
string strMM = Console.ReadLine();
if (strMM.Length >= 8 && strMM.Length <= 16)
{
bool bHaveUpper = false;
bool bHaveLower = false;
bool bHaveNumber = false;
bool bHaveSpecial = false;
for (int i = 0; i < strMM.Length; ++i)
{
char ch = strMM[i];
if (ch >= 'A' && ch <= 'Z')
{
bHaveUpper = true;
continue;
}
if (ch >= 'a' && ch <= 'z')
{
bHaveLower = true;
continue;
}
if (ch >= '0' && ch <= '9')
{
bHaveNumber = true;
continue;
}
if (ch == '~' || ch == '!' || ch == '@' || ch == '#' || ch == '$' || ch == '%' || ch == '^')
{
bHaveSpecial = true;
}
}
int iCount = 0;
if (bHaveUpper) ++iCount;
if (bHaveLower) ++iCount;
if (bHaveNumber) ++iCount;
if (bHaveSpecial) ++iCount;
if (iCount >= 3)
{
Console.WriteLine("是一个安全的密码");
}
else
{
Console.WriteLine("不是一个安全的密码");
}
}
else
{
Console.WriteLine("密码长度不满足条件，需要大于等于8位，小于等于16位");
}
Console.ReadKey();
}
}
}