崔鹏飞的Blog

《Head First C#》将停止翻译和更新

发表于 2009-08-07 Disqus：本文字数： 174 阅读时长 ≈ 1 分钟

近日闻悉国内某出版社即将出版《 Head First C# 》的中文版，为避免版权纠纷，本“山寨”系列将停止翻译和更新。

从去年 10 月开始利用课余时间翻译这本书，到现在翻译完了将近 13 章，总计 12 万余字。

剩余的正文内容已不足百页，无法做到有始有终，颇为遗憾。

感谢 CSDN 和 VeryCD 各位朋友一直以来的关注、支持、鼓励和批评。

2009 年 8 月 7 日

阅读全文 »

格物致知--《Effective C#》读书笔记--验证接口引用指向装箱后的值类型时无需拆箱

发表于 2009-07-29 Disqus：本文字数： 815 阅读时长 ≈ 1 分钟

欲验证的结论：接口引用指向装箱后的值类型时无需拆箱。

代码如下：

interface SomeInterface

{
    void MethodInInterface();
}

struct OneValueType : SomeInterface

{
    public void MethodInInterface()

    {
        Console.WriteLine("get called");
    }
}

class TestUnBox

{
    public static void Main()

    {
    }

    private static void CastStruct()

    {
        OneValueType ovt = new OneValueType();

        object o = ovt; //Box

        ((OneValueType) o).MethodInInterface();
    }

    private static void CastInterface()

    {
        OneValueType ovt = new OneValueType();

        object o = ovt; //Box

        ((SomeInterface) o).MethodInInterface();
    }
}

其中 OneValueType 是值类型，它实现了 SomeInterface 。

两个方法 CastStruct 和 CastInterface 分别把装箱之后的值类型转型为 OneValueType 和
SomeInterface 。预计的结果是第二个方法无需拆箱，查看 IL 来验证：

这是 CastStruct （）：

阅读全文 »

格物致知--《Effective C#》读书笔记--验证四种判等方式

发表于 2009-07-19 Disqus：本文字数： 974 阅读时长 ≈ 1 分钟

原地址在我的CSDN
Blog：http://blog.csdn.net/cuipengfei1/archive/2009/07/19/4362245.aspx

① Object 的静态方法 ReferenceEquals ：

只适用于判断两个引用是否指向同一个实例，不适用于值类型（或者说用于值类型是没意义的，因为永远返回 false ）。如下：

TestEqual  te =  new  TestEqual  ();

bool  b1=  object  .ReferenceEquals(te,te);

bool  b2 =  object  .ReferenceEquals(1, 1);

b1 为 true ， b2 为 false 。 b2 为 false 的原因是两个整型值 1 装箱之后是两个不同的
Object 实例。

② Object 中定义的实例级虚方法 Equals ：

阅读全文 »

格物致知《Effective C#》读书笔记--验证类型转换

发表于 2009-05-31 Disqus：本文字数： 1.5k 阅读时长 ≈ 1 分钟

as 看起来很好用的样子，不会抛出异常，只要根据返回值是否为 null来做不同的处理就可以了。但是它也不是万金油，以下的情况 as 就不适用：

①值类型

比如：

1
2
3

double  d = 100.0;

int  valueType = d  as  int  ;

这两句代码就直接通不过编译，给出的原因是： as 运算符必须用于引用类型或可以为 null类型 (“int” 是一种不可以为 null
值的类型 )

想一下也合理， as 在失败时会返回 null，而值类型是不可以为 null的（ INullable 除外）。

阅读全文 »

CET口语证书，呕嘢~~~~~~~~~~~~

发表于 2009-05-15 Disqus：本文字数： 7 阅读时长 ≈ 1 分钟

三种方式统计string中出现次数最多的char（还是LinQ最简便）

