//////////////////////////////////////////////////////////////////////////////
//
//  2. Ａ、Ｂ、Ｃ、Ｄ、Ｅ五名学生有可能参加计算机竞赛，根据下列条件判断哪些
//  人参加了竞赛：
//   （１）Ａ参加时，Ｂ也参加；
//   （２）Ｂ和Ｃ只有一个人参加；
//   （３）Ｃ和Ｄ或者都参加，或者都不参加；
//   （４）Ｄ和Ｅ中至少有一个人参加；
//   （５）如果Ｅ参加，那么Ａ和Ｄ也都参加。
//////////////////////////////////////////////////////////////////////////////
//(4)&&(5)==>D=1  (6)
//(3)&&(6)==>C=1  (7)
//(7)&&(2)==>B=0  (8)
//设(A==1) 则(1)==>B=1  但是 (8)==>B==0 因此假设(A==1)不成立，故A==0  (9)
//设(E==1) 则(5)==>A=1  但是 (9)==>A==0 因此假设(E==1)不成立，故E==0  (10)
//综上可得： A=0, B=0, C=1, D=1, E=0
#include <stdio.h>
int main()
{
    printf("A=0, B=0, C=1, D=1, E=0");
    return 0;
}
//////////////////////////////////////////////////////////////////////////////
//
// 3. 打印一个 N*N 的方阵，Ｎ为每边           Ｎ＝１５  打印出下面图形
// 字符的个数（３＜Ｎ＜２０）, 要求最               TTTTTTTTTTTTTTT
// 外一层为"T", 第二层为"J", 从第三层               TJJJJJJJJJJJJJT
// 起每层依次打印数字 1,2,3,...                     TJ11111111111JT
// （右图以Ｎ为１５为例）                           TJ12222222221JT
//                                                  TJ12333333321JT
//                                                  TJ12344444321JT
//                                                  TJ12345554321JT
//                                                  TJ12345654321JT
//                                                  TJ12345554321JT
//                                                  TJ12344444321JT
//                                                  TJ12333333321JT
//                                                  TJ12222222221JT
//                                                  TJ11111111111JT
//                                                  TJJJJJJJJJJJJJT
//                                                  TTTTTTTTTTTTTTT
///////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#define N 15
void main()
{
    static char a[N][N], i, j, num;
    int start = 0, end = N -1;
    char str[] = "TJ12345678", ch;
    for(int t =0; t <= N/2; t++, start++, end--, i++, j++)
    {    
        ch = *(str + t);
        for(i = start; i < end; i++)
            a[i][j] = ch;
        for(j = start; j < end; j++)
            a[i][j] = ch;
        for(i = end; i > start; i--)
            a[i][j] = ch;
        for(j = end; j > start; j--)
            a[i][j] = ch;
        if(start == end)
            a[start][end] = ch;
    }
    for(i = 0; i < N; i++)
    {
        for(j = 0; j < N; j++)
            printf("%c", a[i][j]);
        printf("\n");
    }
}

//////////////////////////////////////////////////////////////////////////////
//
//  4. 在Ｎ行Ｎ列的数阵中, 数Ｋ（１〈＝Ｋ〈＝Ｎ）在每行和每列中出现且仅
//  出现一次，这样的数阵叫Ｎ阶拉丁方阵。例如下图就是一个五阶拉丁方阵。
//  编一程序，从键盘输入Ｎ值后，打印出所有不同的Ｎ阶拉丁方阵，并统计个数。
//
//        1  2  3  4  5
//        2  3  4  5  1
//        3  4  5  1  2
//        4  5  1  2  3
//        5  1  2  3  4
//////////////////////////////////////////////////////////////////////////////
#include "stdio.h"
#define  N  4

static int a[N][N], count;

bool legal(int row, int col)
{
    int i;
    for(i = 0; i < row; i++)
    {
        if(a[i][col] == a[row][col])
            return false;
    }
    for(i = 0; i < col; i++)
    {
        if(a[row][i] == a[row][col])
            return false;
    }
    return true;
}

void trial(int row, int col, FILE *fp)
{
    int i, j;
    if(row == N)
    {        
        printf("*********** %d **********\n", ++count);
        fprintf(fp, "*********** %d **********\n", count);
        for(i = 0; i < N; i++)
        {
            for(j = 0; j < N; j++)
            {
                printf("%5d", a[i][j]);
                fprintf(fp, "%5d", a[i][j]);
            }
            putchar(10);
            fputc(10, fp);
        }
    }
    for(i = 1; i <= N; ++i)
    {
        a[row][col] = i;
        if(legal(row, col))
            trial((row*N+col+1)/N, (row*N+col+1)%N, fp);
    }
}

