(C++기초플러스 6판 프로그래밍 연습 정답,솔루션) CHAPTER 16 string 클래스와 표준 템플릿 라이브러리 p.1342~ 1번~10번

1번

#include<iostream>
#include<string>

bool palindrome(const std::string& s);

int main()
{
	std::string temp;
	std::cout << "문자열 입력: ";
	getline(std::cin, temp);
	if (palindrome(temp))
		std::cout <<temp <<"는 회문입니다.\n";
	else
		std::cout <<temp<< "는 회문이 아닙니다.\n";

	return 0;
}

bool palindrome(const std::string& s)
{
	std::string t(s.rbegin(), s.rend());
	return t == s;
}

 

2번

#include<iostream>
#include<string>
#include<cctype>
#include<new>
bool palindrome(const std::string& s);
void change(std::string& s);

int main()
{
	std::string temp;
	std::cout << "문자열 입력: ";
	getline(std::cin, temp);
	change(temp);
	std::cout << temp << '\n';
	if (palindrome(temp))
		std::cout <<temp <<"는 회문입니다.\n";
	else
		std::cout <<temp<< "는 회문이 아닙니다.\n";

	return 0;
}

bool palindrome(const std::string& s)
{
	std::string t(s.rbegin(), s.rend());
	return t == s;
}

void change(std::string& s)
{
	std::string t;
	for (int i=0; i <s.size(); ++i)
	{
		if (isalpha(s[i]))
		{
			s[i] = tolower(s[i]);
			t += s[i];
		}
	}
	s = t;
}

 

 

3번

// hangman.cpp -- string 메서드들
#include <iostream>
#include<fstream>
#include <string>
#include <cstdlib>
#include <ctime>
#include <cctype>
#include<vector>
using std::string;
using std::vector;
vector<string> wordlist;

int main()
{
    using std::cout;
    using std::cin;
    using std::tolower;
    using std::endl;
    std::ifstream inFile;
    inFile.open("wordlist.txt");
    while (inFile.good())
    {
        std::string temp;
        inFile >> temp;
        wordlist.push_back(temp);
    }
    inFile.close();
    const int NUM = wordlist.size();
    std::srand(std::time(0));
    char play;
    cout << "영어 단어 게임을 하시겠습니까? <y/n> ";
    cin >> play;
    play = tolower(play);
    while (play == 'y')
    {
        string target = wordlist[std::rand() % NUM];
        int length = target.length();
        string attempt(length, '-');
        string badchars;
        int guesses = 6;
        cout << "수수께끼 단어를 추측해 보십시오.\n"
            << length << "개의 문자로 이루어져 있습니다.\n"
            << "한 번에 한 문자씩 추측하십시오.\n"
            << "틀릴 수 있는 기회: " << guesses << "번\n";
        cout << "추측하는 단어: " << attempt << endl;
        while (guesses > 0 && attempt != target)
        {
            char letter;
            cout << "문자를 추측하십시오: ";
            cin >> letter;
            if (badchars.find(letter) != string::npos
                || attempt.find(letter) != string::npos)
            {
                cout << "이미 추측한 문자입니다. 다시 하십시오.\n";
                continue;
            }
            int loc = target.find(letter);
            if (loc == string::npos)
            {
                cout << "땡! 틀렸습니다.\n";
                --guesses;
                badchars += letter; // 틀린 추측들을 문자열에 추가한다
            }
            else
            {
                cout << "딩동댕! 맞았습니다.\n";
                attempt[loc] = letter;
                // 같은 문자가 또 있는지 검사한다
                loc = target.find(letter, loc + 1);
                while (loc != string::npos)
                {
                    attempt[loc] = letter;
                    loc = target.find(letter, loc + 1);
                }
            }
            cout << "추측하는 단어: " << attempt << endl;
            if (attempt != target)
            {
                if (badchars.length() > 0)
                    cout << "틀리게 추측한 문자들: " << badchars << endl;
                cout << "틀릴 수 있는 기회: " << guesses << "번\n";
            }
        }
        if (guesses > 0)
            cout << "그렇습니다. 그것이 수수께끼 단어입니다.\n";
        else
            cout << "안타깝습니다. 수수께끼 단어는 " << target << "입니다.\n";

        cout << "게임을 다시 하시겠습니까? <y/n> ";
        cin >> play;
        play = tolower(play);
    }

    cout << "프로그램을 종료합니다.\n";

    return 0;
}

 

 

