Frankenstein - HH11

solutions/Frankenstein_Level1.py

@@ -0,0 +1,9 @@
+def run(rectangle):
+    m = []  # Mittelpunkt des Rechtecks - List
+    # Werte aus dem Tupel mit Formel für x
+    m.append(rectangle[0] + (2 / (rectangle[4] - rectangle[0])))
+    # Werte aus dem Tupel mit Formel für y
+    m.append(rectangle[1] + (2 / (rectangle[5] - rectangle[1])))
+
+    print(m)
+    return m

solutions/Frankenstein_Level2.py

@@ -0,0 +1,18 @@
+import string
+from itertools import product
+
+def run(doorbell):
+    vowels_alphabetical_order = ["a","e","i","o","u"]
+    doorbell_solution_vowels = []
+    for character in doorbell:
+        ##If vowel add to vowel list
+        if character in vowels_alphabetical_order:
+            doorbell_solution_vowels.append(character)
+
+    combination_list = list(product(vowels_alphabetical_order,repeat=len(doorbell_solution_vowels)))
+    position_counter = 1
+    for c in combination_list:
+        position_counter = position_counter + 1
+        if tuple(doorbell_solution_vowels) == c:
+            print(position_counter)
+            return position_counter

solutions/Frankenstein_Level3.py

@@ -0,0 +1,86 @@
+import random
+
+name = 'Adam Chattoway'
+
+def run(name):
+
+    # Slicing & Indexing to get the initials from the name
+
+    def get_initials(name):
+
+        initials =[]
+        names = name.split()
+
+        for i in range(0,2):
+            initials.append(names[i][0])
+
+        return initials
+
+    # Using the initials for the seed
+
+    initials = get_initials(name)
+
+    def create_seed(initials):
+
+        seed_digits = [ord(i) for i in str(initials)]
+
+        return sum(seed_digits)
+
+    seed = create_seed(initials)
+
+    # Check if the digits are unique within a 3 digit block
+
+    def unique_digits(a):
+
+        digits = [int(i) for i in str(a)]
+
+        if digits[0] == digits[1]:
+            return False
+
+        elif digits[0] == digits[2]:
+            return False
+
+        elif digits[1] == digits[0]:
+            return False
+
+        else:
+            return True
+
+    # Calculate a cross sum for a given number
+
+    def cross_sum(a):
+
+        cross_sum_digits = [int(i) for i in str(a)]
+
+        return sum(cross_sum_digits)
+
+    # Randomly create 3-digit numbers from seed, check the requirements and add to list if they are met
+
+    random.seed(seed)
+
+    numbers = []
+
+    while len(numbers) < 3:
+
+        x = random.randint(seed,988)
+
+        if unique_digits(x) == True:
+
+            if cross_sum(x) >= 9 and cross_sum(x) <= 15:
+
+                numbers.append(x)
+
+        else:
+            continue
+
+    # Create the strings and join/add everything together
+
+    badge_initials = ''.join(get_initials(name))
+    badge_nums = '-'.join(map(str, numbers))
+
+    badge_number = badge_initials + '-' + badge_nums
+
+    print(badge_number)
+    return badge_number
+
+run(name)

solutions/Frankenstein_Level4.py

@@ -0,0 +1,48 @@
+from itertools import permutations
+import string
+
+# code = ['A1', 'B1', 'C1', 'D1', 'E1', 'F1']
+
+def run(code):
+    '''
+    find the right 3 keys red, blue, yellow
+    decode numbers from the note
+    '''
+    # Try out all combinations of the keys
+
+    def key_combinations():
+
+        colours =['red', 'yellow', 'blue']
+        all_possible_compinations = []
+
+        p = permutations(colours)
+
+        for p in list(p):
+            all_possible_compinations.append(p)
+
+        return all_possible_compinations
+
+    # Decode the numbers to open the safe, 1-52 (A1 - Z2)
+
+    def decoding_numbers(code):
+
+        # Create the list of the uppercase letters of the alphabet with a 1 and then a 2 added
+
+        alphabet = list(string.ascii_uppercase) 
+
+        key = [item + '1' for item in alphabet] + [item + '2' for item in alphabet]
+
+        # Decode the numbers using their list position 
+
+        decoded_numbers = []
+
+        for item in code:
+
+            num = key.index(item)
+
+            decoded_numbers.append(num+1)
+
+        return decoded_numbers
+
+    print(key_combinations() + decoding_numbers(code))
+    return key_combinations() + decoding_numbers(code)