发表于 2009-04-26 Disqus：本文字数： 3.1k 阅读时长 ≈ 3 分钟

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Collections;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "aaeaabbebbccececddeddd";

            List<char> charList = new List<char>(str.ToCharArray());
            int len = charList.Count;

            Dictionary<char, int> charD = new Dictionary<char, int>();

            int lastTime = 0;

            while (charList.Count != 0)
            {
                int count = CountAChar(charList);

                if (count > lastTime)
                {
                    charD.Clear();
                    charD.Add(charList[0], count);
                    lastTime = count;
                }

                else if (count == lastTime)
                {
                    charD.Add(charList[0], count);
                    lastTime = count;
                }

                DeleteAChar(count, charList);
            }

            foreach (KeyValuePair<char, int> kv in charD)
            {
                Console.WriteLine("{1}有{0}个", kv.Value.ToString(), kv.Key.ToString());
            }

            Console.WriteLine("----------------------------------------");
            SecondProgram.SecondWay(str);
            Console.WriteLine("----------------------------------------");
            ThirdClass.ThirdWay(str);
            Console.Read();
        }

        static void DeleteAChar(int num, List<char> cl)
        {
            char c = cl[0];

            for (int i = 0; i < num; i++)
            {
                cl.Remove(c);
            }
        }

        static int CountAChar(List<char> cl)
        {
            int ret = 0;

            foreach (char c in cl)
            {
                if (c == cl[0])
                {
                    ret++;
                }
            }

            return ret;
        }
    }

//-----------------------------------------------------------------
    class SecondProgram
    {
        public static void SecondWay(string str)
        {
            int len = str.Length;
            char[] strArray = str.ToCharArray();
            int[] count = new int[len];
            for (int y = 0; y < len; y++) //将count数组的每个单元初始为0
                count[y] = 0;

            for (int y = 0; y < len; y++) //将当前字符与之后的字符进行比较，相同count数组中对应索引处++
            {
                for (int yy = y; yy < len; yy++)
                {
                    if (strArray[y].Equals(strArray[yy]))
                    {
                        count[y]++;
                    }
                }
            }

            ArrayList maxCountArr = new ArrayList();
            int maxCount = count[0];

            for (int y = 0; y < len; y++) //获得出现次数的最大值
            {
                if (count[y] > maxCount)
                {
                    maxCount = count[y];
                }
            }

            for (int y = 0; y < len; y++)
//最大值与count数组中的每个数进行比较，相同则出现次数相同，把索引加入到maxCountArr
            {
                if (count[y] == maxCount)
                {
                    maxCountArr.Add(y);
                }
            }

            for (int y = 0; y < maxCountArr.Count; y++) //输出
            {
                Console.Write("Str" + (y + 1) + ":" + strArray[(int) maxCountArr[y]] + "/n");
            }
        }
    }

    /// <summary>
    /// 第三种方式
    /// </summary>
    class ThirdClass
    {
        /// <summary>
        /// 还是LinQ最简便
        /// </summary>
        /// <param name="str"></param>
        public static void ThirdWay(string str)
        {
            var resultGroup = from aChar in str.ToCharArray()
                group aChar by aChar;

            int max = 0;

            foreach (var one in resultGroup)
            {
                if (one.Count() > 0)
                {
                    max = one.Count();
                }
            }

            foreach (var one in resultGroup)
            {
                if (one.Count() == max)
                {
                    Console.WriteLine("{0}字符出现了{1}次", one.Key, max);
                }
            }
        }
    }
}

今天又被门卫大爷小小的雷了一下

发表于 2009-03-26 Disqus：本文字数： 117 阅读时长 ≈ 1 分钟

今天成都血液中心来采血。我去献了300CC的血，今天才知道自己是O型血~~

手里拿着送我的一把天堂伞和《无偿献血证》回寝室。门口大爷（大概60岁）正在择菜，看到我，说：“你们去献血了？好同学！为社会主义献血！”

O(∩_∩)O 年代的烙印啊

被学校的广播大大地雷了一把

发表于 2009-03-25 Disqus：本文字数： 115 阅读时长 ≈ 1 分钟

刚才在食堂吃完午饭回寝室的路上听广播，大意是：学校组织全校党员、领导、干部，本着实践科学发展观的精神进行了深入的调查研究，仅专题座谈会就召开了192场。终于
得出一个重要结论：就业率对于我们学校是很重要的。

