///

1 Formulieren Sie einen Satz, der den Begriff 'Algorithmus' definiert.

Ein Algorithmus ist eine Handlungsanweisung, die eindeutig den Weg zur Lösung eines gegebenen Problems beschreibt.

2 Erstellen Sie eine Übersicht der Eigenschaften von Algorithmen.

• Allgemeinheit Ein Algorithmus muss eine Vielzahl von Problemen der gleichen Art lösen.
• Eindeutigkeit Ein Algorithmus muss eindeutig sein. Er darf keine widersprüchliche Beschreibung haben.
• Ausführbarkeit Jeder Einzelschritt eines Algorithmus muss ausführbar sein.
• Endlichkeit Die Beschreibung eines Algorithmus muss endlich sein.
• Terminierung Ein Algorithmus muss nach endlich vielen Schritten enden und ein Ergebnis liefern.
• Determiniertheit Ein Algorithmus muss bei gleichen Voraussetzungen immer das gleiche Ergebnis liefern.
• Determinismus Für jeden Schritt eines Algorithmus darf höchstens eine Möglichkeit der Fortsetzung bestehen.

Warum benötigt man zwei Vorschleifen?

1. Innenschleife -> Vergleich, Vergleich...
2. Außenschleife -> weil wir noch nicht duschsortiert haben : Phase 1, Phase 2

Warum startet die erste Vorschleife nicht bei 0 sondern bei 1?

Da es z.B. nur 4 Phasen im Durchlauf gibt und nicht 5. Wenn es bei 0 starten würde, würde es eine mehr mitzählen. Bei index 5 also keine Wiederholung.

(I) Problemstellung SORTIERUNG Lottozahlen

Die Zahlen der aktuellen Lottoziehung liegen in der Reihenfolge der Ziehung in einem Array lotto vor (48, 5, 17, 32, 7, 29) und sollen noch sortiert werden. Sie erhalten den Auftrag, ein entsprechendes Programm zu entwickeln, das die Lottozahlen mit Hilfe des Sortieralgorithmus 'Bubble Sort' sortiert und die sortierten Zahlen in der Konsole ausgibt

(II) Problemanalyse

1. Welche Ausgabedaten will man erhalten?

Sortiertes Array lotto[ ]

1. Welche Eingabedaten werden zur Bearbeitung benötigt?

Keine

1. Welche Eigenschaften haben die Eingabe-, Verarbeitungs- und Ausgabedaten? (Variablenliste)

Bedeutung. Typ/Struktur. Variable/Größe

Lottozahlen (gegeben) Array lotto.

Anzahl Elemente des Arrays lotto Ganzzahl laenge

Zwischenspeicher Ganzzahl zwischenspeicher

1. Gewünschter Ablauf des Programms:

Ausgabe [5, 7, 17, 29, 32, 48]

1. Verarbeitung

Sortiere mit dem Bubble Sort das Array lotto.

(IV) Programmcode (Python-Code)

lotto = [48, 5, 17, 32 , 7, 29]

laenge = len(lotto)

#Sortieren

for i in range(1,laenge):

  for j in range(0,laenge-i):

    if lotto[j] > lotto[j+1]:

      zwischenspeicher = lotto[j]

      lotto[j] = lotto[j+1]

      lotto[j+1] = zwischenspeicher

#Ausgabe

print(lotto)

(I) Problemstellung SORTIERUNG Zahlenreihe

Sie sollen ein Programm schreiben, das fünf Zahlen einliest und diese wieder sortiert ausgibt. Implementieren Sie für die Sortierung den Bubble Sort.

Verwenden Sie für die Implementierung Ihrer Lösung die Datei die Ihnen im Ordner Aufgaben/Vorlagen in digitaler Form vorliegt.

Speichern Sie Ihre Lösung in Ihrem Ergebnisordner unter dem Namen

(II) Problemanalyse

1. Welche Ausgabedaten will man erhalten?

Sortiertes Array 

