Informatik-Box - Benutzerbeiträge [de]

Lernpfad:Rekursion in Java/Aufrufbaum

2019-05-22T07:12:54Z

Thi: /* Der Aufrufbaum */

{{Navigation}}
== Der Aufrufbaum ==
Durch einen Aufrufbaum wird die schrittweise Lösung eines Problems dargestellt. Im Aufrufbaum werden die ''Parameter'' und die ''Rückgaben'' der Methode visualisiert. Gerade bei Methoden mit mehreren rekursiven Aufrufen verdeutlicht der Aufrufbaum die Ausführung.

[[Datei:PascalTriangleAnimated2.gif|frame|right|Visualisierung der Berechnung des Pascalschen Dreiecks.]]
Das [[wikipedia:Pascalsches Dreieck|Pascalsche Dreieck]] kann rekursiv berechnet werden, die jeweils oberhalb liegenden Felder werden addiert und ergeben das darunter liegende Feld.

Der untere Aufrufbaum verdeutlicht die Berechnungen, die für die vierte Zeile und die dritte Spalte des Pascalschen Dreiecks benötigt werden:
[[Datei:02_Rekursion_Aufrufbaum_Pascalsche_Dreieck.PNG|Aufrufbaum bei der rekursiven Berechnung des Pascalschen Dreiecks.]]

{{Aufgabe:Start}}
Eine [[wikipedia:Fibonacci-Folge|Fibonacci-Zahl]] wird durch die Summe der zwei vorherigen Fibonacci-Zahlen gebildet.

Mathematisch ausgedrückt:
* <math>f(n) = f(n-2)+f(n-1)</math> für <math>n>1</math>
* <math>f(n) = n</math> für <math>n<2</math>