TMD……彻底被雷了一把…

A double blessing has descended upon the house

发表于 2009-03-10 Disqus：本文字数： 113 阅读时长 ≈ 1 分钟

今天公布了CET-SET（口语）的成绩，在去上课的路上用手机查询。得了一个A。

到教室，没过几分钟收到一封邮包。是O‘reilly寄来的笔记本（是真的笔记本，不是laptop……）

封面是这样的

O(∩_∩)O哈哈~

阅读全文 »

《计算机图形技术》练习--用GDI+模拟DDA算法

发表于 2009-03-02 Disqus：本文字数： 1.4k 阅读时长 ≈ 1 分钟

刘义军老师留的作业

代码简单，一看就懂

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace GDI_DDA
{
    public partial class Form1 : Form
    {
        int pointSize = 22;
        int width = Screen.PrimaryScreen.WorkingArea.Width;
        int height = Screen.PrimaryScreen.WorkingArea.Height;

        public Form1()
        {
            InitializeComponent();
        }

        void DrawGrid(Graphics gra)
        {
            for (int i = 0; i <= Width; i += pointSize)
            {
                gra.DrawLine(Pens.Black, i, 0, i, height);
            }

            for (int i = 0; i <= height; i += pointSize)
            {
                gra.DrawLine(Pens.Black, 0, i, Width, i);
            }
        }

        void MyDrawLine(Graphics gra, float startX, float startY, float endX, float endY)
        {
            float dx = endX - startX;
            float dy = endY - startY;
            float delta = dy / dx;
            float
                y = startY;
            for (int x = (int) startX; x <= endX; x++, y += delta)
            {
                DrawEllipseByCenter(gra, Pens.Red, x * pointSize, y * pointSize, pointSize * 0.5f);
            }
        }

        void DrawEllipseByCenter(Graphics g, Pen p, float centerX, float centerY, float r)
        {
            g.FillEllipse(Brushes.Red, centerX - r * 0.5f, centerY - 0.5f, 2 * r, 2 * r);
        }

        private void Form1_Paint(object sender, PaintEventArgs e)
        {
            Graphics myGra = e.Graphics;
            DrawGrid(myGra);
            MyDrawLine(myGra, 3, 5, 47, 25);
            myGra.DrawLine(Pens.Red, 3 * pointSize, 5 * pointSize, 47 * pointSize, 25 * pointSize);
            myGra.Dispose();
        }
    }
}

阅读全文 »

格物致知《Effective C#》读书笔记--验证二进制兼容性

发表于 2009-02-18 Disqus：本文字数： 1.5k 阅读时长 ≈ 1 分钟

昨天读了《Effective C#》的第一个条款“使用属性代替可访问的数据成员”，讲到要把公有字段修改为私有字段，并用公有属性把它封装起来。这一点不难理解，
不过里面提到了一个关于二进制兼容性的问题，很是有趣，今天来验证一下。

验证思路：创建一个类库内有一个public的类，该类内有一个public的字段。另外创建一个WinForm程序去读区该字段并显示。然后修改类库中的字段为属性
。再去运行WinForm，就应该会出错了。出错具体原因请参看《Effective C#》讲解。

开始吧！

创建一个ClassLibrary，叫做TheDLL。代码如下：

public class DataHolder
{
    public String Data = "Hey! Hey!You!You!";
}

用它生成一个dll。

阅读全文 »

SWPU学分绩点计算器女生版

发表于 2009-02-06 Disqus：本文字数： 264 阅读时长 ≈ 1 分钟

所谓女生版就是指的GUI稍微美化了一点点，我承认是标题党….

注意：需要有.net Framework 2.0才可以运行

.net Framework 2.0下载地址（如果你的电脑没有请在这儿下载）：
http://www.gougou.com/search?search=.net%20Framework%202.0&id=0

学分绩点计算器下载地址：
http://download.csdn.net/source/993661
（要有CSDN账号才可以下载）

没有CSDN账号请向 397649079@QQ.com 索取

