2012年华为杯校园编程大赛决赛 类别：软件C/C++语言

最新推荐文章于 2016-09-16 18:50:24 发布
最新推荐文章于 2016-09-16 18:50:24 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 面试题 c++ 文章标签： 编程 华为 graph c function 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zqt520/article/details/7974446
版权

2012年华为杯校园编程大赛决赛

类别：软件C/C++语言

 

 

编程题（共1题，100分。请上机编写程序，按题目要求提交文件。测试用例不对考生公开，凡不满足提交要求导致不能运行或用例不通过，不予评分。）

1.       俄罗斯方块之棋盘覆盖

俄罗斯方块是一款风靡全球的益智类游戏。由俄罗斯人阿列克谢·帕基特诺夫发明，故得此名。俄罗斯方块的基本规则是移动、旋转和摆放游戏自动输出的各种方块，使之排列成完整的一行或多行并且消除得分。由于上手简单、老少皆宜，从而家喻户晓，风靡世界。

本试题是在俄罗斯方块几种常见的方块基础上，在指定大小和障碍的棋盘上，用标准的方块形状，完成对棋盘的覆盖。用于覆盖棋盘的方块可以是下文所给出方块的全集，也可以是其中的任意一个子集，且使用的方块数量不限，形状变化不限。

l 棋盘大小：

棋盘大小为21行21列的正方形。按照从上到下，从左到右，从1开始，依次进行编号，直到最右下方的格子标识为441。

l 可选方块：

可选方块为标准的俄罗斯方块形状，包括其标准的旋转变化。基本形状如图所示：

各形状的变化如图所示（字母为方块编号）：

a          b

 

c   d

e          f

g

l 障碍说明：

棋盘上仅有一处障碍无法放置方块，障碍可处于棋盘任意位置。障碍为基本形状a及其所有的旋转变化，如图所示：

 

l 输入输出要求：

输入文件名为testin.txt，格式如下所示，各数字用空格隔开，各数字表示棋盘格子编号。

2 3 22 23

该输入表示障碍位于棋盘的左上角。

输出文件名为testout.txt，要求先输出棋盘覆盖结果，再输出未覆盖的格子个数。输出棋盘用21行21列数字/字母表示，其中0表示未覆盖的格子，1表示障碍，字母表示对应方块编号（字母对应关系见“可选方块”一节）。最后输出未覆盖格子个数。这里以6行10列棋盘举例示意输出格式（注意：实际输出应该是21行21列，对应方块形状用对应的字母表示）：

0 e 0 0 0 0 f f f f

e e 0 0 0 1 1 g g g

e 0 0 0 1 1 0 0 0 g

a 0 0 0 c 0 d d 0 0

a a 0 0 c 0 d d b 0

0 a 0 0 c c 0 b b b

28

l 要求：

1、 用所提供的方块尽可能覆盖棋盘并输出结果；

2、 在（1）的基础上，棋盘上的空格越少越好。

l 交付件要求

C/C++：需要提交可执行文件和压缩打包的源代码工程

JAVA：需要提交压缩打包的整个编码工程目录

 

#include <fstream>
#include <iostream>
using namespace std;

/*******************************************************************************
* The maximum map width, height and block size
*******************************************************************************/
const int M_W = 21;
const int M_H = 21;
const int M_N = 4;

/*******************************************************************************
* Current map width, height
*******************************************************************************/
int M_CW = M_W;
int M_CH = M_H;

/*******************************************************************************
* Map for game
*******************************************************************************/
const int M_S = M_W > M_H ? M_W : M_H;
char map[M_S][M_S] = {0};

/*******************************************************************************
* Base class
*******************************************************************************/
class Base
{
public:
    Base(){}
    virtual ~Base(){}
    virtual char GetIDC(void) = 0;
    virtual bool FillAt(int x, int y) = 0;
    virtual bool RemoveAt(int x, int y) = 0;
};

