我的想法：
先将这5个数字放入一个数组num。
设定个bool类型的flag，初值为true。
将冒泡排序算法稍微改动下。添加“==”判断，若有任意两个元素相等，则把flag改为false，且break掉冒泡排序的循环。
冒泡排序结束后，先判断flag，如果为false，则5个数不连续。
如果flag为true，在判断num[4]-num[0]==4。如果成立，则5个数字连续，如果大于4，则5个数字不连续。
过段时间想代码贴过来

大家还有什么别的想法么？

没看太明白， 如果是1,3,5，7,9,11会是什么样子

先从小到大排序，再计算相邻两数的差值是否为1
可以使用
for(int i = 0; i <arr.Length()-1;i++)
{
   if(arr[i+1]-arr[i]==1)
    {
      return true;
     }
    return false;
}

段朝骞 发表于 2013-9-30 17:53
先从小到大排序，再计算相邻两数的差值是否为1
可以使用
for(int i = 0; i

是否连续到底是啥意思，，1,5,4,2,3算连续吗？

haxyek 发表于 2013-9-30 17:55
是否连续到底是啥意思，，1,5,4,2,3算连续吗？

算的，跟顺序无关

haxyek 发表于 2013-9-30 17:55
是否连续到底是啥意思，，1,5,4,2,3算连续吗？

注意前面先从小到大排序

段朝骞 发表于 2013-9-30 17:53
先从小到大排序，再计算相邻两数的差值是否为1
可以使用
for(int i = 0; i

这是效率最低的方法了吧。还不如我上面说的那个效率高。
如果有重复的话，必然就不连续了，排序算法都不用进行完就结束了。
如果没有重复的，你这要进行4次循环判定，上面说的那个只要判定一次就行了。

haxyek 发表于 2013-9-30 17:19
没看太明白， 如果是1,3,5，7,9,11会是什么样子

现在要求就给5个数字啊。按照我上面说的算法，如果你给的1 3 5 7 9的话，我这里先冒泡排序，并且检查是否有相同的数字。你这里没有相同的数字，而且原本就是从小到大排序的，所以冒泡排序算法循环进行一次就完事了。排序结果就是1 3 5 7 9。然后检查9-1==4。不等于，所以不连续。

大虾挂了 发表于 2013-9-30 18:00
这是效率最低的方法了吧。还不如我上面说的那个效率高。
如果有重复的话，必然就不连续了，排序算法都不 ...

冒泡排序本身就是效率最低的排序，可以直接使用内置的高级排序方法，相比之下效率差别应该不算大吧

明白了。

ASCII  前驱  后继

1. int[] num = new int[]{0,1,2,3,4 };
   
2.             bool IsTrue = true;
   
3.             for (int i = 0; i <num.Length-1; i++)
   
4.             {
   
5.                 if ((num + 1) != num[i + 1])
   
6.                 {
   
7.                     IsTrue = false;
   
8.                 }
   
9.             }
   
10.             if (!IsTrue)
    
11.             {
    
12.                 Console.WriteLine("不连续");
    
13.             }
    
14.             else
    
15.             {
    
16.                 Console.WriteLine("连续");
    
17.             }

复制代码

这是我的方法，你看下

段朝骞 发表于 2013-9-30 18:08
冒泡排序本身就是效率最低的排序，可以直接使用内置的高级排序方法，相比之下效率差别应该不算大吧 ...

我不是说冒泡排序算法效率低，我是说你后面检测每个相邻数字是否差1的方法效率太低了，而且当有相同数字的时候直接可以认定不是连续的。

guo329838627 发表于 2013-9-30 20:10
这是我的方法，你看下

你这个没懂我题的意思啊，我的意思是只要数字是连续的就行，位置无所谓。这里要是给1 3 2 4 0，我要求结果也应该是连续，你这里肯定结果是不连续了。
你这段代码是不是只有0 1 2 3 4才会得到连续? 1 2 3 4 5都不连续？

将5个数放入数组   判断是否有重复！有 out ！  没有 排序  求相邻两数之差值   看他们的差值是否都相等吧！

大虾挂了 发表于 2013-9-30 20:42
你这个没懂我题的意思啊，我的意思是只要数字是连续的就行，位置无所谓。这里要是给1 3 2 4 0，我要求结 ...

连续的，不要意思，没看懂你题，你可以这么的，先用冒泡从小到大排序，然后比就行了，你看下我写的代码：

1. static void Main(string[] args)
   
2.         {
   
3.             int[] num = new int[]{1,3,2,4,0};
   
4.             bool IsTrue = true;
   
5.             ////冒泡排序
   
6.             for (int i = 0; i < num.Length - 1; i++)
   
7.             {
   
8.                 for (int j = i + 1; j < num.Length; j++)
   
9.                 {
   
10.                     if (num[i] > num[j])
    
11.                     {
    
12.                         int ls;
    
13.                         ls = num[i];
    
14.                         num[i] = num[j];
    
15.                         num[j] = ls;
    
16.                     }
    
17.                 }
    
18.             }
    
19.             //判断
    
20.             for (int i = 0; i <num.Length-1; i++)
    
21.             {
    
22.                 if ((num[i] + 1) != num[i + 1])
    
23.                 {
    
24.                     IsTrue = false;
    
25.                 }
    
26.             }
    
27.             if (!IsTrue)
    
28.             {
    
29.                 Console.WriteLine("不连续");
    
30.             }
    
31.             else
    
32.             {
    
33.                 Console.WriteLine("连续");
    
34.             }
    
35.         }

复制代码

int[] num = new int[]{a,b,d,e,f};
for(int i=0;i<4;i++)
{
for(int j=i+1;j<=4;j++)
{
if(num[i]==num[j]||(num[i]-num[j])>4)
{
return false;
}
}
}
return true;

static void Main(string[] args)
        {
            //Mp3 M = new Mp3();
            //M.Playe += new Delegate(M_Playe);
            //M.start();
            //Console.Read();


            int[] num = new int[] { 6, 3, 4, 2, 5 };
            Array.Sort(num);
            Console.WriteLine(Is(num));
            Console.Read();
            
         }
         private static bool Is(int[] num)
         {
              for (int i = 0; i < num.Length - 1; i++)
              {
                   if (num[i] + 1 != num[i+1])
                    {
                        return false;
                    }
              }
              return true;
          }

段朝骞 发表于 2013-9-30 17:53
先从小到大排序，再计算相邻两数的差值是否为1
可以使用
for(int i = 0; i

说的是思路，不是具体实现

guo329838627 发表于 2013-9-30 22:06
连续的，不要意思，没看懂你题，你可以这么的，先用冒泡从小到大排序，然后比就行了，你看下我写的代码： ...

大哥你那个是冒泡么，就算是效率超低的，因为你每次排好的你还进行比较，那样重复了。
下面的是冒泡排序
for (int i = 0; i < num.Length - 1; i++)
{
           for (int j =  num.Length-1-i; j >i; j--)
                    {
                             if (num[j] < num[j-1])
                              {
                                      int  temp=num[j];
                                      num[j]= num[j-1];                                                                          
                                      num[j-1]=temp;
                               }
                     }
}