1. Welche Eingabedaten werden zur Bearbeitung benötigt?

Fünf Zahlen

1. Welche Eigenschaften haben die Eingabe-, Verarbeitungs- und Ausgabedaten? (Variablenliste)

Bedeutung Typ/Struktur Variable/Größe

Zahlen Array zahlen

Anzahl der Elemente des Arrays

zahlen Ganzzahl laenge

Zwischenspeicher Ganzzahl zwischenspeicher

1. Gewünschter Ablauf des Programms mit Beispieldaten:

Eingabe: Ausgabe:

Zahl 1: 5 1

Zahl 2: 6 2

Zahl 3: 1 3

Zahl 4: 2 5

Zahl 5: 3 6

(IV) Programmcode (Python-Code)

# Array deklarieren

zahlen = []

#Eingabe

zahlen.append(int(input("Zahl 1: ")))

zahlen.append(int(input("Zahl 2: ")))

zahlen.append(int(input("Zahl 3: ")))

zahlen.append(int(input("Zahl 4: ")))

zahlen.append(int(input("Zahl 5: ")))

laenge = len(zahlen)

#Sortierung

for i in range(1, laenge):

  for j in range(laenge-i):

    if zahlen[j] > zahlen[j+1]:

      zwischenspeicher = zahlen[j]

      zahlen[j] = zahlen[j+1]

      zahlen[j+1] = zwischenspeicher

#Ausgabe

for i in range(laenge):

  print(zahlen[i]) 

Sortierung mit dem Bubble Sort Übung

Das folgende Array ist gegeben: array[12, 50, 11, 85, 2, 5, 9, 10]. Sortieren Sie das Array mit dem Bubble Sort und geben Sie das Array nach jeder Bubble-Phase an.

Optimierung Bubble Sort

Gehen Sie von dem folgenden Array aus: array[10, 1, 2, 3, 4, 5, 6, 7, 8, 9].

2.1 Wie viele Bubble-Phasen würde der Bubble Sort durchlaufen?

Der Bubble Sort durchläuft immer (array.length – 1) Phasen. Bei zehn Elementen wären es in diesem Fall 9 Phasen.

2.2 In wie vielen Bubble-Phasen findet tatsächlich ein Tausch statt?

Das Array ist nach der ersten Bubble-Phase sortiert, weil dann die 10 an das Arrayende „aufgestiegen“ ist. Die verbleibenden neun Elemente des Arrays sind bereits sortiert, weswegen die restlichen Bubble-Phasen ohne einen Tausch durchlaufen werden.

2.3 Bubble-Phasen, die ohne einen Tausch ablaufen sollen in Zukunft vermieden werden. Wie könnte der Bubble Sort Algorithmus optimiert werden, sodass es zu so wenig wie möglich Bubble-Phasen ohne einen Tausch kommt?

Wenn in einer Bubble-Phase kein Tausch vorgenommen wurde, kann davon ausgegangen werden, dass das Array sortiert ist. Nach solch einer Bubble-Phase sollte der Algorithmus seine Arbeit einstellen und keine weitere Bubble-Phase durchlaufen.

Implementieren Sie die Optimierung des Bubble Sorts aus Aufgabenstellung (2.4). Geben Sie am Ende des Suchalgorithmus außerdem das sortierte Array und die Anzahl der Bubble-Phasen aus.

zahlen = [10,1,2,3,4,5,6,7,8,9]

laenge = len(zahlen)

anzahl_bubble_phasen = 0

tausch = True

while tausch:

  tausch = False

  anzahl_bubble_phasen = anzahl_bubble_phasen + 1

  for i in range(1, laenge):

    if zahlen[i-1] > zahlen [i]:

      zwischenspeicher = zahlen[i-1]

      zahlen[i-1] = zahlen[i]

      zahlen[i] = zwischenspeicher

      tausch = True

print(zahlen)

print("Anzahl der Bubble-Phasen: " , anzahl_bubble_phasen)

