回 帖 发 新 帖 刷新版面

主题:入门必做的题

1.  给定等式  A B C D E     其中每个字母代表一个数字,且不同数字对应不
                    D F G     同字母。编程求出这些数字并且打出这个数字的
             +      D F G     算术计算竖式。

             ───────

                X Y Z D E



  2. A、B、C、D、E五名学生有可能参加计算机竞赛,根据下列条件判断哪些
  人参加了竞赛:

   (1)A参加时,B也参加;

   (2)B和C只有一个人参加;

   (3)C和D或者都参加,或者都不参加;

   (4)D和E中至少有一个人参加;

   (5)如果E参加,那么A和D也都参加。



  3. 打印一个 N*N 的方阵,N为每边           N=15  打印出下面图形
 字符的个数(3<N<20), 要求最               TTTTTTTTTTTTTTT
 外一层为"T", 第二层为"J", 从第三层               TJJJJJJJJJJJJJT
 起每层依次打印数字 1,2,3,...                     TJ11111111111JT
 (右图以N为15为例)                           TJ12222222221JT
                                                  TJ12333333321JT
                                                  TJ12344444321JT
                                                  TJ12345554321JT
                                                  TJ12345654321JT
                                                  TJ12345554321JT
                                                  TJ12344444321JT
                                                  TJ12333333321JT
                                                  TJ12222222221JT
                                                  TJ11111111111JT
                                                  TJJJJJJJJJJJJJT
                                                  TTTTTTTTTTTTTTT



  4. 在N行N列的数阵中, 数K(1〈=K〈=N)在每行和每列中出现且仅
  出现一次,这样的数阵叫N阶拉丁方阵。例如下图就是一个五阶拉丁方阵。
  编一程序,从键盘输入N值后,打印出所有不同的N阶拉丁方阵,并统计个数。

        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


  5. 输入一个十进数,将其转换成 N 进制数(0<N<=16)。

回复列表 (共635个回复)

181 楼

希望有人能够把题目和好的答案整理一下,做成电子书格式,提供下载,给我们这些新手参考学习。

182 楼

ding

183 楼

22. 在一个4*4的小方格(如图所示)中放置8个*号,使得每行每列放且
 仅放两个*号。

          ┌─┬─┬─┬─┐
          │*│*│  │  │
          ├─┼─┼─┼─┤
          │*│  │*│  │
          ├─┼─┼─┼─┤
          │  │*│  │*│
          ├─┼─┼─┼─┤
          │  │  │*│*│
          └─┴─┴─┴─┘

 求出所有的基本解。


22.解:
#include<stdio.h>

static int M[4][4] = {0};
static int count;

void Print(void)
{
    printf("Answer #%d:\n", count);
    printf(    "┌─┬─┬─┬─┐\n"
            "│%2c│%2c│%2c│%2c│\n"
            "├─┼─┼─┼─┤\n"
            "│%2c│%2c│%2c│%2c│\n"
            "├─┼─┼─┼─┤\n"
            "│%2c│%2c│%2c│%2c│\n"
            "├─┼─┼─┼─┤\n"
            "│%2c│%2c│%2c│%2c│\n"
            "└─┴─┴─┴─┘\n",
            M[0][0], M[0][1], M[0][2], M[0][3],
            M[1][0], M[1][1], M[1][2], M[1][3],
            M[2][0], M[2][1], M[2][2], M[2][3],
            M[3][0], M[3][1], M[3][2], M[3][3]);
    printf("\n");
}

void Solve(int line)
{
    int i,j,k,c;
    if( line == 4 )
    {
        ++count;
        Print();
        return;
    }
    for(i=0; i<4; ++i)
    {
        /* 检查同一列'*'是否多于2个 */
        c = 0;
        for(k=0; k<line; ++k)
            if(M[k][i])
                ++c;
        if( c>=2 )
            continue;
        /* 在第line行第i列放置'*'号 */
        M[line][i] = '*';
        for(j=i+1; j<4; ++j)
        {
            /* 检查同一列'*'是否多于2个 */
            c = 0;
            for(k=0; k<line; ++k)
                if(M[k][j])
                    ++c;
            if( c>=2 )
                continue;
            /* 在第line行第j列放置'*'号 */
            M[line][j] = '*';
            Solve(line+1);
            M[line][j] = 0;
        }
        M[line][i] = 0;
    }
}

int main(void)
{
    count = 0;
    Solve(0);
    return 0;
}

184 楼

