#10-1

import re

markdown = open('linux.markdown','r').read().split('\n') 
# wie in Blatt 8 Datei öffnen, auslesen und in eine Liste aus Zeilen umwandeln

überschrift_reg = re.compile(r'#+\s+[^#]+')  
# matcht alles, das mit mindestens einer Raute beginnt, während danach keine Raute folgt

for line in markdown:  # iteriert über die Zeilen der Datei
  for match in re.findall(überschrift_reg, line):
  #findet alle Matches innerhalb einer Zeile
      print(match)
      #gibt die Matches hintereinander aus


#10-2

import re

markdown = open('linux.markdown','r').read().split('\n') 
# wie in Blatt 8 Datei öffnen, auslesen und in eine Liste aus Zeilen umwandeln

font_reg = re.compile(r'(\*\*|__)(.+)\1')  
# mit \1 wird genau das wiederholt, auf das die erste Klammer gematcht hat, also entweder __ oder **, damit keine Mischformen auftreten. Die Klammerung von (.+) ist eine Gruppierung, die es ermöglicht im zweiten Teil der Aufgabe nur diesen Teil auszugeben

for line in markdown:  # iteriert über die Zeilen der Datei
  for fett in re.findall(font_reg,line):  
# findet in der Zeile alle Matches, die dem Regex entsprechen und gibt sie als Liste zurück

      print (fett[1])  
      # falls True, geben wir mit [1] den Inhalt der zweiten Klammer (.+) des Matches aus



#10-3

import re

markdown = open('linux.markdown','r').read().split('\n') 
# wie in Blatt 8 Datei öffnen, auslesen und in eine Liste aus Zeilen umwandeln

link_reg = re.compile(r'')  
# matcht alle Links, also alles was mit , also non-greedy (markiert mit dem ? nach dem *, bedeutet dass das kleinstmögliche für .* gematcht wird, also nur bis zum nächsten >)

for line in markdown:  # iteriert über die Zeilen der Datei
  for link in re.findall(link_reg,line):  
# findet in der Zeile alle Matches, die dem Regex entsprechen und gibt sie als Liste zurück

      print (link)
       # falls True, geben wir den Link aus

#10-4

import re

markdown = open('linux.markdown','r').read().split('\n') 
# wie in Blatt 8 Datei öffnen, auslesen und in eine Liste aus Zeilen umwandeln

linux_reg = re.compile(r'[L|l]inux')  
# matched die Wörter "Linux" und "linux" 
# es geht auch: linux_reg = re.compile(r'Linux', re.I) 

for line in markdown:  # iteriert über die Zeilen der Datei
  if re.search(linux_reg,line): 
# wenn re.seach True ist (also etwas findet)

      print (line)
       # falls True, geben wir die Zeile aus 


#10-5

import re

markdown = open('linux.markdown','r').read().split('\n') 
# wie in Blatt 8 Datei öffnen, auslesen und in eine Liste aus Zeilen umwandeln

split_reg = re.compile(r'\w+')
doppel_re = re.compile(r'(\w)\1')  
# matcht erst einen Wordcharacter, und dann genau den gleichen direkt nochmal, also alle doppelten Vorkommen vom Buchstaben direkt nacheinander

for line in markdown:  # iteriert über die Zeilen der Datei
  for word in re.findall(split_reg,line):  
# findall findet in line alle substrings, die dem Regex entsprechen (also Wörter), und gibt sie so zurück, dass wir darüber iterieren können.
      if (re.search(doppel_re,word)):  
# search gibt true zurück, falls irgendwo im String ein match gefunden wurde
          print (word)

#10-6
#wget "http://de.wikipedia.org/wiki/Gerhard_Polt" -O polt.html

#10-7
#lynx -dump polt.html -assume_charset=UTF-8 -hiddenlinks=ignore -nolist -verbose > polt.txt

