706

706.cpp

#include "gtest\gtest.h"
#include "Segment.h"
#include <iostream>
using namespace std;

void resize_pattern(const vector<char> &pattern, size_t size, vector<string> &result)
{
    result.resize(15,"");
    
    result[0] += pattern[0];
    for (size_t i = 0; i < size; i++) result[1] += pattern[1];
    result[2] += pattern[2];

    result[3] += pattern[3];
    for (size_t j = 0; j < size; j++) result[4] += pattern[4];
    result[5] += pattern[5];

    result[6] += pattern[6];
    for (size_t i = 0; i < size; i++) result[7] += pattern[7];
    result[8] += pattern[8];

    result[9] += pattern[9];
    for (size_t i = 0; i < size; i++) result[10] += pattern[10];
    result[11] += pattern[11];

    result[12] += pattern[12];
    for (size_t i = 0; i < size; i++) result[13] += pattern[13];
    result[14] += pattern[14];
}

void output(const vector<vector<string>> &patterns)
{
    size_t size = patterns[0][1].size();
    for (size_t i = 0; i < patterns.size(); i++)
    {
        cout << patterns[i][0];
        cout << patterns[i][1];
        cout << patterns[i][2];
        if (i != patterns.size()-1) cout << " ";
    }

    cout << "\n";

    for (size_t j = 0; j < size; j++)
    {
        for (size_t i = 0; i < patterns.size(); i++)
        {
            cout << patterns[i][3];
            cout << patterns[i][4];
            cout << patterns[i][5];
            if (i != patterns.size() - 1) cout << " ";
        }
        cout << "\n";
    }

    for (size_t i = 0; i < patterns.size(); i++)
    {
        cout << patterns[i][6];
        cout << patterns[i][7];
        cout << patterns[i][8];
        if (i != patterns.size() - 1) cout << " ";
    }

    cout << "\n";

    for (size_t j = 0; j < size; j++)
    {
        for (size_t i = 0; i < patterns.size(); i++)
        {
            cout << patterns[i][9];
            cout << patterns[i][10];
            cout << patterns[i][11];
            if (i != patterns.size() - 1) cout << " ";
        }
        cout << "\n";
    }

    for (size_t i = 0; i < patterns.size(); i++)
    {
        cout << patterns[i][12];
        cout << patterns[i][13];
        cout << patterns[i][14];
        if (i != patterns.size() - 1) cout << " ";
    }

    cout << "\n\n";
}

void run(size_t size, string input)
{
    vector<vector<string>> patterns;
    FifteenSegment test;

    for (size_t i = 0; i < input.size(); i++)
    {
        vector<string> pattern;
        resize_pattern(test.get_number_pattern(input[i]), size, pattern);
        patterns.push_back(pattern);
    }

    output(patterns);
}

int main(int argc, char* argv[])
{
    //testing::InitGoogleTest(&argc, argv);
    //RUN_ALL_TESTS();

    while (1)
    {
        int size;
        string input;
        cin >> size >> input;
        if (size == 0) break;

        run(size, input);
    }
    return 0;
}

Segment.cpp

#include "Segment.h"

using namespace std;

vector<char> FifteenSegment::get_number_pattern(char n)
{
    vector<char> number_pattern;
    number_pattern.push_back(get_pattern()[std::make_pair("0",  get_table()[n][0])]);
    number_pattern.push_back(get_pattern()[std::make_pair("1",  get_table()[n][1])]);
    number_pattern.push_back(get_pattern()[std::make_pair("2",  get_table()[n][2])]);
    number_pattern.push_back(get_pattern()[std::make_pair("3",  get_table()[n][3])]);
    number_pattern.push_back(get_pattern()[std::make_pair("4",  get_table()[n][4])]);
    number_pattern.push_back(get_pattern()[std::make_pair("5",  get_table()[n][5])]);
    number_pattern.push_back(get_pattern()[std::make_pair("6",  get_table()[n][6])]);
    number_pattern.push_back(get_pattern()[std::make_pair("7",  get_table()[n][7])]);
    number_pattern.push_back(get_pattern()[std::make_pair("8",  get_table()[n][8])]);
    number_pattern.push_back(get_pattern()[std::make_pair("9",  get_table()[n][9])]);
    number_pattern.push_back(get_pattern()[std::make_pair("10", get_table()[n][10])]);
    number_pattern.push_back(get_pattern()[std::make_pair("11", get_table()[n][11])]);
    number_pattern.push_back(get_pattern()[std::make_pair("12", get_table()[n][12])]);
    number_pattern.push_back(get_pattern()[std::make_pair("13", get_table()[n][13])]);
    number_pattern.push_back(get_pattern()[std::make_pair("14", get_table()[n][14])]);
    return number_pattern;
}