Notieren Sie den Aufrufbaum des Methodenaufrufs <math>f(4)</math>.
<syntaxhighlight lang="java" line="1" >
public int f(n) {
if (n > 1){
return f(n-2) + f(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Aufgabe:End}}

{{Lösung:Start}}
[[Datei:03_Rekursion_Aufrufbaum_fib_loesung.PNG|Aufrufbaum bei der rekursiven Berechnung von f(4).]]
{{Lösung:End}}

Lernpfad:Rekursion in Java/Aufrufstapel

2019-05-22T06:39:18Z

Thi: /* Der Aufrufstapel */

{{Navigation}}
== Der Aufrufstapel ==

Intern werden die Methodenaufrufe einer rekursiven Methode auf einem ''Stapel'' gespeichert. Die Methoden, die ganz oben auf dem Stapel liegen, werden zuerst abgearbeitet. Danach wird das Resultat der Methode verwendet, um die darunterliegenden Methoden zu berechnen.

Der Quelltext für die Methode fakultät erzeugt den darunter dargestellten Aufrufstapel.
<syntaxhighlight lang="java" line="1" >
public int fakultät (int n){
if (n < 2){
return 1;
}else{
return n*fakultät (n-1);
}
}
</syntaxhighlight>
[[Datei:01_Rekursion_Aufrufstack_Fakultaet.png |600px|center|Aufrufstapel der Methode Fakultät.]]

{{Aufgabe:Start}}
{| class="wikitable"
! Die Methode z
! Ergänze den Aufrufstapel für z(5) .
|-
| <syntaxhighlight lang="java" line="1" >
public int z(x) {
if (x > 1){
return x + z(x - 2);
}else{
return 1;
}
}
</syntaxhighlight>
|
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
|
|
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
|}
{{Aufgabe:End}}
{{Lösung:Start}}
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
| z(3)
| 3+1=4
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
{{Lösung:End}}

Lernpfad:Rekursion in Java/Aufrufstapel

2019-05-22T06:36:58Z

Thi: /* Der Aufrufstapel */

{{Navigation}}
== Der Aufrufstapel ==
[[Datei:01_Rekursion_Aufrufstack_Fakultaet.png |right|thumb|frame|center|Aufrufstapel der Methode Fakultät.]]
Intern werden die Methodenaufrufe einer rekursiven Methode auf einem ''Stapel'' gespeichert. Die Methoden, die ganz oben auf dem Stapel liegen, werden zuerst abgearbeitet. Danach wird das Resultat der Methode verwendet, um die darunterliegenden Methoden zu berechnen.

Der Quelltext für die Methode fakultät erzeugt den rechts dargestellten Aufrufstapel.
<syntaxhighlight lang="java" line="1" >
public int fakultät (int n){
if (n < 2){
return 1;
}else{
return n*fakultät (n-1);
}
}
</syntaxhighlight>

{{Aufgabe:Start}}
{| class="wikitable"
! Die Methode z
! Ergänze den Aufrufstapel für z(5) .
|-
| <syntaxhighlight lang="java" line="1" >
public int z(x) {
if (x > 1){
return x + z(x - 2);
}else{
return 1;
}
}
</syntaxhighlight>
|
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
|
|
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
|}
{{Aufgabe:End}}
{{Lösung:Start}}
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
| z(3)
| 3+1=4
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
{{Lösung:End}}

Lernpfad:Rekursion in Java/Aufrufstapel

2019-05-22T06:31:13Z

Thi: /* Der Aufrufstapel */

{{Navigation}}
== Der Aufrufstapel ==
[[Datei:01_Rekursion_Aufrufstack_Fakultaet.png |right|thumb|frame|center|Aufrufstapel der Methode Fakultät.]]
Intern werden die Methodenaufrufe einer rekursiven Methode auf einem ''Stapel'' gespeichert. Die Methoden, die ganz oben auf dem Stapel liegen, werden zuerst abgearbeitet. Danach wird das Resultat der Methode verwendet, um die darunterliegenden Methoden zu berechnen.

{{Aufgabe:Start}}
{| class="wikitable"
! Die Methode z
! Ergänze den Aufrufstapel für z(5) .
|-
| <syntaxhighlight lang="java" line="1" >
public int z(x) {
if (x > 1){
return x + z(x - 2);
}else{
return 1;
}
}
</syntaxhighlight>
|
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
|
|
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
|}
{{Aufgabe:End}}
{{Lösung:Start}}
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
| z(3)
| 3+1=4
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
{{Lösung:End}}

Lernpfad:Rekursion in Java/Aufrufstapel

2019-05-22T06:30:03Z

Thi: /* Der Aufrufstapel */

{{Navigation}}
== Der Aufrufstapel ==
[[Datei:01_Rekursion_Aufrufstack_Fakultaet.png |right|thumb|frame|center|Aufrufstapel der Methode Fakultät.]]
Intern werden die Methodenaufrufe einer rekursiven Methode auf einem ''Stapel'' gespeichert. Die Methoden, die ganz oben auf dem Stapel liegen, werden zuerst abgearbeitet. Danach wird das Resultat der Methode verwendet, um die darunterliegenden Methoden zu berechnen.

{{Aufgabe:Start}}
{| class="wikitable"
! Die Methode z
! Ergänze den Aufrufstapel für z(5) .
|-
| <syntaxhighlight lang="java" line="1" >
public int z(x) {
if (x > 1){
return a + z(x - 2);
}else{
return 1;
}
}
</syntaxhighlight>
|
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
|
|
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
|}
{{Aufgabe:End}}
{{Lösung:Start}}
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
| z(3)
| 3+1=4
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
{{Lösung:End}}

Lernpfad:Programmierung mit Javascript und p5js/Fallunterscheidung (Farbbereiche)

2019-04-14T21:05:08Z

Thi:

Möchte man in einem Programm Fälle unterscheiden, muss man den if-Befehl verwenden:
Das folgende Programm zeigt je nach Position der Maus eine andere Farbe an.
<syntaxhighlight lang="javascript">
function setup() {
createCanvas(400, 250);
}

function draw() {
background(220);
if(mouseX > 200){
fill(255, 0, 255);
rect(mouseX, 10, 100,100);
}
if(mouseX < 200 && mouseY > 125){
fill(200, 200, 0);
ellipse(mouseX, 10, 100,100);
}
}
</syntaxhighlight>
{{Aufgabe:Start}}
Ändere das obige Programm so ab, dass der Bildschirm auch in drei Teile geteilt wird.
{{Aufgabe:End}}

Lernpfad:Programmierung mit Javascript und p5js/Fallunterscheidung (Farbbereiche)

2019-04-14T21:02:56Z

Thi: Die Seite wurde neu angelegt: „Möchte man in einem Programm Fälle unterscheiden, muss man den if-Befehl verwenden: <syntaxhighlight lang="javascript"> function setup() { createCanvas(40…“

Möchte man in einem Programm Fälle unterscheiden, muss man den if-Befehl verwenden:
<syntaxhighlight lang="javascript">
function setup() {
createCanvas(400, 250);
}

function draw() {
background(220);
if(mouseX > 200){
fill(255, 0, 255);
rect(mouseX, 10, 100,100);
}
if(mouseX < 200){
fill(200, 200, 0);
ellipse(mouseX, 10, 100,100);
}
}
</syntaxhighlight>
{{Aufgabe:Start}}
Ändere das obige Programm so ab, dass der Bildschirm auch in drei Teile geteilt wird.
{{Aufgabe:End}}

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2019-04-14T20:52:12Z

Thi:

Jeder Pixel auf dem Display oder Zeichenfeld hat eine Farbe. Wenn man ganz nah an einen Monitor heran geht, kann man evtl. einzelne Pixel erkennen. Sie bestehen aus drei kleinen Pixeln, die die Farben rot, grün und blau haben.
Das folgende Feld zeigt an, welche Farben durch die verschiedenen Farben entstehen können.

<p5js height="300">https://editor.p5js.org/HerrThiessen/embed/H1DXipu-E</p5js>

In p5js gibt es zwei Möglichkeiten die Zeichenfarbe festzulegen:
# fill(r,g,b) legt die Farbe der Füllung einer Form fest
# stroke(r,g,b) legt die Farbe der Kontur einer Form fest

Das folgende Programm zeichnet ein paar bunte Formen.
<syntaxhighlight lang="javascript">
function setup() {
createCanvas(400, 250);
}

function draw() {
background(220);
fill(255, 0, 255);
rect(10, 10, 100,100);
fill(255,0,0);
ellipse(250,50,20);
fill(0,255,0);
triangle(150,150,110,260,190,260);
}
</syntaxhighlight>
{{Aufgabe:Start}}
Erstelle ein Programm, das ein Haus mit einem Baum darstellt.
{{Aufgabe:End}}

{{Aufgabe:Start}}
Der folgende Quelltext zeichnet zwei Kreise am unteren Rand des Zeichenfeldes.
<syntaxhighlight lang="javascript">
function setup() {
createCanvas(400, 250);
}

function draw() {
background(220);
fill(255, 0, 255);
ellipse(width/2, height, 100);
fill(255,0,0);
ellipse(width/2, height,50);
}
</syntaxhighlight>
Ergänze die zwei Kreise zu einem Regenbogen. Beachte dabei, dass die kleineren Kreise am Ende gezeichnet werden sollten.
{{Aufgabe:End}}

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2019-04-14T20:49:19Z

Thi:

Jeder Pixel auf dem Display oder Zeichenfeld hat eine Farbe. Wenn man ganz nah an einen Monitor heran geht, kann man evtl. einzelne Pixel erkennen. Sie bestehen aus drei kleinen Pixeln, die die Farben rot, grün und blau haben.
Das folgende Feld zeigt an, welche Farben durch die verschiedenen Farben entstehen können.

<p5js height="300">https://editor.p5js.org/HerrThiessen/embed/H1DXipu-E</p5js>

In p5js gibt es zwei Möglichkeiten die Zeichenfarbe festzulegen:
# fill(r,g,b) legt die Farbe der Füllung einer Form fest
# stroke(r,g,b) legt die Farbe der Kontur einer Form fest

Das folgende Programm zeichnet ein paar bunte Formen.
<syntaxhighlight lang="javascript">
function setup() {
createCanvas(400, 250);
}

function draw() {
background(220);
fill(255, 0, 255);
rect(10, 10, 100,100);
fill(255,0,0);
ellipse(250,50,20);
fill(0,255,0);
triangle(150,150,110,260,190,260);
}
</syntaxhighlight>
{{Aufgabe:Start}}
Erstelle ein Programm, das ein Haus mit einem Baum darstellt.
{{Aufgabe:End}}

{{Aufgabe:Start}}
Der folgende Quelltext zeichnet zwei Kreise am unteren Rand des Zeichenfeldes.
<syntaxhighlight lang="javascript">
function setup() {
createCanvas(400, 250);
}

function draw() {
background(220);
fill(255, 0, 255);
ellipse(width/2, height, 100); // width enthält die Breite des Fensters
fill(255,0,0);
ellipse(width/2, height,50); // height enthält die Höhe des Fensters
}
</syntaxhighlight>
Ergänze die zwei Kreise zu einem Regenbogen. Beachte dabei, dass die kleineren Kreise am Ende gezeichnet werden sollten.
{{Aufgabe:End}}

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2019-04-14T18:37:55Z

Thi:

Jeder Pixel auf dem Display oder Zeichenfeld hat eine Farbe. Wenn man ganz nah an einen Monitor heran geht, kann man evtl. einzelne Pixel erkennen. Sie bestehen aus drei kleinen Pixeln, die die Farben rot, grün und blau haben.
Das folgende Feld zeigt an, welche Farben durch die verschiedenen Farben entstehen können.

<p5js height="300">https://editor.p5js.org/HerrThiessen/embed/H1DXipu-E</p5js>

In p5js gibt es zwei Möglichkeiten die Zeichenfarbe festzulegen:
# fill(r,g,b) legt die Farbe der Füllung einer Form fest
# stroke(r,g,b) legt die Farbe der Kontur einer Form fest

Der folgende Quelltext zeichnet zwei Kreise am unteren Rand des Zeichenfeldes.
<syntaxhighlight lang="javascript">
function setup() {
createCanvas(400, 250);
}

function draw() {
background(220);
fill(255, 0, 255);
ellipse(width/2, height, 100); // width enthält die Breite des Fensters
fill(255,0,0);
ellipse(width/2, height,50); // height enthält die Höhe des Fensters
}
</syntaxhighlight>

{{Aufgabe:Start}}
Ergänze die zwei Kreise zu einem Regenbogen. Beachte dabei, dass die kleineren Kreise am Ende gezeichnet werden sollten.
{{Aufgabe:End}}

Lernpfad:Rekursion in Java

2019-02-10T16:27:05Z

Thi: /* Einführung Rekursion */

{{Status/In Bearbeitung von|thi}}{{Warnung/Lernpfad im Aufbau}}
{{Navigation}}
{{Inhalt}}

=Einführung Rekursion=
[[Datei:Screenshot_Recursion_via_vlc.png|thumb|right|Rekursion bei der Aufnahme eines Bildschirmfotos mit dem VLC-Player.]]
In diesem Lernpfad lernst du die Grundlagen der ''rekursiven Programmierung'' kennen. Dieses Prinzip wird in vielen Anwendungen verwendet. Es entsteht aber auch ganz ausversehen im Alltag wenn man zum Beispiel das Bild eines Monitors mit [https://www.videolan.org VLC] aufzeichnet und dabei in diesem Bild auch der VLC-Player selber zu sehen ist. Einen ähnlichen Effekt erhält man, wenn man seinen Handy-Bildschirm auf einem Monitor überträgt und den Monitor filmt.

An diesen Beispielen wird deutlich, dass ''Rekursion'' ein Verfahren ist, bei dem eine ''Wiederholung des Gleichen'' verwendet wird.

[[Datei:Sierpinski-zoom4-ani.gif|left|Animation des Sierpinski-Dreiecks.]]
Auch das [[wikipedia:Sierpinski-Dreieck|Sierpinski-Dreieck]] ist ein Beispiel für Rekursion. Das Dreieck besteht aus Dreiecken, die aus Dreiecken bestehen, die aus ...

=Weitere Quellen=
- http://www.saar.de/~awa/jrekursion.html

[[Kategorie:Lernpfade]][[Kategorie:Lernpfade zu Java]][[Kategorie:Lernpfade Q1/Q2]]

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-09T08:54:04Z

Thi: /* Suche in einem unsortieren Array */

Um eine rekursive Methode zu schreiben müssen die drei Bestandteile der [[Lernpfad:Rekursion in Java/Definition | Definition]] implementiert werden.
{{Aufgabe:Start}}
Hast du die drei Bestandteile noch vor Augen?

{{Aufgabe:End}}

== Kästchen auf einem Gitter ==
[[Datei:05 Kaestchen.png | right]]
Auf einem Schachbrett kann man entlang der Kanten Quadrate zeichnen. Wie viele Quadrate aller Längen passen denn auf ein Schachbrett bzw. Gitter?

Um dieses Problem zu lösen, solltest du zunächst das Problem für kleine Gitter lösen um dann ein allgemeines Muster für große Gitter zu bestimmen.

{{Aufgabe:Start}}
Bestimme die Anzahl der Kästchen in einem
# 2x2-Gitter.
# 3x3-Gitter.
# 4x4-Gitter.
Lösung für 2x2 und 3x3:
{{Collapse:Start}}
#Für das 2x2-Gitter gibt es: vier 1x1 Kästchen und ein 2x2 Kästchen .
#Für das 3x3-Gitter gibt es: neun 1x1 Kästchen und vier 2x2 Kästchen und ein 3x3 Kästchen.
Die Zahlen 1,4,9,16, usw. werden als Quadratzahlen bezeichnet.
{{Collapse:End}}
Lösung für 4x4:
{{Collapse:Start}}
Für das 4x4-Gitter gibt es:sechzehn 1x1 Kästchen und neun 2x2 Kästchen und vier 3x3 Kästchen und ein 4x4 Kästchen und.
{{Collapse:End}}
{{Aufgabe:End}}

{{Aufgabe:Start}}
Natürlich lässt sich auch eine Methode für die Anzahl der Kästchen programmieren. Die Beobachtungen aus den Beispielen für ein 2x2, 3x3 und 4x4-Gitter können bei der Formulierung einer rekursiven Formel helfen.
Aber dieses Problem lässt sich auch sehr gut iterativ lösen.

Rekursive Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_rek(int n){
if(n > 1){
return n*n+k_rek(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}

Iterative Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_it(n){
int sum = 0;
for(int i = 1; i<n+1 ;i++){
sum = sum + i*i;
}
return sum;
}
</syntaxhighlight>
{{Collapse:End}}
{{Aufgabe:End}}

== Suche in einem Array ==
Ein häufiges Problem ist die Suche nach einem speziellen Element.

=== Suche in einem unsortieren Array===
Das einfachste Beispiel ist die Suche der Position einer Zahl in einem Array.
<syntaxhighlight lang="java">
public class Zahlenarray{
int[] zahlen;
public Zahlenarray(){
zahlen = int[10];
for(int i = 0; i<zahlen.length;i++){
zahlen[i] = (int)(Math.random()*10);
}
}
}
</syntaxhighlight>

{{Aufgabe:Start}}
<zuordnung>
Eine kleine Beschreibung
::1::Ein Satz
::2::wort
::3::Text::Lücke
</zuordnung>

<zuordnung>
Fügen Sie die Methode ***public int gibPosition(int z)***, die die Position einer Zahl im Array zurückgibt. Falls die Zahl nicht vorhanden ist, soll -1 als Position zurückgegeben werden.
::1::public_int_gibPosition(int_z){
::2::int pos = -1;
::3::for(int i=0; i < zahlen.length; i++){
::4::if(zahlen[i]==z){
::5::pos = i;
::6::}
::7::}
::8:: return pos;
::9::}
</zuordnung>
{{Aufgabe:End}}

=== Suche in einem unsortierten Kartenhaufen ===
Sucht man in einem heruntergefallenen Kartenstapel nach einer speziellen Karte, so muss man sich alle Karten ansehen, da sie in keiner speziellen Ordnung herunterfallen, sondern völlig durcheinander sind.

<syntaxhighlight lang="java">
public class Karte{
private String farbe;
private String wert;

public Karte(){
String[] farben = {"Kreuz", "Pik", "Herz", "Karo"};
String[] werte = {"5","6","7","8","9","10","Bube","Dame","König","Ass"};
farbe = farben[(int)(Math.random()*farben.length())];
wert= werte[(int)(Math.random()*wert.length())];
}

public boolean istGleich(String pFarbe, String pWert){
return farbe.equals(pFarbe) && wert.equals(pWert);
}
}
</syntaxhighlight>

In Java können die Karten in einem Array verwaltet werden:
<syntaxhighlight lang="java">
public class Kartenhaufen{
private Karte[] haufen;
public Kartenhaufen(){
haufen = new Karte[32];
for (int i= 0; i<haufen.length;i++){
haufen[i] = new Karte(); // Erzeugt eine zufällige Karte
}
}

public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){
Karte k = haufen[i];
if(k.istGleich(farbe,wert)){
return k;
}
}
}
</syntaxhighlight>

Erläuterungen:
{{Collapse:Start }}
<syntaxhighlight lang="java">
public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){ //Der ganze Array soll durchlaufen werden.
Karte k = haufen[i]; //Die aktuelle Karte wird aus dem Array
//geholt und eine Referenz k auf das Element wird erstellt.
if(k.getFarbe().equals(farbe) && //Die Daten der aktuellen Karte k
k.getWert().equals(wert)){ //werden mit der Farbe und dem Wert verglichen
return k; //Falls die Werte übereinstimmen,
//wird eine Referenz auf die aktuelle Karte k zurückgegeben.
} //Die Methode wird dann sofort beendet.
}
}
</syntaxhighlight>
{{Collapse:End}}

Z.B. die Telefonnummer in einem Telefonbuch. Das Telefonbuch ist nur deshalb praktikabel, weil es die Namen der Personen geordnet angibt. In einem geordneten Array kann man also schneller suchen, als in

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-09T08:53:32Z

Thi: /* Suche in einem unsortieren Array */

Um eine rekursive Methode zu schreiben müssen die drei Bestandteile der [[Lernpfad:Rekursion in Java/Definition | Definition]] implementiert werden.
{{Aufgabe:Start}}
Hast du die drei Bestandteile noch vor Augen?

{{Aufgabe:End}}

== Kästchen auf einem Gitter ==
[[Datei:05 Kaestchen.png | right]]
Auf einem Schachbrett kann man entlang der Kanten Quadrate zeichnen. Wie viele Quadrate aller Längen passen denn auf ein Schachbrett bzw. Gitter?

Um dieses Problem zu lösen, solltest du zunächst das Problem für kleine Gitter lösen um dann ein allgemeines Muster für große Gitter zu bestimmen.

{{Aufgabe:Start}}
Bestimme die Anzahl der Kästchen in einem
# 2x2-Gitter.
# 3x3-Gitter.
# 4x4-Gitter.
Lösung für 2x2 und 3x3:
{{Collapse:Start}}
#Für das 2x2-Gitter gibt es: vier 1x1 Kästchen und ein 2x2 Kästchen .
#Für das 3x3-Gitter gibt es: neun 1x1 Kästchen und vier 2x2 Kästchen und ein 3x3 Kästchen.
Die Zahlen 1,4,9,16, usw. werden als Quadratzahlen bezeichnet.
{{Collapse:End}}
Lösung für 4x4:
{{Collapse:Start}}
Für das 4x4-Gitter gibt es:sechzehn 1x1 Kästchen und neun 2x2 Kästchen und vier 3x3 Kästchen und ein 4x4 Kästchen und.
{{Collapse:End}}
{{Aufgabe:End}}

{{Aufgabe:Start}}
Natürlich lässt sich auch eine Methode für die Anzahl der Kästchen programmieren. Die Beobachtungen aus den Beispielen für ein 2x2, 3x3 und 4x4-Gitter können bei der Formulierung einer rekursiven Formel helfen.
Aber dieses Problem lässt sich auch sehr gut iterativ lösen.

Rekursive Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_rek(int n){
if(n > 1){
return n*n+k_rek(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}

Iterative Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_it(n){
int sum = 0;
for(int i = 1; i<n+1 ;i++){
sum = sum + i*i;
}
return sum;
}
</syntaxhighlight>
{{Collapse:End}}
{{Aufgabe:End}}

== Suche in einem Array ==
Ein häufiges Problem ist die Suche nach einem speziellen Element.

=== Suche in einem unsortieren Array===
Das einfachste Beispiel ist die Suche der Position einer Zahl in einem Array.
<syntaxhighlight lang="java">
public class Zahlenarray{
int[] zahlen;
public Zahlenarray(){
zahlen = int[10];
for(int i = 0; i<zahlen.length;i++){
zahlen[i] = (int)(Math.random()*10);
}
}
}
</syntaxhighlight>

{{Aufgabe:Start}}
<zuordnung>
Eine kleine Beschreibung
::1::Ein Satz
::2::wort
::3::Text::Lücke
</zuordnung>

<zuordnung>
Fügen Sie die Methode ***public int gibPosition(int z)***, die die Position einer Zahl im Array zurückgibt. Falls die Zahl nicht vorhanden ist, soll -1 als Position zurückgegeben werden.
1::public_int_gibPosition(int_z){
2::int pos = -1;
3::for(int i=0; i < zahlen.length; i++){
4::if(zahlen[i]==z){
5::pos = i;
6::}
7::}
8:: return pos;
9::}
</zuordnung>
{{Aufgabe:End}}

=== Suche in einem unsortierten Kartenhaufen ===
Sucht man in einem heruntergefallenen Kartenstapel nach einer speziellen Karte, so muss man sich alle Karten ansehen, da sie in keiner speziellen Ordnung herunterfallen, sondern völlig durcheinander sind.

<syntaxhighlight lang="java">
public class Karte{
private String farbe;
private String wert;

public Karte(){
String[] farben = {"Kreuz", "Pik", "Herz", "Karo"};
String[] werte = {"5","6","7","8","9","10","Bube","Dame","König","Ass"};
farbe = farben[(int)(Math.random()*farben.length())];
wert= werte[(int)(Math.random()*wert.length())];
}

public boolean istGleich(String pFarbe, String pWert){
return farbe.equals(pFarbe) && wert.equals(pWert);
}
}
</syntaxhighlight>

In Java können die Karten in einem Array verwaltet werden:
<syntaxhighlight lang="java">
public class Kartenhaufen{
private Karte[] haufen;
public Kartenhaufen(){
haufen = new Karte[32];
for (int i= 0; i<haufen.length;i++){
haufen[i] = new Karte(); // Erzeugt eine zufällige Karte
}
}

public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){
Karte k = haufen[i];
if(k.istGleich(farbe,wert)){
return k;
}
}
}
</syntaxhighlight>

Erläuterungen:
{{Collapse:Start }}
<syntaxhighlight lang="java">
public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){ //Der ganze Array soll durchlaufen werden.
Karte k = haufen[i]; //Die aktuelle Karte wird aus dem Array
//geholt und eine Referenz k auf das Element wird erstellt.
if(k.getFarbe().equals(farbe) && //Die Daten der aktuellen Karte k
k.getWert().equals(wert)){ //werden mit der Farbe und dem Wert verglichen
return k; //Falls die Werte übereinstimmen,
//wird eine Referenz auf die aktuelle Karte k zurückgegeben.
} //Die Methode wird dann sofort beendet.
}
}
</syntaxhighlight>
{{Collapse:End}}

Z.B. die Telefonnummer in einem Telefonbuch. Das Telefonbuch ist nur deshalb praktikabel, weil es die Namen der Personen geordnet angibt. In einem geordneten Array kann man also schneller suchen, als in

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-09T08:53:17Z

Thi: /* Suche in einem unsortieren Array */

Um eine rekursive Methode zu schreiben müssen die drei Bestandteile der [[Lernpfad:Rekursion in Java/Definition | Definition]] implementiert werden.
{{Aufgabe:Start}}
Hast du die drei Bestandteile noch vor Augen?

{{Aufgabe:End}}

== Kästchen auf einem Gitter ==
[[Datei:05 Kaestchen.png | right]]
Auf einem Schachbrett kann man entlang der Kanten Quadrate zeichnen. Wie viele Quadrate aller Längen passen denn auf ein Schachbrett bzw. Gitter?

Um dieses Problem zu lösen, solltest du zunächst das Problem für kleine Gitter lösen um dann ein allgemeines Muster für große Gitter zu bestimmen.

{{Aufgabe:Start}}
Bestimme die Anzahl der Kästchen in einem
# 2x2-Gitter.
# 3x3-Gitter.
# 4x4-Gitter.
Lösung für 2x2 und 3x3:
{{Collapse:Start}}
#Für das 2x2-Gitter gibt es: vier 1x1 Kästchen und ein 2x2 Kästchen .
#Für das 3x3-Gitter gibt es: neun 1x1 Kästchen und vier 2x2 Kästchen und ein 3x3 Kästchen.
Die Zahlen 1,4,9,16, usw. werden als Quadratzahlen bezeichnet.
{{Collapse:End}}
Lösung für 4x4:
{{Collapse:Start}}
Für das 4x4-Gitter gibt es:sechzehn 1x1 Kästchen und neun 2x2 Kästchen und vier 3x3 Kästchen und ein 4x4 Kästchen und.
{{Collapse:End}}
{{Aufgabe:End}}

{{Aufgabe:Start}}
Natürlich lässt sich auch eine Methode für die Anzahl der Kästchen programmieren. Die Beobachtungen aus den Beispielen für ein 2x2, 3x3 und 4x4-Gitter können bei der Formulierung einer rekursiven Formel helfen.
Aber dieses Problem lässt sich auch sehr gut iterativ lösen.

Rekursive Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_rek(int n){
if(n > 1){
return n*n+k_rek(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}

Iterative Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_it(n){
int sum = 0;
for(int i = 1; i<n+1 ;i++){
sum = sum + i*i;
}
return sum;
}
</syntaxhighlight>
{{Collapse:End}}
{{Aufgabe:End}}

== Suche in einem Array ==
Ein häufiges Problem ist die Suche nach einem speziellen Element.

=== Suche in einem unsortieren Array===
Das einfachste Beispiel ist die Suche der Position einer Zahl in einem Array.
<syntaxhighlight lang="java">
public class Zahlenarray{
int[] zahlen;
public Zahlenarray(){
zahlen = int[10];
for(int i = 0; i<zahlen.length;i++){
zahlen[i] = (int)(Math.random()*10);
}
}
}
</syntaxhighlight>

{{Aufgabe:Start}}
<zuordnung>
Eine kleine Beschreibung
::1::EinSatz
::2::wort
::3::Text::Lücke
</zuordnung>

<zuordnung>
Fügen Sie die Methode ***public int gibPosition(int z)***, die die Position einer Zahl im Array zurückgibt. Falls die Zahl nicht vorhanden ist, soll -1 als Position zurückgegeben werden.
1::public_int_gibPosition(int_z){
2::int pos = -1;
3::for(int i=0; i < zahlen.length; i++){
4::if(zahlen[i]==z){
5::pos = i;
6::}
7::}
8:: return pos;
9::}
</zuordnung>
{{Aufgabe:End}}

=== Suche in einem unsortierten Kartenhaufen ===
Sucht man in einem heruntergefallenen Kartenstapel nach einer speziellen Karte, so muss man sich alle Karten ansehen, da sie in keiner speziellen Ordnung herunterfallen, sondern völlig durcheinander sind.

<syntaxhighlight lang="java">
public class Karte{
private String farbe;
private String wert;

public Karte(){
String[] farben = {"Kreuz", "Pik", "Herz", "Karo"};
String[] werte = {"5","6","7","8","9","10","Bube","Dame","König","Ass"};
farbe = farben[(int)(Math.random()*farben.length())];
wert= werte[(int)(Math.random()*wert.length())];
}

public boolean istGleich(String pFarbe, String pWert){
return farbe.equals(pFarbe) && wert.equals(pWert);
}
}
</syntaxhighlight>

In Java können die Karten in einem Array verwaltet werden:
<syntaxhighlight lang="java">
public class Kartenhaufen{
private Karte[] haufen;
public Kartenhaufen(){
haufen = new Karte[32];
for (int i= 0; i<haufen.length;i++){
haufen[i] = new Karte(); // Erzeugt eine zufällige Karte
}
}

public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){
Karte k = haufen[i];
if(k.istGleich(farbe,wert)){
return k;
}
}
}
</syntaxhighlight>

Erläuterungen:
{{Collapse:Start }}
<syntaxhighlight lang="java">
public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){ //Der ganze Array soll durchlaufen werden.
Karte k = haufen[i]; //Die aktuelle Karte wird aus dem Array
//geholt und eine Referenz k auf das Element wird erstellt.
if(k.getFarbe().equals(farbe) && //Die Daten der aktuellen Karte k
k.getWert().equals(wert)){ //werden mit der Farbe und dem Wert verglichen
return k; //Falls die Werte übereinstimmen,
//wird eine Referenz auf die aktuelle Karte k zurückgegeben.
} //Die Methode wird dann sofort beendet.
}
}
</syntaxhighlight>
{{Collapse:End}}

Z.B. die Telefonnummer in einem Telefonbuch. Das Telefonbuch ist nur deshalb praktikabel, weil es die Namen der Personen geordnet angibt. In einem geordneten Array kann man also schneller suchen, als in

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-09T08:51:55Z

Thi: /* Suche in einem unsortieren Array */

Um eine rekursive Methode zu schreiben müssen die drei Bestandteile der [[Lernpfad:Rekursion in Java/Definition | Definition]] implementiert werden.
{{Aufgabe:Start}}
Hast du die drei Bestandteile noch vor Augen?

{{Aufgabe:End}}

== Kästchen auf einem Gitter ==
[[Datei:05 Kaestchen.png | right]]
Auf einem Schachbrett kann man entlang der Kanten Quadrate zeichnen. Wie viele Quadrate aller Längen passen denn auf ein Schachbrett bzw. Gitter?

Um dieses Problem zu lösen, solltest du zunächst das Problem für kleine Gitter lösen um dann ein allgemeines Muster für große Gitter zu bestimmen.

{{Aufgabe:Start}}
Bestimme die Anzahl der Kästchen in einem
# 2x2-Gitter.
# 3x3-Gitter.
# 4x4-Gitter.
Lösung für 2x2 und 3x3:
{{Collapse:Start}}
#Für das 2x2-Gitter gibt es: vier 1x1 Kästchen und ein 2x2 Kästchen .
#Für das 3x3-Gitter gibt es: neun 1x1 Kästchen und vier 2x2 Kästchen und ein 3x3 Kästchen.
Die Zahlen 1,4,9,16, usw. werden als Quadratzahlen bezeichnet.
{{Collapse:End}}
Lösung für 4x4:
{{Collapse:Start}}
Für das 4x4-Gitter gibt es:sechzehn 1x1 Kästchen und neun 2x2 Kästchen und vier 3x3 Kästchen und ein 4x4 Kästchen und.
{{Collapse:End}}
{{Aufgabe:End}}

{{Aufgabe:Start}}
Natürlich lässt sich auch eine Methode für die Anzahl der Kästchen programmieren. Die Beobachtungen aus den Beispielen für ein 2x2, 3x3 und 4x4-Gitter können bei der Formulierung einer rekursiven Formel helfen.
Aber dieses Problem lässt sich auch sehr gut iterativ lösen.

Rekursive Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_rek(int n){
if(n > 1){
return n*n+k_rek(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}

Iterative Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_it(n){
int sum = 0;
for(int i = 1; i<n+1 ;i++){
sum = sum + i*i;
}
return sum;
}
</syntaxhighlight>
{{Collapse:End}}
{{Aufgabe:End}}

== Suche in einem Array ==
Ein häufiges Problem ist die Suche nach einem speziellen Element.

=== Suche in einem unsortieren Array===
Das einfachste Beispiel ist die Suche der Position einer Zahl in einem Array.
<syntaxhighlight lang="java">
public class Zahlenarray{
int[] zahlen;
public Zahlenarray(){
zahlen = int[10];
for(int i = 0; i<zahlen.length;i++){
zahlen[i] = (int)(Math.random()*10);
}
}
}
</syntaxhighlight>

{{Aufgabe:Start}}
<zuordnung>
Eine kleine Beschreibung
1::EinSatz
2::wort
3::Text::Lücke
</zuordnung>

<zuordnung>
Fügen Sie die Methode ***public int gibPosition(int z)***, die die Position einer Zahl im Array zurückgibt. Falls die Zahl nicht vorhanden ist, soll -1 als Position zurückgegeben werden.
1::public_int_gibPosition(int_z){
2::int pos = -1;
3::for(int i=0; i < zahlen.length; i++){
4::if(zahlen[i]==z){
5::pos = i;
6::}
7::}
8:: return pos;
9::}
</zuordnung>
{{Aufgabe:End}}

=== Suche in einem unsortierten Kartenhaufen ===
Sucht man in einem heruntergefallenen Kartenstapel nach einer speziellen Karte, so muss man sich alle Karten ansehen, da sie in keiner speziellen Ordnung herunterfallen, sondern völlig durcheinander sind.

<syntaxhighlight lang="java">
public class Karte{
private String farbe;
private String wert;

public Karte(){
String[] farben = {"Kreuz", "Pik", "Herz", "Karo"};
String[] werte = {"5","6","7","8","9","10","Bube","Dame","König","Ass"};
farbe = farben[(int)(Math.random()*farben.length())];
wert= werte[(int)(Math.random()*wert.length())];
}

public boolean istGleich(String pFarbe, String pWert){
return farbe.equals(pFarbe) && wert.equals(pWert);
}
}
</syntaxhighlight>

In Java können die Karten in einem Array verwaltet werden:
<syntaxhighlight lang="java">
public class Kartenhaufen{
private Karte[] haufen;
public Kartenhaufen(){
haufen = new Karte[32];
for (int i= 0; i<haufen.length;i++){
haufen[i] = new Karte(); // Erzeugt eine zufällige Karte
}
}

public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){
Karte k = haufen[i];
if(k.istGleich(farbe,wert)){
return k;
}
}
}
</syntaxhighlight>

Erläuterungen:
{{Collapse:Start }}
<syntaxhighlight lang="java">
public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){ //Der ganze Array soll durchlaufen werden.
Karte k = haufen[i]; //Die aktuelle Karte wird aus dem Array
//geholt und eine Referenz k auf das Element wird erstellt.
if(k.getFarbe().equals(farbe) && //Die Daten der aktuellen Karte k
k.getWert().equals(wert)){ //werden mit der Farbe und dem Wert verglichen
return k; //Falls die Werte übereinstimmen,
//wird eine Referenz auf die aktuelle Karte k zurückgegeben.
} //Die Methode wird dann sofort beendet.
}
}
</syntaxhighlight>
{{Collapse:End}}

