<jupyter_start><jupyter_text>Die Bekehrung der Ungläubigen Drei Missionare und drei Ungläubige wollen zusammen einen Fluss überqueren, denn die Ungläubigen sollen in der Kirche, die sich auf dem anderen Ufer befindet, getauft werden. Sie haben nur ein Boot, das Platz für **maximal zwei**  Passagiere bietet.  Sowohl die Ungläubigen als auch die Missionare können rudern.  Es ist zusätzlich bekannt, dass die Ungläubigen zum Kannibalismus neigen. Die Kannibalen sind hungrig, wenn die Missionare an einem der beiden Ufer in der Unterzahl sind, haben sie ein **Problem**.  Ihre Aufgabe besteht darin, einen Fahrplan zu erstellen, so dass einerseits alle Personen das andere Ufer erreichen und andererseits die Missionare zwischendurch kein Problem bekommen.  Definition verschiedener Hilfsfunktionen Im Folgenden definieren wir einige Hilfsfunktionen, die wir auch schon bei der Lösung des *Wolf-Ziege-Kohl-Problems* verwendet haben.<jupyter_code>def tripleToStr(t):
    return '(' + str(t[0]) + ',' + str(t[1]) + ',' + str(t[2]) + ')'
import graphviz as gv
%run Breadth-First-Search.ipynb<jupyter_output><empty_output><jupyter_text>Die einzelnen Zustände werden als Tripel der Form$$ \langle m, k, b \rangle $$dargestellt.  Dabei ist $m$ die Anzahl der Missionare am linken Ufer, $k$ ist die Anzahl der Kannibalen am linken Ufer und $b$ ist die Anzahl der Boote am linken Ufer. Implementieren Sie eine Funktion problem, so dass der Aufruf $\texttt{problem}(m, k)$ genau dann True als Ergebnis zurück liefert, wenn an einem Ufer mit $m$ Missionaren und $k$ Kannibalen für die Missionare ein Problem entsteht.<jupyter_code>def problem(m, k):
    '''
    This function returns True if there is a problem on a shore that has 
    m missionaries and k cannibals.
    '''
    return k>m 
    
    
problem(3, 3), problem(2, 1), problem(1, 2)<jupyter_output><empty_output><jupyter_text>Berechnen Sie die Menge aller Zustände States, bei denen es keine Probleme gibt.<jupyter_code>States = { (m,k,b) for m in range(0,3+1) for k in range (0,3+1) for b in {0,1}
          if not problem(m,k)
         
         
         }<jupyter_output><empty_output><jupyter_text>Zur Kontrolle sollten Sie sich die einzelnen Zustände anschauen.<jupyter_code>States<jupyter_output><empty_output><jupyter_text>Wenn Sie alles richtig gemacht haben, dann hat die Menge States 20 verschiedene Elemente.<jupyter_code>len(States)<jupyter_output><empty_output><jupyter_text>R1 ist die Relation, welche die Überfahrten vom linken Ufer zum rechten Ufer beschreibt.<jupyter_code>R1 = { (S,B) for S in States for B in States 
      
      
     
     }
R1<jupyter_output><empty_output><jupyter_text>Die Relation R1 enthält 17 Paare.<jupyter_code>len(R1)<jupyter_output><empty_output><jupyter_text>R2 ist das Inverse der Relation R1.<jupyter_code>R2 = "your code here"
R = R1 | R2<jupyter_output><empty_output><jupyter_text>Wenn Sie sich die Relation R als Graph anschauen, dann sollten Sie sehen, dass Sie einen Pfad von dem Knoten (3,3,1) zu dem Knoten (0,0,0) finden können:<jupyter_code>dot = dot_graph(R)
dot<jupyter_output><empty_output><jupyter_text>Am Anfang sind alle links.  Das Ziel ist, dass am Ende aller rechts sind.  Links ist dann niemand mehr.<jupyter_code>start = "your code here"
goal  = "your code here"
Path  = search(R, start, goal)
Path<jupyter_output><empty_output><jupyter_text>Wenn Sie die Lösung in lesbarer Form anschauen möchten, dann sollten Sie auch den untenstehenden Code ausführen.  Hilfsfunktionen zum Ausdrucken der Lösung Die folgenden Funktionen drucken die Lösung etwas lesbarer aus.<jupyter_code>def printPath(path):
    "This prints the solution Path in a readable way."
    print("Solution:\n")
    for i in range(len(Path)-1):
        m1, k1, b1 = path[i]
        m2, k2, b2 = path[i+1]
        printState(m1, k1, b1)
        printBoat(m1, k1, b1, m2, k2, b2)
    m, k, b = path[-1]
    printState(m, k, b)
