void printLyrics_v1() {
    cout << "Havana ooh na na" << endl;
}

string printLyrics_v2() {
    return "Havana ooh na na";
}

string printLyrics_v3() {
    return "H";
}

char printLyrics_v4() {
    return 'H';
}

// Use const because VOWELS won't change -- no need to declare repeatedly
// in isVowel.
const string VOWELS = "aeiouy";

// Helper function, which I'd highly recommend writing!
bool isVowel(char ch) {
    // A little kludgy, but the handout guarantees that
    // ch will ALWAYS be lower case :)
    // NOTE: For an assignment, you probably want a more robust isVowel.
    return VOWELS.find(ch) != string::npos;
}

string pigLatinReturn(string input) {
    int strOneIndex = 0;
    for (int i = 0; i < input.length(); i++) {
        if (isVowel(input[i])) {
            strOneIndex = i;
            break;
        }
    }
    string strOne = input.substr(0, strOneIndex);
    string strTwo = input.substr(strOneIndex);
    return strTwo + strOne + "ay";
}

void pigLatinReference(string &input) {
    int strOneIndex = 0;
    for (int i = 0; i < input.length(); i++) {
        if (isVowel(input[i])) {
            strOneIndex = i;
            break;
        }
    }
    string strOne = input.substr(0, strOneIndex);
    string strTwo = input.substr(strOneIndex);
    input = strTwo + strOne + "ay";
}

string pigLatin(const string &input);

STUDENT_TEST("Verify getMatches identifies all kinds of matches."){

    // Case 1: A simple 4-for-4.
    string s1 = "ATCG";
    string s2 = "TAGC";
    EXPECT_EQUAL(getMatches(s1,s2), 4);

    // Case 1.5: Make sure order doesn't matter. This would
    // come into play if the writer did some hard-codey stuff.
    EXPECT_EQUAL(getMatches(s2,s1), 4);

    // Case 2: An example with mismatches.
    string s3 = "AAAA";
    EXPECT_EQUAL(getMatches(s1, s3), 1);
}

STUDENT_TEST("Test that bestIndexInSequence does not go off the SEQUENCE string."){
    // Use a modified example from the handout, which could produce the
    // wrong answer if getMatches does something incorrect with the edge case.
    string s1 = "TTCTTC";
    string s2 = "AGT";
    EXPECT_EQUAL(bestIndexInSequence(s1, s2), 1);
}

STUDENT_TEST("Verify bestIndexInSequence actually returns the best index."){

    // Case 1: Perfect match.
    string s1 = "TCGATCAGTCCC";
    string s2 = "AGT";
    EXPECT_EQUAL(bestIndexInSequence(s1, s2), 4);

    // Case 2: Imperfect match, single best index.
    string s3 = "TCTTC";
    string s4 = "AGT";
    EXPECT_EQUAL(bestIndexInSequence(s3, s4), 0);

    // Case 3: Multiple possible best indices.
    string s5 = "TCGATCAGTCCTCAC";
    string s6 = "AGT";
    bool firstMatch = bestIndexInSequence(s5, s6) == 4;
    bool secondMatch = bestIndexInSequence(s5, s6) == 11;
    // A finer point -- you can use EXPECT wherever you can use
    // EXPECT_EQUAL, but sometimes it makes more sense to use one
    // or the other.
    EXPECT(firstMatch || secondMatch);
}

int getMatches (string s1, string s2);
bool baseMatch (char c1, char c2);

/**
 * @brief bestIndexInSequence - returns the index within
 * SEQUENCE with the most base-pair matches
 * @param sequence - a string sequence of ATCG bases.
 * @param sample - a smaller sequence of ATCG bases that
 * we are comparing against subsequences of SEQUENCE to
 * find the index that results in the most matches.
 * @return - the integer value signifying the index with
 * the most base pair matches.
 *
 *
 * As a reference, A matches with T, C matches with G
 */
