#include <iostream>
#include <cstdlib> //利用cstdlib中的rand函数来生成随机数
// #include <cassert> //你不要管这个是啥

using namespace std;

//生成一定范围内的随机数
int RandomNumberInRange(int from, int to) {
  //assert(from < to);
  return from + rand() % (to - from);
}

int main() {
  for (int i = 0; i < 10; i++)
    cout << rand() << endl;
  
  //限制这个随机数在0-99
  for (int i = 0; i < 10; i++)
    cout << rand() % 100 << endl;
  
  //生成一定范围内的随机数
  //注意from一定要小于to
  cout << RandomNumberInRange(-32, 123) << endl;
}

//
// Created by 31838 on 8/8/2019.
//

#include <iostream>
#include <chrono>
#include <random>

using std::cout, std::cin, std::endl;
using std::chrono::system_clock, std::uniform_int_distribution, std::default_random_engine;

auto main() -> int {
  auto now = system_clock::now();
  auto dist = uniform_int_distribution<int>();
  auto engine = default_random_engine(now.time_since_epoch().count());
  
  for (int i = 0; i < 10; i++) {
    int unexpected = dist(engine) % 100;
    cout << "Please enter a number other than " << unexpected << ": ";
    int entered = 0;
    cin >> entered;
    if (entered == unexpected) {
      cout << "Hey! you weren't supposed to enter " << unexpected << " !" << endl;
      return EXIT_FAILURE;
    }
  }
  cout << "Wow, you're more patient then I am, you win." << endl;
  return EXIT_SUCCESS;
}

#include <iostream>
#include <array>
#include <string>

using std::array, std::cout, std::endl, std::cin, std::string, std::getline, std::stoi;

const size_t num_drinks = 5;

array<string, num_drinks> all_drinks;

template<size_t arr_len = num_drinks>
auto ShowDrinks(array<string, arr_len> drinks) -> void {
  cout << "There are " << arr_len << " drinks, which one do you like?" << endl;
  for (size_t i = 0; i < arr_len; i++)
    cout << " " << i + 1 << ") " << drinks[i] << endl;
}

auto Init() -> void {
  all_drinks = {"Cola", "Water", "Sprite", "Juice", "Tea"};
}

auto main() -> int {
  Init();
  ShowDrinks(all_drinks);
  string choice_str;
  int choice = 0;
  getline(cin, choice_str);
  if (choice_str.size() != 1)goto invalid_choice;
  choice = stoi(choice_str);
  if (choice >= 1 && choice <= num_drinks) {
    cout << "OK, your choice is " << all_drinks[choice - 1] << "." << endl;
    exit(EXIT_SUCCESS);
  }
  invalid_choice:
  cout << "Error, your choice was invalid. Here is your money back." << endl;
  exit(EXIT_FAILURE);
}

//
// Created by 31838 on 8/8/2019.
//

#include <iostream>
#include <array>


using std::cin, std::cout, std::endl, std::array, std::swap;

struct person {
  uint num;
  uint id;
  
  bool operator<(const person &p) {
    return num < p.num;
  }
  
  bool operator>(const person &p) {
    return num > p.num;
  }
};

const uint num_person = 5;

auto main() -> int {
  if (num_person < 2) {
    cout << "number of people should bigger or equal to 2" << endl;
    return EXIT_FAILURE;
  }
  
  array<person, num_person> people = {};
  
  for (int i = 0; i < num_person; i++) {
    cout << "Person" << i + 1 << " eat: ";
    cin >> people[i].num;
    people[i].id = i;
  }
  
  person max = people[0], min = people[0];
  
  for (int i = 0; i < num_person; i++) {
    max = people[i] > max ? people[i] : max;
    min = people[i] < min ? people[i] : min;
  }
  
  cout << endl;
  cout << "Person" << max.id + 1 << " ate the most pancakes, the number is " << max.num << endl;
  cout << "Person" << min.id + 1 << " ate the least pancakes, the number is " << min.num << endl;
  cout << endl;
  
  for (uint i = 0; i < num_person; i++)
    for (uint j = 0; j < num_person - 1; j++)
      if (people[j] < people[j + 1])
        swap(people[j], people[j + 1]);
  
  for (uint i = 0; i < num_person; i++)
    cout << "Person" << people[i].id + 1 << " ate " << people[i].num << " pancake(s)" << endl;
  
  return EXIT_SUCCESS;
}

//
// Created by 31838 on 8/8/2019.
//

#include <iostream>
#include <array>
#include <random>
#include <chrono>

using std::cout, std::endl, std::cin, std::getchar;
using std::array, std::string;

const size_t row_num = 10, col_num = 20, trap_num = 50;

auto panic(const string &msg) -> void {
  cout << "\033[2J\033[1;1H";
  cout << "[PANIC] " + msg << endl;
  exit(EXIT_FAILURE);
}

class Position {
protected:
  uint row;
  uint col;
public:
  auto GetRow() -> uint {
    return row;
  }
  
  auto GetCol() -> uint {
    return col;
  }
  
  auto SetRow(uint r) -> void {
    row = r;
  }
  
  auto SetCol(uint c) -> void {
    col = c;
  }
  
  auto operator==(const Position &pos) -> bool {
    return pos.row == row && pos.col == col;
  }
  
  auto operator!=(const Position &pos) -> bool {
    return !operator==(pos);
  }
};

template<size_t row_num, size_t col_num>
class Player : public Position {
  auto MoveOutOfBoard() {
    panic("You are moving out of board!");
  }

public:
  auto GoUp() -> void {
    if (!row)
      MoveOutOfBoard();
    row--;
  }
  