#10-8
#!/usr/bin/python3
import re
splitregex = re.compile(r'\w+')
# Regulären Ausdruck erstellen, der alle Wörter mit beginnendem großbuchstaben und min. 4 folgenden Buchstaben findet
# Dazu geben wir in den geschweiften Klammern die Untergrenze, aber keine Obergrenze an
pattern = re.compile(r'[A-ZÄÖÜ]\w{4,}')
# Frequenzliste erzeugen, dieses Mal mit Hilfe von re
polt = open('polt.txt','r')
freq = {}
# Über jede Zeile der Datei iterieren.
for line in polt:
    # mit findall suchen wir alles in der Zeile, was dem splitregex entspricht, also alles was nur aus Buchstaben besteht
    for word in re.findall(splitregex,line):
        word = word.strip()
        # Wir gucken, ob das Wort dem gesuchten Muster entspricht, falls Ja geben wir dies aus
        if(re.match(pattern, word)):
            # Wie üblich schauen, ob dieses Wort schon in Frequenzliste ist
            if (word in freq):
                freq[word] = freq[word] + 1
            else:
                freq[word] = 1
print("In der Datei kommen", str(len(freq)), "unterschiedliche großgeschriebene Wörter mit min. 5 Buchstaben vor.")
polt.close()

#10-9
# Neue Funktion definieren, die eine Variable annimmt.
def umkehren(eingabe):
    neuer_text = ""
    # Alle Buchstaben des Textes durchgehen
    for buchstabe in eingabe:
        # Den jeweiligen Buchstaben an den Anfang von neuer_text schreiben und den Rest hinten dran
        neuer_text = buchstabe + neuer_text
    # Die Variable neuer_text zurückgeben
    return neuer_text

nutzer_eingabe = input("Bitte Text eingeben: ")
# Wir printen die Rückgabe von unserer Funktion
print(umkehren(nutzer_eingabe))

#10-10
def printposition(wortliste):
    # variable, in der die jeweilige Position hochgezählt wird
    position = 1
    for wort in wortliste:
        print(wort, "steht an Position", str(position))
        # Position eins hochzählen
        position+=1
# Liste anlegen und Funktion mit dieser Liste aufrufen
test_liste = ["spam","and","eggs"]
printposition(test_liste)

#10-11
# Wir legen eine Liste an, in der das jeweils unterschiedliche Wort gespeichert wird.
kardinalszahlen = ["vierter", "dritter", "zweiter", "nächster"]
# Für jedes Element in dieser Liste geben wir eine Strophe aus
for element in kardinalszahlen:
    print("tür auf")
    print("einer raus")
    print("einer rein")
    # Die variable Zeile hier ausgeben. Dann zusätzlichen Zeilen umbruch um Strophe zu kennzeichnen.
    print(element+" sein\n")
# Danach die letzte Strophe ausgeben
print("tür auf")
print("einer raus")
print("selber rein")
print("tagherrdoktor")

#10-12
# Funktion definieren, die eine Liste von Zahlen bekommt.
def selber_sortieren(liste):
    sortierte_liste = []
    # Wir durchlaufen die Schleife für jedes Element der Liste
    for i in range(0,len(liste)):
        # Wir behaubten, das kleinste Element ist das aktuell erste Element
        kleinstes_element = liste[0]
        kleinster_index = 0
        # Wir laufen jetzt durch jedes Element durch und vergleichen dieses mit dem aktuell kleinsten
        for j in range(0,len(liste)):
            # Wenn wir ein kleineres gefunden haben, speichern wir dieses in kleinstes_element
            if liste[j] < kleinstes_element:
                kleinstes_element = liste[j]
                kleinster_index = j
        # Nachdem wir durch alle Elemente durchgelaufen sind haben wir das kleinste Element der Liste gefunden
        # Dieses hängen wir der Liste fortlaufend an
        sortierte_liste.append(kleinstes_element)
        # Aus unserer Ausgangsliste entfernen wir das zuvor gefundene kleinste Element
        del liste[kleinster_index]
    # Sortierte Liste zurückgeben
    return sortierte_liste


test_liste = [1,5,2,9,8,3,11,3,3,3]
print(selber_sortieren(test_liste))