4번

#include<iostream>
#include<algorithm>
int reduce(long ar[], int n);
int main()
{
	long a[5] = { 8,2,4,5,2 };
	int n = reduce(a, 5);
	std::cout << n;
	return 0;
}

int reduce(long ar[], int n)
{
	std::sort(ar, ar + n);
	long* pastend = std::unique(ar, ar + n);
	return pastend - ar;
}

 

 

5번

#include<iostream>
#include<set>
#include<algorithm>
using namespace std;

template<class T>
int reduce(T ar[], int n);

template<class T>
void Show(const T ar[], int n);

int main()
{
	long a[5] = { 8,2,4,5,2 };
	string b[4] = { "abc","fdd","eer","abc" };
	int n=reduce(a, 5);
	Show(a, n);
	n = reduce(b, 4);
	Show(b, n);
	return 0;
}

template<class T>
int reduce(T ar[], int n)
{
	sort(ar, ar + n);
	T* pastend=unique(ar, ar + n);
	return pastend - ar;
}

template<class T>
void Show(const T ar[], int n)
{
	for (int i = 0; i < n; i++)
		cout << ar[i] << " ";
	cout<<endl;
}

 

 

6번

// queue.h -- 큐를 위한 인터페이스
#ifndef QUEUE_H_
#define QUEUE_H_
// 이 큐는 Customer 항목들을 포함하게 된다
class Customer
{
private:
    long arrive;        // 고객이 큐에 도착한 시간
    int processtime;    // 고객의 거래를 처리하는 시간
public:
    Customer() { arrive = processtime = 0; }
    void set(long when);
    long when() const { return arrive; }
    int ptime() const { return processtime; }
};
typedef Customer Item;

#endif


// queue.cpp -- Queue와 Customer 메서드들
#include "queue.h"
#include <cstdlib>         // (또는 stdlib.h) rand()를 위해
// customer 메서드

// when은 고객이 도착한 시간이다
// 도착 시간은 when으로 설정된다
// 처리 시간은 1, 2, 3 중에서 무작위로 한 값이 설정된다
void Customer::set(long when)
{
    processtime = std::rand() % 3 + 1;
    arrive = when;
}



// bank.cpp -- Queue 인터페이스를 사용한다
// queue.cpp와 함께 컴파일한다
#include <iostream>
#include <cstdlib> // rand()와 srand()를 사용하기 위해
#include <ctime>   // time()을 사용하기 위해
#include "queue.h"
#include<queue>
const int MIN_PER_HR = 60;

bool newcustomer(double x); // 새 고객이 도착했는가?

int main()
{
    using std::cin;
    using std::cout;
    using std::endl;
    using std::queue;
    using std::ios_base;
    // 필요한 여러 가지를 준비한다
    std::srand(std::time(0));    //  rand()의 무작위 초기화

    cout << "사례 연구: 히서 은행의 ATM\n";
    cout << "큐의 최대 길이를 입력하십시오: ";
    int qs;
    cin >> qs;
    queue<Item> line;         // line 큐에는 최대 qs명까지 대기할 수 있다

    cout << "시뮬레이션 시간 수를 입력하십시오: ";
    int hours;              // 시뮬레이션 시간 수
    cin >> hours;
    // 시뮬레이션은 1분에 1주기를 실행한다
    long cyclelimit = MIN_PER_HR * hours; // 시뮬레이션 주기 수

    cout << "시간당 평균 고객 수를 입력하십시오: ";
    double perhour;         //  시간당 평균 고객 수
    cin >> perhour;
    double min_per_cust;    //  평균 고객 도착 간격(분 단위)
    min_per_cust = MIN_PER_HR / perhour;

    Item temp;              //  새 고객 데이터
    long turnaways = 0;     //  큐가 가득 차서 발길을 돌린 고객 수
    long customers = 0;     //  큐에 줄을 선 고객 수
    long served = 0;        //  시뮬레이션에서 거래를 처리한 고객 수
    long sum_line = 0;      //  큐의 누적 길이
    int wait_time = 0;      //  ATM이 빌 때까지 대기하는 시간
    long line_wait = 0;     //  고객들이 줄을 서서 대기한 누적 시간


// 시뮬레이션을 실행한다
    for (int cycle = 0; cycle < cyclelimit; cycle++)
    {
        if (newcustomer(min_per_cust))  // 새 고객이 도착했다
        {
            if (qs==line.size())
                turnaways++;
            else
            {
                customers++;
                temp.set(cycle);    // cycle이 도착 시간이 된다
                line.push(temp); // 큐에 새 고객을 추가한다
 
            }
        }
        if (wait_time <= 0 && line.size()!=0)
        {
            temp = line.front();
            line.pop();      // 다음 고객을 받는다
            wait_time = temp.ptime(); // wait_time을 설정한다
            line_wait += cycle - temp.when();
            served++;
        }
        if (wait_time > 0)
            wait_time--;
        sum_line += line.size();
    }

    // 시뮬레이션 결과를 출력한다
    if (customers > 0)
    {
        cout << " 큐에 줄을 선 고객 수: " << customers << endl;
        cout << "거래를 처리한 고객 수: " << served << endl;
        cout << " 발길을 돌린 고객 수: " << turnaways << endl;
        cout << "          평균 큐의 길이: ";
        cout.precision(2);
        cout.setf(ios_base::fixed, ios_base::floatfield);
        cout.setf(ios_base::showpoint);
        cout << (double)sum_line / cyclelimit << endl;
        cout << "       평균 대기 시간: "
            << (double)line_wait / served << "분\n";
    }
    else
        cout << "고객이 한 명도 없습니다!\n";
    cout << "완료!\n";
    return 0;
}