  auto GoDown() -> void {
    row++;
    if (row >= row_num)
      MoveOutOfBoard();
  }
  
  auto GoLeft() -> void {
    if (!col)
      MoveOutOfBoard();
    col--;
  }
  
  auto GoRight() -> void {
    col++;
    if (col >= col_num)
      MoveOutOfBoard();
  }
};

enum class GameOverFlag {
  kSuccess,
  kFail,
  kNotOver
};

enum class KeyboardCommand {
  kUp,
  kDown,
  kLeft,
  kRight
};

template<size_t row_num = 10, size_t col_num = 10, size_t trap_num = 10>
class Game {
private:
  Player<row_num, col_num> player_{};
  array<Position, trap_num> traps_{};
  Position randomTrap_{};
  Position treasure_{};
  
  auto RandomPosition() -> Position {
    using std::chrono::system_clock, std::uniform_int_distribution, std::default_random_engine;
    
    auto now = system_clock::now();
    auto dist = uniform_int_distribution<size_t>();
    auto engine = default_random_engine(now.time_since_epoch().count());
    
    Position pos = {};
    pos.SetRow(dist(engine) % row_num);
    pos.SetCol(dist(engine) % col_num);
    return pos;
  }
  
  auto ValidateTrapPosition(Position pos) -> bool {
    return pos != player_ && pos != treasure_;
  }
  
  auto ValidateTreasurePosition(Position pos) -> bool {
    return pos != player_;
  }
  
  auto Init() -> void {
    ClearScreen();
    player_.SetCol(0);
    player_.SetRow(0);
    
    gen_treasure:
    treasure_ = RandomPosition();
    if (!ValidateTreasurePosition(treasure_))
      goto gen_treasure;
    
    for (size_t i = 0; i < trap_num; i++) {
      gen_trap:
      auto trap = RandomPosition();
      if (!ValidateTrapPosition(trap))
        goto gen_trap;
      traps_[i] = trap;
    }
    
    gen_random_trap:
    auto trap = RandomPosition();
    if (!ValidateTrapPosition(trap))
      goto gen_random_trap;
    randomTrap_ = trap;
  }

public:
  Game() {
    Init();
  }
  
  ~Game() {
    ClearScreen();
  }

private:
  auto ClearScreen() -> void {
    cout << "\033[2J\033[1;1H";
  }
  
  auto ShowBoard() -> void {
    ClearScreen();
    array<array<char, col_num>, row_num> board = {};
    
    for (array<char, col_num> &row:board) {
      for (char &col:row)
        col = '.';
    }
    
    for (auto trap:traps_)
      board[trap.GetRow()][trap.GetCol()] = 'T';
    board[randomTrap_.GetRow()][randomTrap_.GetCol()] = 'T';
    board[treasure_.GetRow()][treasure_.GetCol()] = 'X';
    board[player_.GetRow()][player_.GetCol()] = 'G';
    
    for (array<char, col_num> row:board) {
      for (char col:row)
        cout << col;
      cout << endl;
    }
  }
  
  auto IsGameOver() -> GameOverFlag {
    if (player_ == treasure_)
      return GameOverFlag::kSuccess;
    if (player_ == randomTrap_)
      return GameOverFlag::kFail;
    for (auto trap:traps_) {
      if (trap == player_)
        return GameOverFlag::kFail;
    }
    
    return GameOverFlag::kNotOver;
  }
  
  auto GenerateRandomTrap() -> void {
    gen_random_trap:
    auto trap = RandomPosition();
    if (!ValidateTrapPosition(trap))
      goto gen_random_trap;
    randomTrap_ = trap;
  }
  
  auto DoCommand(KeyboardCommand cmd) {
    switch (cmd) {
      case KeyboardCommand::kUp:
        player_.GoUp();
        break;
      case KeyboardCommand::kDown:
        player_.GoDown();
        break;
      case KeyboardCommand::kLeft:
        player_.GoLeft();
        break;
      case KeyboardCommand::kRight:
        player_.GoRight();
        break;
    }
  }
  
  auto Reset() -> void {
    Init();
  }

public:
  auto Play() -> void {
    GameOverFlag flag;
    do {
      GenerateRandomTrap();
      ShowBoard();
      char ch;
      cin >> ch;
      switch (char(ch)) {
        case 'w':
          DoCommand(KeyboardCommand::kUp);
          break;
        case 's':
          DoCommand(KeyboardCommand::kDown);
          break;
        case 'a':
          DoCommand(KeyboardCommand::kLeft);
          break;
        case 'd':
          DoCommand(KeyboardCommand::kRight);
          break;
        case 'r':
          Reset();
          break;
        default:
          panic("Unknown key from Keyboard");
      }
      flag = IsGameOver();
      ShowBoard();
    } while (flag == GameOverFlag::kNotOver);
    
    if (flag == GameOverFlag::kFail)
      cout << "Sorry, you failed" << endl;
    else
      cout << "Wow! You win!" << endl;
  }
};

auto main() -> int {
  cout << "\033[2J\033[1;1H";
  cout << R"(
Welcome to dungeon crawl game.
You can use w,s,a,d to control player and r to reset the game.
Ready to go? Press ENTER to move on!
)";
  getchar();
  
  play:
  auto g = new Game<row_num, col_num, trap_num>();
  g->Play();
  ask:
  {
    cout << "Would you like to play again? [y/n] ";
    string str;
    cin >> str;
    if (str == "y") {
      delete (g);
      goto play;
    } else if (str == "n") {
      delete (g);
      cout << "Bye Bye." << endl;
      return EXIT_SUCCESS;
    } else {
      cout << "Please enter y or n." << endl;
      goto ask;
    }
  }
}