西工大18年计算机机试真题

前言：西工大机试真题记录 

           代码在CodeBlocks16.01环境下编译通过 

第一题-求积：给定n组数，每组两个整数，输出这两个整数的乘积

/*
 *题目：求积：给定n组数，每组两个整数，输出这两个整数的乘积
 *Input：
        2
        1 1
        2 3
 *Output:
        1
        6
 */

#include <iostream>

using namespace std;

int NoOne()
{
    int num;
    int mult[2] = {0};
    int product = 0;
    cin >> num;
    while (num--)
    {
        cin >> mult[0] >> mult[1];
        product = mult[0] * mult[1];
        cout << product << endl;
    }

    return 0;
}

 第二题-阶乘：给定n组数，每组一个整数，输出该组数的阶乘

/*
 *题目：阶乘：给定n组数，每组一个整数，输出该组数的阶乘
 *Input：
        2
        3
        5
 *Output:
        6
        120
 */

#include <iostream>

using namespace std;

int NoTwo()
{
    int num;
    int factNum;
    int product = 1;
    cin >> num;
    while (num--)
    {
        product = 1;
        cin >> factNum;
        while (factNum != 1)
        {
            product *= factNum;
            factNum--;
        }
        cout << product << endl;
    }
    return 0;
}

第三题-C(n,m)：求出n个数中任取m个数的不同取法个数

/*
 *题目：C(n,m)：求出n个数中任取m个数的不同取法个数
 *Input：
        10 3
 *Output:
        120
 */

#include <iostream>

using namespace std;

int NoThree()
{
    int total, num;
    int totalPrdct = 1, numPrdct = 1;
    cin >> total >> num;
    while (num != 0)
    {
        totalPrdct *= total;
        numPrdct *= num;
        total--;
        num--;
    }
    cout << totalPrdct / numPrdct << endl;
    return 0;
}

第四题-给定n组数，每组m个，对每组数进行从小到大排序（分别用了快速排序，冒泡排序，选择排序，桶排序和插入排序）

/*
 *题目：给定n组数，每组m个，对每组数进行从小到大排序
 *Input：
        2 4
        3 5 2 8
        2 7 9 8
 *Output:
        2 3 5 8
        2 7 8 9
 */

#include <iostream>
#include <vector>
#include <stdio.h>

using namespace std;

/**********************快速排序**************************/
int QuickSort(vector<int> &data, int left, int right)
{
    int leftGuard = left;
    int rightGuard = right;
    int key = data[left];
    int temp = 0;

    if (left >= right)
    {
        return 0;
    }

    while (leftGuard < rightGuard)
    {
        while (leftGuard < rightGuard && key <= data[rightGuard])
        {
            --rightGuard;
        }
        while (leftGuard < rightGuard && key >= data[leftGuard])
        {
            ++leftGuard;
        }
        if (leftGuard < rightGuard)
        {
            temp = data[leftGuard];
            data[leftGuard] = data[rightGuard];
            data[rightGuard] = temp;
        }
    }
    data[left] = data[leftGuard];
    data[leftGuard] = key;

    QuickSort(data, left, leftGuard - 1);
    QuickSort(data, rightGuard + 1, right);

    return 0;
}

/**********************冒泡排序**************************/
int BubbleSort(vector<int> &data, int length)
{
    int temp;
    for (int i = 0; i < length; ++i)
    {
        for (int j = i + 1; j < length; ++j)
        {
            if (data[i] > data[j])
            {
                temp = data[i];
                data[i] = data[j];
                data[j] = temp;
            }
        }
    }

    return 0;
}

/**********************选择排序**************************/
int SelectSort(vector<int> &data, int length)
{

    int temp;
    int key;
    for (int i = 0; i < length - 1; ++i)
    {
        int minNum = data[i];
        for (int j = i + 1; j < length; ++j)
        {
            if (data[j] < minNum)
            {
                minNum = data[j];
                key = j;
            }
        }
        temp = data[i];
        data[i] = minNum;
        data[key] = temp;
    }
    return 0;
}

/**********桶排序(适用于数组的数比较小(小于10）的情况）********/
int BucketSort(vector<int> &data, int length)
{
    vector<int> bucket(10);
    int cnt = 0;
    for (int i = 0; i < length; ++i)
    {
        bucket[data[i]]++;
    }
    for (int j = 0; j < 10; ++j)
    {
        for (int k = 0; k < bucket[j]; ++k)
        {
            data[cnt] = j;
            cnt++;
        }
    }

    return 0;
}