/*******************************************************************************
* Block
*******************************************************************************/
template<char idc>
class Block : public Base
{
public:
    /***************************************************************************
    * Initialize
    ***************************************************************************/
    Block()
    {
        for (int i = 0; i < M_N; i++)
        {
            pos[i] = -1;
        }
    }

    virtual ~Block(){}

    /***************************************************************************
    * Get IDC
    ***************************************************************************/
    virtual char GetIDC(void)
    {
        return idc;
    }

    /***************************************************************************
    * Fill at (x, y)
    ***************************************************************************/
    virtual bool FillAt(int x, int y)
    {
        bool bret;
        for (int i = 0; i < 4; i++)
        {
            bret = CheckMap(x, y);
            if (bret)
            {
                SetMap(x, y);
                return true;
            }
            RotateRight();
        }
        return false;
    }

    /***************************************************************************
    * Remove at (x, y)
    ***************************************************************************/
    virtual bool RemoveAt(int x, int y)
    {
        for (int i = 0; i < M_N; i++)
        {
            if (pos[i] >= 0)
            {
                map[pos[i]/M_W][pos[i]%M_W] = '0';
                pos[i] = -1;
            }
        }
        return true;
    }

    /***************************************************************************
    * Check at (x, y)
    ***************************************************************************/
    virtual bool CheckMap(int x, int y)
    {
        int i, j;
        int xbs, ybs;
        int count = 0;
        for (i = 0; i < 4; i++)
        {
            for (j = 0; j < 4; j++)
            {
                if (block[i][j] == 1)
                {
                    if (count == 0)
                    {
                        xbs = i;
                        ybs = j;
                    }
                    count++;
                    int nx = x+i-xbs;
                    int ny = y+j-ybs;
                    if (nx < 0 || nx >= M_H || ny < 0 || ny >= M_W ||
                        map[nx][ny] != '0')
                    {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    /***************************************************************************
    * Set at (x, y)
    ***************************************************************************/
    virtual bool SetMap(int x, int y)
    {
        int i, j;
        int xbs, ybs;
        int count = 0;
        for (i = 0; i < 4; i++)
        {
            for (j = 0; j < 4; j++)
            {
                if (block[i][j] == 1)
                {
                    if (count == 0)
                    {
                        xbs = i;
                        ybs = j;
                    }
                    if (map[x+i-xbs][y+j-ybs] != '0')
                    {
                        return false;
                    }
                    pos[count++] = (x+i-xbs) * 21 + (y+j-ybs) + 1;
                    map[x+i-xbs][y+j-ybs] = idc;
                }
            }
        }
        return true;
    }

    /***************************************************************************
    * Show block
    ***************************************************************************/
    static void Show(void)
    {
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                cout << (block[i][j] == 1 ? '*' : ' ') << " ";
            }
            cout << endl;
        }
    }

protected:
    /***************************************************************************
    * Rotate Left
    ***************************************************************************/
    static void RotateLeft(void)
    {
        int i, j;
        char tmp_block[4][4];
        for (i = 0; i < 4; i++)
        {
            for (j = 0; j < 4; j++)
            {
                tmp_block[i][j] = block[j][3-i];
            }
        }
        for (i = 0; i < 4; i++)
        {
            for (j = 0; j < 4; j++)
            {
                block[i][j] = tmp_block[i][j];
            }
        }
    }

    /***************************************************************************
    * Rotate right
    ***************************************************************************/
    static void RotateRight(void)
    {
        int i, j;
        char tmp_block[4][4];
        for (i = 0; i < 4; i++)
        {
            for (j = 0; j < 4; j++)
            {
                tmp_block[i][j] = block[3-j][i];
            }
        }
        for (i = 0; i < 4; i++)
        {
            for (j = 0; j < 4; j++)
            {
                block[i][j] = tmp_block[i][j];
            }
        }
    }

protected:
    /***************************************************************************
    * Position data
    ***************************************************************************/
    int pos[M_N];

    /***************************************************************************
    * Graph for block
    ***************************************************************************/
    static char block[4][4];
};

/*******************************************************************************
* Graph for block
*******************************************************************************/
char Block<'a'>::block[4][4] = {
    1, 0, 0, 0,
    1, 1, 0, 0,
    0, 1, 0, 0,
    0, 0, 0, 0,
};

/*******************************************************************************
* Graph for block
*******************************************************************************/
char Block<'b'>::block[4][4] = {
    1, 1, 1, 0,
    0, 1, 0, 0,
    0, 0, 0, 0,
    0, 0, 0, 0,
};

/*******************************************************************************
* Graph for block
*******************************************************************************/
char Block<'c'>::block[4][4] = {
    1, 1, 1, 0,
    1, 0, 0, 0,
    0, 0, 0, 0,
    0, 0, 0, 0,
};

/*******************************************************************************
* Graph for block
*******************************************************************************/
char Block<'d'>::block[4][4] = {
    1, 1, 0, 0,
    1, 1, 0, 0,
    0, 0, 0, 0,
    0, 0, 0, 0,
};

/*******************************************************************************
* Graph for block
*******************************************************************************/
char Block<'e'>::block[4][4] = {
    0, 1, 0, 0,
    1, 1, 0, 0,
    1, 0, 0, 0,
    0, 0, 0, 0,
};

/*******************************************************************************
* Graph for block
*******************************************************************************/
char Block<'f'>::block[4][4] = {
    1, 0, 0, 0,
    1, 0, 0, 0,
    1, 0, 0, 0,
    1, 0, 0, 0,
};

/*******************************************************************************
* Graph for block
*******************************************************************************/
char Block<'g'>::block[4][4] = {
    0, 1, 0, 0,
    0, 1, 0, 0,
    1, 1, 0, 0,
    0, 0, 0, 0,
};

/*******************************************************************************
* Using global variable map as parameter
*******************************************************************************/
int solve(void)
{
    int i, j;
    int count = 0;
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            if (map[i][j] == '0')
            {
                Block<'a'> a;
                Block<'b'> b;
                Block<'c'> c;
                Block<'d'> d;
                Block<'e'> e;
                Block<'f'> f;
                Block<'g'> g;
                bool bret = false;
                bret = bret || d.FillAt(i, j);
                bret = bret || f.FillAt(i, j);
                bret = bret || c.FillAt(i, j);
                bret = bret || g.FillAt(i, j);
                bret = bret || a.FillAt(i, j);
                bret = bret || e.FillAt(i, j);
                bret = bret || b.FillAt(i, j);
                if (bret)
                {
                    count += 4;
                }
            }
        }
    }

    return count;
}

/*******************************************************************************
* Map rotate
*******************************************************************************/
void map_rotate()
{
    int i, j;
    char tmp_map[M_S][M_S];
    for (i = 0; i < M_S; i++)
    {
        for (j = 0; j < M_S; j++)
        {
            tmp_map[i][j] = map[j][M_S-1-i];
        }
    }
    for (i = 0; i < M_S; i++)
    {
        for (j = 0; j < M_S; j++)
        {
            map[i][j] = tmp_map[i][j];
        }
    }

    M_CH ^= M_CW ^= M_CH;
    M_CW ^= M_CH;
}

/*******************************************************************************
* Check map and solve
*******************************************************************************/
int rotate_map_and_solve(void)
{
    /***************************************************************************
    * Save map
    ***************************************************************************/
    int i, j;
    char orig_map[M_H][M_W];
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            orig_map[i][j] = map[i][j];
        }
    }

    /***************************************************************************
    * Solve map
    ***************************************************************************/
    char solve_map[M_H][M_W];
    int solve_count = solve();
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            solve_map[i][j] = map[i][j];
        }
    }

    /***************************************************************************
    * Rotate and solve map
    ***************************************************************************/
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            map[i][j] = orig_map[i][j];
        }
    }
    map_rotate();
    char save_map[M_H][M_W];
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            save_map[i][j] = map[i][j];
        }
    }
    int solve_count_rotate = solve();
    if (solve_count_rotate > solve_count)
    {
        solve_count = solve_count_rotate;
        map_rotate();
        map_rotate();
        map_rotate();
        for (i = 0; i < M_H; i++)
        {
            for (j = 0; j < M_W; j++)
            {
                solve_map[i][j] = map[i][j];
            }
        }
    }

    /***************************************************************************
    * Rotate and solve map
    ***************************************************************************/
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            map[i][j] = save_map[i][j];
        }
    }
    map_rotate();
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            save_map[i][j] = map[i][j];
        }
    }
    solve_count_rotate = solve();
    if (solve_count_rotate > solve_count)
    {
        solve_count = solve_count_rotate;
        map_rotate();
        map_rotate();
        for (i = 0; i < M_H; i++)
        {
            for (j = 0; j < M_W; j++)
            {
                solve_map[i][j] = map[i][j];
            }
        }
    }

    /***************************************************************************
    * Rotate and solve map
    ***************************************************************************/
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            map[i][j] = save_map[i][j];
        }
    }
    map_rotate();
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            save_map[i][j] = map[i][j];
        }
    }
    solve_count_rotate = solve();
    if (solve_count_rotate > solve_count)
    {
        solve_count = solve_count_rotate;
        map_rotate();
        for (i = 0; i < M_H; i++)
        {
            for (j = 0; j < M_W; j++)
            {
                solve_map[i][j] = map[i][j];
            }
        }
    }

    /***************************************************************************
    * Set solve map
    ***************************************************************************/
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            map[i][j] = solve_map[i][j];
        }
    }
    return solve_count;
}

