COMP 142 Project 3: Mesostics

A mesostic is a poem arranged in such a way that a word appears vertically consisting of single letters from the horizontal lines of the poem. Here's an example, albeit with a misspelling. For this project, you will create a program that arranges the words of a poem into a mesostic by adjusting the spacing of the lines of the poem.

Your program will work by opening and reading the lines of a text file. The first line of the file will contain a single word without spaces. The subsequent lines will contain the lines of a poem; these lines may include spaces. Your program will print out the lines of the poem spaced so that the single word from the beginning of the file can be read vertically in the output.

It is guaranteed that all the files I use to test your program will consist of poems for which mesostics can be found. You should also note that this concept only works in computational form because typical computer programs produce their output in a monospace (a font where each letter, number, or punctuation symbol takes up the same amount of horizontal space), as opposed to a proportional font (a font where the amount of horizontal space used for a character is proportional to the normal amount of horizonal space the character actually would take up).

Examples: This is a monospace font. This is a proportional font.

Program details and algorithms

You should use a struct in your program to hold the mesostic. The declaration of the struct should be the following:

struct mesostic
{
  string vert_word;
  vector<string> poem_lines;
  vector<int> match_positions;
};

The struct contains the following information about a mesostic:

vert_word: a string containing the vertical word that will be found in the poem.
poem_lines: a vector containing strings; each string is a lines of the poem.
match_positions: a vector containing integers; each integer specifies where each letter in the vertical word can be found in the appropriate line of the poem.

Let us illustrate these pieces with a short example. Say your input file contains the four lines:

cat
this cuddly
animal
bites me

When your program reads this file, it would create a mesostic struct with vert_word as "cat" and poem_lines consisting of the strings "this cuddly", "animal", and "bites me" in a vector. match_positions would contain a vector of 5, 0, and 2, because the 5th position (counting from zero) in the string "this cuddly" is 'c', the 0th position in "animal" is 'a', and the 2nd position in "bites me" is 't'. Naturally, you will need to write code to calculate the numbers in the match_positions vector. After your program calculates this information, it should be able to print the poem as:

this cuddly
     animal
   bites me

Notice how the word "cat" is found vertically in the output.

There are two main algorithms at work here: calculating match_positions, and printing the mesostic with the right number of leading spaces on each line to get the letters of the vertical word to line up correctly. These algorithms are not complicated, and you should try to figure them out on your own first. However, I will be providing additional ideas later if you get stuck.

And here are the additional ideas.

How the program should work

The user should be asked to type in the name of a text file that contains a mesostic. The user will not type in the vertical word and the lines of the poem manually; that information will be read from the text file. Your program should then calculate the pertinent information and display the mesostic arranged so the vertical word can be seen in the lines. Obviously, some of the lines of the poem will need to be moved to the right on the screen; this can be done by printing a certain number of blank spaces before each line of the poem. The mesostic should always be left-justified; that is, there should be at least one line of the poem that is printed without any leading spaces. This line is not necessarily the first line of the poem.

Coding style

All the normal guidelines for coding from previous projects apply.
You should break your program into logical functions and use parameters and return values to communicate between your functions.
Your only global variables should be global constants, and most likely you won't need any of those.
You should comment your code appropriately:
- You should have a comment block at the top of your program including all the normal pieces of information.
- You should have a comment block before each function you write, describing what the function does, the parameter(s), and the return value(s).
I suggest writing the following functions (but you can use whatever you want that makes sense):
- mesostic read_file(string filename) --- This function will read the file specified by the filename, read the vertical word, the lines of the poem, calculate the match positions, and return the mesostic structure.
- void find_match_positions(mesostic & m) --- This function handles calculating the match positions and updates the mesostic struct; I called this from read_file.
- void print_mesostic(const mesostic & m) --- This function prints the mesostic with spaces in the right places on each line to make the vertical word appear.

Testing your program

You should test your program thoroughly to make sure it works correctly. Here are some sample mesostic files to try: meso0.txt meso1.txt meso2.txt meso3.txt meso4.txt

Sample input and output

The program's output is in normal text; what the user types is in bold. Each test of the program is shown separately; the SAMPLE RUN parts are not part of the output.

-----------------------------------------------------
SAMPLE RUN 1
-----------------------------------------------------
Mesostic input file: meso0.txt

this cuddly
     animal
   bites me
   
-----------------------------------------------------
SAMPLE RUN 2
-----------------------------------------------------
Mesostic input file: meso1.txt

  let us make
      of this
      modest
        place
    a room holding
tons of love
       (&, naturally, much good food, too)
       
-----------------------------------------------------
SAMPLE RUN 3
-----------------------------------------------------
Mesostic input file: meso2.txt

    life is a
   companion
  treat it with
     generosity
    sincerity
patience and
  love
  
-----------------------------------------------------
SAMPLE RUN 4
-----------------------------------------------------
Mesostic input file: meso3.txt

     music
  indeterminacy
 words
    collaboration
     speech
invention
    silence
     cage
     
-----------------------------------------------------
SAMPLE RUN 5
-----------------------------------------------------
Mesostic input file: meso4.txt

    it's just
great theater. there's
       an ordinary guy, balding,
     unknown,
      leaves sunny stratford
penniless, a few plays
   and poems in a bag, ends up on
     the globe stage a master,
  unrivalled
     bard, 100%
    literary genius.

Hints

Even though the first line of the file is a single word, just use getline for reading in every line of the file. It will be easier than using "infile >>" for the first line and getline for the next lines.
Make sure each step of your program works before moving on to the next step. For instance, before you even worry about putting the words into a struct, make sure you are opening the file and reading each line correctly. I recommend adding lots of cout statements throughout your code to print out diagnostic messages (e.g., the lines of the file as you read them). Such messages can then be removed or commented out before you turn in your program.
If you use the string function find, note that it returns a size_t type, which is really just an unsigned int in disguise. You can cast this to an int using static_cast.

What to turn in

Through Moodle, turn in your code as a file called mesostic_yourLastName_yourFirstName.cpp. You do not need to turn in anything other than the .cpp file; I do not need all the other files that Visual Studio creates.

Challenge Problem

Print the mesostic using uppercase letters for the vertical word to make it easier to find quickly. For example, the output for meso4.txt would change to

    it'S just
great tHeater. there's
       An ordinary guy, balding,
     unKnown,
      lEaves sunny stratford
pennileSs, a few plays
   and Poems in a bag, ends up on
     thE globe stage a master,
  unrivAlled
     baRd, 100%
    litErary genius.

For historical reasons, the toupper function returns an int, not a char. If you use toupper to convert from lowercase to uppercase, you will need to static_cast the return value of toupper to a char to get it to print correctly.