算法，一个永恒的话题，挑战你的编程之美。

       最近很少写博客了，最多成为闪存板块一名无业游民和闪民一起闪出精彩，2009年9月1日正式离职，一直处于准备面试和被面的局面，毕竟四年都没有过被面的经历，最近积极准备着数据结构和算法，这是每个公司必须要考察的一方面。

       曾几何时，我第一家公司是这样面试的，公司去学校招聘，呵呵，那时候春风得意，笔试题也轻松搞定，咱在学校也属于“好学生”行列，自然很顺利的来北京谋生，只可惜公司运营不畅......不得不去第二家公司，就是我现在的公司，电话面试，笔试是直接上机，做一个登录系统，可以查MSDN，可以上网，在我的印象中，这样的公司才是真正选拔人才的公司，一晃四年过去了，由于个人原因，辞去了公司的职务，选择了挑战。

       犹如井底之蛙，对外边的世界变化浑然不觉，对于面试，我也曾经面试过别人，可是被面的感觉很糟糕，有点眼高手低，基础的知识没有放眼里，细节没有放心上，我应聘的是高工，面对诸如需要专业方向很强的公司：例如，GDI+，NetWork等必须精通的公司要求，我无能为力，我不是精通这些，也不是熟练掌握，而是熟悉，因为是应聘高工，不仅仅要求软件的架构设计，我们公司是做产品，必然要求对架构设计要求高，而有些公司，现在好多外包公司，讲求的是效率，要拿下项目，必须有很好的台面功夫才行，不论你怎么好的设计，必须在规定时间内实现这些功能，所以这些所谓的设计似乎被消弱很多，更多的是要求你能搞定这些问题，anyway。

       尤其是像微软这样的公司，数据结构和算法是重头戏，这些搞不定，必然是能力上的折扣，虽然微软有自己的“题库”，看了<<编程之美>>你就会发现，其实到处都是他们的面试题，很随机，不要期望去背一些算法什么的，没戏，不排除有些时候也能来个火星撞地球，特别是搞“高级一点”，“傻瓜一点”，“智能一点”语言的同仁更是用类库抵挡一阵，所以面试时还要捡回来这些平时我们不用但能体现你基础水平和思维方式的算法。

        晚上看博客园文章是发现小夏写了一篇“ 趣味算法：返回不重复数的实现”，题目要求如下：

如果一个数字十进制表达时，不存在连续两位相同，则称之为“不重复数”。例如，105、164和198都是“不重复数”，而11、100和122不是。实现一个函数，用一个long类型（ long类型数字A），实现返回大于A的最小“不重复数”。

        看到小夏算法优美，不禁跃跃欲试，其实看了<<编程之美>>后，自己总在寻找最优解法，想了半小时，脑子都乱了，究竟什么是最优呢，考虑了很多途径，终于思考不下去了，这就和面试一样，你总想把你沉淀的架构说上一通，而面试要求你现在把当前的问题解决了，这个时候不是追求完美的时候，有些时候首先要能解决问题，然后再去完善，并使之完美，这也是我四年中不曾悟到的，总想着有一个完美的想法后，再去动手实现。

        切忌用完美去诠释棘手的任务，虽然有点偏激，但是大多数情况下，我们需要先解决了问题，然后再去优化，完善。
       
        想到此，就顺手写了这个算法，无所谓完美，也不要考虑复杂度，切记，你是在完成任务，不是在表演，如果是表演，你可能用所有的技巧和舞台效果去展示。
  

 1   public   static   long  GetNextNotDuplicatedValue( long  a)
 2          {
 3            long temp = a + 1;
 4            while (true)
 5            {
 6                char[] lChars = temp.ToString().ToCharArray();
 7                for (int i = 0; i < lChars.Length; i++)
 8                {
 9                    if (i == lChars.Length - 1) return temp;
10                    if(lChars[i].Equals(lChars[i+1]))
11                    {
12                        temp++;
13                        break;
14                    }
15                }
16            }
17        }

简单的测试了一下，符合题意，测试数据如下：

  long [] xN  =   new   long [] {  1122 ,  18 ,  21 , 123 ,  98 , 100011 , 121989999 };
foreach  (var l  in  xN)
 {
       long  x  =  GetNextNotDuplicatedValue(l);
       Console.WriteLine(x);
}

如果数据更大，例如：121989999991999,花了好几分钟也没算出来，这个时候真的需要考虑时间复杂度等问题了。
但起码，我们完成了”任务“。

天色已晚，优化的任务交给算法大拿了，这次跳槽，立志捡起数据结构和算法，看到园子里高手比拼算法，好羡慕，希望自己以后也是其中一员。
附小夏算法：

