列出3个骰子每种可能和值的所有骰子情况
本题纯属娱乐呵，大家来玩一下。

有3个相同的骰子，扔出的和值当然可能是3，4，5，...18
要求列出所有和值的骰子情况，打印出的格式类似如下即可：
3：1 1 1
4：1 1 2
5：1 1 3 ，1 2 2
.
.
.
18: 6 6 6


看看谁有最简单的代码打印出来啊
[解决办法]
三位6进制数，忽略位顺序，各位和相同的为一组。最后将0～5对应1～6，和加3 ?
[解决办法]

#include <stdio.h>
void output( int sum, char * buffer, int level, int max )
{
    if( sum >= level && sum <= level * max )
    {
        if ( level == 1 )
        {
            * --buffer = "0123456789"[sum];
            * --buffer = ' ';
            printf("%s", buffer);
        }
        else
        {
            int i = sum - level + 1;
            if( i > max )
            {
                i = max;
            }
            for(; i > 0; -- i)
            {
                char * my_buffer = buffer;
                * -- my_buffer = "0123456789"[i];
                * -- my_buffer = ','; 
 
                output( sum - i, my_buffer, level - 1, i );
            }
        }
    }
}

int main()
{
    int i;
    char buffer[20];
    buffer[19] = '\0';
    for( i = 3; i <= 18; ++ i)
    {
        printf("\n%d: ", i);
        output(i, &buffer[19], 3, 6);
    }
}

[解决办法]
“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！
递归函数关注以下几个因素
退出条件
参数有哪些
返回值是什么
局部变量有哪些
全局变量有哪些
何时输出
会不会导致堆栈溢出

[解决办法]
再写一个非递归：

#include <stdio.h>

int first_group( int data[], int size, int sum)
{
    int i = size - 1;
    while( i >= 0 && sum > 0 )
    {
        int value = sum - i;
        value = value > 6 ? 6 : value;
        value = value < 1 ? 1 : value;
        data[ i ] = value;
        sum -= value;
        -- i;
    }
    return i < 0 && sum == 0;
}

int next_group( int data[], int size )
{
    int i = 0;
    int result = 0;
    while( i < size - 1 && data[i] > data[i + 1] - 2)
    {
        ++ i;
    }
    if( i < size - 1 )
    { 
 
        ++ data[i];
        -- data[i + 1];
        result = 1;
    }
    return result;
}

#define COUNT 3

int main()
{
    int data[COUNT];
    int i;
    for( i = 0; i <= 6 * COUNT; ++ i)
    {
        int next = first_group( data, COUNT, i);
        if( next )
        {
            printf("\n%d:", i);
        }
        while(next )
        { 
            int j;
            char prefix = ' ';
            for( j = 0; j < COUNT; ++ j)
            {
                printf("%c%d", prefix, data[j]);
                prefix = ',';
            }
            next = next_group( data, COUNT );
        }
    }
    return 0;
}

其实最简单的代码是三重循环，就是不能适应骰子的数量变化：

#include <stdio.h>

#define min(x, y) ((x) < (y) ? (x) : (y))
int main()
{
    int i, j, k, sum;

    for( sum = 3; sum <= 18; ++ sum)
    {
        printf( "%d:", sum);
        for(i = 1; i <= min(sum, 6); ++ i )
        {
            for( j = i; j <= min(sum - i, 6); ++ j) 
 
            {
                k = sum - i - j;
                if( k <= 6 && k >= j)
                {
                    printf( " %d,%d,%d", i, j, k);
                }
            }
        }
        printf("\n");
    }
    return 0;
}