#include <string.h>
 
//Try not to hardcode values (like '50', '20', or '49')
//Instead, put them into constants so if you ever change the value,
//you won't accidentally miss any usages.
const int WordSize = 32;
 
//Values that belong together should stay together, preferably by putting them in a structure.
typedef struct MnemonicWordStruct
{
	char originalWord[32];
	char memorizedWord[32];
} MnemonicWord;
 
const char *GetWordFromMnemonic(const char *memorizedWord, MnemonicWord *mnemonicWords, int numMnemonicWords)
{ // Don't forget the opening bracket!
 
	//Iterate over each mnemonic work, looking for a match.
	int i;
    for(i = 0; i < numMnemonicWords; ++i)
    {
    	//Compare this mnemonic's memorized word to the memorized word we passed into the function.
        if(strcmp(mnemonicWords
[i
].
memorizedWord, memorizedWord
) == 0)         {
            //If it matches, return the actual word.
            return mnemonicWords[i].originalWord;
        }
    }
 
    //If we haven't found a match, return NULL.
    return NULL;
}
 
int main()
{
	const int NumMnemonicWords = 6;
	MnemonicWord mnemonicWords[6];
 
	strcpy(mnemonicWords
[0].
originalWord, "Paranthesis"); 	strcpy(mnemonicWords
[0].
memorizedWord, "Please");  
	strcpy(mnemonicWords
[1].
originalWord, "Exponents"); 	strcpy(mnemonicWords
[1].
memorizedWord, "Excuse");  
	strcpy(mnemonicWords
[2].
originalWord, "Multiplication"); 	strcpy(mnemonicWords
[2].
memorizedWord, "My");  
	strcpy(mnemonicWords
[3].
originalWord, "Division"); 	strcpy(mnemonicWords
[3].
memorizedWord, "Dear");  
	strcpy(mnemonicWords
[4].
originalWord, "Addition"); 	strcpy(mnemonicWords
[4].
memorizedWord, "Aunt");  
	strcpy(mnemonicWords
[5].
originalWord, "Subtraction"); 	strcpy(mnemonicWords
[5].
memorizedWord, "Sally");  
	int i;
	for(i = 0; i < NumMnemonicWords; ++i)
	{
		const char *lookup = mnemonicWords[i].memorizedWord;
		const char *answer = GetWordFromMnemonic(lookup, mnemonicWords, NumMnemonicWords);
		printf("%s = %s\n", lookup
, answer
); 	}
 
	return 0;
}
				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