Converted everything to orgmode

converted everything to orgmode and added solution to the README files

Vorkurs/Projekt_1/Task_1/README.org

@@ -104,51 +104,20 @@ You can also see the results for your submission on the "Enrolled Courses" tab o
 
 * 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 {

Vorkurs/Projekt_1/Task_2/README.org

@@ -13,11 +13,11 @@ The first project consists of two tasks: *task 1* was to reimplement the first v
 
 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. 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:
+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)
 
@@ -31,7 +31,7 @@ To make it easier for you to develop your solution step by step, you are given a
 
 * 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.
+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
 
@@ -59,7 +59,7 @@ As mentioned above, you can develop the final solution step by step, by iterativ
    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).
+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
 
@@ -102,42 +102,29 @@ You lost after 2 attempt(s) :-( The number to guess was 2.
 
 * 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.
+*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;   
+  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);
 

Vorkurs/Projekt_2/README.md

@@ -1,50 +0,0 @@
-# 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/README.org

@@ -0,0 +1,258 @@
+#+TITLE: Project 2: Hangman
+#+AUTHOR: JirR02
+
+* Project Overview
+
+The goal of this project is to implement a version of the popular guessing game known as Hangman (German: Galgenmännchen). The rules of the game are simple: the first player picks a word which the second player has to guess character by character — with a limited amount of guesses.
+
+When played on paper, a snapshot of the game typically looks as follows:
+
+[[]]
+
+or your version, we focus on the essence of the game:
+
+1. Choosing a word and initialising the game
+1. Repeatedly guessing characters, and uncovering them if they occur in the chosen word
+1. Eventually announcing that the player won ... or lost
+
+** A primer on strings and chars
+
+In =C++= (and in most other programming languages), sequences of characters, such as the word the player needs to guess, can be represented as strings. Strings will be introduced properly in your later, regular computer science course; for now, you only need to know the following about strings in order to implement Hangman:
+
+1. Strings and operations thereon are provided by the *string* library:
+
+   #+begin_src cpp
+    #include <string>
+    using std::string;
+   #+end_src
+
+    The first line allows us to use the =c++= *string* library, the second line allows us to directly use =string= as a data type, instead of having to write =std::string= everywhere.
+
+1. A variable named 'word' of type string can be declared as follows:
+
+    #+begin_src cpp
+    string word;
+    #+end_src
+
+1. String-typed variables can be set as follows:
+
+   - By using string literals, which are enclosed in quotation marks:
+
+     #+begin_src cpp
+     word = "potato";
+     #+end_src
+
+   - By reading a string from the keyboard:
+
+     #+begin_src cpp
+     std::cin >> word;
+     #+end_src 
+
+   - By assigning it another string
+
+     #+begin_src cpp
+     word = chooseWord();
+     #+end_src
+
+     The function chooseWord() returns a string value which is then assigned to the variable word.
+
+1. The length (type unsigned int) of a string can be determined by using the length function, which returns the number of characters in the string:
+
+
+   #+begin_src cpp
+   string word = "hangman";
+   std::cout << word.length(); // outputs: 7
+   #+end_src 
+
+1. The nth character (type char) of a string can be accessed using the at function:
+
+   #+begin_src cpp
+   string word = "hangman";
+   std::cout << word.at(0); // Output: h (the first character)
+   std::cout << word.at(6); // Output: n (the last character)
+   #+end_src
+
+   Note that the first character is at position 0 and the last character at position length() - 1!
+
+   The nth character can also be replaced by using the at function, e.g.
+
+   #+begin_src cpp
+   string workingCopy = "_______";
+   workingCopy.at(3) = 'n';
+   std::cout << workingCopy; // Output: __n____
+   #+end_src
+
+   where '_' denotes a single character (of type char).
+
+1. Similar to whole strings, you can also declare variables for single characters (type char) and read them from the keyboard:
+
+   #+begin_src cpp
+   char guess;
+   std::cin >> guess;
+   #+end_src
+
+** Stepwise development
+
+The program template that you start with has been developed using the /stepwise refinement/ technique, and just like for project 1, task 2, contains master implementations (functions =PART1=... etc.) that you must replace with your own code.
+
+We also provide you with output-generating functions (e.g. =printYouWon()=) that make it easier for you to please the tests (and thus the autograder).
+
+As before, we suggest that you develop your program step-by-step, and run or test it often. I.e. implement a single part, such as reading the next guess from the keyboard or updating the working copy, and then run and test the program to see if it (still) works as intended.
+
+** Implementing the game
+
+Your job is to implement three major parts of the actual algorithm to play the game. As before, each part can be implemented separately.
+
+The following variables are already declared in the template given to you:
+
+- =string= word: This variable contains the word that must be guessed
+
+- =string= workingCopy: This variable is initialized with a string that has the same size as the string word. Each character in this string is initialized with an underscore (_).
+
+- =bool= done: If this variable is set to true the program will not play another round of the game (both in the case of winning and losing).
+
+- =int= wrongGuesses: This variable is initialized with 0 and must be incremented by one every time a guessed character doesn't occur in the word to guess.
+
+- =int= maxWrongGuesses: This variable is initialized with constant 6. Don't change it.
+
+- =bool= found: This variable indicates whether (true) or not (false) the guessed character occurs in the word to guess.
+
+*Note:* Each of the following parts is already implemented in a master implementation function (=PART=...), which you need to replace with your own code. The corresponding places in the code are marked by TODO comments.
+
+*** Part 1
+
+This part is about reading the next guess from the keyboard.
+
+Comment out the call to =PART1_readCharacter= and replace it by an implementation that performs the following steps:
+
+1. Output the text " =Your guess:= "
+1. Read a single character from the keyboard into variable guess.
+
+You already know how to output text; see the string primer above (point 6) for how to input a single character.
+
+*** Part 2
+
+This part involves checking if the guessed character occurs in the word, and updating the =workingCopy= accordingly: by replacing the underlines at the respective position(s) by the guessed character. Variable found indicates if the guessed character was found in the word.
+
+Comment out the call to =PART2_updateWorkingCopy= and replace it by an implementation that performs the requested operation.
+
+*Example (found):* If variable word is set to "success", variable =workingCopy= still contains the initial underlines ("=_______=") and the current guess is '=c=', then two actions must be performed:
+
+1. Variable found must be set to =true=, because '=c=' occurs in the word "success"
+1. All occurrences of the letter '=c=' must be uncovered in the working copy, thus variable =workingCopy= must be changed to have the content "=__cc___="
+
+*Example (not found):* If variable word is set to "success", variable =workingCopy= still contains the initial underlines ("=_______=") and the current guess is '=x=', then the following is important:
+
+1. Variable found must remain =false= (because '=x=' does not occur in "success"
+1. Variable =workingCopy= must not be changed.
+
+*** Part 3
+
+This part is about determining if the game continues, or if it is already won or lost.
+
+Comment out the call to =PART3_updateGameState= and replace it by an equivalent implementation of your own, as described next.
+
+If the player made a correct guess and we uncovered at least one further character in the working copy (in which case variable found has value =true=), and if variable =workingCopy= now equals variable word, then the game has been won. Two things must happen in this case:
+
+1. Set variable done to true, to indicate that the game must not continue.
+1. Call =printYouWon(word)=, which will output the result of the game (in a format required by the autograder).
+
+Otherwise, if the player guessed incorrectly (in which case variable found is =false=), variable =wrongGuesses= must be incremented by one. If this variable is afterwards equal to =maxWrongGuesses= then the game is lost, in which case the following two things must happen:
+
+1. Set variable done to =true=, to indicate that the game must not continue.
+1. Call =printYouLost(word)=, which will output the result of the game (in a format required by the autograder).
+
+In all other situations, just make sure that variable done remains =false=. This ensures that the game continues.
+
+** 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.
+
+To successfully complete this project, your solution needs to pass 12 out of 17 tests, i.e. you don't need to score 100%.
+
+** Hints
+
+- Checking for equality of strings can be done using the ==== operator, the same way you would check equality of numbers or booleans.
+- Pimp your implementation by calling =showHangman(i)= to draw the gallows after =i= incorrect guesses (for i between 0 and 6)
+- You don't need to account for German umlauts, French accents etc. (such as ö or é)
+- You do not need to handle duplicated guesses in any special way. E.g. if the player guesses X twice, then either nothing happens the second time around (if X occurs in the word) or the player loses a point each time (if X does not occur in the word).
+- If you're interested (and brave enough), you can find more information about strings at https://en.cppreference.com/w/cpp/string
+
+
+* Solution
+
+#+begin_src cpp
+#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;
+}
+#+end_src
+
+-----
+
+Made by JirR02 in Switzerland 🇨🇭

Vorkurs/Projekt_2/hangman.cpp

@@ -1,69 +0,0 @@
-#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

@@ -1,97 +0,0 @@
-#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

@@ -1,69 +0,0 @@
-#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

@@ -1,20 +0,0 @@
-#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

@@ -1,100 +0,0 @@
-"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",