Z.B. die Telefonnummer in einem Telefonbuch. Das Telefonbuch ist nur deshalb praktikabel, weil es die Namen der Personen geordnet angibt. In einem geordneten Array kann man also schneller suchen, als in

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-09T08:48:50Z

Thi: /* Suche in einem Array */

Um eine rekursive Methode zu schreiben müssen die drei Bestandteile der [[Lernpfad:Rekursion in Java/Definition | Definition]] implementiert werden.
{{Aufgabe:Start}}
Hast du die drei Bestandteile noch vor Augen?

{{Aufgabe:End}}

== Kästchen auf einem Gitter ==
[[Datei:05 Kaestchen.png | right]]
Auf einem Schachbrett kann man entlang der Kanten Quadrate zeichnen. Wie viele Quadrate aller Längen passen denn auf ein Schachbrett bzw. Gitter?

Um dieses Problem zu lösen, solltest du zunächst das Problem für kleine Gitter lösen um dann ein allgemeines Muster für große Gitter zu bestimmen.

{{Aufgabe:Start}}
Bestimme die Anzahl der Kästchen in einem
# 2x2-Gitter.
# 3x3-Gitter.
# 4x4-Gitter.
Lösung für 2x2 und 3x3:
{{Collapse:Start}}
#Für das 2x2-Gitter gibt es: vier 1x1 Kästchen und ein 2x2 Kästchen .
#Für das 3x3-Gitter gibt es: neun 1x1 Kästchen und vier 2x2 Kästchen und ein 3x3 Kästchen.
Die Zahlen 1,4,9,16, usw. werden als Quadratzahlen bezeichnet.
{{Collapse:End}}
Lösung für 4x4:
{{Collapse:Start}}
Für das 4x4-Gitter gibt es:sechzehn 1x1 Kästchen und neun 2x2 Kästchen und vier 3x3 Kästchen und ein 4x4 Kästchen und.
{{Collapse:End}}
{{Aufgabe:End}}

