Question

In C++ Please!!!!!
2020 continues to do a number on our psyche. Even though we can go outside for a little bit and take walks around the neighborhood, go the Costco, or even hike and bike, most of our time has been spent indoors staring at the same walls and the same faces. I know, I'm making it sound grim. However, it's allowed us some benefits, including learning a new skill, not having to dress up for school or work, and actually eating meals with family and roommates. It also has allowed us to have some game nights again. It could be Cranium, Apples to Apples, or even Cards Against Humanity. There are also word games, like Scrabble, that require rearranging a combination of letters to make a word. This type of arrangement is generally referred to as an anagram, while it's known as a permutation in mathematics. This assignment will give you some experience thinking about and writing recursive functions. Write a C++ program that searches for "anagrams" in a dictionary. An anagram is a word obtained by scrambling the letters of some string. For example, the word "pot" is an anagram of the string "otp." A sample run of the program is given below. Your output does not have to be formatted exactly the same as that shown in the sample, but it should be in a similar style. You can use words.txt as your dictionary file and anagrams.cpp as an example of a main program. Since the purpose of this assignment is to give you experience using recursion, you may not use any of C++'s iteration constructs (do, while, for, and goto) or any STL algorithms (if you have no idea what this means, you're OK). In fact, similar to homework #2, you may only use the substr() and size()/length() functions in the string class. All repetition must be accomplished using recursion. This applies to every operation in the program, even file operations. Obviously, you would never write a program like this in industry but as an exercise it should be useful to gain experience with recursion. Sample Runs Here are two examples of how the program might work:

Example main:

#include <iostream>
#include <fstream>
#include <istream>
#include <cstring>
using namespace std;

const int MAXRESULTS   = 20;    // Max matches that can be found
const int MAXDICTWORDS = 30000; // Max words that can be read in

int main()
{
    string results[MAXRESULTS];
    string dict[MAXDICTWORDS];
    ifstream dictfile;         // file containing the list of words
    int nwords;                // number of words read from dictionary
    string word;
    
    dictfile.open("words.txt");
    if (!dictfile) {
        cout << "File not found!" << endl;
        return (1);
    }
    
    nwords = createDict(dictfile, dict);
    
    cout << "Please enter a string for an anagram: ";
    cin >> word;
    
    int numMatches = characterMixer(word, dict, nwords, results);
    if (!numMatches)
        cout << "No matches found" << endl;
    else
        viewAnswers(results, numMatches);

        return 0;
}

Example word.txt (small version):

10th
1st
2nd
3rd
4th
5th
6th
7th
8th
9th
a
AAA
AAAS
Aarhus
Aaron
AAU
ABA
Ababa
aback
abacus
abalone
abandon
abase
abash
abate
abater
abbas
abbe
abbey
abbot
Abbott
abbreviate
abc
abdicate
abdomen
abdominal
abduct
Abe
abed
Abel
Abelian
Abelson
Aberdeen
Abernathy
aberrant
aberrate
abet
abetted
abetting
abeyance
abeyant
abhorred
abhorrent
abide
Abidjan
Abigail
abject
ablate
ablaze
able
ablution
Abner
abnormal
Abo
aboard
abode
abolish
abolition
abominable
abominate
aboriginal
aborigine
aborning
abort
abound
about
above
aboveboard
aboveground
abovementioned
abrade
Abraham
Abram
Abramson
abrasion
abrasive
abreact
abreast
abridge
abridgment
abroad
abrogate
abrupt
abscess
abscissa
abscissae
absence
absent
absentee
absenteeism
absentia
absentminded
absinthe
absolute
absolution
absolve
absorb
absorbent
absorption
absorptive
abstain
abstention
abstinent
abstract
abstracter
abstractor
abstruse
absurd
abuilding
abundant
abusable
abuse
abusive
abut
abutted
abutting
abysmal
abyss
Abyssinia
AC
academe
academia
academic
academician

Answer 1

Working code implemented in C++ and appropriate comments provided for better understanding:

Source code for anagrams.cpp:

#include <iostream>
#include <fstream>
#include <istream>
#include <cstring>

using namespace std;

const int MAXRESULTS = 20; // Max matches that can be found
const int MAXDICTWORDS = 30000; // Max words that can be read in

int loadWords(istream & dictfile, string dict[]);
bool findWord(string word,
const string dict[], int top, int bot);
void swapme(char & a, char & b);
void permute(string a, int front, int end,
const string dict[], int dict_total, int & matched, string results[]);
void Loop(string & a, int i, int front, int end,
const string dict[], int dict_total, int & matched, string results[]);
int recBlends(string word,
const string dict[], int size, string results[]);
void showResults(const string results[], int size);
bool checkWord(int i, int max, string b, string results[]);

//Adds all the words from dictfile into an array of strings called dict
int loadWords(istream & dictfile, string dict[]) {
string data;

if (dictfile.eof()) { // end of dictfile
return 0;
}

dictfile >> data;
// uses recursion to loop to the end of dictfile (dict starts with Z)
int x = loadWords(dictfile, dict);
if (x < MAXDICTWORDS) {
dict[x] = data;
x++;
return x;
} else
return MAXDICTWORDS; //reached max capacity of array
}

//Checks if a word is in the array dict[]
bool findWord(string word,
const string dict[], int top, int bot) {
if (top > bot) {
return false; // string not found
} else {
int mid = (top + bot) / 2;
string check = dict[mid];
check[0] = tolower(check[0]); // makes all words lowecase
if (word.compare(check) == 0) {
return true;
} else if (word.compare(check) > 0) {
return findWord(word, dict, top, mid - 1);
} else if (word.compare(check) < 0) {
return findWord(word, dict, mid + 1, bot);
}
}
return true;
}

//Swaps 2 characters in a word
void swapme(char & a, char & b) {
char temp = a;
a = b;
b = temp;
}

// Finds all the permutations of a word
void permute(string a, int front, int end,
const string dict[], int dict_total, int & matched, string results[]) {
if (front == end) // found a possible permutation
{
if (findWord(a, dict, 0, dict_total)) // check if word exists
{
if (!(checkWord(0, matched, a, results))) // check if word is already in results
{
results[matched] = a;
matched++;
}
}
} else {
Loop(a, front, front, end, dict, dict_total, matched, results);
}
}

void Loop(string & a, int i, int front, int end,
const string dict[], int dict_total, int & matched, string results[]) {
if (i > end)
return;
// for all remaining letters (i) this loop continues and permutes all possible anagrams
swapme(a[front], a[i]);
permute(a, front + 1, end, dict, dict_total, matched, results);
// returns back the switch so that the next loop can swap 2 different characters
swapme(a[front], a[i]);
//replaces the for loop by incrementing i in every call until it reaches "max" or end
Loop(a, (i + 1), front, end, dict, dict_total, matched, results);

}

// main function used to find the number of anagrams formed from a given string
// puts the anagrams in an array called results
int recBlends(string word,
const string dict[], int size, string results[]) {
int back = word.size() - 1;
int matched = 0;
permute(word, 0, back, dict, size, matched, results);

return matched;
}

// Prints all the strings in results
void showResults(const string results[], int size) {
if (size - 1 < 0)
return;
cout << "Matching word " << results[size - 1] << endl;
showResults(results, size - 1);

}
// checks if a word exists in results already (avoids doubling ex: kool gives look twice
bool checkWord(int i, int max, string b, string results[]) {
if (i == max)
return false;
if (b.compare(results[i]) == 0)
return true;
checkWord(i + 1, max, b, results);
return false;
}

int main() {

string results[MAXRESULTS];
string dict[MAXDICTWORDS];
ifstream dictfile; // file containing the list of words
int nwords; // number of words read from dictionary
string word;

dictfile.open("words.txt");
if (!dictfile) {
cout << "File not found!" << endl;
return (1);
}

nwords = loadWords(dictfile, dict);

cout << "Please enter a string for an anagram: ";
cin >> word;

int numMatches = recBlends(word, dict, nwords, results);
if (!numMatches)
cout << "No matches found" << endl;
else
showResults(results, numMatches);
/*
string results3[5];
string exampleDict[] = { "moe", "kool", "dee"};
int numResults = recBlends("kloo", exampleDict, 3, results3);
cout << numResults << endl;
assert(numResults == 1 && results3[0] == "kool");
cout << "woot" << endl;
return 0;
*/
return 0;
}

Sample Output Screenshots:

X > ulimit -s 12000 3./main Q Please enter a string for an anagram: art Matching word tar Matching word rat Matching word art >./main Please enter a string for an anagram: regardless No matches found

Hope it helps, if you like the answer give it a thumbs up. Thank you.