每一点点进步就是我继续前进的动力

/*
思考:
正方形的数量为:
1 x 1 的数量 + 2 x 2 的正方形数量 + 3 x 3 的数量 + ... 12 x 12 的数量
*/

#include <stdio.h>

#define X 16
#define Y 12

int main(void)
{
    unsigned x, y, next = 1;  //坐标变化
    unsigned sum = 0;   //正方形的个数

    //计算1 x 1, 2 x 2 , 3 x 3 ,......, 12 x 12 大小的正方形的个数
    do
    {
        for (x = next; x <= X; x++)        //x坐标变化,从 x = 1 开始
            for (y = next; y <= Y; y++)    //y坐标变化
                sum++;
        
        next++;    //当计算完1 x 1的个数后,计算 2 x 2的数量.....依次
    }
    while(next <= X);

    printf("共有正方形 %u 个\n", sum);
    return 0;
}

[ 本帖最后由 Ryker 于 2013-4-25 11:37 编辑 ]

多谢鼓励

已经进步了.

从简单的printf("hello world"); 到 开始使用循环.

EN ..单行注释放到语句后面会让代码更清晰

我是为了锻炼自己从程序的角度分析问题,解决问题的能力,当看到一个程序要求的时候不至于一团乱麻不知如何入手

这是循环的自测题..做完后就要开始学习结构体 , 指针了.. 不会纠结在这些数学题上..


我的数学很烂..让我转学数学是坑...

并没有沉迷..那种 ++i , --i, i--, -i--的问题..我从来不感兴趣,因为我觉得实际代码不太可能这么写

循环练习到此结束...开始看书了...

/*
从循环到穷举
练习题:哪些连续的自然数的和为1000
*/

/*
思考:
连续的自然数相加等于1000 : x + (x + 1) + (x + 2) + (x + 3) + (x + 4) + ... ... + (x + n) == 1000
假设5个数相加等于1000: 5 * x + 1 + 2 + 3 + 4 = 1000
推导出n个数相加等于1000: n * x + 1 + 2 + 3 + 4 + ... + (n - 1) = 1000

x = 1000 - ( 1 + 2 + 3 + ... + n-1) / n

n = 1000 - ( 1 + 2 + 3 + ... + n -1) / x
假设题目的连续的自然数是指1个以上的数字,由于 500 + 501 > 1000 ,
所以 x < 500

for(x = 0; x < 500; x++)
    for(n = 2; n <= 1000 - ( 1 + 2 + 3 + n - 1) / x; n++)
        if(n = 1000 - (1 + 2 + 3 +...+ n - 1) / x
            for(i = n; i >= 0; i--)
                printf x;
                x++;
*/

#include <stdio.h>

#define YQ 1000     //一千
#define WB 500      //第一个数字的最大上限
#define WS 50       //连续自然数的个数上限

int main(void)
{
    unsigned first, sum;    //起始数字和数字个数
    unsigned tmp;           //临时记录 n 个连续自然数的和
    short i;                  //循环变量

    for (first = 1; first < WB; first++)      //从 1 到 500 查找连续自然数的第一个数
    {
        for (sum = 2; sum < WS; sum++)        //从 2 个数开始查找共有几个连续数相加等于1000
        {
            tmp = 0;                    //清除上一次循环(1 + 2 + 3 + ... + n-1) 的值

            for(i = 0; i < sum; i++)      //计算(1 + 2 + 3 + ... + n-1)
                    tmp += i;

            if((YQ - tmp) / first == sum && (YQ - tmp) % first == 0)  //判断(1000 - (1+2+3+4+...+n-1)/first)的值
            {
                for(i = 1; i <= sum; i++)     //打印符合条件的连续自然数
                {
                    printf("%u ", first);
                    first++;
                }
                printf("\n");
            }
        }
    }

    return 0;
}

不是 16 x 16啊..

是 16 x 12

好吧,你的更简单,我不会嫉妒你的..

T版会推荐你去数学系

/* 一维数组练习:一

 * 旅馆里有100个房间,从1到100编了号

 * 第一个服务员把所有的房间门都打开了,

 * 第二个服务员把所有编号是2的倍数的房间"相反处理"   (所有相反处理是指:原来开着的门关上

 * 第三个服务员把所有编号是3的倍数的房间做"相反处理"                   原来关着的门打开)

 * ....

 * 问第100个服务员来过后,哪几扇门是打开的
*/

#include <stdio.h>

#define DOOR 100    //100扇门
#define OPEN 1