/*******************************************************************************
* Check map and solve
*******************************************************************************/
int check_map_and_solve(void)
{
    /***************************************************************************
    * Save map
    ***************************************************************************/
    int i, j;
    char orig_map[M_H][M_W];
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            orig_map[i][j] = map[i][j];
        }
    }

    /***************************************************************************
    * Solve map
    ***************************************************************************/
    char solve_map[M_H][M_W];
    int solve_count = solve();
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            solve_map[i][j] = map[i][j];
        }
    }

    /***************************************************************************
    * Rotate and solve map
    ***************************************************************************/
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            map[i][j] = orig_map[i][j];
        }
    }
    int solve_count_rotate = rotate_map_and_solve();
    if (solve_count_rotate > solve_count)
    {
        solve_count = solve_count_rotate;
        for (i = 0; i < M_H; i++)
        {
            for (j = 0; j < M_W; j++)
            {
                solve_map[i][j] = map[i][j];
            }
        }
    }

    /***************************************************************************
    * Rotate and solve map
    ***************************************************************************/
    int xf = -1;
    int yf = -1;
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            map[i][j] = orig_map[i][j];
            if (map[i][j] == '1' && xf < 0)
            {
                xf = i;
                yf = j;
            }
        }
    }

    /***************************************************************************
    * Find '1' and check if we can add some block
    ***************************************************************************/
    if (xf >= 0)
    {
        /***********************************************************************
        * Check : 
        * 1           1 1
        * 1 1  or   1 1
        *   1
        ***********************************************************************/
        int solve_count_match = 0;
        if (map[xf][yf+1] == '1')
        {
            /*******************************************************************
            * Add c c c
            *     c
            *******************************************************************/
            if (xf >= 1)
            {
                map[xf-1][yf-1] = 'c';
                map[xf-1][yf] = 'c';
                map[xf-1][yf+1] = 'c';
                map[xf][yf-1] = 'c';
                solve_count_match += 4;
            }
            /*******************************************************************
            * Add     c
            *     c c c
            *******************************************************************/
            if (xf < M_H - 2)
            {
                map[xf+1][yf+1] = 'c';
                map[xf+2][yf-1] = 'c';
                map[xf+2][yf] = 'c';
                map[xf+2][yf+1] = 'c';
                solve_count_match += 4;
            }
            solve_count_match += rotate_map_and_solve();
            if (solve_count_match > solve_count)
            {
                solve_count = solve_count_match;
                for (i = 0; i < M_H; i++)
                {
                    for (j = 0; j < M_W; j++)
                    {
                        solve_map[i][j] = map[i][j];
                    }
                }
            }
        }
        else
        {
            /*******************************************************************
            * Add c
            *     c
            *     c c
            *******************************************************************/
            if (yf > 0)
            {
                map[xf][yf-1] = 'c';
                map[xf+1][yf-1] = 'c';
                map[xf+2][yf-1] = 'c';
                map[xf+2][yf] = 'c';
                solve_count_match += 4;
            }
            /*******************************************************************
            * Add c c
            *       c
            *       c
            *******************************************************************/
            if (yf < M_W - 2)
            {
                map[xf][yf+1] = 'c';
                map[xf][yf+2] = 'c';
                map[xf+1][yf+2] = 'c';
                map[xf+2][yf+2] = 'c';
                solve_count_match += 4;
            }
            solve_count_match += rotate_map_and_solve();
            if (solve_count_match > solve_count)
            {
                solve_count = solve_count_match;
                for (i = 0; i < M_H; i++)
                {
                    for (j = 0; j < M_W; j++)
                    {
                        solve_map[i][j] = map[i][j];
                    }
                }
            }
        }
    }

    /***************************************************************************
    * Set solve map
    ***************************************************************************/
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            map[i][j] = solve_map[i][j];
        }
    }
    return solve_count;
}