阅读全文 »

西南石油大学--学分绩点计算器（用C#编写，需要有.NET 2.0）

发表于 2009-01-16 Disqus：本文字数： 2.7k 阅读时长 ≈ 2 分钟

注意：需要有.net Framework 2.0才可以运行

.net Framework 2.0下载地址（如果你的电脑没有请在这儿下载）：
http://www.gougou.com/search?search=.net%20Framework%202.0&id=0

学分绩点计算器下载地址：
http://download.csdn.net/source/973619
（要有CSDN账号才可以下载）

运行效果（示例而已）：

——————————————分割线下面是类关系图、代码———————-

阅读全文 »

迅雷账号升级到24了，全球70000名。OhYeah~~

发表于 2009-01-14 Disqus：本文字数： 12 阅读时长 ≈ 1 分钟

也不知道会不会快一些……

数据结构:二叉树的建立和遍历(C#实现)

发表于 2008-12-12 Disqus：本文字数： 1.9k 阅读时长 ≈ 2 分钟

遍历只做了先序,递归实现的,中序和后序都类似.代码比较简单,就不写注释,直接贴出来了

代码:

TreeNode:结点类

using System;
using System.Collections.Generic;
using System.Text;

namespace 二叉树的建立和遍历
{
    class TreeNode
    {
        public char data;
        public TreeNode left, right;

        public TreeNode(char c, TreeNode l, TreeNode r)
        {
            data = c;
            left = l;
            right = r;
        }

        public TreeNode()
        {
            left = right = null;
        }
    }
}

Tree:树类

using System;
using System.Collections.Generic;
using System.Text;

namespace 二叉树的建立和遍历
{
    class Tree
    {
        public TreeNode root;
        Stack<TreeNode> stack = new Stack<TreeNode>();

        public void CreateTree(String description)
        {
            bool left = true;
            char[] descriptionarray = description.ToCharArray();
            root = new TreeNode();
            root.data = descriptionarray[0];
            TreeNode temp = root;
            for (int i = 1; i <= descriptionarray.Length - 1; i++)
            {
                if (descriptionarray[i] == '(')
                {
                    left = true;
                    stack.Push(temp);
                }
                else if (descriptionarray[i] == ',')
                {
                    left = false;
                }
                else if (descriptionarray[i] == ')')
                {
                    stack.Pop();
                }
                else
                {
                    temp = new TreeNode();
                    temp.data = descriptionarray[i];
                    if (left == true)
                    {
                        stack.Peek().left = temp;
                    }
                    else
                    {
                        stack.Peek().right = temp;
                    }
                }
            }
        }

        public void PreOrder(TreeNode t, String sign)
        {
            if (t != null)
            {
                Console.WriteLine(sign + t.data);
                sign += sign;
                if (t.left != null)
                {
                    PreOrder(t.left, sign);
                }

                if (t.right != null)
                {
                    PreOrder(t.right, sign);
                }
            }
        }
    }
}

阅读全文 »

数据结构：用队列模拟理发店的排队情况（C#）

发表于 2008-11-15 Disqus：本文字数： 4.1k 阅读时长 ≈ 4 分钟

题目内容：使用的排队现象，通过仿真手法评估其营业状况。
*基本要求：设某理发馆有N把理发椅，可同时为N位顾客进行理发。
*当顾客进门时，若有空椅，则可以立即坐下理发，否则需要依次排队等候。
*一旦有顾客理完发离去时，排在队头的顾客便可开始理发。
*若理发馆每天连续营业T小时，求一天内顾客在理发馆内的平均逗留时间
*顾客排队等候的队列平均长度

N和T在运行的时候输入

用C#写的，有注释，很混乱，请高人指教~~

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace 队列应用
{
    class Seat
    {
        public bool IsFree;
        public Customer cus = null;

        public Seat(bool b)
        {
            IsFree = b;
        }
    }

    class Customer
    {
        public int cometime;
        public int timetogo;
        public int cost = 30 - new Random().Next(10); //理发需要20~30分钟

        public Customer()
        {
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            System.Console.WriteLine("每天营业多少小时？");
            int workinghours = int.Parse(Console.ReadLine());
            System.Console.WriteLine("有多少个椅子？");
            int seats = int.Parse(Console.ReadLine());
            Process(seats, workinghours);
            Console.ReadLine();
        }

        static void Process(int num, int time)
        {
            //------------准备变量------------------------
            Queue q = new Queue(); //队列
            Seat[] S = new Seat[num]; //所有的椅子
            for (int i = 0; i < num; i++) //初始化椅子
            {
                S[i] = new Seat(true);
                S[i].cus = null;
            }

            int somebodycome = 1; //第一个顾客来的时间
            //int count = 0;//顾客计数器
            List<Customer> cuslist = new List<Customer>();
            int st = num; //椅子数
            int Qlen = 0; //队列长度
            int Qchangetime = 0; //队列长度改变次数
            //------------准备变量--------------------------
            for (int t = 1; t <= time * 60; t++) //时间从第一分钟开始流逝，每分钟检查状态
            {
                //--------检查现在有没有人需要离开--------------
                CheckLeave(S, t);
                //--------检查现在有没有人需要离开--------------
                //-------检查排队的人是否可以找到座位---------
                CheckSeat(q, S, ref Qlen, ref Qchangetime, t);
                //-------检查排队的人是否可以找到座位---------
                //-------------如果来人了，有座位就坐下，没座位就排队-------------------
                if (t == somebodycome)
                {
                    bool IsSitted = false; //当前刚来的顾客是否找到了座位
                    Customer c = new Customer();
                    c.cometime = t;
                    cuslist.Add(c);
                    foreach (Seat s in S)
                    {
                        if (s.IsFree == true)
                        {
                            s.IsFree = false;
                            s.cus = c;
                            s.cus.timetogo = t + s.cus.cost;
                            IsSitted = true;
                            break;
                        }
                    }

                    if (IsSitted == false)
                    {
                        q.Enqueue(c);
                        Qlen += q.Count;
                        Qchangetime++;
                    }
                    else
                    {
                        IsSitted = false;
                    }

                    somebodycome += 10 - new Random().Next(5); //下一个顾客来的时间,假设5~10分钟之内会有一个
                }

                //------如果来人了，有座位就坐下，没座位就排队---------
            }

            //---------加班----------
            bool Inseat = true;
            //bool InQ = true;
            bool KeepWorking = true;
            int curtime = time * 60 + 1;
            while (KeepWorking)
            {
                CheckLeave(S, curtime);
                CheckSeat(q, S, ref Qlen, ref Qchangetime, curtime);
                foreach (Seat s in S)
                {
                    if (s.IsFree == false)
                    {
                        Inseat = true;
                        break;
                    }
                    else
                    {
                        Inseat = false;
                    }
                }

                KeepWorking = Inseat;
                curtime++;
            }

            //---------加班----------
            //--------------
            int no = 1;
            foreach (Customer c in cuslist)
            {
                Console.Write("第{0}个顾客  ", no);
                Console.Write("来的时间：" + c.cometime);
                Console.WriteLine("  走的时间:" + c.timetogo);
                no++;
            } //------------------

            //--------打印结果-------------
            int totalstaytime = 0;
            foreach (Customer c in cuslist)
            {
                int staytime = c.timetogo - c.cometime;
                totalstaytime += staytime;
            }

            int averragestay = totalstaytime / cuslist.Count;
            System.Console.WriteLine("平均逗留时间:" + averragestay);
            System.Console.WriteLine("顾客数量:" + cuslist.Count);
            if (Qchangetime != 0)
            {
                int averagelen = Qlen / Qchangetime;
                Console.WriteLine("队列平均长度：" + averagelen);
            }
            else
            {
                Console.WriteLine("椅子充足，不用排队");
            }

            Console.WriteLine("加班时间：" + (curtime - time * 60) + "分钟");
            //--------打印结果------------
        }

        private static void CheckSeat(Queue q, Seat[] S, ref int Qlen, ref int Qchangetime, int t)
        {
            if (q.Count != 0) //如果有人排队
            {
                foreach (Seat s in S)
                {
                    if (s.IsFree == true)
                    {
                        s.IsFree = false;
                        s.cus = (Customer) q.Dequeue();
                        Qlen += q.Count;
                        Qchangetime++;
                        s.cus.timetogo = t + s.cus.cost; //
                    }
                }
            }
        }

        private static void CheckLeave(Seat[] S, int t)
        {
            foreach (Seat s in S)
            {
                if (s.cus != null)
                {
                    if (s.cus.timetogo == t)
                    {
                        s.IsFree = true;
                    }
                }
            }
        }
    }
}

阅读全文 »

Good news from O'Reilly's Chinese website

发表于 2008-10-30 Disqus：本文字数： 92 阅读时长 ≈ 1 分钟

官方即将出版中文版，看图：

本系列预计将在官方中文版available之后停止翻译

以后大家可以看质量有保证的了~~

但在正版出现之前，我将继续更新，希望大家继续关注，谢谢~~~~~~~~~

阅读全文 »

文字竖排工具 By 崔鹏飞没有混淆，可以用reflector看代码

发表于 2008-10-12 Disqus：本文字数： 189 阅读时长 ≈ 1 分钟

功能全面的文字竖排工具。

实现功能：截图、设置字体、繁体转换、文字竖排、设置行列数实现分页、输入原文的时候同步显示竖排文字、一键复制到剪切板等。

注意：C#编写，需要.net framework 2.0

下载地址：
http://download.csdn.net/source/686787

发现缺陷、不足、bug，请告知我，我会尽快修改

ps：没有混淆，可以用reflector看代码

阅读全文 »

文字竖排工具BY烟锁重楼

发表于 2008-10-09 Disqus：本文字数： 140 阅读时长 ≈ 1 分钟

运行库：.net 2.0

下载地址：
http://pickup.mofile.com/7286535210268103

备用地址：
http://ishare.iask.sina.com.cn/cgi-bin/fileid.cgi?fileid=4452071

ps:烟锁重楼是我原来的网名

阅读全文 »

对Graphic的应用，实现类似九宫格的绘制字符串、制定圆心，半径绘制圆形、用火柴棍拼字[Java ME]

发表于 2008-10-03 Disqus：本文字数： 3.7k 阅读时长 ≈ 3 分钟

import  javax.microedition.midlet.*;
import  javax.microedition.lcdui.*;

public class HomeWork extends MIDlet implements CommandListener {
	Display d = Display.getDisplay(this);
	FormattedFloatingDecimal.Form f = new Form("主窗口");
	Command back = new Command("返回", Command.BACK, 1);
	Command exit = new Command("退出", Command.EXIT, 1);
	Command drs = new Command("绘制字符串", Command.OK, 1);
	Command drc = new Command("画圆", Command.OK, 1);
	Command drn = new Command("火柴棍拼字", Command.OK, 1);

	//用于画圆的
	public class CircleCanvas extends Canvas {
		int pointX, pointY, len;

		public void paint(Graphics g) {
			g.setColor(255, 0, 0);
			g.fillArc(pointX, pointY, len, len, 0, 360);
			g.drawRect(pointX, pointY, len, len);  //框住了就代表对了
		}

		public void drawCircle(int x, int y, int r) {
			pointX = x - r;
			pointY = y - r;
			len = 2 * r;
		}
	}

	//用于在指定位置绘制字符串
	public class MyCanvas extends Canvas {
		String printword = "";
		int[] myenum = {
			0, 0, Graphics.LEFT | Graphics.TOP,
			getWidth() / 2, 0, Graphics.HCENTER | Graphics.TOP,
			getWidth(), 0, Graphics.RIGHT | Graphics.TOP,
			0, getHeight() / 2, Graphics.LEFT | Graphics.TOP, getWidth() / 2,
			getHeight() / 2, Graphics.HCENTER | Graphics.TOP,
			getWidth(), getHeight() / 2, Graphics.RIGHT | Graphics.TOP, 0,
			getHeight(), Graphics.LEFT | Graphics.BOTTOM,
			getWidth() / 2,
			getHeight(), Graphics.HCENTER | Graphics.BOTTOM,
			getWidth(), getHeight(), Graphics.RIGHT | Graphics.BOTTOM
		};

		int[] position = new int[3];

		public void paint(Graphics g) {
			g.setColor(255, 0, 0);
			g.drawString(printword, position[0], position[1], position[2]);
		}

		public void DrawMyStrin(String s, int pos) {
			printword = s;
			position[0] = myenum[pos * 3 - 3];
			position[1] = myenum[pos * 3 - 2];
			position[2] = myenum[pos * 3 - 1];
		}
	}

	//用火柴棍拼字
	public class MatchNum extends Canvas {
		int[][] lines =

			{
				{
					100, 100, 120, 100
				},  //0
				{
					100, 120, 120, 120
				},  //1
				{
					100, 140, 120, 140
				},  //2 //三个横
				{
					100, 100, 100, 120
				},  //3
				{
					100, 120, 100, 140
				},  //4//左边的两竖
				{
					120, 100, 120, 120
				},  //5
				{
					120, 120, 120, 140
				}
			};  //6//右边的两竖
		int[][] nums =

			{
				{
					0, 2, 3, 4, 5, 6
				},  //0
				{
					5, 6
				},  //1
				{
					0, 1, 2, 5, 4
				},  //2
				{
					0, 1, 2, 5, 6
				},  //3
				{
					5, 6, 1, 3
				},  //4
				{
					0, 1, 2, 3, 6
				},  //5
				{
					3, 4, 0, 1, 2, 6
				},  //6
				{
					0, 5, 6
				},  //7
				{
					0, 1, 2, 3, 4, 5, 6
				},  //8
				{
					0, 1, 3, 5, 6, 2
				},  //9
			};
		int[] temp;

		public void drawMyNum(int n) {
			temp = nums[n];
		}

		public void paint(Graphics g) {
			g.setColor(255, 0, 0);
			int i = temp.length;
			for (int j = 0; j <= i - 1; j++) {
				int[] a = lines[temp[j]];
				g.drawLine(a[0], a[1], a[2], a[3]);
			}
		}

	}

	public void startApp() {
		f.addCommand(exit);
		f.addCommand(drs);
		f.addCommand(drc);
		f.addCommand(drn);
		f.setCommandListener(this);
		d.setCurrent(f);
	}

	public void commandAction(Command c, Displayable dis) {
		if (c == exit)
			destroyApp(false);
		else if (c == drs) {
			MyCanvas m = new MyCanvas();
			m.addCommand(back);
			m.setCommandListener(this);
			m.DrawMyStrin("字符串", new java.util.Random().nextInt(8) + 1);
			d.setCurrent(m);
		} else if (c == drc) {
			CircleCanvas cc = new CircleCanvas();
			cc.addCommand(back);
			cc.setCommandListener(this);
			cc.drawCircle(60, 60, 40);
			d.setCurrent(cc);
		} else if (c == drn) {
			MatchNum mn = new MatchNum();
			mn.addCommand(back);
			mn.setCommandListener(this);
			mn.drawMyNum(new java.util.Random().nextInt(9));
			d.setCurrent(mn);
		} else if (c == back) {
			d.setCurrent(f);
		}
	}

	public void pauseApp() {
	}

	public void destroyApp(boolean unconditional) {
		notifyDestroyed();
	}
}

阅读全文 »

编程之美---阶乘末尾有几个"零"?(C#实现)

发表于 2008-09-18 Disqus：本文字数： 1k 阅读时长 ≈ 1 分钟

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        delegate long DoMath(long num);

        static void Main(string[] args)
        {
            Program p = new Program();
            p.GetFactorial(26);
            DoMath d = new DoMath(p.HowManyZero);
            d += p.HowManyZero2;
            d(26);
            Console.Read();
        }

        public long HowManyZero(long num) //第一种解法
        {
            long result = 0;
            for (long i = 1; i <= num; i++)
            {
                long j = i;
                while (j % 5 == 0)
                {
                    result++; //检查每一个数可以分解因式出多少个5
                    j /= 5;
                }
            }

            Console.WriteLine(result);
            return result;
        }

        public long HowManyZero2(long num) //第二种
        {
            long ret = 0;
            while (num != 0)
            {
                ret += num / 5; //可以被5整除，然后是25、125、625......
                num /= 5;
            }

            Console.WriteLine(ret);
            return ret;
        }

        public decimal GetFactorial(long num) //获得阶乘
        {
            decimal ret = 1;
            for (long i = 1; i <= num; i++)
            {
                ret *= i;
            }

            Console.WriteLine(ret);
            return ret;
        }
    }
}