23. (覆盖问题) 有边长为N(N为偶数)的正方形,请你用N^2/2个长为2,
 宽为1的长方形,将它全部覆盖。编程打印出所有覆盖方法。如:N=4

    ┌─┬──┬─┐            ┌──┬──┐
    │  │    │  │ 1224   │    │    │  1122
    │  ├──┤  │            ├──┼──┤
    │  │    │  │ 1334   │    │    │  3344
    ├─┼──┼─┤            ├──┼──┤
    │  │    │  │ 5668   │    │    │  5566
    │  ├──┤  │            ├──┼──┤
    │  │    │  │ 5778   │    │    │  7788
    └─┴──┴─┘            └──┴──┘


23、解答:(对题目有所扩展,本来要求是边长为a的正方形,我做了面积为a*b的长方形)
#include<stdio.h>

#define Max 20

static int a,b;
static int count;
static int M[Max][Max];

/* 函数Print */
/* 输出一组结果 */
void Print(void)
{
    static char *str[] = {"⊙","↓","↑","→","←","错误"};
    int i,j;
    printf("Answer #%d:\n", count);
    for(i=0; i<a; ++i)
    {
        for(j=0; j<b; ++j)
            printf("%s", str[ M[i][j] ]);
        printf("\n");
    }
    printf("\n");
}

/* 定义枚举常量 */
enum JoinKind    {    NotUsed=0,JoinUp=1, JoinDown=2, JoinLeft=3, JoinRight=4    };

/* FindNextPosition */
/* 找到下一个可用的位置,由于C语言不直接支持引用,采用宏实现 */
#define FindNextPosition(i,j)                \
do{                                            \
    int found = 0;                            \
    for( ; j<b; ++j)                        \
        if(M[i][j]==NotUsed)                \
            break;                            \
    if(j==b)                                \
    {                                        \
        for(++i; i<a; ++i)                    \
        {                                    \
            for(j=0; j<b; ++j)                \
                if(M[i][j]==NotUsed)        \
                {    found = 1;break;    }    \
            if(found)break;                    \
        }                                    \
    }                                        \
}while(0)

/* Solve */
/* 递归求解 */
void Solve(int i, int j, int remain)
{
    if( remain == 0 )
    {
        ++count;
        Print();
        //printf("%d\n", count);
        return;
    }
    if( j<b-1 && M[i][j+1]==NotUsed )
    {
        int tmp_i = i;
        int tmp_j = j;
        M[i][j] = JoinRight;
        M[i][j+1] = JoinLeft;
        FindNextPosition(tmp_i,tmp_j);
        Solve(tmp_i,tmp_j,remain-2);
        M[i][j] = M[i][j+1] = 0;
    }
    if( i<a-1 && M[i+1][j]==NotUsed )
    {
        int tmp_i = i;
        int tmp_j = j;
        M[i][j] = JoinDown;
        M[i+1][j] = JoinUp;
        FindNextPosition(tmp_i,tmp_j);
        Solve(tmp_i,tmp_j,remain-2);
        M[i][j] = M[i+1][j] = 0;
    }
}

int main(void)
{
    int i,j;
    scanf("%d%d", &a, &b);
    for(i=0; i<a; ++i)
        for(j=0; j<b; ++j)
            M[i][j] = 0;
    count = 0;
    Solve(0,0,a*b);
    printf("\nTotal Answer: %d.\n", count);
    return 0;
}

185 楼

看得头晕晕得

186 楼

24. 某地街道把城市分割成矩形方格,每一方格叫作块,某人从家中出发上班,
 向东要走M块,向北要走N块,(见图)。请设计一个程序,由计算机寻找并
 打印出所有的上班的路径。

                                               单位

           ┬   ┌─┬─┬─┬─┬─┬─┬─┐
           │   │  │  │  │  │  │  │  │
           │   ├─┼─┼─┼─┼─┼─┼─┤
           ↓   │  │  │  │  │  │  │  │
           N   ├─┼─┼─┼─┼─┼─┼─┤
           ↑   │  │  │  │  │  │  │  │
           │   ├─┼─┼─┼─┼─┼─┼─┤
           │   │  │  │  │  │  │  │  │
           ┴   └─┴─┴─┴─┴─┴─┴─┘
           家   ├─────→M←─────┤

24.解答:
向上一共要走N步,向左一共要走M步。所以,总的步数是M+N。总的方法数是:
C(N, M+N)。即在M+N个元素中取N个的方法数。
另一方面,我们有C(k,N) = C(k,N-1)+C(k-1,N-1)和C(0,N)=1,所以要计算总的方法数是比较容易的。
如果需要求具体路径,则由于路径的条数很多,如果M和N比较大,则可能需要很长时间。
程序代码:

#include<stdio.h>

#define MAX 100

enum Step_Type {Up=1, Right=2};
typedef enum Step_Type step_t;

static int M;
static int N;
static int Count;
static step_t Steps[MAX];

