Intel-Leibniz-Challenge 2009

Zum zweiten Mal habe ich die Ehre, eine Gruppe meiner Schüler bei Intel-Leibniz-Challenge betreuen zu dürfen (Einen Kurzbericht zur ersten Gruppe aus 2008 findet sich hier unter BSGG.BG'ler meets Leibniz

). Die Vierergruppe rekrutiert sich aus einer 11. Klasse des Beruflichen Gymnasiums mit der Schwerpunktkombination Datenverarbeitungstechnik/Elektrotechnik.
Da mir die Aufgaben

ebenfalls gefallen, werde ich meine Lösungen (die die Schüler zum Zeitpunkt der Bearbeitung natürlich *nicht* kennen!) hier nach Abgabeschluss veröffentlichen. Vielleicht mag sich ja jemand meine Lösungen anschauen. Falls Kontakt gewünscht ist, bin ich per EMail gerne bereit Stellung zu nehmen.

Nachtrag 27.Juni 2009

Der Wettbewerb ist vorbei. Leider hat meine diesjährige Gruppe keine so gute Platzierung erreicht wie die letztjährige Gruppe :-/. Der Teamgeist war leider schwächer ausgeprägt und die Gruppe fiel nach der zweiten Aufgabe auseinander. Schade! Mal sehen, was die Zukunft bringt...vielleicht findet sich wieder eine stärker motivierte Schülergruppe...

Aufgabe 1

Aufgabe 1b: Zufallszahlen/Mittelwert/Standardabweichung

Module Module1

Sub Main()

'Zufallsgenerator initialisieren
        Randomize(Timer)

'Feld für Zufallszahlen
        Dim zufallszahl(199) As Double

'Feld für Häufigkeitsverteilung
        Dim haeufigkeit(9) As Integer

Dim summe As Double = 0
        Dim mittelwert As Double = 0
        Dim stdabweichung As Double = 0

'Laufvariablen
        Dim i As Integer
        Dim j As Integer

Console.WriteLine("ILC 2009: Aufgabe 1b")

'Erzeugen und Speichern der Zufallszahlen
        'Wertebereich der Zahlen von 0...20
        For i = 0 To 199
            zufallszahl(i) = Rnd() * 20
        Next

Console.WriteLine("Unsortiert")
        'Ausgabe der Zahlen
        For i = 0 To 19
            For j = 0 To 9
                Console.Write(Format(zufallszahl(i * 10 + j), "00.0000") & " ")
            Next
        Next

Console.Write("Sortierung gestartet...")
        '************************************************
        Array.Sort(zufallszahl)
        Console.WriteLine("beendet!")

'Ausgabe der Zahlen
        For i = 0 To 19
            For j = 0 To 9
                Console.Write(Format(zufallszahl(i * 10 + j), "00.0000") & " ")
            Next
        Next

'************************************************
        'Häufigkeitsverteilung und Mittelwertberechnung
        'zehn Bereiche (0..<2, 2..<4, 4..<6 etc)
        summe = 0
        For i = 0 To 199
            summe += zufallszahl(i)
            Select Case zufallszahl(i)
                Case Is < 2
                    haeufigkeit(0) += 1
                Case Is < 4
                    haeufigkeit(1) += 1
                Case Is < 6
                    haeufigkeit(2) += 1
                Case Is < 8
                    haeufigkeit(3) += 1
                Case Is < 10
                    haeufigkeit(4) += 1
                Case Is < 12
                    haeufigkeit(5) += 1
                Case Is < 14
                    haeufigkeit(6) += 1
                Case Is < 16
                    haeufigkeit(7) += 1
                Case Is < 18
                    haeufigkeit(8) += 1
                Case Is < 20
                    haeufigkeit(9) += 1
            End Select
        Next

mittelwert = summe / 200

'************************************************
        'Standardabweichung berechnen
        summe = 0
        For i = 0 To 199
            summe += (zufallszahl(i) - mittelwert) * (zufallszahl(i) - mittelwert)
        Next

stdabweichung = Math.Sqrt(summe / 200)