/*******************************************************************************
* Test function
*******************************************************************************/
void test()
{
    /***************************************************************************
    * Clear map
    ***************************************************************************/
    int i, j;
    for (i = 0; i < M_H; i++)
    {
        for (j = 0; j < M_W; j++)
        {
            map[i][j] = '0';
        }
    }

    /***************************************************************************
    * Test map
    ***************************************************************************/
    int a, b;
    for (a = 0; a < M_H; a++)
    {
        for (b = 0; b < M_W; b++)
        {
            for (i = 0; i < M_H; i++)
            {
                for (j = 0; j < M_W; j++)
                {
                    map[i][j] = '0';
                }
            }
            if (a < M_H - 2 && b < M_W - 1)
            {
                map[a][b] = '1';
                map[a+1][b] = '1';
                map[a+1][b+1] = '1';
                map[a+2][b+1] = '1';
                int m = check_map_and_solve();
                if (m < 436)
                {
                    cout << "At " << m <<": (" << a << "," << b <<")" << endl;
                }
            }
            map[i][j] = '0';
        }
    }

    /***************************************************************************
    * Test map
    ***************************************************************************/
    for (a = 0; a < M_H; a++)
    {
        for (b = 0; b < M_W; b++)
        {
            for (i = 0; i < M_H; i++)
            {
                for (j = 0; j < M_W; j++)
                {
                    map[i][j] = '0';
                }
            }
            if (a > 0 && a < M_H - 1 && b < M_W - 1)
            {
                map[a][b] = '1';
                map[a][b+1] = '1';
                map[a+1][b] = '1';
                map[a+1][b-1] = '1';
                int m = check_map_and_solve();
                if (m < 436)
                {
                    cout << "At " << m <<": (" << a << "," << b <<")" << endl;
                }
            }
            map[i][j] = '0';
        }
    }
}

