//////////////////////////////////////////////////////////////////////////////
//
//  8. 输入两个正整数Ｘ，Ｙ，将Ｘ，Ｙ化为二进制数，然后将这两个二进制数作二进
//   制加法运算，再将结果化为十进制数输出。
//////////////////////////////////////////////////////////////////////////////
/*
#include "stdio.h"
#include "math.h"
#define N 18

void dtob(unsigned int, int*, char*);
unsigned int  btod(int*);
void badd(int*, int*, int*);
void show(int*, char*);

void main()
{
    unsigned int x, y;
    static int xb[N], yb[N], resultb[N], i;
    printf("input the decimal value X and Y:");
    scanf("%d %d", &x, &y);
    dtob(x, xb, "X");
    dtob(y, yb, "Y");
    badd(xb, yb, resultb);
    printf("\nResult convert to be decimal is:%4d\n", btod(resultb));
}

void dtob(unsigned int n, int *nb, char *s)
{
    int i = N;
    while(n)
    {
        nb[--i] = n & 1;
        n >>= 1;
    }

    nb[--i] = -1;
    show(nb, s);
}

void badd(int *xb, int *yb, int *resultb)
{
    int i = 0;
    while(xb[i] != -1 && yb[i] != -1)
        i++;
    resultb[i++] = -1;
    for(; i < N; i++)
    {
        if(xb[i] == -1)
            resultb[i] = yb[i];
        else if(yb[i] == -1)
            resultb[i] = xb[i];
        else
            resultb[i] = xb[i] + yb[i];
    }

    for(i = N; resultb[i] != -1; i--)
    {
        if(resultb[i] > 1)
        {
            resultb[i] %= 2;
            if(resultb[i-1] == -1)
            {
                resultb[i-1] = 1;
                resultb[i-2] = -1;
            }
            else
                resultb[i-1] += 1;
        }
    }

    show(resultb, "Result");
}

unsigned int btod(int* nb)
{
    static unsigned int i, sum;
    for(; nb[i] != -1; i++);
    for(++i; i < N; i++)
        sum += nb[i]*(int)pow(2, N-1-i);
    return sum;
}

void show(int *nb, char *s)
{
    int i;
    printf("\n%s\t= ", s);
    for(i = 0; nb[i] != -1; i++);
    for(++i; i < N; i++)
        printf("%d", nb[i]);
}
*/

刚学，一个都不会；不过我会努力的。

