Robotik Programmaufbau

Rescue-Line Programmablauf in RobotC:

task main()
{
	//SENSOR-SETUP
		//beide Helligkeitssensoren anmelden
		//Ultraschall anmelden
		//Gyro anmelden

	while (true){

		//MESSWERTE MESSEN
			// Helligkeit links
			// Helligkeit rechts
			// Ultraschall
			// Farbwerte links
			// Farbwerte rechts

		//MESSWERTE DARSTELLEN (DISPLAY)
		// (DEBUGGING)

		//P-REGLER:
			//Helligkeitswerte in Motoransteuerung umrechnen

		//FARBEN AUSWERTEN
			// In Richtung des grünen Punkts abbiegen

		//HINDERNIS: ULTRASCHALL NUTZEN
			//Gyro-Sensor reset()
			//"Haken schlagen"

		//Kurzes Päusschen
		//eraseDisplay()

	}
}

Soccer-Roboter in RobotC:

void RICHTUNG_FESTLEGEN()
{
	//halbmanuell: 
		//	Roboter korrekt platzieren, 
		// 	Kompass oder Gyro als 0-Richtung festlegen
		//	mit Nutzereingabe bestätigen
}

task main(){
	// SENSOR SETUP		
		// IR SEEKER
		// Kompass oder Gyro
		// Ultraschall
		// Helligkeit oder IR-Abstandssensor

		// Korrekten Winkel für Torrichtung festsetzen		
			// funktion RICHTUNG_FESTLEGEN()

	while (true){	
		// Falls Knopf gedrückt: void RICHTUNG_FESTLEGEN()	

		//1. Kompass-Sensor auslesen	
		//2. IR-Seeker auslesen	

		// MESSWERTE AUF DISPLAY DARSTELLEN	

		// Kompass-Abgleich: Wo ist das Tor?	
			// Winkel zum Tor berechnen()
		
		// IR-SEEKER AUSWWERTUNG, 10 FALLUNTERSCHEIDUNGEN nach Richtung des Balls:
	
			//FALL 1: Optimalfall, der Ball ist geradeaus
				//	Helligkeitsensor auslesen
	
				//VERZWEIGUNG 2: Helligkeitssensor auswerten: Hat man den Ball?
				//	Wenn Ja: Torfahrt berechnen()
				//	Wenn Nein: geradeaus zum Ball
		
			//FALL 2 bis FALL 5, Ball schräg vor sich:
				//  Diagonale zum Ball fahren
	
			//FALL 6 bis FALL 10, Ball neben oder hinter sich:
				//	Rückwärts fahren bis Ball schräg vor sich

	}// ENDE while (true)
}// ENDE task main()

IMP Python Skripte

Notenschnitte berechnen:

import board
import time
import random

nl = []

for i in range(10):
    nl.append(random.randint(1,6))

# summe = nl[0]+nl[1]+nl[2]+nl[3]+nl[4]+nl[5]+nl[6]+nl[7]+nl[8]+nl[9]
print(nl)

summe = 0
for i in range(10):
    summe = summe + nl[i]

print(summe)
print(summe/10)

 

Sieb des Eratosthenes, Teil I

Zahlen=[]
for i in range(1, 100):
    Zahlen.append(i) 

print(Zahlen)
for akti in range(2, 100):
    if Zahlen[akti]/2 == Zahlen[akti]//2:
        Zahlen[akti] = "nee"
        print(Zahlen)

print(Zahlen)
for akti in range(3, 100):
    if isinstance(Zahlen[akti], int):
        if Zahlen[akti]/3 == Zahlen[akti]//3:
            Zahlen[akti] = "nee"
            print(Zahlen)

Themen & Pythonskripte Inf4St.

FizzBuzz:

for k in range (1,100,1):
    if k%3 == 0 or k%5 == 0:
        if k%5 !=0:
            print("fizz"" ", end="")
        if k%3 !=0:
            print("buzz"" ", end="")
        if k%3 == 0 and k%5 == 0:
            print("fizzbuzz"" ", end="")
    else:
        print (k," ", end="")


Linear Search:
mit Zufallslisten-Generator und Zeitmessung für die Zeitkomplexität

import random
import time
meineliste=[]

for i in range(0,20):
    zufall = random.randint(1,100)
    meineliste.append(zufall)
print(meineliste)

startzeit = time.monotonic_ns()
maximum = meineliste[0]
for i in range(1, len(meineliste)):
    time.sleep(0.01)
    if maximum<meineliste[i]:
        maximum = meineliste[i]
        print("vorläufiges Maximum: ", maximum)
        time.sleep(0.01)
print("-------------------------------------------")
dauer = (time.monotonic_ns()-startzeit)/1000000
print("zeitdauer in milli-Sekunden: ", dauer)
print("endgültiges Maximum: ", maximum)


BubbleSort:
 mit Zufallslisten-Generator und Zeitmessung für die Zeitkomplexität

import random
import time

mliste = []
for k in range (0,20):
    mliste.append(random.randint(1,100))

print(mliste)

startzeit = time.monotonic_ns()
# bubblesort
for m in range(0,len(mliste)-1):
    time.sleep(0.01)
    for i in range(0,len(mliste)-1-m):
        time.sleep(0.01)
        if mliste[i]>mliste[i+1]:
            time.sleep(0.01)
            temp = mliste[i+1]
            mliste[i+1]= mliste[i]
            mliste[i]=temp
    print(mliste)
