static void Main(string[] args)
        {
            int[] num = { 1, 2, 3, 4 };//一个int类型的数组，存有1,2,3,4 四个元素。
            Console.WriteLine("1,2,3,4这四个数一共可以组成 {0} 个互相不重复的3位数", 1 * 2 * 3 * 4); //因为是4个数，所以可以组成1*2*3*4个不重复的3位数
            Quanpai(num);  //将数组传入方法中
            Console.ReadKey();
        }
        public static void Quanpai(int[] num)
        {
            int[] arr = { 0, 0, 0 ,0}; //申明一个int[]数组 arr，我用这个数组的元素来表示原数组的下标
            while (true)
            {
                arr[0] += 1;   //对arr数组的第一个元素加1操作
                if (arr[0] == arr.Length) //如果arr[0]的值加到了数组的长度
                {
                    arr[1] += 1;    //就对第2个元素加1，
                    arr[0] = 0;   //第一个元素清0.
                }
                if (arr[1] == arr.Length)
                {
                    arr[2] += 1;
                    arr[1] = 0;     //同上一样，第二个元素达到了数组长度就对第3个元素加1，第2个元素清0.
                }
                if (arr[2] == arr.Length)
                {
                    arr[3] += 1;
                    arr[2] = 0;
                }
                if (arr[3] == arr.Length)  //如果第3个元素的值加到了数组的长度，后面没有再加的元素了。程序退出
                    return;
                //如果四个元素的的值都不相等，那就得到了一组不重复的下标，我们就输出这组数据！
                if (arr[0] != arr[1]&&arr[0]!=arr[2]&&arr[0]!=arr[3]&&arr[1]!=arr[2]&&arr[1]!=arr[3]&&arr[2]!=arr[3])
                {  
                    for (int i = 0; i < num.Length-1; i++)  //因为只要组成3位数，所以num.Length要减去1；
                    {
                        Console.Write("{0} ",num[arr] );//arr表示的是当前不重复的下标。
                    }
                    Console.WriteLine();

上面是我能想到的方法，有没有更直观易懂的方法，请带上代码和注释（新人，请莫用太深奥的东东）

1.   static void Main(string[] args)
   
2.                 {
   
3.                         int[] num = { 1, 2, 3, 4 };//一个int类型的数组，存有1,2,3,4 四个元素。
   
4.                         int m = 0;
   
5.                         for (int i = 0; i < num.Length; i++)                //百位遍历
   
6.                         {
   
7.                                 for (int j = 0; j < num.Length; j++)        //十位遍历
   
8.                                 {
   
9.                                         if (j == i)                                                        //百位和十位重复，跳过
   
10.                                         {
    
11.                                                 continue;
    
12.                                         }
    
13.                                         for (int k = 0; k < num.Length; k++)        //个位遍历
    
14.                                         {
    
15.                                                 if (k == j || k == i)                                                        //个位和十位重复，跳过
    
16.                                                 {
    
17.                                                         continue;
    
18.                                                 }
    
19.                                                 else
    
20.                                                 {
    
21.                                                         Console.WriteLine(num[i] * 100 + num[j] * 10 + num[k]);                        //输出
    
22.                                                         Console.WriteLine(++m);
    
23.                                                 }
    
24.                                         }
    
25.                                 }
    
26.                         }
    
27.                         Console.ReadKey();
    
28.                 }

复制代码

static void Main(string[] args)
        {
            int i,j,k;  //定义三个变量分别代表个十百三个数
            int num = 0;  //定义一个变量用于接收三位数的个数
            for (i = 1; i < 5; i++)
            {
                for (j = 1; j < 5; j++)
                {
                    for (k = 1; k < 5; k++)
                    {
                        if(i != j && i != k &&j != k)//判断 如果都不相等的话就输出并且计数加1
                        {
                            num++;
                            Console.WriteLine(i.ToString() + j + k);
                        }
                    }
                }
            }
            Console.WriteLine("共有{0}个三位数",num);
            Console.ReadKey();
        }

芦路 发表于 2013-10-21 09:27
static void Main(string[] args)
        {
            int i,j,k;  //定义三个变量分别代表个十百三个数 ...

人家给你的数组，你没用上啊~亲~

haxyek 发表于 2013-10-21 10:05
人家给你的数组，你没用上啊~亲~

题目：有1、2、3、4 四个数字....
题目中就没有说是数组
干嘛还要定义数组 不就多此一举了吗

如果你只是想知道n个不相同的数选n-1个能组成多少个数字，那么数学上可以根据排列组合原理计算
公式为：
!(n-1)*n
!n表示n的阶乘，代入4，结果为24
然后想要求具体数字的话再用芦路的方法就可以了

荣右铭 发表于 2013-10-21 11:07
如果你只是想知道n个不相同的数选n-1个能组成多少个数字，那么数学上可以根据排列组合原理计算
公式为：
!( ...

!(n-1)*n
!n表示n的阶乘，代入4，结果为24

兄弟，
！n表示n的阶乘？
这句是什么意思，什么是阶乘？

芦路 发表于 2013-10-21 09:27
static void Main(string[] args)
        {
            int i,j,k;  //定义三个变量分别代表个十百三个数 ...

很不错的思路，受教了

haxyek 发表于 2013-10-21 09:18

很好，一目了然。
我之前就想用for写，可是没想出来，呵呵

飞、 发表于 2013-10-21 12:48
!(n-1)*n
!n表示n的阶乘，代入4，结果为24

刚才说反了哈，sorry，阶乘应该是n！
阶乘就是。。。举个例子：
5！=5X4X3X2X1
6！=6X5X4X3X2X1
就像这样从自己那个数一直乘啊乘到1的做法，就叫做“阶乘”

荣右铭 发表于 2013-10-21 13:17
刚才说反了哈，sorry，阶乘应该是n！
阶乘就是。。。举个例子：
5！=5X4X3X2X1

哦，了解了，帮助很大，谢谢啊