{{Aufgabe:Start}}
Natürlich lässt sich auch eine Methode für die Anzahl der Kästchen programmieren. Die Beobachtungen aus den Beispielen für ein 2x2, 3x3 und 4x4-Gitter können bei der Formulierung einer rekursiven Formel helfen.
Aber dieses Problem lässt sich auch sehr gut iterativ lösen.

Rekursive Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_rek(int n){
if(n > 1){
return n*n+k_rek(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}

Iterative Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_it(n){
int sum = 0;
for(int i = 1; i<n+1 ;i++){
sum = sum + i*i;
}
return sum;
}
</syntaxhighlight>
{{Collapse:End}}
{{Aufgabe:End}}

== Suche in einem Array ==
Ein häufiges Problem ist die Suche nach einem speziellen Element.

=== Suche in einem unsortieren Array===
Das einfachste Beispiel ist die Suche der Position einer Zahl in einem Array.
<syntaxhighlight lang="java">
public class Zahlenarray{
int[] zahlen;
public Zahlenarray(){
zahlen = int[10];
for(int i = 0; i<zahlen.length;i++){
zahlen[i] = (int)(Math.random()*10);
}
}
}
</syntaxhighlight>

{{Aufgabe:Start}}
<zuordnung>
Fügen Sie die Methode ***public int gibPosition(int z)***, die die Position einer Zahl im Array zurückgibt. Falls die Zahl nicht vorhanden ist, soll -1 als Position zurückgegeben werden.
1:: public int gibPosition(int z){
2:: int pos = -1;
3:: for(int i=0; i < zahlen.length; i++){
4:: if(zahlen[i]==z){
5:: pos = i;
6::}
7::}
8:: return pos;
9::}
</zuordnung>
{{Aufgabe:End}}

=== Suche in einem unsortierten Kartenhaufen ===
Sucht man in einem heruntergefallenen Kartenstapel nach einer speziellen Karte, so muss man sich alle Karten ansehen, da sie in keiner speziellen Ordnung herunterfallen, sondern völlig durcheinander sind.

<syntaxhighlight lang="java">
public class Karte{
private String farbe;
private String wert;

public Karte(){
String[] farben = {"Kreuz", "Pik", "Herz", "Karo"};
String[] werte = {"5","6","7","8","9","10","Bube","Dame","König","Ass"};
farbe = farben[(int)(Math.random()*farben.length())];
wert= werte[(int)(Math.random()*wert.length())];
}

public boolean istGleich(String pFarbe, String pWert){
return farbe.equals(pFarbe) && wert.equals(pWert);
}
}
</syntaxhighlight>

In Java können die Karten in einem Array verwaltet werden:
<syntaxhighlight lang="java">
public class Kartenhaufen{
private Karte[] haufen;
public Kartenhaufen(){
haufen = new Karte[32];
for (int i= 0; i<haufen.length;i++){
haufen[i] = new Karte(); // Erzeugt eine zufällige Karte
}
}

public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){
Karte k = haufen[i];
if(k.istGleich(farbe,wert)){
return k;
}
}
}
</syntaxhighlight>

Erläuterungen:
{{Collapse:Start }}
<syntaxhighlight lang="java">
public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){ //Der ganze Array soll durchlaufen werden.
Karte k = haufen[i]; //Die aktuelle Karte wird aus dem Array
//geholt und eine Referenz k auf das Element wird erstellt.
if(k.getFarbe().equals(farbe) && //Die Daten der aktuellen Karte k
k.getWert().equals(wert)){ //werden mit der Farbe und dem Wert verglichen
return k; //Falls die Werte übereinstimmen,
//wird eine Referenz auf die aktuelle Karte k zurückgegeben.
} //Die Methode wird dann sofort beendet.
}
}
</syntaxhighlight>
{{Collapse:End}}