//  x는 고객 간의 평균 시간 간격이다(분 단위)
//  이 시간 내에 고객이 도착하면 리턴값은 true이다
bool newcustomer(double x)
{
    return (std::rand() * x / RAND_MAX < 1);
}

 

 

7번

#include<iostream>
#include<vector>
#include<algorithm>
#include<time.h>
using namespace std;
vector<int> Lotto(int total_n, int sel_n);

int main()
{
	srand(time(NULL));
	vector<int> winners = Lotto(51, 6);
	for (int i = 0; i < 6; i++)
		cout << winners[i] << ' ';
	return 0;
}

vector<int> Lotto(int total_n, int sel_n)
{
	vector<int> temp(total_n);
	for (int i = 0; i < total_n; i++)
		temp[i] = i + 1;
	random_shuffle(temp.begin(), temp.end());
	temp.resize(sel_n);
	return temp;
}

 

 

8번

#include<iostream>
#include<set>
#include<vector>
#include<string>
#include<iterator>
#include<algorithm>
using namespace std;

void input(set<string>& s);

int main()
{
	set<string> Mat,Pat;
	cout << "Mat의 친구 목록 입력 (끝내려면 quit 입력) : ";
	input(Mat);
	cout << "Pat의 친구 목록 입력 (끝내려면 quit 입력): ";
	input(Pat);
	ostream_iterator<string, char> out(cout, " ");

	cout << "Mat가 입력한 친구목록\n";
	copy(Mat.begin(), Mat.end(), out);
	cout << endl;

	cout << "Pat가 입력한 친구목록\n";
	copy(Pat.begin(), Pat.end(), out);
	cout << endl;

	set<string> MatPat;
	set_union(Mat.begin(), Mat.end(), Pat.begin(), Pat.end(),
		insert_iterator<set<string>>(MatPat, MatPat.begin()));

	cout << "Mat와 Pat의 친구 목록\n";
	copy(MatPat.begin(), MatPat.end(), out);
	cout << endl;

	return 0;
}

void input(set<string>& s)
{
	string temp;
	getline(cin, temp);
	while (temp != "quit")
	{
		s.insert(temp);
		getline(cin, temp);
	}
}

 

 

9번

#include<iostream>
#include<ctime>
#include<vector>
#include<algorithm>
#include<list>
using namespace std;
const int SIZE = 100000;
int main()
{
	vector<int> vi0(SIZE);
	int i;
	for (i = 0; i < SIZE; i++)
		vi0[i] = std::rand() % 100;
	vector<int> vi;
	list<int> li;
	vi.insert(vi.begin(), vi0.begin(), vi0.end());
	li.insert(li.begin(), vi0.begin(), vi0.end());

	clock_t start = clock();
	sort(vi.begin(), vi.end());
	clock_t end = clock();
	cout << "vi 정렬하는데 걸리는 시간 : " << (double)(end - start) / CLOCKS_PER_SEC << endl;

	start = clock();
	li.sort();
	end = clock();
	cout << "li 정렬하는데 걸리는 시간 : " << (double)(end - start) / CLOCKS_PER_SEC << endl;

	li.insert(li.begin(), vi0.begin(), vi0.end());

	//li를 vi에 복사
	start = clock();
	vi.insert(vi.begin(), li.begin(), li.end());
	sort(vi.begin(), vi.end());
	li.insert(li.begin(), vi.begin(), vi.end());
	end = clock();
	cout << "li를 vi에 복사하고 vi를 정렬하고 정렬된 결과를 다시 li로 복사하는데 걸리는 시간  : " << (double)(end - start) / CLOCKS_PER_SEC << endl;

	return 0;
}

 

 