void Print()
{
    int i,j,k;
    static char *map[MAX+1][MAX+1];

    printf("Answer #%d:\n", Count);

    /* i: 从0到N,表示行,0表示最上一行 */
    /* j: 从0到M,表示列,0表示最左一列 */
    for(i=0; i<=N; ++i)
        for(j=0; j<=M; ++j)
            map[i][j] = "  ";
    map[0][M] = "⊙";
    i = N;
    j = 0;
    for(k=0; k<M+N; ++k)
    {
        switch(Steps[k])
        {
        case Up:
            map[i][j] = "↑";
            --i;
            break;
        case Right:
            map[i][j] = "→";
            ++j;
            break;
        }
    }
    for(i=0; i<=N; ++i)
    {
        for(j=0; j<=M; ++j)
            printf("%s", map[i][j]);
        printf("\n");
    }
    printf("\n");
}

void Go(int x, int y, int step)
{
    if( x==M && y==N )
    {
        ++Count;
        Print();
        return;
    }
    if( x<M )    /* 向右走 */
    {
        Steps[step] = Up;
        Go(x+1, y, step+1);
    }
    if( y<N )    /* 向上走 */
    {
        Steps[step] = Right;
        Go(x, y+1, step+1);
    }
}

int main(void)
{
    scanf("%d%d", &M, &N);
    if( M+N > MAX )
    {
        printf("Error! M or N too large.\n");
        return 1;
    }
    Count = 0;
    Go(0,0,0);
    return 0;
}

187 楼

很不错的哦 ~~~~~~真是好帖,不顶不行啊~~~~

188 楼

牛呀 

189 楼

3. 打印一个 N*N 的方阵,N为每边           N=15  打印出下面图形
 字符的个数(3<N<20), 要求最               TTTTTTTTTTTTTTT
 外一层为"T", 第二层为"J", 从第三层               TJJJJJJJJJJJJJT
 起每层依次打印数字 1,2,3,...                     TJ11111111111JT
 (右图以N为15为例)                           TJ12222222221JT
                                                  TJ12333333321JT
                                                  TJ12344444321JT
                                                  TJ12345554321JT
                                                  TJ12345654321JT
                                                  TJ12345554321JT
                                                  TJ12344444321JT
                                                  TJ12333333321JT
                                                  TJ12222222221JT
                                                  TJ11111111111JT
                                                  TJJJJJJJJJJJJJT
                                                  TTTTTTTTTTTTTTT
新手来试一题~!
#include<stdio.h>
#define N 15
void main()
{ char number(int i);
  int a,i,j,t,k=0,i1=0,j1=0;
  int b[N][N];
  char ch[N][N],ch1;
  t=N;
  for(a=0;a<N/2+1;a++)
  { if(a>=1)
    {
      i1+=1;
      j1+=1;
      t-=1;}
    for(i=i1;i<t;i++)
      for(j=j1;j<t;j++)
      { if(a==0)
        ch[i][j]='T';
        else if(a==1)
               ch[i][j]='J';
             if(a>=2)
               ch[i][j]=number(a-1);}}

  for(i=0;i<N;i++)
   for(j=0;j<N;j++)
   { if(i>k)
     { k=i;
       printf("\n");}
     printf("%c",ch[i][j]);}
  getch();
}

char number(int i)
{
  switch(i)
  {
    case 1: return '1';
    case 2: return '2';
    case 3: return '3';
    case 4: return '4';
    case 5: return '5';
    case 6: return '6';
    case 7: return '7';
    case 8: return '8';
    case 9: return '9';}
}

190 楼

蛇行数

算法1
#include "stdio.h"
#include "conio.h"
#define N  7
void main()
{
    static int a[N][N];
    int i = 0,j = 0,num =2,t =-1;
    a[0][0] = 1;
    for(;num <= N*N;)
    {
        i -= t;
        j += t;
        if(i < 0 && j < N)
        {
            i++;
            t *= -1;
        }
        if(j < 0 && i < N)
        {
            j++;
            t *= -1;
        }
        if(i == N)
        {
            j+=2;
            i--;
            t *= -1;
        }
        if(j == N)
        {
            i+=2;
            j--;
            t *= -1;
        }
        else
            t *= 1;
        a[i][j] = num;
        num++;
    }
    for(i = 0;i < N;i++)
    {
        for(j = 0;j < N;j++)
            printf("%d\t",a[i][j]);
        printf("\n");
    }
    getch();
}

算法2
#include "stdio.h"
#define N 7
void main()
{
    int sum, j, t = 1;
    static int a[N][N];
    for(sum = 0; sum < 2*N -1; sum++)
        for(j = ((sum < N)?0:sum-(N-1)); j <= ((sum < N)?sum:(N-1)); 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");
    }
}

我来回复

您尚未登录,请登录后再回复。点此登录或注册