AUFGABE GRUNDUMSATZ BERECHNEN

faktoren=[0.95, 1.2, 1.4, 1.6, 1.8, 2.1]

#Grundumsatz berechnen

grundumsatz = 4*70*24

print("Grundumsatz", grundumsatz)

#Umrechnung in kcal

kcal = grundumsatz/4.2

print("kcal:", kcal)

#Palwert bestimmen

palwert = ((8*faktoren[0])+(8*faktoren[3])+(7*faktoren[1])+(1*faktoren[5]))/24

print("palwert:", palwert)

#Gesamtenergiebedarf

gesamtenergiebedarf = (palwert*kcal)

print("Gesamtenergiebedarf:", gesamtenergiebedarf)

#Hat der Mensch zu wenig/viel gegessen?

if grundumsatz == 2000:

print("Der Mensch hat genug gegessen")

elif grundumsatz < 2000:

print("Der Mensch hat zu wenig gegessen")

else:

print("Der Mensch hat zu viel gegessen")

____________________________________________________________________________

ERMITTELN/AUSWERTEN

Sie sollen für Ihren Ort eine Wetterstatistik führen. Dafür sollen Sie jeden Tag die Höchsttemperatur aufschreiben und am Ende der Woche die Temperaturen auswerten, indem Sie die höchste, niedrigste und die durchschnittliche Temperatur der Woche ermitteln und ausgeben. Außerdem sollen Sie die Abweichung zwischen der höchsten und der niedrigsten Temperatur ermitteln und ausgeben.

# Deklaration des leeren Arrays

temperaturen = [] # Leeren Array erzeugen

# Einlesen der Tageshöchsttemperaturen

tage = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]

for i in range(len(tage)):

  temp = float(input(tage[i]))

  temperaturen.append(temp)

# Deklaration und Initialisierung der Variablen

maxT = temperaturen[0]

minT = temperaturen[0]

mittelT = 0

diffT = 0

# Auswertung max

for i in range(len(temperaturen)):

  if temperaturen[i] > maxT:

    maxT = temperaturen[i]

# Auswertung min

for i in range(len(temperaturen)):

  if temperaturen[i] < minT:

    minT = temperaturen[i]

# Auswertung mittelT

for i in range(len(temperaturen)):

  mittelT = mittelT + temperaturen[i]

mittelT = mittelT / len(temperaturen)

diffT = maxT - minT

# Ausgabe

print("-------AUSWERTUNG-------")

print("Höchste Temperatur:", maxT)

print("Niedrigste Temperatur:", minT)

print("Durchschnittstemperatur:", mittelT)

print("Temperaturunterschied:", diffT)

EINFÜGEN

Die Software des Trainers der Abteilung Volleyball des Sportvereines Mühlberger SC enthält ein Array mit allen Spielernamen des Mannschaftskaders. 

kader = ["Armin", "Batu", "Kai", "Sven", "Paul", "Milan", "Goran", "Chris", "Nico",

"Dennis", "Emin", "Luca"]

Mit Hilfe der Software soll es möglich sein, an einer bestimmten Stelle einen weiteren Spielernamen einzutragen, z.B. an der Stelle mit dem Index 6.

kader = ["Armin", "Batu", "Kai", "Sven", "Paul", "Milan", "Goran", "Chris","Nico", "Dennis", "Emin", "Luca"]

def zeige_kader():

  print("------------------------")

  print("Kader")

  print("------------------------")

  for i in range(len(kader)):

    print(kader[i])

def einfuegen_spieler():

  spielername = input("Spielername: ")

  index = int(input("Index: "))

  #Einfügen an letzter Stelle

  kader.append(spielername)                

  #Nach vorne wandern, bis an die richtige Position

  for i in range(len(kader)-1, index,-1):   

    zwischenspeicher = kader[i-1]

    kader[i-1] = kader[i]

    kader[i] = zwischenspeicher

  zeige_kader()

