Converted everything to orgmode

converted everything to orgmode and added solution to the README files

Vorkurs/Projekt_1/Task_1/README.org

@@ -0,0 +1,158 @@
+#+TITLE: Project 1: Guess A Number (Task 1)
+#+AUTHOR: JirR02
+
+
+* About this task
+
+** Project overview
+
+The goal of the first project is to program a simple number guessing game: the player needs to correctly guess a number, chosen from an interval \([1,N]\), with at most \{K\} guesses.
+
+In the lecture, a first version of the game was presented, in which the player had only one chance of guessing the correct number. In order to implement the full game, you will have to extend this version by allowing the player to guess up to \(K\) times.
+
+The first project consists of two tasks: *task 1* /(this task)/ is to reimplement the first version of the game that was presented in the lecture, *task 2* is to implement the full game.
+
+** General development advice
+
+Develop your program step-by-step, and save, run and compile it often. I.e. implement a single feature, such as inputting the guess, or comparing the guess and the correct number, and then compile and run the program to see if your code (still) works as intended. Small changes and repeated testing make it easier for you to observe problems, to work out what causes them, and to finally solve them.
+
+** Fulfilling requirements and testing programs
+
+A particular goal of this task is to make you understand how strongly connected requirements and testing (and thus grading submissions) are. E.g. if the task description requires output of the shape "I␣saw␣\(n\)␣cat(s).", where $n$ is a number and ␣ represents blanks/whitespaces, your program will not be considered correct if it outputs a text that is "basically the same", but does not precisely match the requirements. E.g. the following outputs, while very close to the expected output, do not match the shape specified above: "i␣saw␣3␣cat(s).", "I␣saw␣3␣cats.", "I␣saw␣1␣cat.", "I␣saw␣2␣cat(s)" and "i␣saw␣2␣␣cat(s)␣.".
+
+Meeting such requirements precisely is necessary for testing: we automatically (at least to some extent) test correctness of your programs by comparing the expected output to the output produced by your program. Since these comparisons are performed by a computer, it is much much easier to do them syntactically, i.e. letter-by-letter.
+
+However, being able to precisely fulfil requirements is more generally important, in particular when working with customers: imagine you order a black smartphone, but then get delivered a dark blue one (same make and model). Although "basically the same", it's just not what you ordered. The same holds for software — it's the details that matter.
+
+** Your task
+
+To solve this task, proceed as follows:
+
+1. Look at the template program, in particular main.cpp, and see what's already there (e.g. variable declarations) and what's still missing. The latter is hinted at by TODO comments.
+1. The template already contains code for picking the number to guess. By default, the number is randomly choosen from the interval \([1,3]\):
+
+#+begin_src cpp
+number_to_guess = choose_a_number(3);
+#+end_src
+
+/During development/, you might want to change this line: e.g. read the number from the keyboard:
+
+#+begin_src cpp
+std::cin >> number_to_guess;
+#+end_src
+
+or even hard-code (i.e. fix) a specific number, e.g.
+
+#+begin_src cpp
+number_to_guess = 3;
+#+end_src
+
+However, in order to run the automatic tests, and /when submitting your final version/, your program /must/ either read the word from the keyboard or use the ~choose_a_number~ function.
+
+1. Now address the first TODO comment: by outputting the text "Your␣guess:␣" (as before, ␣ denotes a blank/whitespace character), followed by inputting the guess from the keyboard into variable guess.
+2. Now address the second TODO comment: by comparing the two numbers for equality. If they are, output the line
+
+#+begin_src shell
+Congratulations,␣you␣correctly␣guessed␣X!
+#+end_src
+
+where X is the correctly guessed number. Since the output is expected to be a /line/, don't forget to end it with either ~\n~ or ~std::endl~.
+
+If the guess was wrong, however, output the line
+
+#+begin_src shell
+Sorry,␣but␣Y␣is␣wrong,␣X␣was␣the␣number␣to␣guess.
+#+end_src
+
+where Y is the incorrectly guessed number.
+
+** Examples
+
+As an illustration, consider the following example in- and outputs of two games (in which the number to guess was randomly chosen). A successfully completed game:
+
+#+begin_src shell
+Number to guess: ?
+Your guess: 3
+Congratulations, you correctly guessed 3!
+#+end_src
+
+And a lost game:
+
+#+begin_src shell
+Number to guess: ?
+Your guess: 2
+Sorry, but 2 is wrong, 1 was the number to guess.
+#+end_src
+
+** Testing your program
+
+You can always test your program manually: click the "play" button in the bottom panel, run your program and see if it behaves as expected.
+
+Relevant for your final submission, however, is if it passes the automated tests: to run those, click the "chemistry flask" button in the bottom panel and wait for the output to appear. If your program passes all tests — everything is green and your score is 100% — then your program is ready to be submitted.
+
+Otherwise, /carefully/ compare the expected output to the actual output to find out what went wrong.
+
+*Reminder*: The devil is in the detail! Pay attention to whitespace and newline characters, and in general check that your output fulfils all requirements, even the "boring" ones.
+
+** Submitting your solution
+
+Finally, submit your solution (your program) by clicking the corresponding button in the top right corner of the Code Expert IDE (open Task/History first). Your program will be tested automatically, and your score will be shown in the "History" view, which can be opened by clicking on the corresponding tab on the right of the Code Expert IDE. Note that you can submit arbitrarily often (before the exercise deadline, of course), and your last submission will be considered for grading.
+
+For this task, all tests need to pass in order to successfully solve this task. This should be rather easy, though, since there isn't much that can go wrong.
+
+You can also see the results for your submission on the "Enrolled Courses" tab of Code Expert, as green or red percentage values to the left of the task's name.
+
+* Solution
+
+Front End to import libraries and files.
+
+#+begin_src cpp
+#include <iostream>
+#include "guess_a_number.h"
+#+end_src
+
+Main function where the code runs.
+
+#+begin_src cpp
+int main() {
+#+end_src
+
+Declaring Variable which will be used.
+#+begin_src cpp
+  int number_to_guess; // The number to guess
+  int guess;           // The guessed number
+#+end_src
+
+Front end terminal output.
+
+#+begin_src cpp
+  std::cout << "Number to guess: ";
+#+end_src
+
+~choose_a_number()~ function is called to choose a number between 1 and 3
+
+#+begin_src cpp
+  number_to_guess = choose_a_number(3);
+#+end_src
+
+Input front end.
+#+begin_src cpp
+  std::cin >> guess;
+#+end_src
+
+Output the input of the user.
+
+#+begin_src cpp
+  std::cout << "Your guess: ";
+#+end_src
+
+Depending on the guess, the output in the terminal is different, if the input of the user is the same with the random number, it will output ~Congratulations, you correctly guessed x!~. Otherwise it will output something else.
+
+#+begin_src cpp
+  if (guess == number_to_guess) {
+    std::cout << "Congratulations, you correctly guessed " << number_to_guess << "!";
+  } else {
+    std::cout << "Sorry, but " << guess << " is wrong, " << number_to_guess << " was the number to guess.";
+  }
+}
+#+end_src

