# 1
# Einzelne Bücher runterladen und in 1,2,3,4 speichern.

#wget "http://gutenberg.spiegel.de/buch/5560/i" -O 1.html

# 2

#lynx -dump -assume_charset=UTF−8 −hiddenlinks=ignore -nolist -verbose 1.html > 1.txt

# 3
# Wir geben den Inhalt von 1.txt aus und leiten ihn direkt mit > in eine Datei bibel.txt um
# Die folgenden Bücher hängen wir mit Hilfe von >> an bibel.txt an

#cat 1.txt > bibel.txt cat 2.txt >> bibel.txt cat 3.txt >> bibel.txt cat 4.txt >> bibel.txt

# 4
import re
def find_longest_word(line):
    word_regex = re.compile(r'\w+')
    longest = ''
    # Wir laufen durch alle Wörter von line durch (Mit Hilfe von re.findall)
    for word in re.findall(word_regex ,line):
        # Wenn das aktuelle Wort der Zeile länger ist als das bisher größte: neues größtes Wort gefunden
         if(len(longest) < len(word)):
             longest = word
    return longest
# Wir rufen die Funktion mit einer Testzeile auf. Auf dem Bildschirm sollte "Testzeile" ausgegeben werden.
testline = "Dies ist eine Testzeile"
print(find_longest_word(testline))

# 5
import re
def count_words(line):
    word_regex = re.compile(r'\w+')
    # re.findall ist ein Objekt, welches einen 'Eintrag' für JEDES gefundene Element des regulären Ausdrucks beinhaltet.
    # In unserem Fall heißt das: Ein Eintrag für jedes Wort der Zeile (wegen \w+).
    # Zählen wir die Anzahl der Einträge mit len(), so zählen wir in diesem Fall die Wörter.
    word_count = len(re.findall(word_regex ,line))
    return word_count
# Wir rufen die Funktion mit einer Testzeile auf. Auf dem Bildschirm sollte 4 ausgegeben werden.
testline = "Dies ist eine Testzeile"
print(count_words(testline))

# 6a
import re
splitregex = re.compile(r'\w+')
bibel = open('bibel.txt', 'r')
frequenzliste = {}
for line in bibel:
    # Unser regulärer Ausruck findet alle Wörter der Zeile und läuft durch diese einzeln durch.
    for word in re.findall(splitregex,line):
        # Entfernt Komma, Punkt, etc. vom Wort
        word = word.strip()
        # Frequenzliste wie üblich erstellen.
        if (word in frequenzliste):
            frequenzliste[word] = frequenzliste[word] + 1
        else:
            frequenzliste[word] = 1
# Filestream schließen
bibel.close()
print('In der Datei kamen', len(frequenzliste),'unterschiedliche Wörter vor.')

# 6b
# Frequenzliste wie oben erstellen
import re
splitregex = re.compile(r'\w+')
bibel = open('bibel.txt', 'r')
frequenzliste = {}
for line in bibel:
    for word in re.findall(splitregex,line):
        word = word.strip()
        if (word in frequenzliste):
            frequenzliste[word] = frequenzliste[word] + 1
        else:
            frequenzliste[word] = 1
bibel.close()
# Wir sortieren die Frequenzliste nach ihrem Wert absteigend - ACHTUNG, das Ergebnis ist kein Dictionary mehr, sondern eine Liste mit Tupeln
frequenzliste = sorted(frequenzliste.items(), key=lambda x: x[1], reverse = True)
# Wir legen eine leere Liste an, in der die Zehn häufigsten groß geschriebenen Wörter gespeichert werden
most_occurences = []
# Wir lassen uns alle Elemente (Wort, Anzahl) der sortierten Liste ausgeben
for element in frequenzliste:
    # Wir wollen nur weitere Wörter suchen/anhängen, wenn in der Liste noch nicht 10 Wörter gespeichert sind
    if len(most_occurences) < 10:
        # Prüfen, ob das aktuelle Wort groß geschrieben ist - ansonsten machen wir nichts mit dem Wort
        if element[0].istitle():
            # Wort der Liste anhängen
            most_occurences.append(element[0])
# Liste ausgeben
print("Dies sind zehn häufigsten großgeschriebenen Wörter: \n", most_occurences)

# 6c
# Frequenzliste wie oben erstellen
import re
splitregex = re.compile(r'\w+')
bibel = open('bibel.txt', 'r')
frequenzliste = {}
for line in bibel:
    for word in re.findall(splitregex,line):
        word = word.strip()
        if (word in frequenzliste):
            frequenzliste[word] = frequenzliste[word] + 1
        else:
            frequenzliste[word] = 1
bibel.close()
# Wir sortieren die Frequenzliste nach ihrem Wert absteigend - ACHTUNG, das Ergebnis ist kein Dictionary mehr, sondern eine Liste mit Tupeln
frequenzliste = sorted(frequenzliste.items(), key=lambda x: x[1], reverse = True)
# Wir legen eine leere Liste an, in der die Zehn am öftesten vorkommenden klein geschriebenen Wörter gespeichert werden
most_occurences = []
for element in frequenzliste:
    if len(most_occurences) < 10:
        # Prüfen, ob das aktuelle Wort klein geschrieben ist - ansonsten machen wir nichts mit dem Wort
        if not element[0].istitle():
            # Wort der Liste anhängen
            most_occurences.append(element[0])
