汉诺塔:
namespace 汉诺塔
{class HanoiBuilder
{void hanoi(int n,string A,string B,string C)
{if(n==1)
Console.WriteLine(A+”——>”+C);
else{ hanoi(n-1,A,C,B);//借助C把A上的盘子移到B
Console.WriteLine(A+”——->”+C);
hanoi(n-1,B,A,C);//借助A把B上的盘子移到C}}
public void Hanoi(int n)
{hanoi(n,”A”,”B”,”C”);}
}
class Test
{static void Main()
{HanoiBuilder hb=new HanoiBuilder();
hb.Hanoi(2);
Console.ReadLine();}
}}

二叉树遍历:
namespace BinaryTree
{
public class Node//节点类
{
private object _nodeva lue;
private Node _leftNode;
private Node _rightNode;

public object Nodeva lue
{
get { return this._nodeva lue; }
}
public Node LeftNode
{
get {return this._leftNode; }
set {this._leftNode = value; }
}
public Node RightNode
{
get{return this._rightNode; }
set{this._rightNode = value;}
}
public Node()
{ }
public Node(object nodeva lue, Node leftNode, Node rightNode)
{
this._nodeva lue = nodeva lue;
this._leftNode = leftNode;
this._rightNode = rightNode;
}
public Node(object nodeva lue)
{
this._nodeva lue = nodeva lue;
this._leftNode = null;
this._rightNode = null;
}
}
public class BTree
{
private static Node root = null;

public static void CreateTree()
{
Node node1 = new Node(1, null, null);
Node node2 = new Node(2, null, null);
Node node3 = new Node(3, null, null);
Node node4 = new Node(4, null, null);
Node node5 = new Node(5, null, null);
Node node6 = new Node(6, null, null);
Node node7 = new Node(7, null, null);

node1.LeftNode = node2;
node1.RightNode = node3;
node2.LeftNode = node4;
node2.RightNode = node5;
node3.LeftNode = node6;
node3.RightNode = node7;

root = node1;
}
private static void frontList(Node node)
{
if (node == null)
{return; }
else
{ Console.WriteLine(node.Nodeva lue+”\t”);
frontList(node.LeftNode);
frontList(node.RightNode); }
}
private static void middleList(Node node)
{
if (node == null)
{ return; }
else
{ middleList(node.LeftNode);
Console.WriteLine(node.Nodeva lue+”\t”);
middleList(node.RightNode); }
}
private static void backList(Node node)
{
if (node == null)
{ return; }
else
{ backList(node.LeftNode);
backList(node.RightNode);
Console.WriteLine(node.Nodeva lue+”\t”);}
}
public static void ShowList()
{
CreateTree();
Console.WriteLine(“前序遍历如下：”);
frontList(root);
Console.WriteLine(“中序遍历如下：”);
middleList(root);
Console.WriteLine(“后序遍历如下：”);
backList(root);
}
}
public class Demo
{
public static void Main(string[] args)
{ BTree.ShowList();}
}
}

快速排序:
namespace QuickSort
{
public static class Sort
{
public static void Main()
{
Console.WriteLine(“排序前:”);
ShowAry();
Console.WriteLine(“排序后:”);
quickSortAry(al, 0, al.Count-1);
ShowAry();
Console.ReadLine();
}
private static ArrayList al;
private static Random random;
static Sort()
{
random = new Random(System.DateTime.Now.Millisecond);
al = new ArrayList();
for (int i = 0; i < 500; i++)
{
al.Add(random.Next(1, 100001));
}
}
public static void ShowAry()
{
foreach (int i in al)
{
Console.Write(i+”\t”);
}
}
private static void quickSortAry(ArrayList al, int start, int end)
{
int i = start;
int j = end;
int pivot = (int)al[i];
while (i < j)
{
while (i < j && pivot <= (int)al[j])
{j–;}
al[i] = al[j];
while (i < j && pivot >= (int)al[i])
{i++;}
al[j] = al[i];
}
al[i] = pivot;
if (i > start)
{quickSortAry(al, start, i – 1); }
if (i < end)
{quickSortAry(al, i + 1, end); }}}}

冒泡排序算法:
public class BubbleSort
{public static void Main()
{ int[] intary={45,67,34,23,12,89};
Console.WriteLine(“排序前，输出数组如下：”);
PrintArray(intary);
Sort(intary);
Console.WriteLine(“冒泡排序之后，输出数组如下：”);
PrintArray(intary); }
public static void PrintArray(int[] tmpary)
{ for(int i=0;i {Console.Write(tmpary[i]+”\t”);}
Console.WriteLine();
}
public static void Sort(int[] ary)
{ int tmpint;
for(int i=0;i {for(int j=i+1;j {if(ary[i]>ary[j])
{tmpint=ary[i];
ary[i]=ary[j];
ary[j]=tmpint; }
}
}
}}

插入排序:
public class InsertSort
{ public static void Main()
{ int[] intary ={ 10, 8, 7, 6, 5, 4, 3, 2, 1, 1 };
Console.WriteLine(“排序前，输出数组如下：”);
PrintArray(intary);
Insert(intary);
Console.WriteLine(“插入排序之后，输出数组如下：”);
PrintArray(intary);
}
public static void PrintArray(int[] tmpary)
{ foreach (int tmpnum in tmpary)
{Console.Write(tmpnum + “\t”);}
Console.WriteLine();
}
public static void Insert(int[] ary)
{ int tmp;
for (int i = 1; i < ary.Length; i++)//从第个元素开始，准备待插入前方位置
{
for (int j = 0; j <= i; j++)//在待插元素前方寻找比它大的元素
{
if (ary[i] < ary[j])//找到比它大的元素
{ tmp = ary[i];//将待插元素保存下来
for (int k = i; k > j; k–)//从待插位置向前移动
{ary[k] = ary[k - 1]; }//将前面元素一个个向后移动
ary[j] = tmp;//在找到的位置插入待插元素
}
}
}
}}

打印出100的阶乘(即1*2*3*…*100)的精确数值结果（不能是浮点数）。如5的阶乘是1*2*3*4*5=120。
double num = 1;
for (int i = 1; i <= 100; i++)
{num = num * i; }
Console.WriteLine(num);

产生一个int数组，长度为100，并向其中随机插入1-100，并且不能重复。
int[] intArr=new int[100];
ArrayList myList=new ArrayList();
Random rnd=new Random();
while(myList.Count<100)
{
int num=rnd.Next(1,101);
if(!myList.Contains(num))
myList.Add(num);
}
for(int i=0;i<100;i++)
{ intArr[i]=(int)myList[i];}

写一个HTML页面，实现以下功能，左键点击页面时显示“您好”，右键点击时显示“禁止右键”。并在2分钟后自动关闭页面。
答：<script language=java script>
setTimeout(‘window.close();’,3000);
function show()
{
if (window.event.button == 1)
{alert(“左”);}
else if (window.event.button == 2)
{alert(“右”); }
}

使用DataSet，在数据库中增加、修改、删除一个数据
DataSet ds = new DataSet();
DataTable dt = new DataTable(“table”);
ds.Tables.Add(dt);
DataColumn column = new DataColumn(“column”, typeof(string));
dt.Columns.Add(column);
DataRow dr = dt.NewRow();
dr[column] = “name”;
Console.WriteLine(dr[column]);
dt.Rows.Add(dr);

ds.Tables["table"].Rows[0][column] = “hello”;
Console.WriteLine(dr[column]);
ds.Tables["table"].Rows[0].Delete();

if (ds.HasErrors)
{ds.RejectChanges();}
MyComm.Update(MyDataSet); //更新数据库中所有的表

写一个枚举的例子 使用C#
public class EnumTest
{ enum Colors{ Red = 1,Green = 2,Blue = 3,Yellow = 4}
public static void Main()
{Colors myColors = Colors.Red|Colors.Blue;
Console.WriteLine(myColors); }
}

求1到100之间的偶数和
int sum = 0;
for (int i = 1; i <= 100; i++)
{if (i % 2 == 0)
{sum = sum + i; }
}
Console.WriteLine(sum);

计算1到100之间的偶数和，当和大于等于500，则不再求，最后输出和值。
int sum = 0;
for (int i = 1; i <= 100; i++)
{
if (i % 2 == 0)
{sum = sum + i; }
if (sum >= 500)
break;
}
Console.WriteLine(sum);

计算1+6+11+….，直到和大于200为止 。
int sum = 1;
for (int i = 1; i >= 1; i++)
{
sum = sum + (i + 5);
if (sum >= 200)
break;
}
Console.WriteLine(sum);

求1到10的阶乘和,即求:1!+2!+3!+……+10！
static void Main(string[] args)
{long sum =0;
for(int i=1;i<=10;i++){sum+=N(i);}Console.WriteLine(sum);}
static long N(int n)
{if(n==1){return 1;}else{return n*N(n-1);}}

求1到100的偶数及奇数和
int one=0,two=0;
for(int i=1;i<=100;i++)
{if(i%2==0) {two+=i;}
else{one+=i;} }
Console.WriteLine(“奇数和为：{0} 偶数和为：{1}”,one,two);

按下式累加求自然对数的近似值：
直到最后一项的值小于10-6为止。
static void Main(string[] args)
{
double e = 1.0;
int i = 1;
while (1.0 / N(i) >= 0.000001)
{e += 1.0 / N(i);
i++;}
Console.WriteLine(e);
}
static long N(int n)
{ if (n == 1) {return 1;}
return n * N(n – 1);
}

输入一个0~6之间的整数,然后根据该数转换成相应的星期,其中0位星期日,1~6分别为星期一 到星期六
Console.WriteLine(“请输入0~~~6之间的数:”);
switch(Convert.ToInt32(Console.ReadLine()))
{
case 0:
Console.WriteLine(“星期日”);
break;
case 1:
Console.WriteLine(“星期一”);
break;
case 2:
Console.WriteLine(“星期二”);
break;
case 3:
Console.WriteLine(“星期三”);
break;
case 4:
Console.WriteLine(“星期四”);
break;
case 5:
Console.WriteLine(“星期五”);
break;
case 6:
Console.WriteLine(“星期六”);
break;
default:
Console.WriteLine(“你的输入错误”);
break;
}

“水仙花数”是指一个3位数，其各位数的立方和等于该数，如： 153=13+53+33。编写程序，输出所有的“水仙花数”.
int one = 0, two = 0, three = 0;
for (int i = 100; i < 1000; i++)
{
three = i / 100;
two = (i / 10) % 10;
one = i % 10;
if (i == one * one * one + two * two * two + three * three * three)
Console.WriteLine(i);
}

斐波那契序列数的特点是除前两项数外，其他项数的值等于前两项的和。 0，1，1，2，3，5，8, 13，21,34,55，…求前24项斐波那契序列数。
static void Main(string[] args)
{
Console.WriteLine(“前24项 各项的值为：”);
Console.Write(“0″);
for (int i = 1; i <= 24; i++)
{
Console.Write(” {0}”, Fab(i));
if (i % 8 == 0)
Console.WriteLine();
}
Console.ReadLine();
}
static long Fab(int n)
{
if (n == 1 || n == 2) return 1;
return Fab(n – 1) + Fab(n – 2);
}

编一个统计10个学生语文平均分和总分。
double sum = 0.0;
int count = 10;
for (int i = 1; i <= count; i++)
{
Console.Write(“请输入第{0}个学生的成绩:”, i);
double x = Convert.ToDouble(Console.ReadLine());
sum += x;
}
Console.WriteLine(“{0}个学生的语文总成绩为：{1} 平均成绩为：{2}”, count, sum, sum / count);

调用存储过程及返回值的提取
答案：int id;
using(SqlConnection conn = new SqlConnection(“数据库连接字符串”))
{SqlCommand comm = new SqlCommand(“存储过程名称”,conn);
comm.CommandType = CommandType.StoredProcedure;
SqlParameter parid = new SqlParameter(“@id”,SqlDbType.VarChar 50);
parid.Direction = ParameterDirection.OutPut;
comm.Parameters.Add(parid);
conn.Open();
id = (int) comm.ExcuteScalar();
return id;
}

一列数的规则如下: 1、1、2、3、5、8、13、21、34…… 求第50位数是多少， 用递归算法实现。
public static void Main()
{
for (int i = 1; i <= 50; i++)
{int result = Foo(i); }
Console.WriteLine(result);
}
public static int Foo(int i)
{ if (i <= 0) { return 0; } else if (i > 0 && i <= 2) { return 1; } else { return Foo(i – 1) + Foo(i – 2); } }

用C＃实现以下功能
a 产生一个int数组，长度为100，并向其中随机插入1-100，并且不能重复。
b 对上面生成的数组排序，需要支持升序、降序两种顺序
class Class1:IComparer
{
int IComparer.Compare( Object x, Object y )
{return( (new CaseInsensitiveComparer()).Compare( y, x ) ); }
static void Main(string[] args)
{
ArrayList arr=new ArrayList();
Random ran=new Random();
while(arr.Count<100)
{ int num=ran.Next(1,101);
if(!arr.Contains(num))
arr.Add(num); }
arr.Sort();

IComparer myComparer = new Class1();
arr.Sort(0,arr.Count,myComparer );
for(int i=0;i {Console.WriteLine(arr [i]); }
}
}

求以下表达式的值，写出您想到的一种或几种实现方法： 1-2+3-4+……+m
int Num = Convert.ToInt32( Console.ReadLine());
int Sum = 0;
for (int i = 0; i < Num + 1; i++)
{
if ((i % 2) == 1)
{Sum += i; }
else
{Sum = Sum – i; }
}
System.Console.WriteLine(Sum.ToString());
System.Console.ReadLine();

请用两种不同的方法写出以下要求的函数：统计一个字符串中单词的个数（以空格分隔），只限使用.NET标准类库中的成员。（难度：较高）
参考答案：
方法一：
public static int WordCount(string data)
{
if (sData==null) return 0; // null返回0
string sData = data.Trim(); // 除出首尾多余空格
if (sData.Length == 0) return 0; // 空串则返回0
return (sData.Split(‘ ‘).Length); // 将字符串以空格分割, 返回分割后的元素数
}
方法二：
public static int WordCount(string data)
{
if (sData==null) return 0; // null返回0
string sData = data.Trim(); // 除出首尾多余空格
if (sData.Length == 0) return 0; // 空串则返回0
int iCount = 0; // 空格的个数
char[] cData = sData.ToCharArray(); // 将字符串转换为字符数组
// 统计空格数
foreach (char ch in cData)
{if (ch == ‘ ‘) iCount++;}
return iCount + 1; // 空格数+1即为单词个数
}

程序设计: 猫大叫一声，所有的老鼠都开始逃跑，主人被惊醒。(C#语言)
观察者模式
1.要有联动性，老鼠和主人的行为是被动的。
2.考虑可扩展性，猫的叫声可能引起其他联动效应。
要点：1. 联动效果，运行代码只要执行Cat.Cryed()方法。2. 对老鼠和主人进行抽象
评分标准: <1>.构造出Cat、Mouse、Master三个类，并能使程序运行(2分)
<2>从Mouse和Master中提取抽象（5分）
<3>联动效应，只要执行Cat.Cryed()就可以使老鼠逃跑，主人惊醒。(3分)
public interface Observer
{
void Response(); //观察者的响应，如是老鼠见到猫的反映
}
public interface Subject
{
void AimAt(Observer obs); //针对哪些观察者，这里指猫的要扑捉的对象—老鼠
}
public class Mouse : Observer
{
private string name;
public Mouse(string name, Subject subj)
{
this.name = name;
subj.AimAt(this);
}
public void Response()
{
Console.WriteLine(name + ” attempt to escape!”);
}
}
public class Master : Observer
{
public Master(Subject subj)
{
subj.AimAt(this);
}

public void Response()
{
Console.WriteLine(“Host waken!”);
}
}
public class Cat : Subject
{
private ArrayList observers;
public Cat()
{
this.observers = new ArrayList();
}
public void AimAt(Observer obs)
{
this.observers.Add(obs);
}
public void Cry()
{
Console.WriteLine(“Cat cryed!”);
foreach (Observer obs in this.observers)
{
obs.Response();
}
}
}
class MainClass
{
static void Main(string[] args)
{
Cat cat = new Cat();
Mouse mouse1 = new Mouse(“mouse1″, cat);
Mouse mouse2 = new Mouse(“mouse2″, cat);
Master master = new Master(cat);
cat.Cry();
}
}
//——-设计方法二: 使用event — delegate设计.

public delegate void SubEventHandler();
public abstract class Subject
{
public event SubEventHandler SubEvent;
protected void FireAway()
{
if (this.SubEvent != null)
this.SubEvent();
}
}
public class Cat : Subject
{
public void Cry()
{
Console.WriteLine(“cat cryed.”);
this.FireAway();
}
}
public abstract class Observer
{
public Observer(Subject sub)
{
sub.SubEvent += new SubEventHandler(Response);
}
public abstract void Response();
}
public class Mouse : Observer
{
private string name;
public Mouse(string name, Subject sub) : base(sub)
{
this.name = name;
}
public override void Response()
{
Console.WriteLine(name + ” attempt to escape!”);
}
}
public class Master : Observer
{
public Master(Subject sub) : base(sub){}
public override void Response()
{
Console.WriteLine(“host waken”);
}
}
class Class1
{
static void Main(string[] args)
{
Cat cat = new Cat();
Mouse mouse1 = new Mouse(“mouse1″, cat);
Mouse mouse2 = new Mouse(“mouse2″, cat);
Master master = new Master(cat);
cat.Cry();
}
}
———————————————————–

将手机号转化为由随机字母表示
答案1：
Random random = new Random();
int num;
char code;
char phone;
string phonenum =null;
string letter=null;
Hashtable hs = new Hashtable();

for(int i=0;i<11;i++)
{
num = random.Next();
code = (char)(‘A’ + (char)(num % 26));
phone = (char)(’0′ +(char)(num%10));

letter += code.ToString().ToLower();
phonenum += phone.ToString();
}
hs.Add(phonenum,letter);
IDictionaryEnumerator id = hs.GetEnumerator();
while(id.MoveNext())
Console.WriteLine(“这是随机手机号码” + id.Key +”这是根据手机号码随机产生的字母”+id.Value);

答案2：
口头描述：利用c#类 产生md5 用whlie() 判断 产生的前11位是否含有数字 如有 跳过 再产生一个 直到 找到一个前11为是字母的 然后把这个md5和手机号码 棒定在一起, 显示手机号码对应的随即字母的时候 再截取这个手机号码所对应的md5的前11位即可

答案3：
static void Main(string[] args)
{string a =null;
Hashtable hs = new Hashtable();
Console.WriteLine(“plz input your mobile number:”);
string s=Console.ReadLine();
ArrayList al=new ArrayList();
al.Add(s);
ArrayList al2=null;
String[] ss=new String[]{“a”,”b”,”c”,”d”,”e”,”f”,”g”,”h”,”i”,”j”,”k”,”l”,”m”,”n”,”o”,”p”,”q”,”r”,”s”,”t”,”u”,”v”,”w”,”x”,”y”,”z”};
Random r=new Random();
for(int i=0;i<11;i++)
{al2=new ArrayList();
string x = ss[r.Next(0,25)];
a +=x; }
al2.Add(a.ToUpper());
hs.Add(al,al2);
IDictionaryEnumerator id = hs.GetEnumerator();
while(id.MoveNext())
Console.WriteLine(“手机号码” + ((ArrayList)id.Key)[0].ToString() +”生成码” + ((ArrayList)id.Value)[0].ToString()); Console.ReadLine(); }

写一个程序，语言不限,能将人民币金额从阿拉伯数字转换为大写汉字表示。例如，把1234.56转换为壹仟贰佰叁拾肆圆零伍角陆分。
答案：[使用java script来实现]
1、对一给定字符串，如：1234.55，转换成正确的中文货币描述：如：人民币壹仟贰佰叁拾四元五角五分
2、输入的字符串形式可以是以下几种：带分隔符的，如：123,456,789.00；不带分隔符的，如：123456789
3、输出的中文货币描述要符合规范，如：0.3—-人民币三角；0.33—-人民币三角三分；1—-人民币壹元整;100—-人民币壹佰元整；1001—-人民币壹仟零壹元整；10000001—-人民币壹仟万零壹元整；
1001001—-人民币壹仟零壹万零壹元整，等
4、最大转换能到百亿

<script language=”jscript”>
function convertCurrency(currencyDigits) {
// Constants:
var MAXIMUM_NUMBER = 99999999999.99;
// Predefine the radix characters and currency symbols for output:
var CN_ZERO = “零”;
var CN_ONE = “壹”;
var CN_TWO = “贰”;
var CN_THREE = “叁”;
var CN_FOUR = “肆”;
var CN_FIVE = “伍”;
var CN_SIX = “陆”;
var CN_SEVEN = “柒”;
var CN_EIGHT = “捌”;
var CN_NINE = “玖”;
var CN_TEN = “拾”;
var CN_HUNDRED = “佰”;
var CN_THOUSAND = “仟”;
var CN_TEN_THOUSAND = “万”;
var CN_HUNDRED_MILLION = “亿”;
var CN_SYMBOL = “人民币”;
var CN_DOLLAR = “元”;
var CN_TEN_CENT = “角”;
var CN_CENT = “分”;
var CN_INTEGER = “整”;

// Variables:
var integral; // Represent integral part of digit number.
var decimal; // Represent decimal part of digit number.
var outputCharacters; // The output result.
var parts;
var digits, radices, bigRadices, decimals;
var zeroCount;
var i, p, d;
var quotient, modulus;

// Validate input string:
currencyDigits = currencyDigits.toString();
if (currencyDigits == “”) {
alert(“Empty input!”);
return “”;
}
if (currencyDigits.match(/[^,.\d]/) != null) {
alert(“Invalid characters in the input string!”);
return “”;
}
if ((currencyDigits).match(/^((\d{1,3}(,\d{3})*(.((\d{3},)*\d{1,3})) )|(\d+(.\d+) ))$/) == null) {
alert(“Illegal format of digit number!”);
return “”;
}

// Normalize the format of input digits:
currencyDigits = currencyDigits.replace(/,/g, “”); // Remove comma delimiters.
currencyDigits = currencyDigits.replace(/^0+/, “”); // Trim zeros at the beginning.
// Assert the number is not greater than the maximum number.
if (Number(currencyDigits) > MAXIMUM_NUMBER) {
alert(“Too large a number to convert!”);
return “”;
}

// Process the coversion from currency digits to characters:
// Separate integral and decimal parts before processing coversion:
parts = currencyDigits.split(“.”);
if (parts.length > 1) {
integral = parts[0];
decimal = parts[1];
// Cut down redundant decimal digits that are after the second.
decimal = decimal.substr(0, 2);
}
else {
integral = parts[0];
decimal = “”;
}
// Prepare the characters corresponding to the digits:
digits = new Array(CN_ZERO, CN_ONE, CN_TWO, CN_THREE, CN_FOUR, CN_FIVE, CN_SIX, CN_SEVEN, CN_EIGHT, CN_NINE);
radices = new Array(“”, CN_TEN, CN_HUNDRED, CN_THOUSAND);
bigRadices = new Array(“”, CN_TEN_THOUSAND, CN_HUNDRED_MILLION);
decimals = new Array(CN_TEN_CENT, CN_CENT);
// Start processing:
outputCharacters = “”;
// Process integral part if it is larger than 0:
if (Number(integral) > 0) {
zeroCount = 0;
for (i = 0; i < integral.length; i++) {
p = integral.length – i – 1;
d = integral.substr(i, 1);
quotient = p / 4;
modulus = p % 4;
if (d == “0″) {
zeroCount++;
}
else {
if (zeroCount > 0)
{
outputCharacters += digits[0];
}
zeroCount = 0;
outputCharacters += digits[Number(d)] + radices[modulus];
}
if (modulus == 0 && zeroCount < 4) {
outputCharacters += bigRadices[quotient];
}
}
outputCharacters += CN_DOLLAR;
}
// Process decimal part if there is:
if (decimal != “”) {
for (i = 0; i < decimal.length; i++) {
d = decimal.substr(i, 1);
if (d != “0″) {
outputCharacters += digits[Number(d)] + decimals[i];
}
}
}
// Confirm and return the final output string:
if (outputCharacters == “”) {
outputCharacters = CN_ZERO + CN_DOLLAR;
}
if (decimal == “”) {
outputCharacters += CN_INTEGER;
}
outputCharacters = CN_SYMBOL + outputCharacters;
return outputCharacters;
}

在页面中这样使用：