int main(void)
{
    unsigned short i, waiter;   //循环变量
    unsigned short door[DOOR];  //门

    for (waiter = 1; waiter <= DOOR; waiter++)  //初始状态,第一个服务员把所有门打开
        door[waiter - 1] = OPEN;

    for (waiter = 2; waiter <= DOOR; waiter++)       //从第二到第一百名服务器依次开关门
        for (i = waiter; i <= DOOR; i += waiter) //每次下标从第几名服务员开始
            door[i - 1] = !door[i - 1];                      //相反处理

    printf("第100个服务员来过之后,第 ");
    for (i = 0; i < DOOR; i++)
        door[i]?printf("%u ", i + 1):0;
    printf("扇门是打开的!\n");

    return 0;
}

[ 本帖最后由 Ryker 于 2013-4-26 12:04 编辑 ]

/* 求一个二维数组中元素的最大,最小值 */

#include <stdio.h>

#define X 3
#define Y 7

void maxandmin(const int [][Y], const int, const int); //输出最大和最小数字

int main(void)
{
    const int sz[X][Y] = {
                    {11, 21, 11, 42, 34, 73, 28},
                    {14, 121, 101, 54, 32, 13, 128},
                    {52, 62, 79, 18, 23, 24, 8}
                   };

    maxandmin(sz, sizeof sz / sizeof sz[0], sizeof sz[0] / sizeof sz[0][0]);

    return 0;
}

void maxandmin(const int sz[][Y], const int x, const int y)
{
    int sum_max, sum_min;
    int i, j;                           //循环变量

    sum_max = sum_min = sz[0][0];       //设定最大,最小数的初值

    for (i = 0; i < x; i++)             //遍历数组,找出最大值和最小值
        for (j = 0; j < y; j++)
        {
            if (sz[i][j] > sum_max)
                sum_max = sz[i][j];
            if (sz[i][j] < sum_min)
                sum_min = sz[i][j];
        }

    printf("max = %d , min = %d\n", sum_max, sum_min);
}

/* 二维数组练习:二

 * 在上下对齐的数中用大数减小数并输出

 * 15  13  16  11  8  14  12  17  16  14

 *  8   9   7   7  3   8   9   9   8   7

 *
*/

#include <stdio.h>

#define X 2
#define Y 10

void sub(const int [][Y], const int, const int);

int main(void)
{
    const int arr[X][Y] = {
                            {15, 13, 16, 11, 8, 14, 12, 17, 16, 14},
                            {8, 9, 7, 7, 3, 8, 9, 9, 8, 7}
                          };

    sub(arr, sizeof arr / sizeof arr[0], sizeof arr[0] / sizeof arr[0][0]);

    return 0;
}

void sub(const int arr[][Y], const int x, const int y)
{
    int i, j;   //循环变量
    int diff[Y];    //存储差的数组

    for(j = 0; j < y; j++)
        for(diff[j] = 0, i = x - 1; i >= 0; i--)
            diff[j] = arr[i][j] - diff[j];

    for(i = 0; i < y; i++)
        printf("%d ", diff[i]);

    return;
}

核心部分进位控制没写出来...我自己是用了个判断,当数组中某位大于1000的时候才进位... 算法没想明白,结果总是在中间多几个0..

参考了版主的进位控制...

/*精确计算100!*/

#include <stdio.h>

#define NUM 100     //求100!
#define MAX 3000    //保存阶乘结果的数组最大位数

void fac();    //计算大数阶乘

int main(void)
{
    fac();
    return 0;
}

void fac()
{
    int i, j;                       //循环变量
    unsigned short arr[MAX] = {1};    //保存结果的数组

    for(i = 2; i <= NUM; i++)       //被乘数从2 到 100
    {
        for(j = 0; j < MAX; j++)    //用 i 与数组中每一个数据相乘
                arr[j] = i * arr[j];

        for(j = 0; j < MAX; j++)    //进位控制
        {
            arr[j + 1] += arr[j] / 10;  // arr[j] 大于十时,向前进位
            arr[j] = arr[j] % 10;       //进位后,arr[j]保留个位
        }
    }

    for (i = MAX - 1; i >= 0; i--)  //判断数组下标边界
        if(arr[i])
            break;

    printf("结果共 %d 位, 100! = ", i);

    for(; i >= 0; i--)              //打印结果
        printf("%u", arr[i]);

    printf("\n");

    return;
}

[ 本帖最后由 Ryker 于 2013-4-27 14:34 编辑 ]