Vorkurs/Projekt_1/Task_2/README.org

@@ -0,0 +1,174 @@
+#+TITLE: Project 1: Guess the Number (Task 2)
+#+AUTHOR: JirR02
+
+* Project overview
+
+The goal of the first project is to program a simple number guessing game: the player needs to correctly guess a number, chosen from an interval\([1,N]\), with at most \(K\)guesses.
+
+In the lecture, a first version of the game was presented, in which the player had only one chance of guessing the correct number. In order to implement the full game, you will have to extend this version by allowing the player to guess up to \(K\) times.
+
+The first project consists of two tasks: *task 1* was to reimplement the first version of the game that was presented in the lecture, *task 2* /(this task)/ is to implement the full game.
+
+* Stepwise development
+
+The program template of task 2 differs from that of task 1 in two important ways:
+
+1. A goal of task 1 was to show you how important — and potentially cumbersome — it is to precisely fulfil output requirements and to pass the automated tests. This is no longer the focus of task 2, and you are therefore given functions such as `print_you_won(...)` that generate the expected output for you.
+
+1. The final program consists of three major parts, and the template has three corresponding "holes" where you have to fill in code: inputting the next guess, checking the guess, and finishing the current round (we refer to each guess as one round of the game).
+
+To make it easier for you to develop your solution step by step, you are given a "master implementation" for these steps, e.g `PART1_read_next_guess(...)`, which you must replace with your own code. Use the following workflow:
+
+1. Run the tests: everything should be fine (thanks to the master implementations)
+
+1. Comment the first master implementation; now all tests should fail
+
+1. Write your own code that replaces the commented master implementation
+
+1. Once all tests pass again, continue by commenting and replacing the next master implementation
+
+1. Once you have replaced all master implementations with your own code (and all tests pass), your solution is ready to be submitted. *Read the remarks at the end of this text!*
+
+* Your task
+
+As mentioned above, you can develop the final solution step by step, by iteratively replacing each call to a `STEP...` master implementation by your own code.
+
+** Step 1: input the next guess
+
+1. Find the code line
+
+   #+begin_src cpp
+    PART1_read_next_guess(guess);
+   #+end_src
+
+    and comment it, i.e. change it to
+
+    #+begin_src cpp
+    // PART1_read_next_guess(guess);
+    #+end_src
+
+1. As a replacement for the commented master implementation, write code that outputs "Your␣guess:␣" (as before, ␣ denotes a blank/whitespace character), and then inputs the next guess from the keyboard into variable guess.
+
+1. Run the tests, they should all pass again
+
+** Step 2: handle the guess the user made
+
+1. Find and comment the code line
+
+   #+begin_src cpp
+   PART2_handle_guess(guess, number_to_guess, play);
+   #+end_src
+
+1. Write code that compares the user-made guess with the number to guess: if the two are equal, call `print_you_won(guess)` to generate a you-won message, and set variable `play` to `false` to end the game. Otherwise, call `print_wrong_guess(guess)` to generate a wrong-guess message (and let the game continue).
+
+** Step 3: handle the guess the user made
+
+1. Find and comment the code line
+
+#+begin_src cpp
+PART3_finish_round(number_to_guess, max_attempts, attempts, play);
+#+end_src   
+
+1. Write code that increments the number of attempts the user made by 1. Furthermore, write code that 1. checks if the maximum number of attempts has been reached, and if so, 2. call print_you_lost(number_to_guess, attempts) and set play to false.
+
+* Examples
+
+As an illustration, consider the following example in- and outputs of two games (in which the number to guess was randomly chosen). A successfully completed game:
+
+#+begin_src shell
+Number to guess: ?
+Number of attempts: 3
+You have 3 attempt(s) left.
+Your guess: 7
+Sorry, but 7 is wrong.
+You have 2 attempt(s) left.
+Your guess: 3
+Congratulations, you correctly guessed 3!
+#+end_src
+
+And a lost game:
+
+#+begin_src shell
+Number to guess: ?
+Number of attempts: 2
+You have 2 attempt(s) left.
+Your guess: 123
+Sorry, but 123 is wrong.
+You have 1 attempt(s) left.
+Your guess: 321
+Sorry, but 321 is wrong.
+You lost after 2 attempt(s) :-( The number to guess was 2.
+#+end_src
+
+* Submitting your solution
+
+*Important*: you /must/ replace all three master implementations (calls to functions `PART1/2/3`) with your own code! Your submission /will not be accepted/ if it still uses the master implementations, regardless of how many tests pass when /you/ run them.
+
+-----
+* Solutions
+
+Fronted to import libraries and the code from Task 1
+#+begin_src cpp
+#include <iostream>
+#include "guess_a_number.h"
+#+end_src
+
+Main funtion where the magic happens. We define two variables: `number_to_guess` and `max_attempts` and we assign them.
+
+#+begin_src cpp
+int main() {
+  int number_to_guess; 
+  int max_attempts;   
+
+  std::cout << "Number to guess: ";
+  number_to_guess = choose_a_number(10);
+
+  std::cout << "Number of attempts: ";
+#+end_src
+
+Afterwards we make sure that the player has at least one attempts and create a variable `attempts` to count the attempts the player had.
+
+#+begin_src cpp
+  if (max_attempts < 1) max_attempts = 1;
+
+  int attempts = 0; // Attempts made so far
+  bool play = true; // false once the game is over
+#+end_src
+
+Now in a while loop, we solve `PART 1` to `3` commenting out the master functions.
+
+#+begin_src cpp
+  while (play) {
+    print_attempts_left(max_attempts - attempts);
+
+    // *** Part 1: input the next guess ****************************************
+    int guess; // The user's guess
+    //PART1_read_next_guess(guess);
+    std::cout << "Your guess: ";
+    std::cin >> guess;
+
+    // *** Part 2: handle the guess the user made  *****************************
+    //PART2_handle_guess(guess, number_to_guess, play);
+    if (guess == number_to_guess) {
+      print_you_won(guess);
+      play = false;
+    } else {
+      print_wrong_guess(guess);
+    }
+
+    // *** Part 3: finish up the round  ****************************************
+    if (play) {
+      //PART3_finish_round(number_to_guess, max_attempts, attempts, play);
+      attempts += 1;
+      if (attempts == max_attempts) {
+        print_you_lost(number_to_guess, attempts);
+        play = false;
+      }
+    }
+  }
+}
+#+end_src
+
+-----
+
+Made by JirR02 in Switzerland 🇨🇭

Vorkurs/Projekt_2/README.md

@@ -0,0 +1,50 @@
+# Projekt 2: Hangman
+
+## Layers
+
+### Start (Optional)
+
+Beim Starten des Spiels soll ein Welcome screen erscheinen mit den Optionen, das Spiel zu starten und das Spiel zu beenden. Damit der Welcome screen gut aussieht soll es Terminal Art beinhalten. Nach dem Start Vorgang wird der Anzahl der Spieler gefragt.
+Daraus entstehen 2 Szenarien:
+
+1. Falls es im Einzelspieler Modus ist, wird ein Wort aus der Liste ausgesucht.
+1. Falls im Mehrspieler Modus, darf der andere Spieler ein Wort zum Raten auswählen.
+
+- [ ] Start input
+- [ ] End input
+- [ ] Invalid Input
+- [ ] Single or Multiplayer
+- [ ] Terminal Art
+
+### Game
+
+Das zu ratende Wort wird verdeckt im Terminal gezeigt. Es wird dann ein Input als Buchstabe verlangt. Wenn der Input zu lang oder ein invalid character ist, wird der Spieler nochmals dazu aufgefordert, ein Buchstabe einzugeben.
+Daraus entstehen 2 Szenarien:
+
+1. Ist der Buchstabe in der Zahl enthalten, wird der Buchstabe aufgedeckt und ein positiver Satz erscheint im Terminal.
+1. Ist der Buchstabe falsch, so wird ein Leben abgezogen und ein negativer Satz wird ausgespuckt.
+
+Während des ganzen Spiels wird der Terminal Art aktualisiert.
+
+- [ ] Wort verdeckt im Terminal anzeigen
+- [ ] Input von einem Buchstaben verlangen
+- [ ] Input kontrollieren
+- [ ] Buchstabe kontrollieren
+- [ ] Positiver Satz 
+- [ ] Buchstabe aufdecken
+- [ ] Negativer Satz
+- [ ] (Optional) Terminal Art
+
+### End
+
+Es entstehen daraus zwei Endszenarien:
+
+1. Wurden alle Buchstaben eraten, so wird ein Gewinner Satz ausgesprochen und gefragt ob das Spiel neugestartet werden soll.
+1. Wurden alle Versuche verbraucht, so wird ein verlierer Satz ausgesprochen, das Wort aufgelöst und gefragt, ob das Spiel neugestartet werden soll.
+
+Falls das Programm geschlossen wird, wird ein Abschiedssatz gezeigt.
+
+- [ ] Gewinner Satz
+- [ ] Verlierer Satz
+- [ ] (Optional) Fragen für eine neue Runde
+- [ ] Abschiedssatz

Vorkurs/Projekt_2/hangman.cpp

@@ -0,0 +1,69 @@
+#include "hangman.h"
+#include "termcolor.h"
+
+
+// NOTE: You cannot change this file, and you don't need to understand its
+// content in order to solve your task. Feel free to look around, however,
+// in case you're interested.
+
+
+const string action = std::getenv("ACTION");
+const string words[] = { 
+  #include "words.csv"
+  "sentinel"
+};
+
+string color(string c) {
+  return action == "run" ?  c : "";
+}
+
+string chooseWord() {
+  string word;
+  if (action == "test" || action == "submit") {
+    std::cin >> word;
+  } else {
+    int i = rand() % (sizeof(words)/sizeof(*words) - 1);  // don't take the last word (which is 'sentinel')
+    word = words[i];
+    std::cout << "A random (english) word with " << word.length() << " characters has been chosen." << std::endl;
+    return word;
+  }
+  return word;
+}
+
+string createWorkingCopy(string word){
+  string result = word;
+  for (unsigned int i = 0; i < result.length(); ++i) {
+    result.at(i) = '_';
+  }
+  return result;
+}
+
+void showHangman(int wrongGuesses) {
+  std::cout
+    << "<cx:html>\n"
+//    << "<p>Attempts left: " << maxWrongGuesses - wrongGuesses << "</p>\n"
+    << "<img alt='' src='https://lec.inf.ethz.ch/mavt/et/2019/img/hangman/hang_" << wrongGuesses + 1 << ".gif'/>\n"
+    << "</cx:html>" << std::endl;
+}
+
+void printGameState(int maxWrongGuesses, int wrongGuesses){
+  std::cout << color(gray) << "\nAttempts left: " << (maxWrongGuesses - wrongGuesses) << color(reset) << "\n";
+}
+
+void printWorkingCopy(string workingCopy){
+  std::cout << color(blue) << "[ "  ;
+  for (unsigned int i = 0; i < workingCopy.length(); ++i) {
+    std::cout << workingCopy.at(i) << " ";
+  }
+  std::cout << "]\n" << color(reset);
+}
+
+void printYouLost(string word){
+  std::cout << "The word was: " << color(white) << word << color(red) << "\nYou lost!\n" << color(reset);
+}
+
+void printYouWon(string word){
+  std::cout << "\n";
+  printWorkingCopy(word);
+  std::cout << color(green) << "You won!\n" << color(reset);  
+}

Vorkurs/Projekt_2/hangman.h

@@ -0,0 +1,97 @@
+#ifndef HANGMAN_H
+#define HANGMAN_H
+
+#include <iostream>
+#include <string>
+
+using std::string;
+
+// NOTE: You cannot change this file. It "only" contains declarations and
+// short descriptions of the functionality we provided to you.
+
+
+/**
+ * This function returns a random english word. Use this to generate a new
+ * word to guess. It is imperative that you use this function to get a word,
+ * otherwise, the auto-grader will not work properly when testing or
+ * submitting your project.
+ */
+string chooseWord();
+
+/**
+ * This function creates a "working copy" based on a given word. It returns a
+ * string with the same amount of characters than the word, but all of them
+ * are initially set to "_" (underscore)
+ */
+string createWorkingCopy(string word);
+
+/**
+ * You may call this function to render a little hangman figure in the HTML view.
+ * This is completely optional, the tests don't rely on this function being 
+ * called. As argument, the function takes the number of wrong guesses and
+ * selects the correct hangman picture to show.
+ */
+void showHangman(int wrongGuesses);
+
+/**
+ * This function prints the number of remaining attempts (based on the provided
+ * number of wrong guesses. Call this method before each attempt.
+ * 
+ * Example: The call 'printGameState(2)' will output: "Attempts left: 4"
+ * because MAX_WRONG_GUESSES is 6, and 6 - 2 = 4
+ */
+void printGameState(int maxWrongGuesses, int wrongGuesses);
+
+/**
+ * This function prints the partly uncovered word (the working copy) in the
+ * desired format. 
+ * 
+ * Example: If workingCopy is "_xp_rt", a call to printWorkingCopy(workingCopy)
+ * will print "[ _ x p _ r t ]" - this is the format that is expected by the
+ * autograder.
+ */
+void printWorkingCopy(string workingCopy);
+
+/**
+ * This function must be called if the game was lost (that is, on the 6th 
+ * wrong guess). 
+ * 
+ * Example: If the correct word was "expert", its outputs
+ * "The word was: expert
+ *  You lost!"
+ */
+void printYouLost(string word);
+
+/**
+ * This function must be called if the game was won (that is, the word was
+ * guessed with less than 6 wrong guesses). 
+ * 
+ * Example: If the correct word was "expert", its outputs
+ * "[ e x p e r t ]
+ *  You won!"
+ */
+void printYouWon(string word);
+
+
+// THE FOLLOWING FUNCTIONS CAN BE USED INTERACTIVELY TO IMPLEMENT THE INDIVIDUAL
+// PARTS, BUT THEY DONT'T WORK DURING SUBMISSION
+
+/**
+ * Part 1: Ask the user to enter a character and update parameter 'guess'
+ */
+void PART1_readCharacter(char& guess);
+
+/**
+ * Part 2: Set the guessed character in the working copy. Updates parameter
+ * 'workingCopy' and sets parameter 'found' to either true or false
+ */
+void PART2_updateWorkingCopy(string word, char guess, string& workingCopy, bool& found);
+
+/**
+ * Part 3: Check if game is finished and update wrongGuesses variable.
+ * Print the approriate messages in the console. Updates parameters 'done' and
+ * 'wrongGuesses'
+ */
+void PART3_updateGameState(string word, string workingCopy, bool found, int maxWrongGuesses, bool& done, int& wrongGuesses);
+
+#endif

Vorkurs/Projekt_2/main.cpp

@@ -0,0 +1,69 @@
+#include <iostream>
+#include <string>
+#include "hangman.h"
+
+using std::string;
+
+int main() {
+  // Word the player needs to guess (randomly selected)
+  string word = chooseWord(); 
+  //string word = "success";
+  
+  // Initialise the "uncovered" word that is shown to the player: the uncovered
+  // word is obtained by replacing each letter from the original word (variable
+  // word) with an underscore (i.e. _).
+  string workingCopy = createWorkingCopy(word);
+  
+  // This variable indicates whether or not the game is over
+  bool done = false; 
+  
+  int wrongGuesses = 0; // Number of wrong guesses
+  int maxWrongGuesses = 6; // Maximum number of wrong guesses (don't change)
+  
+  // Draw the empty gallow
+  showHangman(0); 
+  
+  // Game loop (each iteration is a round of the game)
+  while (!done) {
+    printGameState(maxWrongGuesses, wrongGuesses);
+    printWorkingCopy(workingCopy);
+    
+    
+    /** Part 1: input next guess **********************************************/
+    char guess = '\0';
+    // TODO: replace the following line with your implementation
+    //PART1_readCharacter(guess);
+    std::cout << "Your guess: ";
+    std::cin >> guess;
+    
+    
+    /** Part 2: update working copy *******************************************/
+    bool found = false;
+    // TODO: replace the following line with your implementation
+    //PART2_updateWorkingCopy(word, guess, workingCopy, found);
+    for (int i = 0; i != word.length(); i++) {
+      if (guess == word.at(i)) {
+        found = true;
+        workingCopy.at(i) = guess;
+      }
+    }
+
+    
+    
+    /** Part 3: update game state *********************************************/
+    // TODO: replace the following line with your implementation
+    //PART3_updateGameState(word, workingCopy, found, maxWrongGuesses, done, wrongGuesses);
+    if (workingCopy == word) {
+      done = true;
+      printYouWon(word);
+    } else if (found == false) {
+      wrongGuesses += 1;
+    }
+    if (wrongGuesses == maxWrongGuesses) {
+      done = true;
+      printYouLost(word);
+    }
+  }
+  
+  return 0;
+}

Vorkurs/Projekt_2/termcolor.h

@@ -0,0 +1,20 @@
+#ifndef TERMCOLOR_H
+#define TERMCOLOR_H
+
+
+// NOTE: You cannot change this file, and you don't need to understand its
+// content in order to solve your task. Feel free to look around, however,
+// in case you're interested.
+
+
+const auto red = "\033[31;1m";
+const auto green = "\033[32;1m";
+const auto yellow = "\033[33;1m";
+const auto blue = "\033[34;1m";
+const auto magenta = "\033[35;1m";
+const auto cyan = "\033[36;1m";
+const auto gray = "\033[39;2m";
+const auto white = "\033[39;1m";
+const auto reset = "\033[0m";
+
+#endif

Vorkurs/Projekt_2/words.csv

@@ -0,0 +1,100 @@
+"available",
+"exaggerate",
+"ancestor",
+"architect",
+"neighborhood",
+"curriculum",
+"promotion",
+"opera",
+"frequency",
+"excavation",
+"guarantee",
+"reflection",
+"benefit",
+"development",
+"average",
+"ghostwriter",
+"unlikely",
+"disturbance",
+"initiative",
+"hospitality",
+"mastermind",
+"eyebrow",
+"consciousness",
+"operational",
+"vehicle",
+"housewife",
+"capital",
+"execution",
+"terrify",
+"disagree",
+"exclusive",
+"equinox",
+"essential",
+"imperial",
+"publicity",
+"secretary",
+"nationalist",
+"attention",
+"established",
+"magnitude",
+"orientation",
+"contraction",
+"intention",
+"seminar",
+"forecast",
+"manufacturer",
+"reception",
+"fabricate",
+"mosquito",
+"cooperative",
+"parachute",
+"exotic",
+"demonstrate",
+"production",
+"spontaneous",
+"minimum",
+"abolish",
+"holiday",
+"formation",
+"admission",
+"handicap",
+"continuous",
+"presentation",
+"constituency",
+"unique",
+"violation",
+"radical",
+"notebook",
+"custody",
+"dictionary",
+"comprehensive",
+"dominant",
+"requirement",
+"opponent",
+"business",
+"national",
+"manufacture",
+"nominate",
+"liberal",
+"continuation",
+"galaxy",
+"interest",
+"ignorant",
+"indirect",
+"illustrate",
+"proportion",
+"projection",
+"philosophy",
+"acceptable",
+"aluminium",
+"continental",
+"potential",
+"vegetarian",
+"elephant",
+"advantage",
+"recording",
+"agenda",
+"electronics",
+"engagement",
+"lonely",