CXX = clang++
CXXFLAGS = -g -Wall -Wextra -pedantic
LIBS = -lranduint32
TARGETS = rand-test dice

# Note: The rules below use useful-but-cryptic make "Automatic variables"
#       to avoid duplicating information in multiple places, the most useful
#       of which are:
#
#   $@  The file name of the target of the rule
#   $^  The names of all the prerequisites, with spaces between them.
#   $<  The name of the first prerequisite
#
# For GNU make, you'll find that it supports quite an extensive list, at
#   http://www.gnu.org/software/make/manual/html_node/Automatic-Variables.html

all: $(TARGETS)

rand-test: rand-test.o
    $(CXX) $^ -o $@ $(LIBS)

rand-test.o: rand-test.cpp
    $(CXX) $(CXXFLAGS) -c $<

dice: dice.o
    $(CXX) $^ -o $@ $(LIBS)

dice.o: dice.cpp
    $(CXX) $(CXXFLAGS) -c $<

clean:
    rm -rf $(TARGETS) *.o

#include <iostream>
#include <cs70/randuint32.hpp>

int main() {
    // We are going to generate some number of random samples
    constexpr size_t NUM_TO_GENERATE = 10;

    // Let's generate numbers between 0 and 99
    constexpr size_t RAND_RANGE = 100;

    // Using a specified seed, we can create a pseudorandom
    // number generator that always produces the same
    // random-seeming sequence on every run of the program
    //
    // This is good for debugging programs that need to use
    // random numbers so that you get the same 'random'
    // sequence while you test your code
    size_t SEED = 17;

    // pass the seed to to construct a CS70random object
    RandUInt32 rng_repeatable{SEED};

    // We can now generate the same sequence each time we run the program
    std::cout << "Reproducible pseudorandom sequence:" << std::endl;
    for (size_t i = 0; i < NUM_TO_GENERATE; ++i) {
        std::cout << rng_repeatable.get(RAND_RANGE) << " ";
    }
    std::cout << std::endl;

    // If we do not pass a seed to the constructor, we will get
    // a different random sequence every time we run the program
    RandUInt32 rng_nonrepeatable;

    // We can now generate a different sequence each time we run the program
    std::cout << "Different pseudorandom sequence for every run:" << std::endl;
    for (size_t i = 0; i < NUM_TO_GENERATE; ++i) {
        std::cout << rng_nonrepeatable.get(RAND_RANGE) << " ";
    }
    std::cout << std::endl;

    return 0;
}

#include <iostream>
#include <cmath>
#include <cs70/randuint32.hpp>

using std::cout;
using std::endl;

int main() {
    // Let's simulate a game where we are trying to roll
    // a die and get the winning number
    constexpr size_t NUM_OF_DICE_ROLLS = 1000;
    constexpr size_t DICE_SIDES = 6;
    constexpr size_t WINNING_NUMBER = 2;

    // create a random number generator with no seed
    RandUInt32 rng_nonrepeatable;

    size_t num_wins = 0;

    for (size_t i = 0; i < NUM_OF_DICE_ROLLS; ++i) {
        unsigned int dice_roll = rng_nonrepeatable.get(DICE_SIDES);
        if (dice_roll == WINNING_NUMBER) {
            // you get 1 point for rolling the winning number
            cout << '+';
            ++num_wins;
        } else {
            // you get 0 points for rolling anything else
            cout << '_';
        }
    }

    // In the code below, notice that we convert the numerator to a double,
    // otherwise, we would get integer division and have a value of 0 for
    // the result!  We either do that with an explicit conversion, or by
    // multiplying by a double constant.

    double expected_wins = double(NUM_OF_DICE_ROLLS) / DICE_SIDES;
    double expected_percent = 100.0 / DICE_SIDES;
    double actual_percentage = 100.0 * num_wins / NUM_OF_DICE_ROLLS;

    cout << "\n\nYou won " << num_wins << " points out of " << NUM_OF_DICE_ROLLS
         << " trials.\n\n"

         << "We'd expect to win " << expected_percent << "% of games ("
         << expected_wins << " wins on average)\n"
         << "In this simulation, we won " << actual_percentage << "% of games"
         << endl;
    if (std::abs(actual_percentage - expected_percent) <= 0.5) {
        cout << "Whoa, that's pretty close!" << endl;
    } else if (actual_percentage < expected_percent) {
        cout << "Better luck next time!" << endl;
    } else if (actual_percentage > expected_percent) {
        cout << "I guess we got lucky!" << endl;
    }

    return 0;
}

#include <iostream>
#include <random>
#include <vector>
#include <algorithm>
#include <cs70/randuint32.hpp>

enum suit_t { HEARTS, CLUBS, DIAMONDS, SPADES };
constexpr const char* SUITS[] = {"♥", "♣", "♦", "♠"};
constexpr const char* RANKS[] = {"A", "2", "3",  "4", "5", "6", "7",
                                 "8", "9", "10", "J", "Q", "K"};

int main() {
    // Create a deck of cards, in order
    std::vector<std::string> deck;
    for (const auto& suit : SUITS) {
        for (const auto& rank : RANKS) {
            std::string card = std::string(rank) + suit;
            // If red, wrap with ANSI escape codes to make it red
            if (suit == SUITS[HEARTS] || suit == SUITS[DIAMONDS]) {
                card = "\033[31m" + card + "\033[0m";  // Red
            }
            deck.push_back(card);
        }
    }

    // Create a RandUInt32 object with random seed
    RandUInt32 rng;

    // Show four games of shuffling the deck
    for (int game = 1; game <= 4; ++game) {
        std::cout << "Game " << game << ":" << std::endl;

        // Shuffle the deck using std::shuffle and our RandUInt32 as the PRNG
        std::shuffle(deck.begin(), deck.end(), rng);

        // Print out four 13 card hands
        for (int hand = 0; hand < 4; ++hand) {
            std::cout << "  - Hand " << (hand + 1) << ": ";
            for (int card = 0; card < 13; ++card) {
                if (card > 0) {
                    std::cout << ", ";
                }
                std::cout << deck[hand * 13 + card];
            }
            std::cout << std::endl;
        }
        std::cout << std::endl;
    }

    return 0;
}