01-Leap Year

tdd_intro/demo/02_word_count/02_word_count.pro

@@ -0,0 +1,10 @@
+include(../../gtest.pri)
+
+TEMPLATE = app
+CONFIG += console c++11
+CONFIG -= app_bundle
+CONFIG -= qt
+
+SOURCES += \
+    test.cpp
+

tdd_intro/demo/02_word_count/test.cpp

@@ -0,0 +1,132 @@
+/*
+Given a phrase, count the occurrences of each word in that phrase. Ignore whitespaces and punctual symbols
+For example for the input "olly olly in come free please please let it be in such manner olly"
+olly: 3
+in: 2
+come: 1
+free: 1
+please: 2
+let: 1
+it: 1
+be: 1
+manner: 1
+such: 1
+*/
+
+#include <gtest/gtest.h>
+#include <string>
+#include <map>
+
+using words_mt = std::map<std::string, size_t>;
+const static char wordSeparator = ' ';
+
+bool TrimWord(std::string& phrase, std::string& word, const char seperator)
+{
+    if (phrase.empty())
+    {
+        return false;
+    }
+
+    size_t index = phrase.find_first_of(seperator);
+    if (index == std::string::npos || index == phrase.size())
+    {
+        word = phrase;
+        phrase.clear();
+    }
+    else
+    {
+        word = phrase.substr(0, index);
+        phrase = phrase.substr(index + 1, phrase.size() - index);
+    }
+
+    return true;
+}
+
+words_mt SeparateWords(const std::string& phrase)
+{
+    words_mt words;
+    std::string currentPhrase = phrase;
+    std::string curentWord;
+
+    while (TrimWord(currentPhrase, curentWord, wordSeparator))
+    {
+        ++words[curentWord];
+    }
+
+    return words;
+}
+
+TEST(WordsCount, TestSeparateFirstWord)
+{
+    words_mt words = SeparateWords("hello");
+    EXPECT_EQ(1, words.size());
+    EXPECT_TRUE(words.find("hello") != words.end());
+    EXPECT_EQ(1, words["hello"]);
+}
+
+TEST(WordsCount, TestTrimOneWord)
+{
+    std::string phrase = "tdd course";
+    std::string word;
+    EXPECT_TRUE(TrimWord(phrase, word, ' '));
+    EXPECT_EQ("course", phrase);
+
+    EXPECT_TRUE(TrimWord(phrase, word, ' '));
+    EXPECT_EQ("", phrase);
+
+    EXPECT_FALSE(TrimWord(phrase, word, ' '));
+}
+
+TEST(WordsCount, TestCountSeveralDifferentWords)
+{
+    words_mt words = SeparateWords("hello bro");
+    EXPECT_EQ(2, words.size());
+
+    EXPECT_TRUE(words.find("hello") != words.end());
+    EXPECT_EQ(1, words["hello"]);
+
+    EXPECT_TRUE(words.find("bro") != words.end());
+    EXPECT_EQ(1, words["bro"]);
+}
+
+TEST(WordsCount, TestCountSeveralSameWords)
+{
+    words_mt words = SeparateWords("hello bro hello");
+
+    EXPECT_EQ(2, words.size());
+    EXPECT_TRUE(words.find("hello") != words.end());
+    EXPECT_EQ(2, words["hello"]);
+}
+
+TEST(WordsCount, TestNoWordsWhenEmptyInput)
+{
+    words_mt words = SeparateWords("");
+    EXPECT_TRUE(words.empty());
+}
+
+TEST(WordsCount, TestOneWordWhenSeparatorInEnd)
+{
+    words_mt words = SeparateWords("hello ");
+
+    EXPECT_EQ(1, words.size());
+    EXPECT_TRUE(words.find("hello") != words.end());
+    EXPECT_EQ(1, words["hello"]);
+}
+
+TEST(WordsCount, AcceptanceTest)
+{
+    words_mt words = SeparateWords("olly olly in come free please please let it be in such manner olly");
+
+    ASSERT_EQ(10, words.size());
+
+    ASSERT_EQ(3, words["olly"]);
+    ASSERT_EQ(2, words["in"]);
+    ASSERT_EQ(1, words["come"]);
+    ASSERT_EQ(1, words["free"]);
+    ASSERT_EQ(2, words["please"]);
+    ASSERT_EQ(1, words["let"]);
+    ASSERT_EQ(1, words["it"]);
+    ASSERT_EQ(1, words["be"]);
+    ASSERT_EQ(1, words["manner"]);
+    ASSERT_EQ(1, words["such"]);
+}

tdd_intro/demo/demo.pro

@@ -4,6 +4,7 @@ SUBDIRS += \
     01_bob \
     01_fizz_buzz \
     02_anagram \
+    02_word_count \
     #03_allergies \
     03_roman_numerals \
     04_timer

tdd_intro/homework/01_leap_year/test.cpp

@@ -13,3 +13,58 @@ If your language provides a method in the standard library that does this look-u
 */
 
 #include <gtest/gtest.h>