Code
 1static long GNext(long A)
 2        {
 3            long n = A;
 4            int[] a = new int[100];
 5            int cnt = 0;//输入数的位数
 6            while (n > 0)
 7            {
 8                a[cnt++] = (int)(n % 10);
 9                n /= 10;//输入几位数执行几遍
10            }
11            long tmp = 0;//存放临时值
12            for (int j = cnt - 1; j >= 0; j--)//循环取值
13            {
14                tmp = tmp * 10 + a[j];//按高位取值
15                if (a[j] == a[j + 1])//比较两个数是否相等
16                {
17                    tmp = tmp + 1;//比较结果相等则加1
18                }
19
20            }
21            if (cnt > 2)/**/////输入位数大于两位执行
22            {
23                cnt = 1;
24                for (int i = cnt; i > 0; i--)
25                {
26                    if (a[i] == a[i - 1])//比较两个数是否相等
27                    {
28                        tmp = tmp + 1;
29                    }
30                }
31            }
32            return tmp;
33        }
34        static long GetNext(long A)
35        {
36            return GNext(A + 1);
37        }

如果你热爱算法，想挑战一下，看看<<编程之美>>，保证你受益匪浅。
补充老流的思路：

Code
01.public static long GetNextNotDuplicatedValue(long a)
02.{
03.    if (a < 0) return -1 * GetPrevNotDuplicatedValue(a * -1);
04.    long temp = a + 1;
05.    while (true)
06.    {
07.        char[] lChars = temp.ToString().ToCharArray();
08. 
09.        for (int i = 0; i < lChars.Length; i++)
10.        {
11.            if (i == lChars.Length - 1) return temp;
12.            if (lChars[i].Equals(lChars[i + 1]))
13.            {
14.                if (lChars[i + 1].ToString() == "9")
15.                {
16.                    //对有进位的考虑可能会有n次进位所以偷懒下累加后直接交由程序下次处理（此处可继续优化）
17.                    temp += (long)Math.Pow(10, (lChars.Length - i - 2));
18.                    break;
19.                }
20.                else
21.                {
22.                    lChars[i + 1] = (char)((int)lChars[i + 1] + 1);
23.                    char current = '0';
24.                    for (int j = i + 2; j < lChars.Length; j++)
25.                    {
26.                        lChars[j] = current;
27.                        if (current == '1')
28.                            current = '0';
29.                        else
30.                            current = '1';
31.                    }
32.                    return long.Parse(new string(lChars));
33.                }
34.            }
35.        }
36.    }
37.}
38. 
39. 
40.public static long GetPrevNotDuplicatedValue(long a)
41.{
42.    if (a < 0) return -1 * GetNextNotDuplicatedValue(a * -1);
43.    long temp = a - 1;
44.    while (true)
45.    {
46.        char[] lChars = temp.ToString().ToCharArray();
47. 
48.        for (int i = 0; i < lChars.Length; i++)
49.        {
50.            if (i == lChars.Length - 1) return temp;
51.            if (lChars[i].Equals(lChars[i + 1]))
52.            {
53.                if (lChars[i + 1].ToString() == "0")
54.                {
55.                    //对有消位的考虑可能会有n次消位所以偷懒下累减后直接交由程序下次处理（此处可继续优化）
56.                    temp -= (long)Math.Pow(10, (lChars.Length - i - 2));
57.                    break;
58.                }
59.                else
60.                {
61.                    lChars[i + 1] = (char)((int)lChars[i + 1] - 1);
62.                    char current = '9';
63.                    for (int j = i + 2; j < lChars.Length; j++)
64.                    {
65.                        lChars[j] = current;
66.                        if (current == '9')
67.                            current = '8';
68.                        else
69.                            current = '9';
70.                    }
71.                    return long.Parse(new string(lChars));
72.                }
73.            }
74.        }
75.    }
76.}

补充jt的思路，递增机制没什么不好，效率也不低：

Code
 1 static void Main(string[] args)
 2 {
 3 long[] xN = new long[] {
 4 1122, 18, 21, 123, 98, 100011, 121989999,
 5 121989999991999 };
 6 foreach (var l in xN)
 7 {
 8 long x = GetNextNotDuplicatedValue(l);
 9 Console.WriteLine(x.ToString());
10 }
11 Console.ReadLine();
12 }
13 
14 public static long GetNextNotDuplicatedValue(long a)
15 {
16 long temp = a + 1;
17 while (true)
18 {
19 char[] Chars = temp.ToString().ToCharArray();
20 for (int i = 0; i < Chars.Length; i++)
21 {
22 if (i == Chars.Length - 1) return temp;
23 if(Chars[i].Equals(Chars[i+1]))
24 {
25 long j = Mi(Chars.Length - i - 2);
26 
27 temp =((temp / j)+1) * j;
28 
29 break;
30 }
31 }
32 }
33 }
34 
35 public static long Mi(int x)
36 {
37 long re = 1;
38 for (int i = 0; i < x; i++)
39 {
40 re *= 10;
41 }
42 return re;
43 }

态度决定一切，技术改变生活作者：winzheng                                                                                                                                               
出处： http://cnblogs.com/winzheng                                                                                                      
本文为原创作品，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文链接，否则保留追究法律责任的权利。

转载于:https://www.cnblogs.com/winzheng/archive/2009/09/05/1560660.html