Z.B. die Telefonnummer in einem Telefonbuch. Das Telefonbuch ist nur deshalb praktikabel, weil es die Namen der Personen geordnet angibt. In einem geordneten Array kann man also schneller suchen, als in

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-09T08:16:00Z

Thi: /* Suche in einem unsortierten Haufen */

Um eine rekursive Methode zu schreiben müssen die drei Bestandteile der [[Lernpfad:Rekursion in Java/Definition | Definition]] implementiert werden.
{{Aufgabe:Start}}
Hast du die drei Bestandteile noch vor Augen?

{{Aufgabe:End}}

== Kästchen auf einem Gitter ==
[[Datei:05 Kaestchen.png | right]]
Auf einem Schachbrett kann man entlang der Kanten Quadrate zeichnen. Wie viele Quadrate aller Längen passen denn auf ein Schachbrett bzw. Gitter?

Um dieses Problem zu lösen, solltest du zunächst das Problem für kleine Gitter lösen um dann ein allgemeines Muster für große Gitter zu bestimmen.

{{Aufgabe:Start}}
Bestimme die Anzahl der Kästchen in einem
# 2x2-Gitter.
# 3x3-Gitter.
# 4x4-Gitter.
Lösung für 2x2 und 3x3:
{{Collapse:Start}}
#Für das 2x2-Gitter gibt es: vier 1x1 Kästchen und ein 2x2 Kästchen .
#Für das 3x3-Gitter gibt es: neun 1x1 Kästchen und vier 2x2 Kästchen und ein 3x3 Kästchen.
Die Zahlen 1,4,9,16, usw. werden als Quadratzahlen bezeichnet.
{{Collapse:End}}
Lösung für 4x4:
{{Collapse:Start}}
Für das 4x4-Gitter gibt es:sechzehn 1x1 Kästchen und neun 2x2 Kästchen und vier 3x3 Kästchen und ein 4x4 Kästchen und.
{{Collapse:End}}
{{Aufgabe:End}}

{{Aufgabe:Start}}
Natürlich lässt sich auch eine Methode für die Anzahl der Kästchen programmieren. Die Beobachtungen aus den Beispielen für ein 2x2, 3x3 und 4x4-Gitter können bei der Formulierung einer rekursiven Formel helfen.
Aber dieses Problem lässt sich auch sehr gut iterativ lösen.

Rekursive Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_rek(int n){
if(n > 1){
return n*n+k_rek(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}

Iterative Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_it(n){
int sum = 0;
for(int i = 1; i<n+1 ;i++){
sum = sum + i*i;
}
return sum;
}
</syntaxhighlight>
{{Collapse:End}}
{{Aufgabe:End}}

== Suche in einem Array ==
Ein häufiges Problem ist die Suche nach einem speziellen Element.
=== Suche in einem unsortierten Kartenhaufen ===
Sucht man in einem heruntergefallenen Kartenstapel nach einer speziellen Karte, so muss man sich alle Karten ansehen, da sie in keiner speziellen Ordnung herunterfallen, sondern völlig durcheinander sind.

<syntaxhighlight lang="java">
public class Karte{
private String farbe;
private String wert;

public Karte(){
String[] farben = {"Kreuz", "Pik", "Herz", "Karo"};
String[] werte = {"5","6","7","8","9","10","Bube","Dame","König","Ass"};
farbe = farben[(int)(Math.random()*farben.length())];
wert= werte[(int)(Math.random()*wert.length())];
}

public boolean istGleich(String pFarbe, String pWert){
return farbe.equals(pFarbe) && wert.equals(pWert);
}
}
</syntaxhighlight>

In Java können die Karten in einem Array verwaltet werden:
<syntaxhighlight lang="java">
public class Kartenhaufen{
private Karte[] haufen;
public Kartenhaufen(){
haufen = new Karte[32];
for (int i= 0; i<haufen.length;i++){
haufen[i] = new Karte(); // Erzeugt eine zufällige Karte
}
}

public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){
Karte k = haufen[i];
if(k.istGleich(farbe,wert)){
return k;
}
}
}
</syntaxhighlight>

Erläuterungen:
{{Collapse:Start }}
<syntaxhighlight lang="java">
public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){ //Der ganze Array soll durchlaufen werden.
Karte k = haufen[i]; //Die aktuelle Karte wird aus dem Array
//geholt und eine Referenz k auf das Element wird erstellt.
if(k.getFarbe().equals(farbe) && //Die Daten der aktuellen Karte k
k.getWert().equals(wert)){ //werden mit der Farbe und dem Wert verglichen
return k; //Falls die Werte übereinstimmen,
//wird eine Referenz auf die aktuelle Karte k zurückgegeben.
} //Die Methode wird dann sofort beendet.
}
}
</syntaxhighlight>
{{Collapse:End}}

Z.B. die Telefonnummer in einem Telefonbuch. Das Telefonbuch ist nur deshalb praktikabel, weil es die Namen der Personen geordnet angibt. In einem geordneten Array kann man also schneller suchen, als in

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-09T08:07:47Z

Thi: /* Suche in einem unsortierten Haufen */

Um eine rekursive Methode zu schreiben müssen die drei Bestandteile der [[Lernpfad:Rekursion in Java/Definition | Definition]] implementiert werden.
{{Aufgabe:Start}}
Hast du die drei Bestandteile noch vor Augen?

{{Aufgabe:End}}

== Kästchen auf einem Gitter ==
[[Datei:05 Kaestchen.png | right]]
Auf einem Schachbrett kann man entlang der Kanten Quadrate zeichnen. Wie viele Quadrate aller Längen passen denn auf ein Schachbrett bzw. Gitter?

Um dieses Problem zu lösen, solltest du zunächst das Problem für kleine Gitter lösen um dann ein allgemeines Muster für große Gitter zu bestimmen.

{{Aufgabe:Start}}
Bestimme die Anzahl der Kästchen in einem
# 2x2-Gitter.
# 3x3-Gitter.
# 4x4-Gitter.
Lösung für 2x2 und 3x3:
{{Collapse:Start}}
#Für das 2x2-Gitter gibt es: vier 1x1 Kästchen und ein 2x2 Kästchen .
#Für das 3x3-Gitter gibt es: neun 1x1 Kästchen und vier 2x2 Kästchen und ein 3x3 Kästchen.
Die Zahlen 1,4,9,16, usw. werden als Quadratzahlen bezeichnet.
{{Collapse:End}}
Lösung für 4x4:
{{Collapse:Start}}
Für das 4x4-Gitter gibt es:sechzehn 1x1 Kästchen und neun 2x2 Kästchen und vier 3x3 Kästchen und ein 4x4 Kästchen und.
{{Collapse:End}}
{{Aufgabe:End}}

