Python-Code

"""
#352: Binärzahl enthält maximal eine Folge von Einsen
Eine als String (Text) dargestellte Binärzahl (0 und 1) soll dahingehend geprüft werden, ob sie maximal eine Folge
von Einsen enthält.
"""


def prf_bin(b):
    erg = True
    b = ([index for index, char in enumerate(([int(num) for num in str(b)])) if char == 1])
    for i in range(0, len(b) - 1):
        if b[i + 1] > b[i] + 1:
            erg = False
    return erg


print(prf_bin("1100"))
print(prf_bin("1010"))
print(prf_bin("00111000"))
print(prf_bin("10000001"))

Python-Code

input = ("00111000")
counter1 = 0
counter2 = 0

zahl = str(int(input))

for e in zahl:
    if e == "1":
        counter1 += 1

for e in zahl:
    if e == "1":
        counter2 += 1
    elif e == "0":
        break
if counter1 == counter2:
    print("TRUE")
else:
    print("FALSE")

Python-Code

def prüfe_folge(b):
    for i in range(len(b)-1):
        if b[i] == '1' and b[i+1] == '1':
            return True
    return False


beispiele = ["1100", "1010", "00111000", "10000001"]

for b in beispiele:
    print(prüfe_folge(b))

Python-Code

# Die Aufgabenstellung erinnerte mich sofort an klassische deterministische endliche Automaten.
# Daher habe ich hier für diese Aufgabe einen etwas ungewöhnlichen Lösungsweg gewählt.
# Die Klasse DFA implementiert ein Modell für beliebige deterministische endliche Automaten.
# Die Spezifizierung erfolgt durch das 5-Tupel Zustände (list), Alphabet (list),
# Übergangsfunktion als Tabelle (2d list), Startzustand (str) und akzeptierende Endzustände (list).

# Eine graphische Darstellung des Automaten für die konkrete Aufgabenstellung habe ich als Anhang beigefügt.


# Deterministic Finite Automaton
class DFA:
    def __init__(self, S, A, d, s0, F):
        self.states = S
        self.alphabet = A
        self.transition_table = d
        self.start_state = s0
        self.final_states = F

    def delta(self, state, word):
        return self.transition_table[self.states.index(state)][self.alphabet.index(word)]

    def delta_circumflex(self, state, word_list):
        if not word_list:
            return state
        else:
            return self.delta(self.delta_circumflex(state, word_list[:-1]), word_list[-1])

    def run(self, words):
        return self.delta_circumflex(self.start_state, [word for word in words]) in self.final_states


# automaton to solve the problem
states = ["s0", "s1", "s2", "s3"]
alphabet = ["0", "1"]
transition_table = [["s0", "s1"],
                     ["s2", "s1"],
                     ["s2", "s3"],
                     ["s3", "s3"]]
start_state = "s0"
final_states = ["s1", "s2"]


# Test

automaton = DFA(states, alphabet, transition_table, start_state, final_states)

test_data = ["1100", "1010", "00111000", "10000001"]

for element in test_data:
    print(automaton.run(element))

Python-Code

def prüfe_folge(b):
    n = []
    for i in range(len(b)-1):
        if b[i] == '1' and b[i+1] == '1':
            n.append(i)        
        if len(n) > 1 and n[0] == n[1]-1:
            n.remove(n[0])
    if len(n) == 1: 
        return True
    return False


beispiele = ["1100", "1010", "00111000", "10000001", "0010101100000110"]

for b in beispiele:
    print('b= "{}"'.format(b))
    print('Lösung:',prüfe_folge(b),'\n')