+
+
+const size_t g_four         = 4;
+const size_t g_oneHundred   = 100;
+const size_t g_fourHundred  = g_four * g_oneHundred;
+
+bool isDivisible(size_t number, size_t divider)
+{
+    return number % divider == 0;
+}
+
+bool IsLeapYear(size_t year)
+{
+    if (isDivisible(year, g_fourHundred))
+    {
+        return true;
+    }
+    if (isDivisible(year, g_oneHundred))
+    {
+        return false;
+    }
+    if (isDivisible(year, g_four))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+TEST(LeapYear, TestDivisible400)
+{
+    EXPECT_TRUE(IsLeapYear(g_fourHundred));
+    EXPECT_TRUE(IsLeapYear(g_fourHundred * 2));
+    EXPECT_TRUE(IsLeapYear(g_fourHundred * 3));
+}
+
+TEST(LeapYear, TestDivisible4AndNot100)
+{
+    EXPECT_TRUE(IsLeapYear(104));
+    EXPECT_TRUE(IsLeapYear(404));
+    EXPECT_TRUE(IsLeapYear(2008));
+    EXPECT_TRUE(IsLeapYear(2012));
+}
+
+TEST(LeapYear, TestDivisible100)
+{
+    EXPECT_FALSE(IsLeapYear(g_oneHundred));
+    EXPECT_FALSE(IsLeapYear(g_oneHundred * 5));
+}
+
+TEST(LeapYear, TestNotDivisible4_400_100)
+{
+    EXPECT_FALSE(IsLeapYear(333));
+    EXPECT_FALSE(IsLeapYear(555));
+}

tdd_intro/homework/02_ternary_numbers/test.cpp

@@ -1,4 +1,6 @@
 #include <gtest/gtest.h>
+#include <cmath>
+#include <string>
 
 /*
 Convert a ternary number, represented as a string (e.g. '102012'), to its decimal equivalent using first principles.
@@ -16,3 +18,72 @@ The last place in a ternary number is the 1's place. The second to last is the 3
 
 If your language provides a method in the standard library to perform the conversion, pretend it doesn't exist and implement it yourself.
 */
+
+size_t ConvertTernaryToDecimal(size_t numerical, size_t position)
+{
+    if(numerical > 2)
+    {
+        return 0;
+    }
+
+    double ternaryPow = std::pow(3, position);
+    return static_cast<size_t>(ternaryPow) * numerical;
+}
+
+size_t ConvertTernaryToDecimal(const std::string& ternary)
+{
+    size_t result = 0;
+    size_t position = ternary.size();
+    for (const char ternarySymbChar: ternary)
+    {
+        int ternaryNumb = std::atoi(&ternarySymbChar);
+        result += ConvertTernaryToDecimal(static_cast<size_t>(ternaryNumb), --position);
+    }
+
+    return result;
+}
+
+TEST(TernaryNumber, TestConvertTernaryNum_Pos0_ToDecimal)
+{
+    EXPECT_EQ(0, ConvertTernaryToDecimal(0, 0));
+    EXPECT_EQ(1, ConvertTernaryToDecimal(1, 0));
+    EXPECT_EQ(2, ConvertTernaryToDecimal(2, 0));
+}
+
+TEST(TernaryNumber, TestConvertTernaryNum_Larger0_ToDecimal)
+{
+    EXPECT_EQ(3, ConvertTernaryToDecimal(1, 1));
+    EXPECT_EQ(0, ConvertTernaryToDecimal(0, 2));
+    EXPECT_EQ(54, ConvertTernaryToDecimal(2, 3));
+}
+
+TEST(TernaryNumber, TestConvertInvalidTernary)
+{
+    EXPECT_EQ(0, ConvertTernaryToDecimal(4, 0));
+    EXPECT_EQ(0, ConvertTernaryToDecimal(5, 0));
+    EXPECT_EQ(0, ConvertTernaryToDecimal(20, 0));
+}
+
+TEST(TernaryNumber, TestConvertOneTernaryNumericalStrToDecimal)
+{
+    EXPECT_EQ(0, ConvertTernaryToDecimal("0"));
+    EXPECT_EQ(1, ConvertTernaryToDecimal("1"));
+    EXPECT_EQ(2, ConvertTernaryToDecimal("2"));
+    EXPECT_EQ(0, ConvertTernaryToDecimal("3"));
+}
+
+TEST(TernaryNumber, TestConvertTernaryStrToDecimal)
+{
+    EXPECT_EQ(302, ConvertTernaryToDecimal("102012"));
+}
+
+TEST(TernaryNumber, TestEmptyTernaryString)
+{
+    EXPECT_EQ(0, ConvertTernaryToDecimal(""));
+}
+
+TEST(TernaryNumber, TestIncorrectTernaryNumberInString)
+{
+    EXPECT_EQ(302, ConvertTernaryToDecimal("192612"));
+    EXPECT_EQ(302, ConvertTernaryToDecimal("1*2%12"));
+}