{{Aufgabe:Start}}
Natürlich lässt sich auch eine Methode für die Anzahl der Kästchen programmieren. Die Beobachtungen aus den Beispielen für ein 2x2, 3x3 und 4x4-Gitter können bei der Formulierung einer rekursiven Formel helfen.
Aber dieses Problem lässt sich auch sehr gut iterativ lösen.

Rekursive Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_rek(int n){
if(n > 1){
return n*n+k_rek(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}

Iterative Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_it(n){
int sum = 0;
for(int i = 1; i<n+1 ;i++){
sum = sum + i*i;
}
return sum;
}
</syntaxhighlight>
{{Collapse:End}}
{{Aufgabe:End}}

== Suche in einem Array ==
Ein häufiges Problem ist die Suche nach einem speziellen Element.
=== Suche in einem unsortierten Haufen ===
Sucht man in einem heruntergefallenen Kartenstapel nach einer speziellen Karte, so muss man sich alle Karten ansehen, da sie in keiner speziellen Ordnung herunterfallen, sondern völlig durcheinander sind.

In Java können die Karten in einem Array verwaltet werden:
<syntaxhighlight lang="java">
public class Kartenhaufen{
Karte[] haufen;
public Kartenhaufen(){
haufen = new Karte[32];
for (int i= 0; i<haufen.length;i++){
haufen[i] = new Karte(); // Erzeugt eine zufällige Karte
}
}

public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){
Karte k = haufen[i];
if(k.getFarbe().equals(farbe) &&
k.getWert().equals(wert)){
return k;

}
}
}
</syntaxhighlight>

Erläuterungen:
{{Collapse:Start }}
<syntaxhighlight lang="java">
public Karte sucheKarte(String farbe, String wert){
for (int i=0; i< haufen.length;i++){ //Der ganze Array soll durchlaufen werden.
Karte k = haufen[i]; //Die aktuelle Karte wird aus dem Array
//geholt und eine Referenz k auf das Element wird erstellt.
if(k.getFarbe().equals(farbe) && //Die Daten der aktuellen Karte k
k.getWert().equals(wert)){ //werden mit der Farbe und dem Wert verglichen
return k; //Falls die Werte übereinstimmen,
//wird eine Referenz auf die aktuelle Karte k zurückgegeben.
} //Die Methode wird dann sofort beendet.
}
}
</syntaxhighlight>
{{Collapse:End}}

Z.B. die Telefonnummer in einem Telefonbuch. Das Telefonbuch ist nur deshalb praktikabel, weil es die Namen der Personen geordnet angibt. In einem geordneten Array kann man also schneller suchen, als in

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-09T07:54:16Z

Thi: /* Suche in einem unsortierten Haufen */

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-09T07:30:19Z

Thi: /* Suche in einem Array */

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-09T07:26:41Z

Thi:

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-09T07:20:44Z

Thi:

Um eine rekursive Methode zu schreiben müssen die drei Bestandteile der implementiert werden.

== Kästchen auf einem Gitter ==
[[Datei:05 Kaestchen.png | right]]
Auf einem Schachbrett kann man entlang der Kanten Quadrate zeichnen. Wie viele Quadrate aller Längen passen denn auf ein Schachbrett bzw. Gitter?

Um dieses Problem zu lösen, solltest du zunächst das Problem für kleine Gitter lösen um dann ein allgemeines Muster für große Gitter zu bestimmen.

{{Aufgabe:Start}}
Bestimme die Anzahl der Kästchen in einem
# 2x2-Gitter.
# 3x3-Gitter.
# 4x4-Gitter.
Lösung für 2x2 und 3x3:
{{Collapse:Start}}
#Für das 2x2-Gitter gibt es: vier 1x1 Kästchen und ein 2x2 Kästchen .
#Für das 3x3-Gitter gibt es: neun 1x1 Kästchen und vier 2x2 Kästchen und ein 3x3 Kästchen.
Die Zahlen 1,4,9,16, usw. werden als Quadratzahlen bezeichnet.
{{Collapse:End}}
Lösung für 4x4:
{{Collapse:Start}}
Für das 4x4-Gitter gibt es:sechzehn 1x1 Kästchen und neun 2x2 Kästchen und vier 3x3 Kästchen und ein 4x4 Kästchen und.
{{Collapse:End}}
{{Aufgabe:End}}

{{Aufgabe:Start}}
Natürlich lässt sich auch eine Methode für die Anzahl der Kästchen programmieren. Die Beobachtungen aus den Beispielen für ein 2x2, 3x3 und 4x4-Gitter können bei der Formulierung einer rekursiven Formel helfen.
Aber dieses Problem lässt sich auch sehr gut iterativ lösen.

Rekursive Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_rek(int n){
if(n > 1){
return n*n+k_rek(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}

Iterative Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_it(n){
int sum = 0;
for(int i = 1; i<n+1 ;i++){
sum = sum + i*i;
}
return sum;
}
</syntaxhighlight>
{{Collapse:End}}
{{Aufgabe:End}}

== Suche in einem Array ==

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-08T22:47:24Z

Thi:

== Kästchen auf einem Gitter ==
[[Datei:05 Kaestchen.png | right]]
Auf einem Schachbrett kann man entlang der Kanten Quadrate zeichnen. Wie viele Quadrate aller Längen passen denn auf ein Schachbrett bzw. Gitter?

Um dieses Problem zu lösen, solltest du zunächst das Problem für kleine Gitter lösen um dann ein allgemeines Muster für große Gitter zu bestimmen.

{{Aufgabe:Start}}
Bestimme die Anzahl der Kästchen in einem
# 2x2-Gitter.
# 3x3-Gitter.
# 4x4-Gitter.
Lösung für 2x2 und 3x3:
{{Collapse:Start}}
#Für das 2x2-Gitter gibt es: vier 1x1 Kästchen und ein 2x2 Kästchen .
#Für das 3x3-Gitter gibt es: neun 1x1 Kästchen und vier 2x2 Kästchen und ein 3x3 Kästchen.
Die Zahlen 1,4,9,16, usw. werden als Quadratzahlen bezeichnet.
{{Collapse:End}}
Lösung für 4x4:
{{Collapse:Start}}
Für das 4x4-Gitter gibt es:sechzehn 1x1 Kästchen und neun 2x2 Kästchen und vier 3x3 Kästchen und ein 4x4 Kästchen und.
{{Collapse:End}}
{{Aufgabe:End}}

{{Aufgabe:Start}}
Natürlich lässt sich auch eine Methode für die Anzahl der Kästchen programmieren. Die Beobachtungen aus den Beispielen für ein 2x2, 3x3 und 4x4-Gitter können bei der Formulierung einer rekursiven Formel helfen.
Aber dieses Problem lässt sich auch sehr gut iterativ lösen.

Rekursive Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_rek(int n){
if(n > 1){
return n*n+k_rek(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}

Iterative Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_it(n){
int sum = 0;
for(int i = 1; i<n+1 ;i++){
sum = sum + i*i;
}
return sum;
}
</syntaxhighlight>
{{Collapse:End}}
{{Aufgabe:End}}

== Suche in einem Array ==

Datei:05 Kaestchen.png

2019-01-08T22:45:02Z

Thi:

== Lizenz ==
{{CC-by-sa/3.0/de}}

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-08T22:43:49Z

Thi:

== Kästchen auf einem Gitter ==
{{Aufgabe:Start}}
Bestimme die Anzahl der Kästchen in einem
# 2x2-Gitter.
# 3x3-Gitter.
# 4x4-Gitter.
Lösung für 2x2 und 3x3:
{{Collapse:Start}}
#Für das 2x2-Gitter gibt es: vier 1x1 Kästchen und ein 2x2 Kästchen .
#Für das 3x3-Gitter gibt es: neun 1x1 Kästchen und vier 2x2 Kästchen und ein 3x3 Kästchen.
Die Zahlen 1,4,9,16, usw. werden als Quadratzahlen bezeichnet.
{{Collapse:End}}
Lösung für 4x4:
{{Collapse:Start}}
Für das 4x4-Gitter gibt es:sechzehn 1x1 Kästchen und neun 2x2 Kästchen und vier 3x3 Kästchen und ein 4x4 Kästchen und.
{{Collapse:End}}
{{Aufgabe:End}}

{{Aufgabe:Start}}
Natürlich lässt sich auch eine Methode für die Anzahl der Kästchen programmieren. Die Beobachtungen aus den Beispielen für ein 2x2, 3x3 und 4x4-Gitter können bei der Formulierung einer rekursiven Formel helfen.
Aber dieses Problem lässt sich auch sehr gut iterativ lösen.

Rekursive Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_rek(int n){
if(n > 1){
return n*n+k_rek(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}

Iterative Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_it(n){
int sum = 0;
for(int i = 1; i<n+1 ;i++){
sum = sum + i*i;
}
return sum;
}
</syntaxhighlight>
{{Collapse:End}}
{{Aufgabe:End}}

== Suche in einem Array ==

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-08T22:43:02Z

Thi: /* Kästchen auf einem Gitter */

== Kästchen auf einem Gitter ==

{{Aufgabe:Start}}
Bestimme die Anzahl der Kästchen in einem
# 2x2-Gitter.
# 3x3-Gitter.
# 4x4-Gitter.
Lösung für 2x2 und 3x3:
{{Collapse:Start}}
#Für das 2x2-Gitter gibt es: vier 1x1 Kästchen und ein 2x2 Kästchen .
#Für das 3x3-Gitter gibt es: neun 1x1 Kästchen und vier 2x2 Kästchen und ein 3x3 Kästchen.
Die Zahlen 1,4,9,16, usw. werden als Quadratzahlen bezeichnet.
{{Collapse:End}}
Lösung für 4x4:
{{Collapse:Start}}
Für das 4x4-Gitter gibt es:sechzehn 1x1 Kästchen und neun 2x2 Kästchen und vier 3x3 Kästchen und ein 4x4 Kästchen und.
{{Collapse:End}}
{{Aufgabe:End}}

{{Aufgabe:Start}}
Natürlich lässt sich auch eine Methode für die Anzahl der Kästchen programmieren. Die Beobachtungen aus den Beispielen für ein 2x2, 3x3 und 4x4-Gitter können bei der Formulierung einer rekursiven Formel helfen.
Aber dieses Problem lässt sich auch sehr gut iterativ lösen.

Rekursive Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_rek(int n){
if(n > 1){
return n*n+k_rek(n-1);
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}

Iterative Lösung
{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k_it(n){
int sum = 0;
for(int i = 1; i<n+1 ;i++){
sum = sum + i*i;
}
return sum;
}
</syntaxhighlight>
{{Collapse:End}}

== Suche in einem Array ==

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-08T21:43:50Z

Thi:

== Kästchen auf einem Gitter ==

{{Collapse:Start}}
<syntaxhighlight lang="java">
public int k(int n){
if(n > 1){
return 4*k(n-1)+1;
}else{
return 1;
}
}
</syntaxhighlight>
{{Collapse:End}}
== Suche in einem Array ==

Lernpfad:Rekursion in Java/Selbst eine rekursive Methode schreiben

2019-01-08T21:12:40Z

Thi: Die Seite wurde neu angelegt: „ Suche in einem Array“

Suche in einem Array

Lernpfad:Rekursion in Java/Rekursion bei Schachproblemen

2019-01-08T21:11:25Z

Thi:

Im Kontext des Schachspiels gibt es zwei sehr bekannte Problemstellungen.
An dieser Stelle sollen einfach nur ein paar Links für interessierte hinzugefügt werden:
== Dameproblem ==

https://de.wikipedia.org/wiki/Damenproblem
Man versucht 8 Damen auf dem Schachbrett zu positionieren. Dabei müssen die Damen so aufgestellt werden,
dass sich keine Damen gegenseitig schlagen.
{{Aufgabe:Start}}
Versuche auf einem 5x5 Feld 5 Damen aufzustellen.

Lösung:
{{Collapse:Start}}
<p5js height="201">https://editor.p5js.org/HerrThiessen/embed/HJJo3XGfE</p5js>
{{Collapse:End}}
{{Aufgabe:End}}

Ein rekursiver Algorithmus könnte wie folgt aussehen:
<syntaxhighlight >
dame(t)
Falls t < 8 ist DANN
Wiederhole für alle Positionen (starte bei 0)
aktuelle Reihe gleich nächste Position
Falls die aktuelle Reihe noch frei ist DANN
setze die Dame auf die freie Reihe
Falls die Dame mit keiner anderen kollidiert DANN
dame(t+1)
Entferne die aktuelle Dame aus der Reihe
SONST
speicher die Lösung
</syntaxhighlight >

<p5js >

</p5js>

== Springerproblem ==
## https://de.wikipedia.org/wiki/Springerproblem
## http://www.axel-conrad.de/springer/springer.html
## https://docplayer.org/41857208-Backtracking-mit-heuristiken.html

# https://www.mathe-online.at/materialien/matroid/files/schach/schachbrett.html

#Labyrinth http://www.erasmus-reinhold-gymnasium.de/info/rekursion-iteration/Backtracking_final.pdf

Lernpfad:Rekursion in Java/Rekursion bei Schachproblemen

2019-01-08T21:04:01Z

Thi:

Im Kontext des Schachspiels gibt es zwei sehr bekannte Problemstellungen.
An dieser Stelle sollen einfach nur ein paar Links für interessierte hinzugefügt werden:
# Dameproblem
Man versucht 8 Damen auf dem Schachbrett zu positionieren. Dabei müssen die Damen so aufgestellt werden,
dass sich keine Damen gegenseitig schlagen.
{{Aufgabe:Start}}
Versuche auf einem 5x5 Feld 5 Damen aufzustellen.

Lösung:
{{Collapse:Start}}
<p5js height="201">https://editor.p5js.org/HerrThiessen/embed/HJJo3XGfE</p5js>
{{Collapse:End}}
{{Aufgabe:End}}

Ein rekursiver Algorithmus könnte wie folgt aussehen:
<syntaxhighlight >
dame(t)
Falls t < 8 ist DANN
Wiederhole für alle Positionen (starte bei 0)
aktuelle Reihe gleich nächste Position
Falls die aktuelle Reihe noch frei ist DANN
setze die Dame auf die freie Reihe
Falls die Dame mit keiner anderen kollidiert DANN
dame(t+1)
Entferne die aktuelle Dame aus der Reihe
SONST
speicher die Lösung
</syntaxhighlight >

<p5js >

</p5js>

# Springerproblem
## https://de.wikipedia.org/wiki/Springerproblem
## http://www.axel-conrad.de/springer/springer.html
## https://docplayer.org/41857208-Backtracking-mit-heuristiken.html

# https://www.mathe-online.at/materialien/matroid/files/schach/schachbrett.html

#Labyrinth http://www.erasmus-reinhold-gymnasium.de/info/rekursion-iteration/Backtracking_final.pdf

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2019-01-08T20:54:42Z

Thi:

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2019-01-08T20:54:27Z

Thi:

Lernpfad:Rekursion in Java/Rekursion bei Schachproblemen

2019-01-08T20:43:58Z

Thi:

Im Kontext des Schachspiels gibt es zwei sehr bekannte Problemstellungen.
An dieser Stelle sollen einfach nur ein paar Links für interessierte hinzugefügt werden:
# Dameproblem
Man versucht 8 Damen auf dem Schachbrett zu positionieren. Dabei müssen die Damen so aufgestellt werden,
dass sich keine Damen gegenseitig schlagen.
{{Aufgabe:Start}}
Versuche auf einem 5x5 Feld 5 Damen aufzustellen.
{{Aufgabe:End}}

Ein rekursiver Algorithmus könnte wie folgt aussehen:
<syntaxhighlight >
dame(t, zeilen)
Falls t < 8 ist DANN
Wiederhole für alle Positionen (starte bei 0)
aktuelle Reihe gleich nächste Position
Falls die aktuelle Reihe noch frei ist DANN
setze die Dame auf die freie Reihe
Falls die Dame mit keiner anderen kollidiert DANN
dame(t+1, zeilen)
Entferne die aktuelle Dame aus der Reihe
SONST
speicher die Lösung
</syntaxhighlight >

<p5js >

</p5js>

# Springerproblem
## https://de.wikipedia.org/wiki/Springerproblem
## http://www.axel-conrad.de/springer/springer.html
## https://docplayer.org/41857208-Backtracking-mit-heuristiken.html

# https://www.mathe-online.at/materialien/matroid/files/schach/schachbrett.html

#Labyrinth http://www.erasmus-reinhold-gymnasium.de/info/rekursion-iteration/Backtracking_final.pdf

Lernpfad:Rekursion in Java/Rekursion bei Schachproblemen

2019-01-08T09:24:32Z

Thi:

Im Kontext des Schachspiels gibt es zwei sehr bekannte Problemstellungen.
An dieser Stelle sollen einfach nur ein paar Links für interessierte hinzugefügt werden:
# Dameproblem
Man versucht 8 Damen auf dem Schachbrett zu positionieren. Dabei müssen die Damen so aufgestellt werden,
dass sich keine Damen gegenseitig schlagen.

Ein rekursiver Algorithmus könnte wie folgt aussehen:
<syntaxhighlight >
dame(t, zeilen)
Falls t < 8 ist
DANN
pos = erste Leere Zeile
wiederhole solange pos < 8 ist
setze die Dame auf die Position
prüfe ob die Dame mit einer anderen kollidiert
Falls ja
nächste freie Zeile verwenden
Falls nein
loesung = dame(t+1, zeilen)
Falls !loesung
DANN
gib false zurueck
SONST
speicher die Lösung / gib die Lösung aus
gib true zurueck
</syntaxhighlight >
# Springerproblem
## https://de.wikipedia.org/wiki/Springerproblem
## http://www.axel-conrad.de/springer/springer.html
## https://docplayer.org/41857208-Backtracking-mit-heuristiken.html

# https://www.mathe-online.at/materialien/matroid/files/schach/schachbrett.html

#Labyrinth http://www.erasmus-reinhold-gymnasium.de/info/rekursion-iteration/Backtracking_final.pdf

Lernpfad:Rekursion in Java/Rekursion bei Schachproblemen

2019-01-08T09:22:46Z

Thi:

Im Kontext des Schachspiels gibt es zwei sehr bekannte Problemstellungen.
An dieser Stelle sollen einfach nur ein paar Links für interessierte hinzugefügt werden:
# Dameproblem
Man versucht 8 Damen auf dem Schachbrett zu positionieren. Dabei müssen die Damen so aufgestellt werden,
dass sich keine Damen gegenseitig schlagen.

Ein rekursiver Algorithmus könnte wie folgt aussehen:
<code>
dame(t, zeilen, n)
Falls t < n ist
DANN
pos = erste Leere Zeile
wiederhole solange pos < n ist
setze die Dame auf die Position
prüfe ob die Dame mit einer anderen kollidiert
Falls ja
nächste freie Zeile verwenden
Falls nein
loesung = dame(t+1)
Falls !loesung
DANN
gib false zurueck
SONST
speicher die Lösung / gib die Lösung aus
gib true zurueck
</code>
# Springerproblem
## https://de.wikipedia.org/wiki/Springerproblem
## http://www.axel-conrad.de/springer/springer.html
## https://docplayer.org/41857208-Backtracking-mit-heuristiken.html

# https://www.mathe-online.at/materialien/matroid/files/schach/schachbrett.html

#Labyrinth http://www.erasmus-reinhold-gymnasium.de/info/rekursion-iteration/Backtracking_final.pdf

Lernpfad:Rekursion in Java/Rekursion bei Schachproblemen

2019-01-08T08:41:07Z

Thi:

Im Kontext des Schachspiels gibt es zwei sehr bekannte Problemstellungen.
An dieser Stelle sollen einfach nur ein paar Links für interessierte hinzugefügt werden:
# Dameproblem
##
# Springerproblem
## https://de.wikipedia.org/wiki/Springerproblem
## http://www.axel-conrad.de/springer/springer.html
## https://docplayer.org/41857208-Backtracking-mit-heuristiken.html

# https://www.mathe-online.at/materialien/matroid/files/schach/schachbrett.html

#Labyrinth http://www.erasmus-reinhold-gymnasium.de/info/rekursion-iteration/Backtracking_final.pdf

Lernpfad:Rekursion in Java/Rekursion bei Schachproblemen

2019-01-08T08:40:34Z

Thi: Die Seite wurde neu angelegt: „Im Kontext des Schachspiels gibt es zwei sehr bekannte Problemstellungen. An dieser Stelle sollen einfach nur ein paar Links für interessierte hinzugefügt w…“

Im Kontext des Schachspiels gibt es zwei sehr bekannte Problemstellungen.
An dieser Stelle sollen einfach nur ein paar Links für interessierte hinzugefügt werden:
# Dameproblem
##
# Springerproblem
## [[https://de.wikipedia.org/wiki/Springerproblem]]
## [[http://www.axel-conrad.de/springer/springer.html]]
## [[https://docplayer.org/41857208-Backtracking-mit-heuristiken.html]]

#https://www.mathe-online.at/materialien/matroid/files/schach/schachbrett.html

#Labyrinth [[http://www.erasmus-reinhold-gymnasium.de/info/rekursion-iteration/Backtracking_final.pdf]]

Lernpfad:Rekursion in Java/Aufrufstapel

2019-01-08T08:11:01Z

Thi: /* Der Aufrufstapel */

{{Navigation}}
== Der Aufrufstapel ==
[[Datei:01_Rekursion_Aufrufstack_Fakultaet.png |right|thumb|frame|center|Aufrufstapel der Methode Fakultät.]]
Intern werden die Methodenaufrufe einer rekursiven Methode auf einem ''Stapel'' gespeichert. Die Methoden, die ganz oben auf dem Stapel liegen, werden zuerst abgearbeitet. Danach wird das Resultat der Methode verwendet, um die darunterliegenden Methoden zu berechnen.

{{Aufgabe:Start}}
{| class="wikitable"
! Die Methode z
! Ergänzen Sie den Aufrufstapel zu dem Methodenaufruf z(5) .
|-
| <syntaxhighlight lang="java" line="1" >
public int z(x) {
if (x > 1){
return a + z(x - 2);
}else{
return 1;
}
}
</syntaxhighlight>
|
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
|
|
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
|}
{{Aufgabe:End}}
{{Lösung:Start}}
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
| z(3)
| 3+1=4
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
{{Lösung:End}}

Lernpfad:Rekursion in Java/Aufrufstapel

2019-01-08T08:10:38Z

Thi: /* Der Aufrufstapel */

{{Navigation}}
== Der Aufrufstapel ==
[[Datei:01_Rekursion_Aufrufstack_Fakultaet.png |right|400px|frame|center|Aufrufstapel der Methode Fakultät.]]
Intern werden die Methodenaufrufe einer rekursiven Methode auf einem ''Stapel'' gespeichert. Die Methoden, die ganz oben auf dem Stapel liegen, werden zuerst abgearbeitet. Danach wird das Resultat der Methode verwendet, um die darunterliegenden Methoden zu berechnen.

{{Aufgabe:Start}}
{| class="wikitable"
! Die Methode z
! Ergänzen Sie den Aufrufstapel zu dem Methodenaufruf z(5) .
|-
| <syntaxhighlight lang="java" line="1" >
public int z(x) {
if (x > 1){
return a + z(x - 2);
}else{
return 1;
}
}
</syntaxhighlight>
|
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
|
|
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
|}
{{Aufgabe:End}}
{{Lösung:Start}}
{|class="wikitable"
|
|
|z(1)
|1
|
|-
|
| z(3)
| z(3)
| 3+1=4
|
|-
| z(5)
| z(5)
| z(5)
| z(5)
| 5+4=9
|-
|}
{{Lösung:End}}

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2019-01-03T19:38:12Z

Thi:

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2019-01-03T19:36:36Z

Thi:

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2019-01-03T19:23:33Z

Thi:

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2019-01-03T19:16:27Z

Thi:

Jeder Pixel auf dem Display oder Zeichenfeld hat eine Farbe. Wenn man ganz nah an einen Monitor heran geht, kann man evtl. einzelne Pixel erkennen. Sie bestehen aus drei kleinen Pixeln, die die Farben rot, grün und blau haben.

<p5js | right>https://editor.p5js.org/HerrThiessen/embed/H1DXipu-E</p5js>
In p5js gibt es zwei Möglichkeiten die Zeichenfarbe festzulegen:
# fill(r,g,b) legt die Farbe der Füllung einer Form fest
# stroke(r,g,b) legt die Farbe der Kontur einer Form fest

<syntaxhighlight lang="javascript">
function setup() {
createCanvas(400, 250);
}

function draw() {
background(220);
fill(255, 0, 255);
ellipse(width/2, height, 100);
fill(255,0,0);
ellipse(width/2, height,50);
}
</syntaxhighlight>

[[Datei:Regenbogen.gif]]

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2019-01-03T07:32:09Z

Thi:

Jeder Pixel auf dem Display oder Zeichenfeld hat eine Farbe. Wenn man ganz nah an einen Monitor heran geht, kann man evtl. einzelne Pixel erkennen. Sie bestehen aus drei kleinen Pixeln, die die Farben rot, grün und blau haben.

In p5js gibt es zwei Möglichkeiten eine Farbe einzugeben:

<p5js>https://editor.p5js.org/HerrThiessen/embed/H1DXipu-E</p5js>
[[Datei:Regenbogen.gif]]

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2019-01-02T22:52:04Z

Thi:

Jeder Pixel auf dem Display oder Zeichenfeld hat eine Farbe. Wenn man ganz nah an einen Monitor heran geht, kann man evtl. einzelne Pixel erkennen. Sie bestehen aus drei kleinen Pixeln, die die Farben rot, grün und blau haben.

In p5js gibt es zwei Möglichkeiten eine Farbe einzugeben:

[https://editor.p5js.org/HerrThiessen/embed/H1DXipu-E Farbauswahl]
[[Datei:Regenbogen.gif]]

Lernpfad:Programmierung mit Javascript und p5js/Farbe in p5js (Regenbogen)

2018-12-31T16:03:33Z

Thi: Die Seite wurde neu angelegt: „Datei:Regenbogen.gif“

[[Datei:Regenbogen.gif]]

Datei:Regenbogen.gif

2018-12-31T16:02:39Z

Thi: Ein animierter Regenbogen

== Beschreibung ==
Ein animierter Regenbogen
== Lizenz ==
{{CC-by-sa/3.0/de}}

Lernpfad:Rekursion in Java

2018-12-31T00:51:37Z

Thi: /* Einführung Rekursion */

{{Status/In Bearbeitung von|thi}}{{Warnung|Dieser Lernpfad ist derzeit noch im Aufbau.}}
{{Navigation}}
{{Inhalt}}

=Einführung Rekursion=
[[Datei:Screenshot_Recursion_via_vlc.png|thumb|right]]
In diesem Lernpfad lernst du die Grundlagen der ''rekursiven Programmierung'' kennen. Dieses Prinzip wird in vielen Anwendungen verwendet. Es entsteht aber auch ganz ausversehen im Alltag wenn man z.B. das Bild eines Bildschirms mit VLC aufzeichnet und dabei in diesem Bild auch der Player selber zu sehen ist. Einen ähnlichen Effekt erhält man, wenn man seinen Handy-Bildschirm auf einem Monitor überträgt und den Monitor filmt.

In diesen Beispielen wird deutlich, dass Rekursion ein Verfahren ist, bei dem eine Wiederholung des Gleichen verwendet wird.

[[Datei: Sierpinski-zoom4-ani.gif]]
Auch das Sierpinski-Dreieck ist ein Beispiel für eine Rekursion. Das Dreieck besteht aus Dreiecken, die aus Dreiecken bestehen.

Lernpfad:Rekursion in Java

2018-12-31T00:42:53Z

Thi: Der Seiteninhalt wurde durch einen anderen Text ersetzt: „{{Status/In Bearbeitung von|thi}}{{Warnung|Dieser Lernpfad ist derzeit noch im Aufbau.}} {{Navigation}} {{Inhalt}} =Einführung Rek…“

{{Status/In Bearbeitung von|thi}}{{Warnung|Dieser Lernpfad ist derzeit noch im Aufbau.}}
{{Navigation}}
{{Inhalt}}

=Einführung Rekursion=
In diesem Lernpfad lernst du die Grundlagen der ''rekursiven Programmierung'' kennen. Dieses Prinzip wird in vielen Anwendungen verwendet.

Lernpfad:Rekursion in Java/Aufrufbaum

2018-12-31T00:42:24Z

Thi: Die Seite wurde neu angelegt: „==Der Aufrufbaum== Das pascal'sche Dreieck Durch einen Aufrufbaum wird die schrittweise Lösung eines Problem…“

==Der Aufrufbaum==
[[Datei:PascalTriangleAnimated2.gif|thumb|right|Das pascal'sche Dreieck]]
Durch einen Aufrufbaum wird die schrittweise Lösung eines Problems dargestellt. Im Aufrufbaum werden die Parameter und die Rückgaben der Methode visualisiert. Gerade bei Methoden mit mehreren rekursiven Aufrufen verdeutlicht der Aufrufbaum die Ausführung.

Das pascalsche Dreieck kann rekursiv berechnet werden, die jeweils oberhalb liegenden Felder werden addiert und ergeben das untere Feld.

Der untere Aufrufbaum verdeutlicht die Berechnungen, die für die vierte Zeile und die dritte Spalte des pascal'schen Dreiecks benötigt werden:
[[Datei:02_Rekursion_Aufrufbaum_Pascalsche_Dreieck.PNG|02_Rekursion_Aufrufbaum_Pascalsche_Dreieck.PNG]]

{{Aufgabe:Start}}
Eine Fibonacci-Zahl wird durch die Summe der zwei vorherigen Fibonacci-Zahlen gebildet.

*Mathematisch ausgedrückt:
** f(n) = f(n-2)+f(n-1) für n>1,
** f(n) = n für n<2

Notieren Sie den Aufrufbaum des Methodenaufrufs f(4).
<syntaxhighlight lang="java" line="1" >
public int f(n) {
if (n > 1){
return f(n-2) + f(n-1);
}else{
return n;
}
}
</syntaxhighlight>

{{Lösung:Start}}
[[Datei:03_Rekursion_Aufrufbaum_fib_loesung.PNG]]
{{Lösung:End}}
{{Aufgabe:End}}