Updated to new Semester

Vorkurs/Projekt_1/Task_1/README.md

@@ -0,0 +1,9 @@
+# Guess A Number (Task 1)
+
+## 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, with at most 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 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.

Vorkurs/Projekt_1/Task_1/guess_a_number.cpp

@@ -0,0 +1,33 @@
+#include <cstdlib>
+#include <iostream>
+#include <string>
+#include "guess_a_number.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 std::string action = std::getenv("ACTION");
+
+// This function returns a randomly chosen integer from the interval [1, max].
+int randomly_choose_a_number(int max) {
+  return std::rand() % max + 1;
+}
+
+int choose_a_number(int max) {
+  if (action == "run") {
+    std::cout << "?\n";
+      // Just here to achieve the same output behaviour, in terms of newlines,
+      // when a user replaces 
+      //   std::cin >> number_to_guess;
+      // by
+      //   number_to_guess = choose_a_number(MAX);
+    
+    return randomly_choose_a_number(max);
+  } else {
+    int guess;
+    std::cin >> guess;
+
+    return guess;
+  }
+}

Vorkurs/Projekt_1/Task_1/guess_a_number.h

@@ -0,0 +1,15 @@
+#ifndef PROJECT_H
+#define PROJECT_H
+
+// NOTE: You cannot change this file. In "only" contains declarations and
+// short descriptions of the functionality we provided to you.
+
+// This function returns a randomly chosen integer from the interval [0, max].
+int randomly_choose_a_number(int max);
+
+// This function returns a number from the interval [1, max].
+// The number is randomly chosen if we're in interactive mode and parameter
+// choose_randomly is true, and read from the keyboard (std::cin) otherwise.
+int choose_a_number(int max);
+
+#endif

Vorkurs/Projekt_1/Task_1/main.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include "guess_a_number.h"
+
+int main() {
+  // Declare the required variables
+  int number_to_guess; // The number to guess
+  int guess;           // The guessed number
+  
+  // Pick the number to guess
+  std::cout << "Number to guess: ";
+  number_to_guess = choose_a_number(3); // Randomly choose a number from the interval [1, 3]
+
+  // Save number inputted by user into variable guess
+  std::cin >> guess;
+  std::cout << "Your guess: ";
+  
+  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.";
+  }
+}

Vorkurs/Projekt_1/Task_2/README.md

@@ -0,0 +1,9 @@
+# Guess A Number (Task 2)
+
+## 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, with at most 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 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.

Vorkurs/Projekt_1/Task_2/guess_a_number.cpp

@@ -0,0 +1,49 @@
+#include <cstdlib>
+#include <iostream>
+#include <string>
+#include "guess_a_number.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 std::string action = std::getenv("ACTION");
+
+void print_attempts_left(int attempts_left) {
+  std::cout << "You have " << attempts_left << " attempt(s) left.\n";
+}
+
+void print_you_won(int correct_guess) {
+  std::cout << "Congratulations, you correctly guessed " << correct_guess << "!\n";
+}
+
+void print_wrong_guess(int wrong_guess) {
+  std::cout << "Sorry, but " << wrong_guess << " is wrong.\n";
+}
+
+void print_you_lost(int number_to_guess, int attempts) {
+  std::cout << "You lost after " << attempts << " attempt(s) :-( The number to guess was " << number_to_guess << ".\n";
+}
+
+// This function returns a randomly chosen integer from the interval [1, max].
+int randomly_choose_a_number(int max) {
+  return std::rand() % max + 1;
+}
+
+int choose_a_number(int max) {
+  if (action == "run") {
+    std::cout << "?\n";
+      // Just here to achieve the same output behaviour, in terms of newlines,
+      // when a user replaces 
+      //   std::cin >> number_to_guess;
+      // by
+      //   number_to_guess = choose_a_number(MAX);
+    
+    return randomly_choose_a_number(max);
+  } else {
+    int guess;
+    std::cin >> guess;
+
+    return guess;
+  }
+}

Vorkurs/Projekt_1/Task_2/guess_a_number.h