void main()
{
    FILE *fp = fopen("latin.txt", "w");
    trial(0, 0, fp);
}

//////////////////////////////////////////////////////////////////////////////
//
//  5. 输入一个十进数，将其转换成 N 进制数（0<N<=16)。  
//////////////////////////////////////////////////////////////////////////////
//只能是整数型
#include "iostream.h"
#include "assert.h"
void convert(int, int);
void main()
{
    int num, carry;
    cout<<"input the decimal number and carry:";
    cin>>num>>carry;
    assert(carry <= 17);
    convert(num, carry);
}

void convert(int num, int carry)
{
    int *a = new int[100];
    int i = 0;
    cout<<"decimal value "<<num<<" convert to the value by the carry as "<<carry<<" is: ";
    while(num)
    {
        *(a+i) = num%carry;
        num   /= carry;
        i++;
    }
    while(--i >= 0)
        (*(a+i) < 10)?cout<<*(a+i):cout<<(char)(55+*(a+i));
    cout<<endl;
}

//////////////////////////////////////////////////////////////////////////////
//
//6. 矩阵中填数. 当给出 N*N 的矩阵，要求用程序填入下列形式的数：
//   ① 倒填，例如N=5             ② 蛇形填数              ③ 回转填数
//
// ┌─┬─┬─┬─┬─┐   ┌─┬─┬─┬─┬─┐   ┌─┬─┬─┬─┬─┐
// │25│24│23│22│21│   │ 1│ 3│ 4│10│11│   │ 1│16│15│14│13│
// ├─┼─┼─┼─┼─┤   ├─┼─┼─┼─┼─┤   ├─┼─┼─┼─┼─┤
// │20│19│18│17│16│   │ 2│ 5│ 9│12│19│   │ 2│17│24│23│12│
// ├─┼─┼─┼─┼─┤   ├─┼─┼─┼─┼─┤   ├─┼─┼─┼─┼─┤
// │15│14│13│12│11│   │ 6│ 8│13│18│20│   │ 3│18│25│22│11│
// ├─┼─┼─┼─┼─┤   ├─┼─┼─┼─┼─┤   ├─┼─┼─┼─┼─┤
// │10│ 9│ 8│ 7│ 6│   │ 7│14│17│21│24│   │ 4│19│20│21│10│
// ├─┼─┼─┼─┼─┤   ├─┼─┼─┼─┼─┤   ├─┼─┼─┼─┼─┤
// │ 5│ 4│ 3│ 2│ 1│   │15│16│22│23│25│   │ 5│ 6│ 7│ 8│ 9│
// └─┴─┴─┴─┴─┘   └─┴─┴─┴─┴─┘   └─┴─┴─┴─┴─┘
//////////////////////////////////////////////////////////////////////////////
// 6.1
#include "stdio.h"
void main()
{
    int n, i, j;
    scanf("%d", &n);
    int t = n*n;
    for(i = n; i > 0; i--)
    {
        for(j = n; j > 0; j--)
            printf("%5d", t--);
        printf("\n");
    }
}

// 6.2
#include "stdio.h"
#define N 15
void main()
{
    int sum, j, t = 1, start, end;
    static int a[N][N];
    for(sum = 0; sum < 2*N -1; sum++)
    {
        start = (sum < N)?0:sum-(N-1);
        end   = (sum < N)?sum:(N-1);
        for(j = start; j <= end; j++)
            (sum%2)?(a[j][sum-j] = t++):(a[sum-j][j] = t++);  //(sum%2)控制环绕方向
    }
    for(sum = 0; sum < N; sum++)
    {
        for(j = 0; j < N; j++)
            printf("%5d", a[sum][j]);
        printf("\n");
    }
}

// 6.3
#include <stdio.h>
#define elem a[i][j] //用于控制方向， 若改为a[j][i]， 则方向相反
#define N 10
void main()
{
    static int a[N][N], i, j, num;
    int start = 0, end = N -1;
    for(int t =0; t <= N/2; t++, start++, end--, i++, j++)
    {    
        for(i = start; i < end; i++)
            a[i][j] = ++num;
        for(j = start; j < end; j++)
            a[i][j] = ++num;
        for(i = end; i > start; i--)
            a[i][j] = ++num;
        for(j = end; j > start; j--)
            a[i][j] = ++num;
        if(start == end)
            a[start][end] = ++num;
    }
    for(i = 0; i < N; i++)
    {
        for(j = 0; j < N; j++)
            printf("%4d", elem);
        printf("\n");
    }
}