# Liste ausgeben
print("Dies sind zehn häufigsten klein geschriebenen Wörter: \n", most_occurences)


##Aufgabe 11-7##
#!/usr/bin/python3

import re
buchregex = re.compile(r'^\d+\. Buch \w+')  
# matcht Zeilen, die mit einer Zahl, dem Wort "Buch" und noch einem Wort beginnen
kapitelregex = re.compile(r'^Kapitel \d+')  
# matcht Zeilen, die mit dem Wort "Kapitel" und einer Zahl beginnen
versregex = re.compile(r'^   (\d+)')  
# matcht Zeilen, die mit 3 spaces und einer Zahl beginnen 
emptylineregex = re.compile(r'^\s*$')  
# matcht Zeilen, die leer sind oder nur Whitespaces enthalten

filebibel = open('bibel.txt', 'r')  # öffnet die Datei zum lesen
bibel = filebibel.readlines()

vers_zuende = False  
# Boolvariable, wird auf True gesetzt, sobald die letzte Zeile Beginn eines Verses war
for line in bibel:   # iteriert über die Zeilen der Datei
	if re.search(buchregex, line):  
		print(line) # wird eine Buchüberschrift gefunden, wird die Zeile ausgegeben
	elif re.search(kapitelregex, line):  
		print (line) # wird eine Kapitelüberschrift gefunden, wird die Zeile ausgegeben
	elif re.search(versregex, line):  
		match = re.findall(versregex, line)[0]
		# erstellt eine Liste aller Matches und speichert das erste Match in der Variablen "match"
		if (int(match) <= 3):
            # wenn der Zahlenwert der Variablen "match" höchstens 3 ist, wird die Zeile ausgegeben und die Boolvariable auf True gesetzt
			print(line)
			vers_zuende = True
	elif vers_zuende:  
        # wird nur ausgeführt, wenn die Zeile auf keinen der Regex passt und die Boolvariable True ist
		if not re.search(emptylineregex, line):  
            # wenn die Zeile nach dem Versanfang nicht leer ist, wird sie ausgegeben, weil sie zum Vers gehört
			print(line)
		else:  # eine Leerzeile merkiert das Ende des Verses, wird also nicht mit ausgegeben
			vers_zuende = False # die Boolvariable wird auf False gesetzt und damit die Schleife beendet

filebibel.close()  


##Aufgabe11-8##
#!/usr/bin/python3

import re
bibelfile = open('bibel.txt', 'r')
bibel = bibelfile.read()

sohn_regex = re.compile(r'(\w+), der Sohn (\w+)s')  
# matcht das Pattern "Name1, der Sohn Name2s"
# beide Namen werden gruppiert, um separat auf sie zugreifen zu können

vater_von = {}  
#legt ein leeres Dictionary an, in dem der Name des Sohns als Key und der Name des Vaters als Value gespeichert werden soll

for match in re.findall(sohn_regex, bibel):  
# erstellt mit re.findall eine Liste aller Matches und iteriert darüber
    vater_von[match[0]] = match[1]
    # greift auf die beiden Gruppen zu und hinterlegt den Namen des Sohnes als Key, den Namen des Vaters als Value im Dictionary

anzahl_sohn = {}  
# legt ein Dictionary an, in das in Form einer Frequenzliste füt jeden Vater die Anzahl der Söhne eingetragen wird

for sohn, vater in vater_von.items():  # iteriert durch die keys und values des Dictionarys
    if vater in anzahl_sohn:  
        anzahl_sohn[vater] += 1
        # ist der Vater bereits in der Frequenzliste, wird der Value erhöht
    else:  
        anzahl_sohn[vater] = 1

meiste_soehne = 0  
# Variable, um einen Vergleich mit der Frequenzliste durchführen zu können

for vater, sohn in anzahl_sohn.items():  
    if sohn > meiste_soehne:  # wenn der aktuelle Value größer ist als meiste_kinder
        meiste_soehne = sohn  # die Variable erhält den Wert des aktuellen Values
        gewinner_vater = vater  # der aktuelle Key wird in einer neuen Variablen gespeichert

print("Der Vater mit den meisten Söhnen ist:", gewinner_vater, "mit",meiste_soehne,"Söhnen:")  
# der Name des Vaters mit dem höchsten Score wird ausgegeben, sowie der Score selbst

for sohn in vater_von.keys():  # alle Namen der Söhne ausgeben
    if vater_von[sohn] == gewinner_vater:
        print(" -",sohn)


##Aufgabe 11-9##
#!/usr/bin/python3

import re
def shortest_word(line):  
# definiert die Funktion "shortest_word" mit dem Argument "line"
    splitregex = re.compile(r'\w+')
    sort_wörter = sorted(re.findall(splitregex, line), key=lambda x: len(x))
    # erstellt eine Liste mit allen Matches und sortiert sie nach der Länge 
    return sort_wörter[0] # gibt das erste Element zurück
testline = "Computerlinguistik LMU Student Computer Informatik"
print ('Das kürzseste Wort der Testzeile ist:"',shortest_word(testline),'".') 
# gibt den Rückgabewert der Funktion aus