书上只标了2颗星，我怎么觉得这么费劲….
PS：decimal都算不到30的阶乘啊……

具体讲解书上有

顺便复习一下delegate~~~~~~~

阅读全文 »

编程之美---1的个数C#笨（效率低）方法实现

发表于 2008-09-18 Disqus：本文字数： 498 阅读时长 ≈ 1 分钟

编程之美—1的个数C#笨（效率低）的方法实现

class Program
{
    static void Main(string[] args)
    {
        Program p = new Program();
        Console.WriteLine(p.count_1_in_a_bounch_of_nums(13));
        Console.Read();
    }

    public int count_1_in_a_num(int num)
    {
        int count = 0;
        while (num != 0)
        {
            count += (num % 10) == 1 ? 1 : 0;
            num /= 10;
        }

        return count;
    }

    public int count_1_in_a_bounch_of_nums(int end)
    {
        int count = 0;
        for (int i = 1; i <= end; i++)
        {
            count += count_1_in_a_num(i);
        }

        return count;
    }
}

cpu占用率为正弦曲线（C#实现）基本照抄书上的C++

发表于 2008-09-17 Disqus：本文字数： 830 阅读时长 ≈ 1 分钟

internal值根据配置调整

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            const double SPLIT = 0.01;
            const int COUNT = 200;
            const double PI = 3.14159265;
            const int INTERVAL = 100;
            double[] busySpan = new double [COUNT]; //array of busy times
            double[] idleSpan = new double [COUNT]; //array of idle times
            int half = INTERVAL / 2;
            double radian = 0.0;
            for (int i = 0; i < COUNT; i++)
            {
                busySpan[i] = (double) (half + (Math.Sin(PI * radian) * half));
                idleSpan[i] = INTERVAL - busySpan[i];
                radian += SPLIT;
            }

            double startTime = 0;
            int j = 0;
            while (true)
            {
                j = j % COUNT;
                startTime = Environment.TickCount;
                while ((Environment.TickCount - startTime) <= busySpan[j]) ;
                System.Threading.Thread.Sleep((int) idleSpan[j]);
                j++;
            }
        }
    }
}

《编程之美——微软技术面试心得》的C#实现---电梯调度问题解法一

发表于 2008-09-11 Disqus：本文字数： 481 阅读时长 ≈ 1 分钟

class Program
{
    static void Main(string[] args)
    {
        int[] person = {0, 1, 1, 1, 1, 1, 15}; //总共六层楼，没有0层
        int needed = 0;
        int min = 0;
        int target = 0;
        for (int i = 1; i <= 6; i++)
        {
            needed = 0;
            for (int j = 1; j < i; j++)
            {
                //目的在i层以下的
                needed += person[j] * (i - j);
            }

            for (int j = i + 1; j <= 6; j++)
            {
                //目的在i层上面的
                needed += person[j] * (j - i);
            }

            if (min == 0 || min >= needed)
            {
                min = needed;
                target = i;
            }
        }

        Console.WriteLine(target);
        Console.Read();
    }

可以为null的值类型

发表于 2008-09-09 Disqus：本文字数： 91 阅读时长 ≈ 1 分钟

可以为null的值类型

地址：
http://topic.csdn.net/u/20080909/11/ad46c1db-327d-4c23-a78a-d65deebd9d1d.html