【華爲機試之C++】 明明的随机数

描述

明明生成了NN个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。

数据范围： 1≤ n ≤1000 ，输入的数字大小满足 1≤ val ≤500

輸入描述：

第一行先输入随机整数的个数 N 。 接下来的 N 行每行输入一个整数，代表明明生成的随机数。 具体格式可以参考下面的"示例"。

輸出描述：

输出多行，表示输入数据处理后的结果

示例

输入：
3
2
2
1
复制
输出：
1
2
复制
说明：
输入解释：
第一个数字是3，也即这个小样例的N=3，说明用计算机生成了3个1到500之间的随机整数，接下来每行一个随机数字，共3行，也即这3个随机数字为：
2
2
1
所以样例的输出为：
1
2     

思路

代碼

errcode.h

#pragma once
enum {
    ERRCODE_NO_ERR              = 0,
    ERRCODE_INVALID_ARGUMENT    = 1,
};

RandomNumberProcessor.h

#pragma once
#include <memory>

using namespace std;

class RandomNumberProcessor
{
public:
    virtual void input() = 0;
    virtual void process() = 0;
    virtual void output() = 0;

public:
    static shared_ptr<RandomNumberProcessor> create();
};

RandomNumberProcessorImpl.h

#pragma once
#include <string>
#include <vector>
#include "RandomNumberProcessor.h"

class RandomNumberProcessorImpl :public RandomNumberProcessor
{
public:
    void input() override;
    void process() override;
    void output() override;

public:
    RandomNumberProcessorImpl();
    ~RandomNumberProcessorImpl();

private:
    bool isExisted(uint16_t number);
    void add(uint16_t number);
    uint8_t sortByValue();

private:
    uint16_t totalRandomNumber;
    vector<uint16_t> randomNumbers;
    uint8_t errcode;
};

RandomNumberProcessor.cpp

#include "RandomNumberProcessorImpl.h"

shared_ptr<RandomNumberProcessor> RandomNumberProcessor::create()
{
    return dynamic_pointer_cast<RandomNumberProcessor>(make_shared<RandomNumberProcessorImpl>());
}

RandomNumberProcessorImpl.cpp

#include <iostream>
#include <algorithm>
#include "errcode.h"
#include "RandomNumberProcessorImpl.h"


void RandomNumberProcessorImpl::input()
{
    cout << "Input the toal count of random numbers" << endl;
    cin >> totalRandomNumber;

    if (totalRandomNumber > 1000) {
        errcode = ERRCODE_INVALID_ARGUMENT;
        return;
    }

    cout << "Input the random number line by line" << endl;

    uint16_t currentCount = 0;
    uint16_t randomNumber = 0;
    while (++currentCount) {
        cin >> randomNumber;

        if (randomNumber > 500) {
            continue;
        }

        if (isExisted(randomNumber)) {
            continue;
        }

        add(randomNumber);
        cout << "current count:" << currentCount << endl;
        if (currentCount == totalRandomNumber) {
            cout << "Input done" << endl;
            break;
        }
    }
}

void RandomNumberProcessorImpl::process()
{
    errcode = sortByValue();
}

void RandomNumberProcessorImpl::output()
{
    switch (errcode) {
    case ERRCODE_NO_ERR:
        break;
    case ERRCODE_INVALID_ARGUMENT:
        cout << "Invalid argument" << endl;
        return;
    default:
        return;
    }

    for (auto ele : randomNumbers) {
        cout << ele << '\n';
    }

    cout << endl;
}


RandomNumberProcessorImpl::RandomNumberProcessorImpl()
    :errcode(ERRCODE_NO_ERR)
    ,totalRandomNumber(0)
{

}

RandomNumberProcessorImpl::~RandomNumberProcessorImpl()
{
    vector<uint16_t> a;
    randomNumbers.swap(a);
}

bool RandomNumberProcessorImpl::isExisted(uint16_t number)
{
    for (auto& ele : randomNumbers) {
        if (ele == number) {
            return true;
        }
    }

    return false;
}

void RandomNumberProcessorImpl::add(uint16_t number)
{
    randomNumbers.push_back(number);
}

uint8_t RandomNumberProcessorImpl::sortByValue()
{
    if (randomNumbers.empty()) {
        return ERRCODE_INVALID_ARGUMENT;
    }

    sort(randomNumbers.begin(), randomNumbers.end(), [](uint16_t a, uint16_t b) { return a < b; });

    return ERRCODE_NO_ERR;
}

main.cpp

#include "RandomNumberProcessor.h"


int main(int argc, char* argv[])
{
    auto processor = RandomNumberProcessor::create();

    processor->input();
    processor->process();
    processor->output();

    return 0;
}

測試

測試環境

測試結果