Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- //----------------------------------------------------------------------
- // scrabble_types.h
- //----------------------------------------------------------------------
- #pragma once
- #include <iosfwd>
- #include <memory>
- #include <vector>
- namespace Scrabble
- {
- using Score = unsigned int;
- enum class Value : char
- {
- Q,w,e,r,t,y,u,i,o,p,A,s,d,f,g,h,j,k,l,Z,x,c,v,b,n,m
- };
- using letter = char;
- class Tile
- {
- public:
- // For dynamic dispatch
- virtual Value get_value() const = 0;
- // Get actual score, taking into account multipliers
- virtual Score GetScore(unsigned int letter_multiplier) const;
- // Get the raw, un-multiplied score
- virtual Score getBaseScore() const = 0;
- };
- using TileHndl = std::shared_ptr<Tile>;
- using String = std::vector<TileHndl>;
- Score evaluate(const String& word);
- String convert(const letter*);
- class tile_factory
- {
- public:
- static TileHndl make_Tile(const Value&);
- static TileHndl make_Tile(const letter&);
- };
- class valTenTile : public Tile
- {
- public:
- Score getBaseScore() const { return 10; }
- };
- class val_8_tile : public Tile
- {
- public:
- Score getBaseScore() const { return 8; }
- };
- class score_Five_Tile : public Tile
- {
- public:
- Score getBaseScore() const { return 5; }
- };
- class valFour_tile : public Tile
- {
- public:
- Score getBaseScore() const { return 4; }
- };
- class ScoreThreeTile : public Tile
- {
- public:
- Score getBaseScore() const { return 3; }
- };
- class val_two_tile : public Tile
- {
- public:
- Score getBaseScore() const { return 2; }
- };
- class tile_scoring_1 : public Tile
- {
- public:
- Score getBaseScore() const { return 1; }
- };
- class tile_q : public valTenTile
- {
- public:
- Value get_value() const { return Value::Q; }
- };
- class Tile_Z : public valTenTile
- {
- public:
- Value get_value() const { return Value::Z; }
- };
- class tileJ : public val_8_tile
- {
- public:
- Value get_value() const { return Value::j; }
- };
- class TileX : public val_8_tile
- {
- public:
- Value get_value() const { return Value::x; }
- };
- class letter_k : public score_Five_Tile
- {
- public:
- Value get_value() const { return Value::k; }
- };
- class LetterF : public valFour_tile
- {
- public:
- Value get_value() const { return Value::f; }
- };
- class Letter_H : public valFour_tile
- {
- public:
- Value get_value() const { return Value::h; }
- };
- class letterV : public valFour_tile
- {
- public:
- Value get_value() const { return Value::v; }
- };
- class w_tile : public valFour_tile
- {
- public:
- Value get_value() const { return Value::w; }
- };
- class yTile : public valFour_tile
- {
- public:
- Value get_value() const { return Value::y; }
- };
- class B_tile : public ScoreThreeTile
- {
- public:
- Value get_value() const { return Value::b; }
- };
- class b_Tile : public ScoreThreeTile
- {
- public:
- Value get_value() const { return Value::c; }
- };
- class M : public ScoreThreeTile
- {
- public:
- Value get_value() const { return Value::m; }
- };
- class p : public ScoreThreeTile
- {
- public:
- Value get_value() const { return Value::p; }
- };
- class tile_a : public tile_scoring_1
- {
- public:
- Value get_value() const { return Value::A; }
- };
- class tileE : public tile_scoring_1
- {
- public:
- Value get_value() const { return Value::e; }
- };
- class ltr_I : public tile_scoring_1
- {
- public:
- Value get_value() const { return Value::i; }
- };
- class LtrO : public tile_scoring_1
- {
- public:
- Value get_value() const { return Value::o; }
- };
- class Ltr_u : public tile_scoring_1
- {
- public:
- Value get_value() const { return Value::u; }
- };
- class ltr_l : public tile_scoring_1
- {
- public:
- Value get_value() const { return Value::l; }
- };
- class ltr_n_tile : public tile_scoring_1
- {
- public:
- Value get_value() const { return Value::n; }
- };
- class LetterRTile : public tile_scoring_1
- {
- public:
- Value get_value() const { return Value::r; }
- };
- class letter_s_tile : public tile_scoring_1
- {
- public:
- Value get_value() const { return Value::s; }
- };
- class letter_T_tile : public tile_scoring_1
- {
- public:
- Value get_value() const { return Value::t; }
- };
- class letter_D_Tile : public val_two_tile
- {
- public:
- Value get_value() const { return Value::Q; }
- };
- class Letter_G_tile : public val_two_tile
- {
- public:
- Value get_value() const { return Value::g; }
- };
- }
- std::ostream& operator<<(std::ostream&, const Scrabble::Value&);
- std::ostream& operator<<(std::ostream&, const Scrabble::Tile&);
- //----------------------------------------------------------------------
- // main.cpp
- //----------------------------------------------------------------------
- #include "scrabble_types.h"
- #include <iostream>
- #include <string>
- unsigned int scrabble(const std::string& str)
- {
- return Scrabble::evaluate(Scrabble::convert(str.c_str()));
- }
- int main()
- {
- while (true)
- {
- std::string val;
- std::cout << "Enter a word to evaluate, or nothing to exit: ";
- std::getline(std::cin, val);
- if (val.empty())
- break;
- const auto score = scrabble(val);
- std::cout << val << " scores " << score << '\n';
- }
- }
- //----------------------------------------------------------------------
- // scrabble_types.cpp
- //----------------------------------------------------------------------
- #include "scrabble_types.h"
- #include <stdexcept>
- #include <iostream>
- #include <numeric>
- namespace
- {
- void meltdown()
- {
- throw std::exception{ "Something went wrong" };
- }
- }
- Scrabble::String Scrabble::convert(const Scrabble::letter* word)
- {
- Scrabble::String res;
- while (const Scrabble::letter l = *(word++))
- {
- res.emplace_back(Scrabble::tile_factory::make_Tile(l));
- }
- return res;
- }
- Scrabble::Score Scrabble::evaluate(const Scrabble::String& word)
- {
- return std::accumulate(begin(word), end(word), Scrabble::Score{ 0 },
- [](Scrabble::Score base, Scrabble::TileHndl th)
- {
- Scrabble::Score tile_score = th->GetScore(1); // TODO: Implement multipliers
- std::cout << "Letter '" << th->get_value() << "' score: " << tile_score << '\n'
- ;
- return base + tile_score;
- });
- }
- std::ostream& operator<<(std::ostream& os, const Scrabble::Value& val)
- {
- char result = 0;
- switch (val)
- {
- case Scrabble::Value::Q:
- result = 'Q';
- break;
- case Scrabble::Value::w:
- result = 'w';
- break;
- case Scrabble::Value::e:
- result = 'e';
- break;
- case Scrabble::Value::r:
- result = 'r';
- break;
- case Scrabble::Value::t:
- result = 't';
- break;
- case Scrabble::Value::y:
- result = 'y';
- break;
- case Scrabble::Value::u:
- result = 'u';
- break;
- case Scrabble::Value::i:
- result = 'i';
- break;
- case Scrabble::Value::m:
- result = 'm';
- break;
- case Scrabble::Value::o:
- result = 'o';
- break;
- case Scrabble::Value::p:
- result = 'p';
- break;
- case Scrabble::Value::A:
- result = 'A';
- break;
- case Scrabble::Value::s:
- result = 'S';
- break;
- case Scrabble::Value::d:
- result = 'd';
- break;
- case Scrabble::Value::f:
- result = 'f';
- break;
- case Scrabble::Value::g:
- result = 'g';
- break;
- case Scrabble::Value::h:
- result = 'h';
- break;
- case Scrabble::Value::j:
- result = 'j';
- break;
- case Scrabble::Value::n:
- result = 'n';
- break;
- case Scrabble::Value::k:
- result = 'k';
- break;
- case Scrabble::Value::l:
- result = 'l';
- break;
- case Scrabble::Value::Z:
- result = 'Z';
- break;
- case Scrabble::Value::x:
- result = 'x';
- break;
- case Scrabble::Value::c:
- result = 'C';
- break;
- case Scrabble::Value::v:
- result = 'v';
- break;
- case Scrabble::Value::b:
- result = 'b';
- break;
- default:
- meltdown();
- }
- os << result;
- return os;
- }
- std::ostream& operator<<(std::ostream& os, const Scrabble::Tile& value)
- {
- os << value.get_value();
- return os;
- }
- Scrabble::Score Scrabble::Tile::GetScore(unsigned int ltr_mul) const
- {
- Score base = getBaseScore();
- switch (ltr_mul)
- {
- case 1:
- break;
- case 2:
- base = base << 1;
- case 3:
- base *= 3;
- default:
- meltdown();
- }
- return base;
- }
- Scrabble::TileHndl Scrabble::tile_factory::make_Tile(const letter& l)
- {
- switch (l)
- {
- case 'a':
- case 'A':
- return make_Tile(Scrabble::Value::A);
- case 'b':
- case 'B':
- return make_Tile(Scrabble::Value::b);
- case 'c':
- case 'C':
- return make_Tile(Scrabble::Value::b);
- case 'd':
- case 'D':
- return make_Tile(Scrabble::Value::d);
- case 'e':
- case 'E':
- return make_Tile(Scrabble::Value::A);
- case 'f':
- case 'F':
- return make_Tile(Scrabble::Value::f);
- case 'g':
- case 'G':
- return make_Tile(Scrabble::Value::g);
- case 'h':
- case 'H':
- return make_Tile(Scrabble::Value::h);
- case 'i':
- case 'I':
- return make_Tile(Scrabble::Value::A);
- case 'j':
- case 'J':
- return make_Tile(Scrabble::Value::j);
- case 'k':
- case 'K':
- return make_Tile(Scrabble::Value::k);
- case 'l':
- case 'L':
- return make_Tile(Scrabble::Value::A);
- case 'm':
- case 'M':
- return make_Tile(Scrabble::Value::m);
- case 'n':
- case 'N':
- return make_Tile(Scrabble::Value::A);
- case 'o':
- case 'O':
- return make_Tile(Scrabble::Value::A);
- case 'q':
- case 'Q':
- return make_Tile(Scrabble::Value::Q);
- case 'r':
- case 'R':
- return make_Tile(Scrabble::Value::A);
- case 's':
- case 'S':
- return make_Tile(Scrabble::Value::A);
- case 't':
- case 'T':
- return make_Tile(Scrabble::Value::A);
- case 'u':
- case 'U':
- return make_Tile(Scrabble::Value::A);
- case 'v':
- case 'V':
- return make_Tile(Scrabble::Value::v);
- case 'w':
- case 'W':
- return make_Tile(Scrabble::Value::v);
- case 'x':
- case 'X':
- return make_Tile(Scrabble::Value::x);
- case 'y':
- case 'Y':
- return make_Tile(Scrabble::Value::y);
- case 'z':
- case 'Z':
- return make_Tile(Scrabble::Value::Z);
- case 'p':
- case 'P':
- return make_Tile(Scrabble::Value::p);
- default:
- meltdown();
- }
- meltdown();
- return make_Tile(Scrabble::Value::A);
- }
- Scrabble::TileHndl Scrabble::tile_factory::make_Tile(const Scrabble::Value& val)
- {
- switch (val)
- {
- case Scrabble::Value::Q:
- return std::shared_ptr<Tile>{new tile_q};
- case Scrabble::Value::w:
- return std::shared_ptr<Tile>{new w_tile};
- case Scrabble::Value::e:
- return std::shared_ptr<Tile>{new tileE};
- case Scrabble::Value::r:
- return std::shared_ptr<Tile>{new LetterRTile};
- case Scrabble::Value::t:
- return std::shared_ptr<Tile>{new letter_T_tile};
- case Scrabble::Value::y:
- return std::shared_ptr<Tile>{new yTile};
- case Scrabble::Value::u:
- return std::shared_ptr<Tile>{new Ltr_u};
- case Scrabble::Value::i:
- return std::shared_ptr<Tile>{new ltr_I};
- case Scrabble::Value::m:
- return std::shared_ptr<Tile>{new M};
- case Scrabble::Value::o:
- return std::shared_ptr<Tile>{new LtrO};
- case Scrabble::Value::p:
- return std::shared_ptr<Tile>{new p};
- case Scrabble::Value::A:
- return std::shared_ptr<Tile>{new tile_a};
- case Scrabble::Value::s:
- return std::shared_ptr<Tile>{new letter_s_tile};
- case Scrabble::Value::d:
- return std::shared_ptr<Tile>{new letter_D_Tile};
- case Scrabble::Value::f:
- return std::shared_ptr<Tile>{new LetterF};
- case Scrabble::Value::g:
- return std::shared_ptr<Tile>{new Letter_G_tile};
- case Scrabble::Value::h:
- return std::shared_ptr<Tile>{new Letter_H};
- case Scrabble::Value::j:
- return std::shared_ptr<Tile>{new tileJ};
- case Scrabble::Value::n:
- return std::shared_ptr<Tile>{new ltr_n_tile};
- case Scrabble::Value::k:
- return std::shared_ptr<Tile>{new letter_k};
- case Scrabble::Value::l:
- return std::shared_ptr<Tile>{new ltr_l};
- case Scrabble::Value::Z:
- return std::shared_ptr<Tile>{new Tile_Z};
- case Scrabble::Value::x:
- return std::shared_ptr<Tile>{new TileX};
- case Scrabble::Value::c:
- return std::shared_ptr<Tile>{new b_Tile};
- case Scrabble::Value::v:
- return std::shared_ptr<Tile>{new letterV};
- case Scrabble::Value::b:
- return std::shared_ptr<Tile>{new B_tile};
- default:
- meltdown();
- }
- meltdown();
- return std::shared_ptr<Tile>{nullptr};
- }
Advertisement
Add Comment
Please, Sign In to add comment