endzeit = time.monotonic_ns()
zeitdifferenz= (endzeit - startzeit)/1000000
print("vergangene Zeit: ", zeitdifferenz)


Quicksort!
Die Simulation aus dem Unterricht:
https://www.hackerearth.com/practice/algorithms/sorting/quick-sort/visualize/


Prinzip von Funktionen:
mit Parameterübergabe, Returnwert und globaler Variable für die Rückgabe

import random
import time

def macheZufallsliste(listenlaenge, obergrenze):
    print("übergebener Parameter: " + str(listenlaenge))
    meineListe = []
    for i in range(0,listenlaenge):
        meineListe.append(random.randint(1,obergrenze))
    print ("noch im Stack:           ", meineListe)
    return meineListe

auffangVariable= macheZufallsliste(10,10)

print("aufgefangen über Return: ", auffangVariable)
time.sleep(2)
print("aufgefangen über Return: ", auffangVariable)


Selection-Sort:
mit Linear-Search-Funktion und Python „append()“ bzw. „insert()“

import random

def sucheLinear(testliste, modus):
    if modus=="max":
        maximum = testliste[0]
        for num in testliste:
            if num>maximum:
                maximum = num
        return maximum

    if modus=="min":
        minimum = testliste[0]
        for num in testliste:
            if num<minimum:
                minimum = num
        return minimum

mliste = []
for k in range (20):
    mliste.append(random.randint(1, 100))

for j in range (0, len(mliste)):
    groesstesElement = sucheLinear(mliste[0:len(mliste)-j], "max")
    print("aktuell grösstes Element:", groesstesElement)
    mliste.remove(groesstesElement)
    mliste.append(groesstesElement)
    print("Sortier-Schritt ",j+1, ": ", mliste)
print("endgültig sortierte Liste: ", mliste)


Stack-Simulation:
Wie Funktionen im Speicher verwaltet werden, wichtig für Rekursion
https://visualgo.net/en/list


Rekursions-Skripte:

def rek1(n):
    if n>1:
        print("lokales n: ", n)
        n-= 1
        rek1(n)
    else:
        print("lokales n: ", n, ", fertig: Basisfall, bzw. Abbruchbedingung")
        n-= 1
    print("lokales n: ", n)

rek1(4)
print("------------------------------------------------------")

summe=0
def rek2(n):
    global summe
    if n>1:
        summe=summe+n
        print("Hin ...     lokales n: ", n, "summe: ", summe)
        n-= 1
        rek2(n)
    else:
        summe=summe+n
        print("fertig.     lokales n: ", n, "summe: ", summe)
        n-= 1
    print("...& zurück lokales n: ", n, "summe: ", summe)

rek2(4)
print("------------------------------------------------------")

prod=1
def rek3(n):
    global prod
    if n>1:
        prod=prod*n
        print("Hin ...     lokales n: ", n, "prod: ", prod)
        n-=1
        rek3(n)
    else:
        prod = prod * n
        print("fertig.     lokales n: ", n, "prod: ", prod)
        n -= 1
    print("...& zurück lokales n: ", n, "prod: ", prod)

rek3(5)
print("------------------------------------------------------")

def rek4(n):
    if n>1:
        print("vorher, lokales n: ", n)
        prod = n * rek4(n-1)
        print("danach, lokales n: ", n, "zwischenergebnis: ", prod)
        return prod
    else:
        print("fertig. Lokales n: ", n)
        return 1
    print("...& zurück lokales n: ", n)

rek4(5)
print("------------------------------------------------------")

def rek5(n):
    if n>1:
        print("vorher, lokales n: ", n)
        knoten = rek5(n-1) + rek5(n-1)
        print("Ast.  Lokales n: ", n, "zwischenknoten: ", knoten)
        return knoten
    else:
        print("Blatt. Lokales n: ", n)
        return 1
    print("...& zurück lokales n: ", n)

rek5(3)
print("------------------------------------------------------")

F.S. Quicksort-Pythonskript:

import random
laenge=10

list=[]

for i in range (0,laenge):
    list.append(random.randint(1,100))

print("Die zufällig ausgewählte Liste ist: ")
print(list)

def quicksort(list):
    rekursion(list,0,len(list)-1)


def rekursion (list,first,last):

    if first<last:                                 #Abbruchbedingung

        splitpoint=sortieren(list,first,last)

        rekursion(list,first,splitpoint-1)       #Rekursion für erste Listenhälfte!
        rekursion(list,splitpoint+1,last)        #Rekursionfür zweite Listenhälfte!


def sortieren(list,first,last):
    pivot=list[last]


    leftmark=first
    rightmark=last-1

    done=False

    while not done:

        while leftmark<=rightmark and list[leftmark]<= pivot:
            leftmark=leftmark+1


        while leftmark<=rightmark and list[rightmark]>= pivot:
            rightmark=rightmark-1


        if rightmark<leftmark:
            done=True


        else:
            temp=list[rightmark]
            list[rightmark]=list[leftmark]
            list[leftmark]=temp


    temp=list[leftmark]
    list[leftmark]=list[last]
    list[last]=temp


    return leftmark




quicksort(list)
print("--------------------------------------------------------------------------------------")
print("Die Liste ist nun sortiert.")
print(list)
print("--------------------------------------------------------------------------------------")