solutions/Frankenstein_Level5.py

@@ -0,0 +1,12 @@
+def run(task_messages):
+    picture_lines = task_messages[0:10]
+    aligned_picture_lines = []
+    date_from_picture = list(map(int, str(picture_lines[9])))
+
+    for i, elem in enumerate(picture_lines[0:8]):
+        picture_line = list(picture_lines[i])
+        del picture_line[:date_from_picture[i]]
+        picture_line = ''.join(picture_line)    
+        aligned_picture_lines.append(str(picture_line))
+
+    return aligned_picture_lines

solutions/Frankenstein_Level6.py

@@ -0,0 +1,34 @@
+def run(data):  # Tupel/Tripel 3 Elemente
+    msg_encr = data[0]
+    a = data[1]
+    b = data[2]
+
+    def decrypt(y, a_inv, b):
+        return ((a_inv*(y - b)) % 26)
+
+    def euklid(a, m):
+        def ggt_euklid(a, b):
+            if a == 0:
+                return (b, 0, 1)
+            else:
+                ggt, y, x = ggt_euklid(b % a, a)
+                return (ggt, x - (b // a) * y, y)
+
+        ggt, x, y = ggt_euklid(a, m)
+        if ggt != 1:
+            # Laufzeitfehler
+            raise Exception("Es gibt kein inverses zu a modulo m")
+        else:
+            return x % m
+
+    alphabet = "abcdefghijklmnopqrstuvwxyz"
+    msg = ""
+    for y in msg_encr:
+        if alphabet.find(y) == -1:
+            msg = msg + y
+        else:
+            a_inv = euklid(a, 26)
+            x = decrypt(alphabet.find(y), a_inv, b)
+            msg = msg + alphabet[x]
+    print(msg)  # die Lösung wird in der Kommandozeile ausgegeben
+    return msg  # auf msg ist nun die entschlüsselte Nachricht gespeichert

solutions/Frankenstein_Level6_Crypt.py

@@ -0,0 +1,21 @@
+def crypt(x, a, b):
+    return ((a*x+b) % 26)
+
+
+msg = "der junge lebt wieder. das tonikum hat geholfen, seinen aggressiven drang zu lindern, aber er wird von den erinnerungen an seine vergangenheit heimgesucht. ich ertappte ihn wieder beim schleichen zum fenster dieses maedchens. meine theorien brauchen mehr arbeit. diese schoepfung ist wie so viele andere unvollkommen."
+msg_crypt = ""
+a = 25
+b = 13
+
+alphabet = "abcdefghijklmnopqrstuvwxyz"
+
+for x in msg:
+    if alphabet.find(x) == -1:
+        msg_crypt = msg_crypt + x
+    else:
+        y = crypt(alphabet.find(x), a, b)
+
+        msg_crypt = msg_crypt + alphabet[y]
+
+
+print(msg_crypt)

static/escape.js

@@ -62,12 +62,13 @@ function next_room() {
         );
 }
 
+//changed from "text" to "html" convert
 function notify(message, fadeout = true) {
     if (fadeout) {
-        $("#message").text(message).fadeTo(500, 1).delay(3000).fadeTo(500, 0);
+        $("#message").html(message).fadeTo(500, 1).delay(6000).fadeTo(500, 0);
     }
     else {
-        $("#message").text(message).fadeTo(500, 1);
+        $("#message").html(message).fadeTo(500, 1);
     }
 }
 
@@ -136,12 +137,23 @@ function upload() {
     });
 }
 
+//Convert message to html and make sure it can handle arrays if solution returns an array
 function show_result(result) {
+    var html_msg = "Deine Lösung ist:<br>"
+    if (result.solution.constructor.name == "Array") {
+        result.solution.forEach(function(m, index){
+        html_msg = html_msg + m + "<br>";
+    });
+    }
+    else {
+        html_msg = html_msg + result.solution + "<br>"
+    }
+
     if (result.correct) {
-        notify("Deine Lösung ist: " + result.solution + ". Juhu, das war richtig!");
+        notify(html_msg + "Juhu, das war richtig!");
         next_level();
     }
     else {
-        notify("Deine Lösung ist: " + result.solution + ". Das ist leider falsch.");
+        notify(html_msg + "Das ist leider falsch.");
     }
 }