//////////////////////////////////////////////////////////////////////////////
//
//  7. 读入一行文本，包含若干个单词（以空格间隔，％结尾）。将其中以 A 开头的
//  单词与以 N 结尾的单词，用头尾交换的办法予以置换。
//  
//    i am  a student what about you region code modern%
//    i ma  a student what tboua you negior code noderm%
//////////////////////////////////////////////////////////////////////////////
#include "stdio.h"
void main()
{
    char str[] = "i am  a student what about you region code modern%";
    char *p, *q, temp;
    p = q = str;
    while(*p != '%')
    {
        if(*p == ' ')
            while(*p == ' ')
                printf("%c", *p++);
        q = p;
        while(*p != ' ' && *p != '%')
            p++;
        if(*q == 'a' || *(p-1) == 'n')
        {
            temp   = *q;
            *q     = *(p-1);
            *(p-1) = temp;
        }
        while(q != p)
            printf("%c", *q++);
    }
}

//////////////////////////////////////////////////////////////////////////////
//
//  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]);
}

///////////////////////////////////////////////////////////////////////////////
//
//  9. 四人玩火柴棍游戏，每一次都是三个人赢，一个人输。输的人要按赢者手中的火柴
//  数进行赔偿，即赢者手中有多少根火柴棍，输者就赔偿多少根。现知道玩过四次后，
//  每人恰好输过一次， 而且每人手中都正好有１６根火柴。问此四人做游戏前手中各有
//  多少根火柴? 编程解决此问题。
///////////////////////////////////////////////////////////////////////////////
#include "iostream.h"
#include "iomanip.h"
void main()
{
    int a[4] = {16, 16, 16, 16};
    int i, j;
    for(i = 0; i < 4; i++)
    {
        for(j = 0; j < 4; j++)
        {
            if(j != i)
            {
                a[j] /=2;
                a[i] += a[j];
            }
        }
    }

    cout<<"In the begining:"<<endl;
    for(i = 0; i < 4; i++)
    {
        cout<<(char)(65+i)<<" has "<<setw(3)<<a[i]<<
            " matches, and lost at round "<<4-i<<endl;
    }
}

//////////////////////////////////////////////////////////////////////////////
//
// 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);
}

//////////////////////////////////////////////////////////////////////////////
//
// 11. 巧排数字。将１、２、．．．、２０这２０个数排成一排，使得相邻的两个数之
//     和为一个素数，且首尾两数字之和也为一个素数。编程打印出所有的排法。
//////////////////////////////////////////////////////////////////////////////
#include "stdio.h"
#include "math.h"

static used[21], link[21];
bool isprime(int a)
{
    for(int i = 2; i <= sqrt(a); i++)
    {
        if(!(a%i))
            return false;
    }
    return true;
}

void trace(int node)
{
    int i;
    if((node == 21) && isprime(link[20] + link[1]))
    {
        for(i = 1; i < 21; i++)
            printf("%4d", link[i]);
        putchar(10);
    }
    for(i = 1; i <= 20; i++)
    {
        if(!used[i])
        {
            link[node] = i;
            used[i] = 1;
            if(isprime(link[node]+link[node-1]))
                trace(node+1);
            used[i] = 0;
        }
    }
}

void main()
{
    trace(1);
}

//////////////////////////////////////////////////////////////////////////////
//
// 13. 有N个硬币（N为偶数）正面朝上排成一排，每次将 N-1 个硬币翻过来放在原位
// 置， 不断地重复上述过程，直到最后全部硬币翻成反面朝上为止。编程让计算机把
// 翻币的最简过程及翻币次数打印出来（用＊代表正面，O 代表反面）。
//////////////////////////////////////////////////////////////////////////////
#include "stdio.h"
#include "assert.h"
#include "string.h"
#define  N  10

void main()
{
    assert(!(N%2));
    bool s[N];
    int i, j;
    for(j = 0; j < N; j++)
    {
        s[j] = true;
        printf("%3c", '*');
    }
    printf("\n");        
    for(i = 0; i < N; i++)
    {
        for(j = 0; j < N; j++)
        {
            if(j != i)
                s[j] = !s[j];
            printf("%3c", s[j]?'*':'0');
        }
        printf("\n");
    }
}