10번

// vect3.cpp -- STL 함수들을 사용한다
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include<memory>
struct Review {
    std::string title;
    int rating;
    int price;
};

bool operator<(const Review& r1, const Review& r2);
bool worseThan(const Review& r1, const Review& r2);
bool FillReview(Review& rr);
void ShowReview(const Review& rr);
bool worseThan2(const Review& r1, const Review& r2);

int main()
{
    using namespace std;

    shared_ptr<vector<Review>> books  (new vector<Review>);
    Review temp;
    while (FillReview(temp))
        books->push_back(temp);

    shared_ptr<vector<Review>> rem(new vector<Review>);
    *rem = *books;
    char choice;
    cout << "다음의 선택 사항 중 하나를 입력하십시오.\n"
        << "a. 원래 순서\tb. 알파벳 순서\tc. 증가율 순서\n"
        << "d. 감소율 순서\te. 가격 증가 순서\tf. 가격 감소 순서\ng. 작업 끝내기\n";
    cin >> choice;
    while (choice !='q')
    {
        if (choice == 'g')
            break;
        switch (choice)
        {
        case 'a':
            cout << "원래 순서\n등급\t제목\t가격\n";
            for_each(rem->begin(), rem->end(), ShowReview);
            break;
        case 'b':
            sort(books->begin(), books->end());
            cout << "알파벳 순서\n등급\t제목\t가격\n";
            for_each(books->begin(), books->end(), ShowReview);
            break;
        case 'c':
            sort(books->begin(), books->end(), worseThan);
            cout << "증가율 순서\n등급\t제목\t가격\n";
            for_each(books->begin(), books->end(), ShowReview);
            break;
        case 'd':
            sort(books->begin(), books->end(), worseThan);
            cout << "감소율 순서\n등급\t제목\t가격\n";
            for_each(books->rbegin(), books->rend(), ShowReview);
            break;
        case 'e':
            sort(books->begin(), books->end(), worseThan2);
            cout << "가격 증가율 순서\n등급\t제목\t가격\n";
            for_each(books->begin(), books->end(), ShowReview);
            break;
        case 'f':
            sort(books->begin(), books->end(), worseThan2);
            cout << "가격 감소율 순서\n등급\t제목\t가격\n";
            for_each(books->rbegin(), books->rend(), ShowReview);
            break;
        }
        cout << "다음의 선택 사항 중 하나를 입력하십시오.\n"
            << "a. 원래 순서\tb. 알파벳 순서\tc. 증가율 순서\n"
            << "d. 감소율 순서\te. 가격 증가 순서\tf. 가격 감소 순서\ng. 작업 끝내기\n";
        cin >> choice;
    }
   
    return 0;
}

bool operator<(const Review& r1, const Review& r2)
{
    if (r1.title < r2.title)
        return true;
    else if (r1.title == r2.title && r1.rating < r2.rating)
        return true;
    else
        return false;
}

bool worseThan(const Review& r1, const Review& r2)
{
    if (r1.rating < r2.rating)
        return true;
    else
        return false;
}

bool worseThan2(const Review& r1, const Review& r2)
{
    if (r1.price < r2.price)
        return true;
    else
        return false;
}


bool FillReview(Review& rr)
{
    std::cout << "책 제목을 입력하십시오(끝내려면 quit): ";
    std::getline(std::cin, rr.title);
    if (rr.title == "quit")
        return false;
    std::cout << "책 등급(0-10)을 입력하십시오: ";
    std::cin >> rr.rating;
    if (!std::cin)
        return false;
    std::cout << "책 가격을 입력하십시오: ";
    std::cin >> rr.price;
    if (!std::cin)
        return false;
    // 나머지 입력 줄을 삭제한다
    while (std::cin.get() != '\n')
        continue;
    return true;
}

void ShowReview(const Review& rr)
{
    std::cout << rr.rating << "\t" << rr.title <<"\t"<<rr.price <<std::endl;
}