/**********************插入排序**************************/
int InsertSort(vector<int> &data, int length)
{
    for (int i = 1; i < length; ++i)
    {
        if (data[i] < data[i - 1])
        {
            int temp = data[i];
            int j;
            for (j = i - 1; j >= 0 && data[j] > temp; --j)
            {
                data[j + 1] = data[j];
            }
            data[j + 1] = temp;
        }
    }
    return 0;
}

int NoFour()
{
    int group, length;
    int num;
    char newLine;
    cin >> group >> length;
    vector<int> data;
    while (group--)
    {
        data.clear();
        do
        {
            cin >> num;
            data.push_back(num);
        }while ((newLine = getchar()) != '\n');

        QuickSort(data, 0, length - 1);
        BubbleSort(data, length);
        SelectSort(data, length);
        BucketSort(data, length);
        InsertSort(data, length);
        for (int &i : data)
        {
            cout << i << " ";
        }
        cout << endl;
    }

    return 0;
}

第五题-字符串反转：给定n组字符串，每组字符串不超过20，输出每组字符串的反串

/*
 *题目：字符串反转：给定n组字符串，每组字符串不超过20，输出每组字符串的反串
 *Input：
       3
       nwpu
       china
       xi an
 *Output:
       upwn
       anihc
       na ix
 */

#include <iostream>
#include <string>
#include <stdio.h>

using namespace std;

int NoFive()
{
    int num;
    string inpt;
    cin >> num;
    while (num--)
    {
        getline(cin, inpt);

        for (int i = inpt.size() - 1; i >= 0; --i)
        {
            cout << inpt[i];
        }
        cout << endl;
    }
    return 0;
}

第六题-判断是否回文：（包括空格 数字 英文 符号），若是输出yes，否则输出no

/*
 *题目：判断是否回文：（包括空格 数字 英文 符号），若是输出yes，否则输出no
 *Input：
       4
       nwpu
       madam
       1001
       xi ix
 *Output:
       no
       yes
       yes
       yes
 */

#include <iostream>
#include <string>
#include <stdio.h>

using namespace std;

int NoSix()
{
    int num;
    int flag;
    string inpt;
    cin >> num;
    getchar();                              //cin会把回车留在缓冲区中，消掉回车
    while (num--)
    {
        flag = 0;
        getline(cin, inpt);
        for (int i = 0; i < inpt.size() / 2; ++i)
        {
            if (inpt[i] != inpt[inpt.size() - i - 1])
            {
                flag = 1;
                cout << "no" << endl;
                break;
            }
        }
        if (!flag)
        {
            cout << "yes" << endl;
        }

    }
    return 0;
}

第七题-判断括号是否匹配：给定n组数，每组为一个字符串，测试三种括号：{}（）[]，且顺序都是前左括号，后右括号，括号之间可以嵌套。若匹配则输出yes，否则输出no

/*
 *题目：判断括号是否匹配：给定n组数，每组为一个字符串，测试三种括号：{}（）[]，且顺序都是前左括号，后右括号，括号之间可以嵌套。若匹配则输出yes，否则输出no
 *Input：
       2
       {9}[00](tt)
       {[](}
 *Output:
       yes
       no
 */

#include <iostream>
#include <string>
#include <stack>
#include <stdio.h>

using namespace std;

int NoSeven()
{
    int num;
    int flag;
    string word;
    stack<char> brackets;
    cin >> num;
    getchar();
    while (num--)
    {
        while (!brackets.empty())       //清空栈
        {
            brackets.pop();
        }
        flag = 0;
        getline(cin, word);
        for (auto &i : word)
        {
            if (i == '{' || i == '(' || i == '[')
            {
                brackets.push(i);
            }
            else if (i == '}')
            {
                if (!brackets.empty())          //空栈不能调用top()，否则会发生段错误，所以要先检查栈是否为空
                {
                    if (brackets.top() == '{')
                    {
                        brackets.pop();
                    }
                    else
                    {
                        flag = 1;
                        break;
                    }
                }
                else
                {
                    flag = 1;
                    break;
                }
            }
            else if (i == ')')
            {
                if (!brackets.empty())
                {
                    if (brackets.top() == '(')
                    {
                        brackets.pop();
                    }
                    else
                    {
                        flag = 1;
                        break;
                    }
                }
                else
                {
                    flag = 1;
                    break;
                }
            }
            else if (i == ']')
            {
                if (!brackets.empty())
                {
                    if (brackets.top() == '[')
                    {
                        brackets.pop();
                    }
                    else
                    {
                        flag = 1;
                        break;
                    }
                }
                else
                {
                    flag = 1;
                    break;
                }
            }
        }

        if (flag)
        {
            cout << "no" << endl;
        }
        else
        {
            cout << "yes" << endl;
        }
    }
    return 0;
}