int bestIndexInSequence (string sequence, string sample) {
    int bestMatches = -1;
    int bestIndex = 0;
    int maxIndex = sequence.length() - sample.length();
    for (int i = 0; i < maxIndex; i++) {
        int numMatches = getMatches(sequence.substr(i, sample.length()), sample);
        if (numMatches >= bestMatches) {
            bestMatches = numMatches;
            bestIndex = i;
        }
    }
    return bestIndex;
}

/**
 * @brief getMatches - returns the number of ATCG matches between s1 and s2.
 * Assumes s1 and s2 are the same length.
 * @param s1 - the first string, representing a portion of SEQUENCE.
 * @param s2 - the second string, equivalent to SAMPLE.
 * @return - the integer value signifying how many AT or CG pairs exist between
 * the two strings.
 */
int getMatches (string s1, string s2) {
    int numMatches = 0;
    for (int i = 0; i < s1.length(); i++) {
        if (baseMatch(s1[i], s2[i])) numMatches++;
    }

    return numMatches;
}

/**
 * @brief baseMatch - returns true if c1 and c2 consist of a proper
 * nucleotide match, namely, 'A' matching with 'T', and 'C' matching with 'G'.
 * @param c1
 * @param c2
 * @return - a boolean signifying the validity of the match.
 */
bool baseMatch (char c1, char c2) {
    switch (c1) {
        case 'A':
            return c2 == 'T';
        case 'T':
            return c2 == 'A';
        case 'C':
            return c2 == 'G';
        case 'G':
            return c2 == 'C';
        default:
            return false;
    }
}

// DO NOT USE ALL OF THIS CODE AS AN EXAMPLE OF GOOD STYLE!!!
const char LETTER_A = 'A';          // Changed to const

/**
Takes in a string s and returns whether
it contains an A
**/
bool containsA(string s) {          // non-const var names should be lower case.
    bool sawAnA = false;
    for (char curr: s) {              // more descriptive variable name: curr.
        if (curr == LETTER_A) {
            sawAnA = true;
        }
    }

    return sawAnA;                  // directly return the boolean.
}

// USE ME AS AN EXAMPLE OF GOOD STYLE!

char LETTER_A = 'A';

/**
Takes in a string s and returns whether
it contains an A
**/
bool containsA (string s) {
    for (char c: s) {
        if (c == LETTER_A) {
            return true;
        }
    }
    return false;
}

// ***************************
// WARNING: STYLE BUGS AHEAD !!!!
// ***************************

const char LETTER_A = 'A';

/**
Returns the number of A's in the passed in string       // Add a function comment
**/
int countA(string s) {
    if (s == "") {
        return 0;
    }

    int countNumA = 0;      // be consistent with lowerCamelCase

    int i = 0;
    while (i < s.length()) {  // be consistent with bracket location
        if (s[i] == LETTER_A) {
            countNumA++;
            i++;
        } else {  // use if/else if/else pattern whenever applicable                             
            i++;
        }
    }             // keep bracketing clean

    return countNumA;
}

// ***************************
// WARNING: STYLE BUGS AHEAD !!!!
// ***************************
const char LETTER_A = 'A';

/**
Returns the number of A's in the passed in string       
**/
int countA(string s) {
    if (s == "") {
        return 0;
    }

    int countNumA = 0;                             

    int i = 0;
    while (i < s.length()) {                      
        if (s[i] == LETTER_A) {
            countNumA++;
        } 
        i++;                        // factor out duplicate code
    }                                              

    return countNumA;
}

----
This is the final product!

const char LETTER_A = 'A';

/**
Returns the number of A's in the passed in string       
**/
int countA(string s) {
    if (s == "") {
        return 0;
    }

    int countNumA = 0;                             

    for (int i = 0; i < s.length(); i++) {      // use a for loop
        if (s[i] == LETTER_A) {
            countNumA++;
        } 
    }                                              

    return countNumA;
}