#Funktionsaufruf

einfuegen_spieler()

ENTFERNEN

kader = ["Armin", "Batu", "Kai", "Sven", "Paul", "Milan", "Goran", "Chris","Nico", "Dennis", "Emin", "Luca"]

def zeige_kader():
    print("------------------------")
    print("Kader")
    print("------------------------")
    for i in range(len(kader)):
        print(kader[i])

def entferne_spieler():
    
    index = int(input("Entferne Spieler an der Stelle mit dem Index: "))
    
    #Spieler rücken nach vorne auf
    for i in range(index, len(kader)-1):    
        kader[i] = kader[i+1]
    
    #letztes Element 'leeren'
    kader[len(kader)-1] = ""
    
    zeige_kader()
    
    
#Funktionsaufruf
entferne_spieler()

ANZEIGEN

spieler = ["Armin", "Batu", "Kai", "Sven", "Paul", "Milan"]
ersatz  = ["Chris", "Dennis", "Emin", "Goran", "Luca", "Nico"]

print("(1) Startaufstellung anzeigen")
print("(2) Ersatzspieler anzeigen")
print("(3) Kader anzeigen")

anzeige = int(input("Anzeigewunsch (1-3): "))

def zeige_startaufstellung():
    print("-----------------------")
    print("Startaufstellung")
    print("-----------------------")
    for i in range(len(spieler)):
        print(spieler[i])

def zeige_ersatzspieler():
    print("-----------------------")
    print("Ersatzspieler")
    print("-----------------------")
    for i in range(len(ersatz)):
        print(ersatz[i])

def zeige_kader():
    kader = spieler + ersatz
    print("-----------------------")
    print("Kader:",)
    print("-----------------------")
    for i in range(len(kader)):
        print(kader[i]) 

if anzeige == 1: zeige_startaufstellung()    

elif anzeige == 2: zeige_ersatzspieler()   

elif anzeige == 3: zeige_kader()

TAUSCHEN

spieler = ["Armin", "Batu", "Kai", "Sven", "Paul", "Milan"]

def zeige_startaufstellung():
    print("------------------------")
    print("Neue Startaufstellung")
    print("------------------------")
    for i in range(len(spieler)):
        print(spieler[i])

def mannschaft_umstellen_pos():
    
    
    

#Funktionsaufruf
mannschaft_umstellen_pos()

Im Training für die Vereinsmeisterschaften wirft jeder Dartspieler 6 Pfeile auf die Dartscheibe bevor der nächste Dartspieler an der Reihe ist. Sie sollen ein Programm schreiben, das aufgrund der 6 geworfenen Pfeile eine Analyse durchführt. 

Es sollen folgende Angaben in der Konsole ausgegeben werden: Höchste Punktzahl, niedrigste Punktzahl und die durchschnittliche Punktzahl. Die Eingaben der Wurfergebnisse erfolgten ebenfalls über die Konsole (Bei einem Wurf sind maximal 60 Punkte erreichbar.)

#Deklaration und Initialisierung leeres Array

wuerfe = []

# Einlesen der Würfe

for i in range(6):

  wurf = int(input("Wurf: "))

  wuerfe.append(wurf)

#Deklaration und Initialisierung der Variablen

maxP = wuerfe[0]

minP = wuerfe[0]

mittelP = 0

# Bester Wurf

for i in range(len(wuerfe)):

  if wuerfe[i] > maxP:

    maxP = wuerfe[i]

# Schlechtester Wurf

for i in range(len(wuerfe)):

  if wuerfe[i] < minP:

    minP = wuerfe[i]

# Durchschnittliche Punktzahl pro Wurf

for i in range(len(wuerfe)):

  mittelP = mittelP + wuerfe[i]

mittelP = mittelP / len(wuerfe)

#Ausgabe

print("Bester Wurf:", maxP)

print("Schlechtester Wurf:", minP)

print("Durchschnittliche Punktzahl:", mittelP)