카드게임 헤더 클래스
#pragma once
#include <iostream>
#include <time.h>
#include <sstream>
using namespace std;
class Deck
{
static bool isUsedCard[53];
static int remainCard;
public:
/// <summary>
/// 카드를 7장 뽑아서 구성
/// 모든 덱의 카드는 중복 x
/// </summary>
/// <returns>덱이 성공적이면 true, 아니면 false</returns>
bool Make()
{
// isUsedCard을 순회하면서 남은 카드가 7장 이상인지를 확인한다.
/*int count = 0;
for (int i = 0; i < 53; i++)
{
if (isUsedCard == false)
{
++count;
if (count > 7)
{
break;
}
}
}
if (count < 7)
{
return false;
}*/
if (remainCard < 7)
{
return false;
}
// 사전 조건 : 남은 카드가 7장 이상일 때
for (int i = 0; i < 7; i++)
{
int card = 0;
do
{
card = rand() % 53;
} while (isUsedCard[card]);
_deck[i] = card;
isUsedCard[card] = true;
}
// 사후 조건 : 카드가 완성
remainCard -= 7;
return true;
}
// ToString()
// : 현재 덱의 카드를 표현하는 문자열을 만든다.
// 카드가 없는 경우 "The deck is empty" 로 반환한다.
// 예시 : ♥6, ◆2, ◆5, ♠Q, ♠K, ♠2, ♠3
std::string ToString()
{
if (_deck[0] == -1)
{
return "카드게임";
}
// 덱에 어떻게 데이터가 저장되어 있는지를 알아야 함.
// deck[index] : card index
std::string result;
static const string CARD_TYPE[] = { "♠", "♣", "◆", "♥", "Joker" };
static const string CARD_NUMBER[] = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };
for (int i = 0; i < 7; i++)
{
if (_deck[i] == 52)
{
result += "Joker, ";
}
else
{
result += CARD_TYPE[_deck[i] / 13] + CARD_NUMBER[_deck[i] % 13] + ", ";
}
}
return result;
}
private:
int _deck[7] = { -1 };
int _cardIndex;
};
bool Deck::isUsedCard[53] = { false };
int Deck::remainCard = 53;
카드 게임 cpp
#include <iostream>
#include "Deck.h"
using namespace std;
int main()
{
srand(time(NULL));
Deck decks[8];
for (int i = 0; i < 8; i++)
{
if (false == decks[i].Make())
{
cout << i << "번째는 덱 구성 실패\\n";
}
}
for (int i = 0; i < 8; i++)
{
cout << decks[i].ToString() << "\\n";
}
}
빙고 헤더
#pragma once
#include <iostream>
#include <time.h>
#include <stdlib.h>
using namespace std;
#define BLANK 0
class Bingo
{
static const int BOARD_SIZE = 5;
public:
/// <summary>
/// 빙고판을 초기화한다.
/// </summary>
void Init()
{
srand(time(NULL));
bool isUsed[26] = { false };
for (int r = 0; r < BOARD_SIZE; r++)
{
for (int c = 0; c < BOARD_SIZE; c++)
{
int N = 0;
do
{
N = 1 + rand() % 25;
} while (isUsed[N]);
_board[r][c] = N;
isUsed[N] = true;
}
}
}
/// <summary>
/// 빙고판을 출력한다.
/// </summary>
void Print() const
{
for (int r = 0; r < BOARD_SIZE; r++)
{
for (int c = 0; c < BOARD_SIZE; c++)
{
if (_board[r][c] == BLANK) //BLANK 쓰면 =를 의도했냐고 되물음
{
cout << "\\t";
}
else
{
cout << _board[r][c] << "\\t";
}
}
cout << endl;
}
cout << "현재 " << _bingoCount << "줄의 빙고가 완성되었습니다.\\n";
}
/// <summary>
/// 빙고를 업데이트한다.
/// </summary>
/// <param name="input">입력 데이터</param>
void Update(int input)
{
if (input < 0 || input > BOARD_SIZE * 2)
{
// 2번부터 다시 시작한다.
return;
}
// 4. 빙고판을 최신화 => 해당 숫자를 지워준다.
for (int r = 0; r < BOARD_SIZE; r++)
{
bool isExit = false;
for (int c = 0; c < BOARD_SIZE; c++)
{
if (_board[r][c] == input)
{
_board[r][c] = BLANK;
isExit = true;
}
}
if (isExit)
{
break;
}
}
int count = countHorizontalBingo();
count += countVerticalBingo();
count += countDiagonalBingo();
_bingoCount = count;
}
/// <summary>
/// 빙고가 끝났는지 판별한다.
/// </summary>
/// <returns>끝났다면 true, 아니면 false</returns>
bool IsCompleted()
{
if (_bingoCount == BOARD_SIZE * 2 + 2)
{
return true;
}
else
{
return false;
}
}
private:
/// <summary>
/// 가로줄의 빙고를 센다.
/// </summary>
int countHorizontalBingo()
{
int count = 0;
for (int r = 0; r < BOARD_SIZE; r++)
{
bool isBingo = true;
for (int c = 0; c < BOARD_SIZE; c++)
{
if (_board[r][c] != 0)
{
isBingo = false;
break;
}
}
if (isBingo)
{
++count;
}
}
return count;
}
/// <summary>
/// 세로줄의 빙고를 센다.
/// </summary>
int countVerticalBingo()
{
int count = 0;
for (int r = 0; r < 5; r++)
{
bool isBingo = true;
for (int c = 0; c < BOARD_SIZE; c++)
{
if (_board[c][r] != 0)
{
isBingo = false;
break;
}
}
if (isBingo)
{
++count;
}
}
return count;
}
/// <summary>
/// 대각선의 빙고를 센다.
/// </summary>
int countDiagonalBingo()
{
// board[0][0] / [1][1] / [2][2] / [3][3] / [4][4]
int count = 0;
{
bool isBingo = true;
for (int i = 0; i < BOARD_SIZE; i++)
{
if (_board[i][i] != 0)
{
isBingo = false;
break;
}
}
if (isBingo)
{
count++;
}
}
// [0][4] / [1][3] / [2][2] / [3][1] / [4][0]
{
bool isBingo = true;
for (int i = 0; i < BOARD_SIZE; i++)
{
if (_board[i][4 - i] != 0)
{
isBingo = false;
break;
}
}
if (isBingo)
{
count++;
}
}
return count;
}
private:
int _board[BOARD_SIZE][BOARD_SIZE] = { 0 };
int _bingoCount = 0;
};
빙고 cpp
#include <iostream>
#include "bingo.h"
using namespace std;
int main()
{
// 1. 빙고 판을 초기화
Bingo bingo;
bingo.Init();
while (false == bingo.IsCompleted())
{
system("cls");
// 2. 빙고 현황 출력
bingo.Print();
// 3. 사용자로부터 입력을 받음
int input;
cout << "숫자를 입력해주세요 : ";
cin >> input;
// 4. 빙고를 업데이트 한다.
bingo.Update(input);
}
}
달팽이 헤더(myself)
#pragma once
#include <iostream>
using namespace std;
#define NOT_VISITED 0
class Snail
{
public:
void Make(int size)
{
_size = size;
arr = new int[_size * _size];
Direction direction = DIR_RIGHT;
memset(arr, 0, sizeof(int) * _size * _size);
for (int i = 0; i < _size * _size; i++)
{
// 2-2. 발자국을 남긴다.
arr[r * _size + c] = footstep;
++footstep;
// 2-3, 이동할 위치를 계산한다.
static const int dr[] = { 0, 1, 0, -1 };
static const int dc[] = { 1, 0, -1, 0 };
int nr = r + dr[direction];
int nc = c + dc[direction];
if (nr < 0 || nr >= _size || nc < 0 || nc >= _size || arr[nr * _size + nc] != NOT_VISITED)
{
direction = (Direction)((direction + 1) % DIR_MAX);
nr = r + dr[direction];
nc = c + dc[direction];
}
r = nr;
c = nc;
}
}
void Print()
{
for (int r = 0; r < _size; r++)
{
for (int c = 0; c < _size; c++)
{
cout << arr[r * _size + c] << "\\t";
}
cout << "\\n";
}
}
void Clear()
{
delete[] arr;
}
private:
enum Direction { DIR_RIGHT, DIR_DOWN, DIR_LEFT, DIR_UP, DIR_MAX };
int arrNum = 0;
int* arr;
int _size;
int r = 0; // 달팽이 가로 좌표
int c = 0; // 달팽이 세로 좌표
int footstep = 1; // 왔던 길
};
달팽이 Cpp
#include <iostream>
#include "snail.h"
int main()
{
cout << "배열의 크기를 입력하세요 : ";
int size;
cin >> size;
Snail a;
a.Make(size);
a.Print();
a.Clear();
}
Pro’s 달팽이 헤더
#pragma once
class Snail
{
static const int NOT_VISITED = 0;
public:
/// <summary>
/// 달팽이 배열을 만든다.
/// </summary>
/// <param name="ground">발자국을 저장할 배열</param>
/// <param name="size">배열의 크기</param>
void MoveOn(int* ground, int size)
{
int arrNum = 0;
for (int i = 0; i < size * size; i++)
{
ground[_r * size + _c] = _footstep;
++_footstep;
static const int dr[] = { 0, 1, 0, -1 };
static const int dc[] = { 1, 0, -1, 0 };
int nr = _r + dr[_direction];
int nc = _c + dc[_direction];
if (nr < 0 || nr >= size || nc < 0 || nc >= size || ground[nr * size + nc] != NOT_VISITED)
{
_direction = (Direction)((_direction + 1) % DIR_MAX);
nr = _r + dr[_direction];
nc = _c + dc[_direction];
}
// 2-7 이동한다.
_r = nr;
_c = nc;
}
}
private:
enum Direction { DIR_RIGHT, DIR_DOWN, DIR_LEFT, DIR_UP, DIR_MAX };
int _r = 0; // 달팽이 가로 좌표
int _c = 0; // 달팽이 세로 좌표
int _footstep = 1; // 왔던 길
Direction _direction = DIR_RIGHT; // 달팽이가 움직이는 방향
};
Pro’s 달팽이 cpp
#include <iostream>
#include "snailSolution.h"
using namespace std;
int main()
{
cout << "배열의 크기를 입력하세요 : ";
int size;
cin >> size;
int* arr = new int[size * size];
memset(arr, 0, sizeof(int) * size * size);
Snail snail;
snail.MoveOn(arr, size);
// 3. 출력
for (int r = 0; r < size; r++)
{
for (int c = 0; c < size; c++)
{
cout << arr[r * size + c] << "\\t";
}
cout << "\\n";
}
delete[] arr;
}