Console.WriteLine("Häufigkeitsverteilung bei 200 Zahlen")
        For i = 0 To 9
            Console.WriteLine(StrDup(haeufigkeit(i), "#"))
        Next
        Console.WriteLine("Mittelwert = " & Format(mittelwert, "0.0000"))
        Console.WriteLine("Standardabweichung = " & Format(stdabweichung, "0.0000"))

Call ZeigeGraph(haeufigkeit, 1)

'************************************************
        '20.000 Zahlen
        '************************************************
        'Erzeugen
        Dim zufallszahl100(19999) As Double

For i = 0 To 19999
            zufallszahl100(i) = Rnd() * 20
        Next
        Console.WriteLine("20.000 Zufallszahlen erzeugt")

'************************************************
        'Sortieren
        Console.Write("Sortierung gestartet...")
        Array.Sort(zufallszahl100)
        Console.WriteLine("beendet!")

'************************************************
        'Verteilung
        summe = 0
        For i = 0 To 19999
            summe += zufallszahl100(i)
            Select Case zufallszahl100(i)
                Case Is < 2
                    haeufigkeit(0) += 1
                Case Is < 4
                    haeufigkeit(1) += 1
                Case Is < 6
                    haeufigkeit(2) += 1
                Case Is < 8
                    haeufigkeit(3) += 1
                Case Is < 10
                    haeufigkeit(4) += 1
                Case Is < 12
                    haeufigkeit(5) += 1
                Case Is < 14
                    haeufigkeit(6) += 1
                Case Is < 16
                    haeufigkeit(7) += 1
                Case Is < 18
                    haeufigkeit(8) += 1
                Case Is < 20
                    haeufigkeit(9) += 1
            End Select
        Next

mittelwert = summe / 20000

'************************************************
        'Standardabweichung berechnen
        summe = 0
        For i = 0 To 19999
            summe += (zufallszahl100(i) - mittelwert) ^ 2
        Next

stdabweichung = Math.Sqrt(summe / 20000)

Console.WriteLine("Häufigkeitsverteilung bei 20.000 Zahlen")
        For i = 0 To 9
            Console.WriteLine(StrDup(CInt(haeufigkeit(i) / 100), "#"))
        Next
        Console.WriteLine("Mittelwert = " & Format(mittelwert, "0.0000"))
        Console.WriteLine("Standardabweichung = " & Format(stdabweichung, "0.0000"))

Call ZeigeGraph(haeufigkeit, 100)

'************************************************
        '2.000.000 Zahlen
        '************************************************
        'Erzeugen
        Dim zufallszahl10000(1999999) As Double

For i = 0 To 1999999
            zufallszahl10000(i) = Rnd() * 20
        Next
        Console.WriteLine("2.000.000 Zufallszahlen erzeugt")

'************************************************
        'Sortieren
        Console.Write("Sortierung gestartet...")
        Array.Sort(zufallszahl10000)
        Console.WriteLine("beendet!")

'************************************************
        'Verteilung
        summe = 0
        For i = 0 To 1999999
            summe += zufallszahl10000(i)
            Select Case zufallszahl10000(i)
                Case Is < 2
                    haeufigkeit(0) += 1
                Case Is < 4
                    haeufigkeit(1) += 1
                Case Is < 6
                    haeufigkeit(2) += 1
                Case Is < 8
                    haeufigkeit(3) += 1
                Case Is < 10
                    haeufigkeit(4) += 1
                Case Is < 12
                    haeufigkeit(5) += 1
                Case Is < 14
                    haeufigkeit(6) += 1
                Case Is < 16
                    haeufigkeit(7) += 1
                Case Is < 18
                    haeufigkeit(8) += 1
                Case Is < 20
                    haeufigkeit(9) += 1
            End Select
        Next

mittelwert = summe / 2000000

'************************************************
        'Standardabweichung berechnen
        summe = 0
        For i = 0 To 1999999
            summe += (zufallszahl10000(i) - mittelwert) ^ 2
        Next