@@ -0,0 +1,82 @@
+#ifndef PROJECT_H
+#define PROJECT_H
+
+
+// NOTE: You cannot change this file. It "only" contains declarations and
+// short descriptions of the functionality we provided to you.
+
+
+// This function outputs the number of attempts that are left.
+//
+// Example: the function call print_attempts_left(3) results in the output
+// "You have 3 attempt(s) left".
+void print_attempts_left(int attempts_left);
+
+// This function outputs the winning message.
+//
+// Example: the function call print_you_won(9) results in the output
+// "Congratulations, you correctly guessed 9!".
+void print_you_won(int correct_guess);
+
+// This function outputs a message telling the user that their guess was wrong.
+//
+// Example: the function call print_wrong_guess(1) results in the output
+// "Sorry, but 1 is wrong.".
+void print_wrong_guess(int wrong_guess);
+
+// This function outputs the losing message.
+//
+// Example: the function call print_you_lost(2, 5) results in the output
+// "You lost after 5 attempts :-( The number to guess was 2.".
+void print_you_lost(int number_to_guess, int attempts);
+
+
+// This function returns a randomly chosen integer from the interval [0, max].
+int randomly_choose_a_number(int max);
+
+// This function returns a number from the interval [1, max].
+// The number is randomly chosen if we're in interactive mode and parameter
+// choose_randomly is true, and read from the keyboard (std::cin) otherwise.
+int choose_a_number(int max);
+
+
+// Master implementation for part 1: reads the next guess from the keyboard
+// and stores it in the passed variable.
+//
+// Example: given the function call PART1_read_next_guess(my_guess) and
+// assuming that the player enters 1, variable my_guess will afterwards
+// have the value 1.
+void PART1_read_next_guess(int& guess);
+
+// Master implementation for part 2: compares guess to number_to_guess,
+// outputs a result-depending message (correct/wrong) and updates
+// variable play to false if the guess was correct.
+//
+// Example: given the function call
+// PART2_handle_guess(1, 2, continue_playing), a wrong-guess message
+// will be outputted.
+//
+// Example: given the function call
+// PART2_handle_guess(2, 2, continue_playing), a correct-guess message
+// will be output and variable continue_playing will be set to false.
+void PART2_handle_guess(int guess, int number_to_guess, bool& play);
+
+// Master implementation for part 3: increments the number of guessing
+// attempts the player made (variable attempts), and if the maximum
+// number of guesses has been made, outputs a corresponding message and
+// sets variable play to false.
+//
+// Example: given the function call
+// PART3_finish_round(2, 10, performed_attempts, continue_playing), and
+// assuming that performed_attempts has a value of 5, then the only
+// effect of the function call is that performed_attempts will be updated
+// to 6.
+//
+// Example: given the function call
+// PART3_finish_round(2, 10, performed_attempts, continue_playing), and
+// assuming that performed_attempts has a value of 9, then
+// performed_attempts will be incremented to 10, a you-lost message will
+// be output and continue_playing will be set to false.
+void PART3_finish_round(int number_to_guess, int max_attempts, int& attempts, bool& play);
+
+#endif

Vorkurs/Projekt_1/Task_2/main.cpp

@@ -0,0 +1,48 @@
+#include <iostream>
+#include "guess_a_number.h"
+
+int main() {
+  int number_to_guess; // The number to guess
+  int max_attempts;    // The guessed number
+
+  std::cout << "Number to guess: ";
+  number_to_guess = choose_a_number(10); // Randomly choose a number from the interval [1, 10]
+
+  std::cout << "Number of attempts: ";
+  std::cin >> max_attempts;
+  
+  // Make sure that the player has at least one attempt
+  if (max_attempts < 1) max_attempts = 1;
+  
+  int attempts = 0; // Attempts made so far
+  bool play = true; // false once the game is over
+  
+  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;
+      }
+    }
+  }
+}

Vorkurs/Projekt_2/README.md

@@ -0,0 +1,11 @@
+# Project 2
+
+## 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.
+
+For 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

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",

Vorkurs/README.md

@@ -0,0 +1,3 @@
+# Vorkurs Informatik
+
+In diesem Verzeichnis findest du die Projekte für den Vorkurs Informatik.