Segment.h

#pragma once
#include <map>
#include <vector>
#include <string>

class FifteenSegment
{
public:
    std::vector<char> get_number_pattern(char n);

private:
    std::map<char, std::string>& get_table()
    {
        static std::map<char, std::string> table =
        {
            { '0', "010101000101010" },
            { '1', "000001000001000" },
            { '2', "010001010100010" },
            { '3', "010001010001010" },
            { '4', "000101010001000" },
            { '5', "010100010001010" },
            { '6', "010100010101010" },
            { '7', "010001000001000" },
            { '8', "010101010101010" },
            { '9', "010101010001010" }
        };

        return table;
    }
    
    std::map<std::pair<std::string, char>, char>& get_pattern()
    {
        static std::map<std::pair<std::string, char>, char> pattern =
        {
            { std::make_pair("0", '0'), ' ' }, { std::make_pair("0", '1'), ' ' },
            { std::make_pair("1", '0'), ' ' }, { std::make_pair("1", '1'), '-' },
            { std::make_pair("2", '0'), ' ' }, { std::make_pair("2", '1'), ' ' },
            { std::make_pair("3", '0'), ' ' }, { std::make_pair("3", '1'), '|' },
            { std::make_pair("4", '0'), ' ' }, { std::make_pair("4", '1'), ' ' },
            { std::make_pair("5", '0'), ' ' }, { std::make_pair("5", '1'), '|' },
            { std::make_pair("6", '0'), ' ' }, { std::make_pair("6", '1'), ' ' },
            { std::make_pair("7", '0'), ' ' }, { std::make_pair("7", '1'), '-' },
            { std::make_pair("8", '0'), ' ' }, { std::make_pair("8", '1'), ' ' },
            { std::make_pair("9", '0'), ' ' }, { std::make_pair("9", '1'), '|' },
            { std::make_pair("10", '0'), ' ' }, { std::make_pair("10", '1'), ' ' },
            { std::make_pair("11", '0'), ' ' }, { std::make_pair("11", '1'), '|' },
            { std::make_pair("12", '0'), ' ' }, { std::make_pair("12", '1'), ' ' },
            { std::make_pair("13", '0'), ' ' }, { std::make_pair("13", '1'), '-' },
            { std::make_pair("14", '0'), ' ' }, { std::make_pair("14", '1'), ' ' },
        };

        return pattern;
    }
};

test706.cpp

#pragma once
#include <gtest\gtest.h>
#include <vector>
#include "Segment.h"

TEST(ConvolutionTest, ConvolutionTest)
{
    std::vector<std::vector<char>> number_pattern =
    {
        { ' ', '-', ' ', '|', ' ', '|', ' ', ' ', ' ', '|', ' ', '|', ' ', '-', ' ' },
        { ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', ' ' },
        { ' ', '-', ' ', ' ', ' ', '|', ' ', '-', ' ', '|', ' ', ' ', ' ', '-', ' ' },
        { ' ', '-', ' ', ' ', ' ', '|', ' ', '-', ' ', ' ', ' ', '|', ' ', '-', ' ' },
        { ' ', ' ', ' ', '|', ' ', '|', ' ', '-', ' ', ' ', ' ', '|', ' ', ' ', ' ' },
        { ' ', '-', ' ', '|', ' ', ' ', ' ', '-', ' ', ' ', ' ', '|', ' ', '-', ' ' },
        { ' ', '-', ' ', '|', ' ', ' ', ' ', '-', ' ', '|', ' ', '|', ' ', '-', ' ' },
        { ' ', '-', ' ', ' ', ' ', '|', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', ' ' },
        { ' ', '-', ' ', '|', ' ', '|', ' ', '-', ' ', '|', ' ', '|', ' ', '-', ' ' },
        { ' ', '-', ' ', '|', ' ', '|', ' ', '-', ' ', ' ', ' ', '|', ' ', '-', ' ' },
    };

    FifteenSegment test;
    EXPECT_EQ(number_pattern[0], test.get_number_pattern('0'));
    EXPECT_EQ(number_pattern[1], test.get_number_pattern('1'));
    EXPECT_EQ(number_pattern[2], test.get_number_pattern('2'));
    EXPECT_EQ(number_pattern[3], test.get_number_pattern('3'));
    EXPECT_EQ(number_pattern[4], test.get_number_pattern('4'));
    EXPECT_EQ(number_pattern[5], test.get_number_pattern('5'));
    EXPECT_EQ(number_pattern[6], test.get_number_pattern('6'));
    EXPECT_EQ(number_pattern[7], test.get_number_pattern('7'));
    EXPECT_EQ(number_pattern[8], test.get_number_pattern('8'));
    EXPECT_EQ(number_pattern[9], test.get_number_pattern('9'));
}