def printState(m, k, b):
    """
    Die Prozedur printState(m, k, b) druckt den Zustand, bei dem
    m Missionare, k Kannibalen und b Boote am linken Ufer sind.    
    """
    print( fillCharsRight(m * "M", 6) + 
           fillCharsRight(k * "K", 6) + 
           fillCharsRight(b * "B", 3) + "    |~~~~~|    " + 
           fillCharsLeft((3 - m) * "M", 6) + 
           fillCharsLeft((3 - k) * "K", 6) + 
           fillCharsLeft((1 - b) * "B", 3) 
         )
def printBoat(m1, k1, b1, m2, k2, b2):
    """
    Die Prozedur printBoat(m1, k1, b1, m2, k2, b2) druckt den Zustand des
    Bootes, wenn der Zustand sich von [m1, k1, b1] zu [m2, k2, b2] ändert.
    """
    if b1 == 1:
        if m1 < m2:
            print("Fehler in printBoat: negative Anzahl von Missionaren im Boot!")
            return
        if k1 < k2:
            print("Fehler in printBoat: negative Anzahl von Kannibalen im Boot!")
            return
        print(19*" " + "> " + fillCharsBoth((m1-m2)*"M" + " " + (k1-k2)*"K", 3) + " >")
    else:
        if m1 > m2:
            print("Fehler in printBoat: negative Anzahl von Missionaren im Boot!")
            return
        if k1 > k2:
            print("Fehler in printBoat: negative Anzahl von Kannibalen im Boot!")
            return
        print(19*" " + "< " + fillCharsBoth((m2-m1)*"M" + " " + (k2-k1)*"K", 3) + " <")
def fillCharsLeft(x, n):
    """
    Die Prozedur fillCharsLeft(x, n) wandelt x in einen String der Länge n um.
    Dabei wird der String von links mit Leerzeichen aufgefüllt.
    """
    s = x + ""
    m = n - len(s)
    return m * " " + s
def fillCharsRight(x, n):
    """
    Die Prozedur fillCharsRight(x, n) wandelt x in einen String der Länge n um.
    Dabei wird der String von rechts mit Leerzeichen aufgefüllt.
    """
    s = x + ""
    m = n - len(s)
    return s + m * " "
def fillCharsBoth(x, n):
    """
    Die Prozedur fillCharsBoth(x, n) wandelt x in einen String der Länge n um.
    Dabei wird der String von links und rechts mit Leerzeichen aufgefüllt.
    """
    s  = x + ""
    ml = (n     - len(s)) // 2
    mr = (n + 1 - len(s)) // 2
    return ml * " " + s + mr * " "
printPath(Path)<jupyter_output><empty_output><jupyter_text>Twin Prime Conjecture<jupyter_code>def stops(function_f,input_a):
    """
    solves the halting problem for function f with input a
    if function terminates: return 1
    if function diverges: return 0
    """

def divisors(k):
    return { t for t in range(1,k+1) if k%t==0}

def is_prime(k):
    return divisors(k)=={1,k}



def search_twin(n):
    i=n
    while True:
        p=i
        p2=p+2
        if is_prime(p) and is_prime(p2):
            return p2
        else:
            i+=1
            
def twin_prime(n):
    while True:
        check=stops(search_twin, n)
        if check==1:
            n=search_twin(n)+1
        else:
            return False
        
def check_twin_prime_conjecture(n):
    if stops(twin_prime(),n)==1:
        return False
    else:
        return True<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10620233127068643, 'fraction_numerical': 0.017700388545114406, 'mean_word_length': 3.117298578199052, 'pattern_counts': {'":': 0, '<': 53, '<?xml version=': 0, '>': 54, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '73776', 'license': 'MIT', 'n_tokens_mistral': 2576, 'n_tokens_neox': 2557, 'n_words': 786, 'path': 'Python/completedExercises/.ipynb_checkpoints/Blatt-02-checkpoint.ipynb', 'repo_name': 'rahilchughtai/Logic', 'size': '6949'}