stdabweichung = Math.Sqrt(summe / 2000000)

Console.WriteLine("Häufigkeitsverteilung 2000000")
        For i = 0 To 9
            Console.WriteLine(StrDup(CInt(haeufigkeit(i) / 10000), "#"))
        Next
        Console.WriteLine("Mittelwert = " & Format(mittelwert, "0.0000"))
        Console.WriteLine("Standardabweichung = " & Format(stdabweichung, "0.0000"))

Call ZeigeGraph(haeufigkeit, 10000)

End Sub

'************************************************
    'haufigkeit = Array mit der Haufigkeitsverteilung
    'divisor = zur Normierung der Anzahl pro Spalte
    Public Sub ZeigeGraph(ByRef haeufigkeit As Array, ByVal divisor As Integer)

'Festlegung der Größe des Graphen
        Const maxZeilenIndex As Integer = 39
        Const maxSpaltenIndex As Integer = 9

'Der Graph hat 40 Zeilen in der Vertikalen
        'und 10 Spalten in der Horizontalen (die 10 Bereiche)
        'Der Index 0 ist identisch mit dem Nullpunkt des Graphen!
        Dim graph(maxZeilenIndex, maxSpaltenIndex) As String

Dim zeile As Integer = 0
        Dim spalte As Integer = 0

'Das Array muss mit Leerzeichen gefüllt werden
        For zeile = 0 To maxZeilenIndex
            For spalte = 0 To maxSpaltenIndex
                graph(zeile, spalte) = " "
            Next
        Next

'Schleife über alle Spalten
        For spalte = 0 To maxSpaltenIndex
            'Schleife über alle Zeilen in einer Spalte
            For zeile = 0 To CInt(haeufigkeit(spalte) / divisor)
                graph(zeile, spalte) = "#"
            Next
        Next

'Anzeigen des Graphen
        Console.WriteLine("**********")
        'Das erfolgt zeilenweise; in einer Zeile sind
        'alle Spaltenwerte auszugeben
        'Begonnen wird bei der obersten Zeile (#19)
        For zeile = maxZeilenIndex To 0 Step -1
            Console.Write(Format(zeile, "00") & "|")
            For spalte = 0 To maxSpaltenIndex
                Console.Write(graph(zeile, spalte))
            Next
            'Zeilenumbruch
            Console.WriteLine()
        Next
        Console.WriteLine("-------------")
        Console.WriteLine("   0000111112")
        Console.WriteLine("   2468024680")
    End Sub
End Module

Aufgabe 1

Aufgabe 1c: Galton-Brett

Diese Aufgabe habe ich objektorientiert gelöst. Hierzu habe ich eine Klasse Galtonbrett und eine Klasse Kugel modelliert. Beide Klassen werden jeweils unverändert in einer Konsolenanwendung und in einer GUI-Anwendung genutzt, um die Häufigkeitsverteilung zu ermitteln. Erstellt wurden die Projekte mit Visual Studio 2005

Klasse Galtonbrett

Class Galtonbrett

Private rows As Integer = 0
    Private kugeln As Integer
    Private pots As Array
    Private cntLeft As Integer
    Private cntRight As Integer
    Private rndValue As Double = 0.5
    Private mittelwert As Double = 0
    Private stdabweichung As Double = 0

Public ReadOnly Property row() As Integer
        Get
            Return rows
        End Get
    End Property

Public ReadOnly Property pot() As Array
        Get
            Return pots
        End Get
    End Property

Public ReadOnly Property mwert() As Double
        Get
            Return mittelwert

End Get
    End Property

Public ReadOnly Property sigma() As Double
        Get
            Return stdabweichung
        End Get
    End Property

Public Sub New(ByVal r As Integer, ByVal k As Integer)

If r > 0 And k > 0 Then
            rows = r
            kugeln = k
        Else
            rows = 3
            kugeln = 1000
        End If

'Index für Töpfe von 0..rows -> ein Topf mehr als Zeilen
        'pots(rows)
        pots = Array.CreateInstance(GetType(Integer), rows + 1)
        '3 Zeilen und 4 Töpfe
        'O
        'OO
        'OOO
        'TTTT