//////////////////////////////////////////////////////////////////////////////
//
// 17. 编写一个程序，当输入不超过６０个字符组成的英文文字时，计算机将这个句子
// 中的字母按英文字典字母顺序重新排列，排列后的单词的长度要与原始句子中的长度
// 相同。例如：
//
//    输入：
//
//    ＴＨＥ ＰＲＩＣＥ ＯＦＢＲＥＡＤ ＩＳ ￥１ ２５ ＰＥＲ ＰＯＵＮＤ
//
//    输出：
//
//    ＡＢＣ ＤＤＥＥＥ ＥＦＨＩＩＮＯ ＯＰ ￥１ ２５ ＰＰＲ ＲＲＳＴＵ
//
// 并且要求只对Ａ到Ｚ的字母重新排列，其它字符保持原来的状态。
//////////////////////////////////////////////////////////////////////////////
/*
#include "stdio.h"
#include "ctype.h"
#include "string.h"
#define  MAX  60

void main()
{
    char str[MAX]  = " THE PRICE OFBREAD IS $1 25 PER POUND", *p, *q, temp;   
    int len = strlen(str);
    for(p = str; p < str+len-1; p++)
    {
        for(q = p; q < str+len; q++)
        {
            if(!isalpha(*q))
                continue;
            if(*p > *q)
            {
                temp = *p;
                *p   = *q;
                *q   = temp;
            }
        }
    }
    printf("%s\n", str);
}

虽然我还没学完C语言！但看了你的帖我对C越来越感兴趣了！
呵呵！谢谢啊
[em3]

//////////////////////////////////////////////////////////////////////////////
//
// 10. 如图１所示，编写程序计算               ┎┰┰┰┰┰┰┰┰┰┒
//    大大小小正方形共有多少？当最小          ┠╂╂╂╂╂╂╂╂╂┨
//    正方行边长为１时，它们的总面积          ┠╂╂╂╂╂╂╂╂╂┨
//    共为多少？                              ┠╂╂╂╂╂╂╂╂╂┨
//                                            ┠╂╂╂╂╂╂╂╂╂┨
//                                            ┠╂╂╂╂╂╂╂╂╂┨
//                                            ┠╂╂╂╂╂╂╂╂╂┨
//                                            ┠╂╂╂╂╂╂╂╂╂┨
//                                            ┠╂╂╂╂╂╂╂╂╂┨
//                                            ┠╂╂╂╂╂╂╂╂╂┨
//                                            ┖┸┸┸┸┸┸┸┸┸┚ 
/////////////////////////////////////////////////////////////////////////////

// 依次以每个小正方形为右上角，该小正方形（数组元素）的内容为所有符合条件的正方形个数
#include "stdio.h"
#define N  10

void main()
{
    static int a[N][N];
    int i, j, k, num, count = 0, area = 0;
    for(i = 0; i < N; i++)
    {
        for(j = 0, num = 0; j < N; j++)
        {
            a[i][j] = (num > N-i-1)?num :++num;
            printf("%4d", a[i][j]);
            count += a[i][j];
            for(k = 1; k <= a[i][j]; k++)
                area += k*k; 
        }
        putchar('\n');
    }

    printf("count = %d, total area = %d\n", count, area);
}/*
结果：
   1   2   3   4   5   6   7   8   9  10
   1   2   3   4   5   6   7   8   9   9
   1   2   3   4   5   6   7   8   8   8
   1   2   3   4   5   6   7   7   7   7
   1   2   3   4   5   6   6   6   6   6
   1   2   3   4   5   5   5   5   5   5
   1   2   3   4   4   4   4   4   4   4
   1   2   3   3   3   3   3   3   3   3
   1   2   2   2   2   2   2   2   2   2
   1   1   1   1   1   1   1   1   1   1

count= 385，total area= 5368

以元素a[0][9]为例， 以该小正方形为右上角的正方形个数为10，这些正方形的面积之和为
1^2 + 2^2 + 3^2 +.......+10^2

    ┌─┬─┬─┬─┬─┐
    │ 1│ 3│ 4│10│11│   
    ├─┼─┼─┼─┼─┤   
    │ 2│ 5│ 9│12│19│   
    ├─┼─┼─┼─┼─┤   
    │ 6│ 8│13│18│20│   
    ├─┼─┼─┼─┼─┤   
    │ 7│14│17│21│24│   
    ├─┼─┼─┼─┼─┤   
    │15│16│22│23│25│   
    └─┴─┴─┴─┴─┘   
蛇形填数:
#include <iostream>
using namespace std;
main()
{
    int number=1;
    int xunhuan=1;
    int i=0,j=0;
    int arr[100][100];
    int N;
    int n;
    int extra=0;
    int tmp;

    cin>>N;
    n=N*2;
    while(xunhuan<n)
    {
        if(xunhuan>N)
        {
            extra++;
        }
        tmp=xunhuan-extra*2;
        while(i<tmp)
        {
            j=xunhuan-1-extra-i;
            if(xunhuan&1)
                arr[i+extra][j]=number++;
            else
                arr[j][i+extra]=number++;
            i++;
        }
        xunhuan++;
        i=0;
    }
    for(i=0;i<N;i++)
    {
        for(j=0;j<N;j++)
            printf("%5d",arr[i][j]);
        cout<<endl;
    }
    
}

//////////////////////////////////////////////////////////////////////////////
//
// 41. (合并链表) 已知两个链表 AN={a1,a2,...an}, BN={b1,b2,...bm}, 将其合并
// 为一个链表 CN={a1,b1,a2,b2,...}
//////////////////////////////////////////////////////////////////////////////

#include "stdio.h"
#include "malloc.h"
struct node
{
    int data;
    node* next;
};

node* create(char ch)
{
    node *p, *q, *head =NULL;
    int i,n;
    printf("\ninput the size of link %c:", ch);
    scanf("%d", &n);
    printf("\ninput the data's value of each element of link:\n");
    p = head = (node *)malloc(sizeof(node));
    for(i = 0;i < n; i++)
    {
        scanf("%d", &p->data);    
        p->next = (node *)malloc(sizeof(node));
        q = p;
        p = p->next;
    }
    q->next = NULL;
    return head;
}

void print(node *head)
{
    node *s = head;
    while(s)
    {
        printf("%5d", s->data);
        s = s->next;
    }
    printf("\n");
}

node* combine(node *la, node *lb)
{
    node *p = la, *q = lb;
    node *tp, *tq, *temp;
    while(p && q)
    {
        tp      = p->next;
        tq      = q->next;
        p->next = q;
        q->next = tp;
        temp    = q;
        p       = tp;
        q       = tq;
    }
    temp->next = (q)? q :p;
    return la;
}
void main()
{
    node *la, *lb;
    la = create('A');
    printf("\nlink A is:");
    print(la);
    lb = create('B');
    printf("\nlink B is:");
    print(lb);
    printf("\nafter combined, the link  is:");
    print(combine(la, lb));
}

////////////////////////////////////////////////////////////////////////////////
//
// 43. 44. (一元多项式加法) 实现两个整系数一元多项式的加法与乘法。例如, 对于多项式
//     5*X^6＋4*X^3－7*X^4＋1 与多项式 50*X^2＋4*X, 运算结果为：
//                   5*X^6－7*X^4＋4*X^3＋50*X^2＋4*X＋1。
//                   250*x^8+20*x^7-350*x^6+172*x^5+16*x^4+50*x^2+4*x
//
//     程序要求：键盘输入多项式的各项系数及指数，每项系数及指数为一组数据（系
//     数及指数之一可为零），以'0 0'结束一个多项式的输入，结果按降幂排列，同类
//     项要合并（指数最大不超过３０）。
//
//     上例第一式的输入为：    5 6
//                             4 3
//                            -7 4
//                             1 0
//                             0 0
//     输出结果应为：5*x^6-7*x^4+4*x^3+50*x^2+4*x+1.
//                   250*x^8+20*x^7-350*x^6+172*x^5+16*x^4+50*x^2+4*x.
////////////////////////////////////////////////////////////////////////////////

#include "stdio.h"
#include "malloc.h"
#include "memory.h"
#include "process.h"
typedef struct node
{
    int coe;
    int exp;
    node *next;
}node;

typedef struct
{
    int coe;
    int exp;
}elem;

typedef struct link
{
    node *head, *tail;
    int length;
}link;

bool initial(link &l)
{
    if(!(l.head = (node *)malloc(sizeof(node))))
        return false;
    l.tail = l.head;
    l.length = 0;
    return true;
}

void makenode(link &l, int coe, int exp)
{
    l.tail->next = (node *)malloc(sizeof(node));
    l.tail = l.tail->next;
    l.tail->coe  = coe;
    l.tail->exp  = exp;
    l.tail->next = NULL;
    ++l.length;
}

void print(link l)
{
    node *p = l.head->next;
    char *s;
    if(!p)
        return;    
    while(p)
    {
        s = (p == l.head->next)? ""
            :((p->coe > 0)?" +":" ");
        if(p->coe == 1)
        {
            if(p->exp == 1)
                printf("%sx", s);
            else if(p->exp == 0)
                printf("%s%d", s, p->coe);
            else
                printf("%sx^%d", s, p->exp);            
        }
        else
        {
            if(p->exp == 1)
                printf("%s%d*x", s, p->coe);
            else if(p->exp == 0)
                printf("%s%d", s, p->coe);
            else
                printf("%s%d*x^%d", s, p->coe, p->exp);
        }

        p = p->next;
    }
    printf("\t length = %d\n", l.length);
}

void create(link &l, char *s)
{
    int coe, exp;
    printf("\ninput the coefficient and exponential of the %s polynomial:\n", s);
    scanf("%d %d", &coe, &exp);
    while(coe)
    {
        makenode(l, coe, exp);
        scanf("%d %d", &coe, &exp);
    }
    printf("the %s polynomial is :\n", s);
    print(l);
}

void sort(elem *a, int size)
{
    elem *p, *q, temp;
    for(p = a; p< a +size -1; p++)
        for(q = p; q < a +size; q++)
            if(q->exp > p->exp)
            {
                temp = *q;
                *q   = *p;
                *p   = temp;
            }
}

void combine(elem *a, int size)
{
    int i, j, t;
    for(i = 0; i < size; i+= ++t)
    {
        for(j = i+1, t = 0; a[j].exp == a[i].exp && j < size; j++, t++)
        {
            a[i].coe += a[j].coe;
            a[j].coe =  0;
        }
    }
}

void clearlink(link &l)
{
    node *p = l.head->next, *temp;
    while(p)
    {
        temp = p->next;
        free(p);
        p    = temp;
    }
    l.length = 0;
    l.head->next = NULL;
    l.tail = l.head;
}

void tidy(link &l)
{
    int size = l.length, i;
    elem *a  = new elem[size];
    memset(a, 0, size*sizeof(elem));

    node *p = l.head->next;
    for(i = 0; p; i++, p = p->next)
    {
        a[i].coe = p->coe;
        a[i].exp = p->exp;
    }

    sort(a, size);
    combine(a, size);
    clearlink(l);

    for(i = 0; i < size; i++)
    {
        if(a[i].coe == 0)
            continue;
        makenode(l, a[i].coe, a[i].exp);
    }
}
void multiply(link la, link lb)
{
    node *p, *q;
    link lc;
    if(!initial(lc))
    {
        printf("Initial false...\n");
        exit(-1);
    }

    for(p = la.head->next; p; p = p->next)
    {
        for(q = lb.head->next; q; q = q->next)
            makenode(lc, p->coe *q->coe, p->exp +q->exp);
    }
    printf("\nthe multi-polynomial is :\n");
    tidy(lc);
    print(lc);
    clearlink(lc);
}

void merge(link &la, link &lb)
{
    node *p;
    link lc;
    if(!initial(lc))
    {
        printf("Initial false...\n");
        exit(-1);
    }

    for(p = la.head->next; p; p = p->next)
        makenode(lc, p->coe, p->exp);
    for(p = lb.head->next; p; p = p->next)
        makenode(lc, p->coe, p->exp);
    printf("\nthe merge-polynomial is :\n");
    tidy(lc);
    print(lc);
    clearlink(lc);
}

void main()
{
    link la, lb;
    if(!initial(la) || !initial(lb))
    {
        printf("Initial false...\n");
        exit(-1);
    }
    create(la, "first");
    create(lb, "second");
    merge(la, lb);
    multiply(la, lb);
}

要是有个最简洁的代码,供参考就好了!