int main()
{
    /***************************************************************************
    * Test function
    ***************************************************************************/
    test();
    return 0;

    /***************************************************************************
    * Clear map
    ***************************************************************************/
    for (int i = 0; i < M_H; i++)
    {
        for (int j = 0; j < M_W; j++)
        {
            map[i][j] = '0';
        }
    }

    /***************************************************************************
    * Read data from input file
    ***************************************************************************/
    int n = 0;
    ifstream ifs;
    ifs.open("testin.txt");
    if (ifs.is_open())
    {
        while (!ifs.eof())
        {
            int pos = -1;
            ifs >> pos;
            if (pos > 0)
            {
                n++;
                pos--;
                map[pos/M_W][pos%M_W] = '1';
            }
        }
        ifs.close();
    }

    /***************************************************************************
    * Solve this problem
    ***************************************************************************/
    int m = check_map_and_solve();

    /***************************************************************************
    * Write data to output file
    ***************************************************************************/
    ofstream ofs;
    ofs.open("testout.txt");
    if (ofs.is_open())
    {
        for (int i = 0; i < M_H; i++)
        {
            for (int j = 0; j < M_W; j++)
            {
                ofs << map[i][j] << " ";
            }
            ofs << endl;
        }
        ofs << M_H * M_W - n - m << endl;
        ofs.close();
    }

    return 0;
}

 