End Sub

Public Sub New(ByVal r As Integer, ByVal k As Integer, ByVal p As Double)

If p >= 0 And p <= 1 Then
            rndValue = p
        Else
            rndValue = 0.5
        End If

If r > 0 And k > 0 Then
            rows = r
            kugeln = k
        Else
            rows = 3
            kugeln = 1000
        End If

'Index für Töpfe von 0..rows -> ein Topf mehr als Zeilen
        pots = Array.CreateInstance(GetType(Integer), rows + 1)
        '3 Zeilen und 4 Töpfe
        'O
        'OO
        'OOO
        'TTTT

End Sub

Public Sub start()

'Zufallsgenerator initialisieren
        Randomize()

'Array für Kugeln erstellen
        Dim ak(kugeln) As Kugel
        Dim i As Integer
        Dim pos As Integer

For i = 0 To kugeln - 1
            ''Kugel-Objekt erstellen
            ak(i) = New Kugel(rows, rndValue)
            'Kugel fallen lassen
            ak(i).fall()
            'Endposition der Kugel
            pos = ak(i).pot
            'Anzahl im  Topf erhöhen
            pots(pos) += 1
            cntLeft += ak(i).left
            cntRight += ak(i).right
        Next

'Mittelwert berechnen
        Dim summe As Long = 0
        For i = 0 To rows
            summe += i * pots(i)
        Next
        mittelwert = summe / kugeln

'Standardabweichung berechnen
        summe = 0
        For i = 0 To rows
            summe += (i - mittelwert) ^ 2 * pots(i)
        Next

stdabweichung = Math.Sqrt(summe) / kugeln

End Sub

End Class

Klasse Kugel

Class Kugel

'Aktuelle Kugelposition
    Private rowpos As Integer = 0
    Private colpos As Integer = 0

'Endgültige Kugelposition --> Topf!
    Private endpos As Integer = 0

'Anzahl der Reihen
    Private height As Integer = 0
    'Summe des Links- bzw. Rechtsfallens der Kugel
    Private cntLeft As Integer = 0
    Private cntRight As Integer = 0

'Verschiebung der Wahrscheinlichkeit (0...1)
    Private rndValue As Double = 0.5

Public ReadOnly Property row() As Integer
        Get
            Return rowpos
        End Get
    End Property

Public ReadOnly Property col() As Integer
        Get
            Return colpos
        End Get
    End Property

Public ReadOnly Property pot() As Integer
        Get
            Return endpos
        End Get
    End Property

Public ReadOnly Property left() As Integer
        Get
            Return cntLeft
        End Get
    End Property

Public ReadOnly Property right() As Integer
        Get
            Return cntRight
        End Get
    End Property

Public Sub New(ByVal h As Integer)
        height = h
    End Sub

Public Sub New(ByVal h As Integer, ByVal p As Double)
        height = h
        If p >= 0 And p <= 1 Then
            rndValue = p
        Else
            rndValue = 0.5
        End If

End Sub

Public Sub fall()

Dim row As Integer
        Dim zufall As Double

For row = 1 To height
            rowpos = row
            zufall = Rnd()
            'Für zufall<=0.5 fällt die Kugel links
            'Für zufall>0.5 fällt die Kugel rechts
            If zufall <= rndValue Then
                cntLeft += 1
                'Mein Denkfehler :-)
                'Wenn die Kugel nach links fällt, ändert sich
                'die Spalte NICHT!
                'colpos -= 1
                If colpos < 0 Then colpos = 0
            Else
                cntRight += 1
                colpos += 1
            End If
        Next

endpos = colpos

End Sub
End Class

Intel-Leibniz-Challenge 2009

Nachtrag 27.Juni 2009

Aufgabe 1

Aufgabe 1b: Zufallszahlen/Mittelwert/Standardabweichung

Aufgabe 1

Aufgabe 1c: Galton-Brett

Klasse Galtonbrett

Klasse Kugel

Applikation