zqt520
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2012年华为杯校园编程大赛决赛
05-29
2012年的华为杯校园编程大赛决赛聚焦于软件开发领域，尤其是C/C++语言的应用。本次比赛旨在考验参赛者在算法设计、问题解决以及编程实践方面的能力。通过解决复杂的编程题目，如“俄罗斯方块之棋盘覆盖”，不仅考察...
华为C/C++语言编程与安全编程规范
最新发布
05-04
这套规范涵盖了C和C++两种广泛使用的编程语言，特别强调了在实际开发中的安全编程原则。 1. **C语言编程规范**： - **命名规范**：华为C语言规范要求变量、函数和常量的命名应具有清晰的可读性，通常使用小写字母...
2012年华为杯校园编程大赛决赛题目
weixin_34293902的博客
06-08 72
2019独角兽企业重金招聘Python工程师标准>>> ...
2017华为笔试、面试经历
热门推荐
远洋科技的博客
09-16 4万+
2017华为笔试、面试经历
C++语言编程规范pdf,c++语言编程规范 华为,C,C++
09-10
《C++语言编程规范》是华为公司制定的一套详尽的编程指导原则，旨在提高代码质量和可维护性，是程序员进入大厂时应当遵循的重要准则。这份规范不仅适用于C++，也涵盖了C语言的部分内容，因为C++是在C的基础上发展...
华为技术有限公司C++语言编程规范,华为技术有限公司c语言编程规范.pdf,C,C++
09-10
《华为技术有限公司C++语言编程规范》是一份深入细致的编程指南，旨在为开发者提供一套在C++编程中应遵循的最佳实践。这份规范不仅适用于华为公司内部开发，也对外界开发者具有很高的参考价值，帮助他们提升代码质量...
二进制，八进制，十进制，十六进制互相转化的C语言源代码
zqt520的专栏
09-23 2万+
#include #include #include void D_B(int); void D_O(int); void D_X(int); void B_D(int); void B_O(int); void B_X(int); void O_B(int); void O_D(int); void O_X(int); void X_B(char r[],int k); void X_D(cha
华为下午编程大赛题目（C/C++） 2012
zqt520的专栏
04-23 6679
1.扑克问题问题描述： 在扑克中，牌的类型包括：A(1),2,3,4,5,6,7,8,9,T(10),J(11),Q(12),K(13),D（小鬼devilkin），B(大鬼Belial）。 请做一个简单的程序，输入两张牌的字符，比如"2"和"K"，判断牌的大小，规则如下： B>D>2>A>K>Q>J>10....>3 最小的为3 判断规则：比较cFirstCard和cSecondCard，如果F
算法实现——X和Y的中位数问题
zqt520的专栏
04-10 3441
问题描述： 设X[0:n-1]和Y[0:n-1]为2 个数组,每个数组中含有n 个已排好序的数。试设计一个 O(log n)时间的算法,找出X和Y 的2n个数的中位数。 例如，当n=7，X=[1，3，6，7，8，9，10]；Y=[2，4，5，11，12，13，14]时，X 和Y 的中位数是7。 «算法设计： 对于给定的n 个元素的数组X[0:n-1]和Y[0:n-1]，试设计一个O(log n)时
华为编程大赛2012
zqt520的专栏
04-22 3394
华为编程大赛高级下午4-6点场 纯交流 1、比较两个扑克牌大小，这个很简单就是把A J Q K 大小王 10 对应的字符赋值成数字，然后数字比较就可以 2、干瞪眼。先判断特殊情况，因为输入符合规范，所以 （0）A=B无论什么情况返回平局 （1）A BB /AA B这种情况不满足题意，无法比较 （2）AAA/AA|B AA|A/BBB，也就是一
poll 的例子
zqt520的专栏
09-09 2773
server: /* * Pollserver.c * * Created on: 2012-9-9 * Author: sangerhoo */ #include #include #include #include #include #include #include #include #include #include #include #include #i
Linux一个多线程的面试题
zqt520的专栏
05-11 2337
int main(int argc, char *argv[]) { int i; for(i=0; i<10; i++) fork(); while(1); } 这段程序运行时，系统中存在多少个进程实例？ 每执行一次for循环里面的操作，父进程和子进程都会产生一个进程。因此对于for(i=0; i 这种情况是2**10，也就是1024个进程。          for
2011年华为编程大赛题目
zqt520的专栏
04-14 1534
3.公交站寻址（50分） l  问题描述 一个N*N二维矩阵代表城市布局，元素值只有’.’,’X’ , ‘B’ , ‘S’，X代表当前位置，B代表路障，S代表公交站，’.’代表可行的路径。 现给定路径长度Y，找到能够到达的公交站的个数，路径中不能包含路障。 路径长度定义： 1、 节点与其自身的距离为0 2、 节点与其上、下、左、右四个相邻节点
设置进程的显示名称
zqt520的专栏
09-30 1385
一直觉得nginx显示master和worker进程名字的方式很酷，一目了然，相比之下apache就逊色一点。 root     23340     1  0 May24 ?        00:00:00 nginx: master process /usr/local/nginx/sbin/nginx nobody   23341 23340  0 May24 ?        0
i/o多路复用例子
zqt520的专栏
05-06 1224
/*客户：从命令行接收服务器地址，并向服务器发起连接请求，连接成功后， 从标准输入接收字符串并发送给服务器，等待服务器响应并打印接收的信息。*/ #include #include #include #include #include #include #include #define PORT 2088 #define MAXLINE 100 int main(int argc,
epoll例子
zqt520的专栏
07-02 1142
令人高兴的是，2.6内核的epoll比其2.5开发版本的/dev/epoll简洁了许多，所以，大部分情况下，强大的东西往往是简单的。唯一有点麻烦是epoll有2种工作方式:LT和ET。 LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作
c++100题
zqt520的专栏
10-08 1029
用C++写个程序，如何判断一个操作系统是16位还是32位的？不能用sizeof()函数。    【参考答案】             int a = ~0; if( a>65536 ) { cout<<"32 bit"<<endl;} else { cout  多态类中的虚函数表是Compile-Time，还是Run-Time时建立的?    【标准答案】虚拟函数表是在编译期就
华为杯软件编程大赛：历年试题与规范
1. **编程竞赛环境**：华为杯编程大赛采用Visual C++ 6.0作为开发调试环境，运行平台是Windows操作系统，编程语言为C/C++。 2. **竞赛规则**：参赛者需在封闭环境下独立完成编程，不许参考书籍或其他资料，禁止相互...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值