Tim
/
cheese-champion-1
forked from IF-LK-2020/cheese-champion-1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Initial commit

This commit is contained in:
Jonas Neugebauer 2020-09-13 15:16:43 +02:00
commit 86db7da2be
7 changed files with 416 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
.gitignore vendored Normal file
View File

@ -0,0 +1,26 @@
# ---> Java
# Compiled class file
*.class
# Log file
*.log
# BlueJ files
*.ctxt
Dokumente*
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*

57
CheeseChampion.java Normal file
View File

@ -0,0 +1,57 @@
public class CheeseChampion {
// TODO: Ersetze ??? durch die passende Datenstruktur
private ??? eingang;
private ??? seitengang;
private ??? ausgang;
public CheeseChampion() {
// TODO: Ersetze ??? durch die passende Datenstruktur
eingang = ???;
seitengang = ???;
ausgang = ???;
}
/**
* Erzeugt <var>anzahl</var> fortlaufend nummerierte Mäuse (von 1 bis
* <var>anzahl</var>) mit zufälliger Stärke.
* @param anzahl
* @see java.util.Random
*/
public void erzeugeMaeuse( int anzahl ) {
// TODO: Erzeuge hier "anzahl" Mäuse mit zufälliger Stärke
}
/**
* Führt den Mäusekampf nach den bekannten Regeln durch.
*
* Siehe im Buch auf Seite 88 für eine Beschreibung des Kampfes.
*/
public void kampf() {
// TODO: Implemenitere hier den Mäusekampf
}
/**
* Erzeugt eine Startaufstellung von zehn Mäusen mit festen Stärken, mit
* denen der Kampf geprüft werden kann. Die erwartete Reihenfolge der Mäuse
* im Ausgang lautet:
* <pre>
* #2, #3, #5, #6, #4, #1, #8, #9, #10, #7
* </pre>
*/
public void erzeugeTestMaeuse() {
eingang.enqueue( new Maus(1, 8) );
eingang.enqueue( new Maus(2, 75) );
eingang.enqueue( new Maus(3, 33) );
eingang.enqueue( new Maus(4, 23) );
eingang.enqueue( new Maus(5, 73) );
eingang.enqueue( new Maus(6, 71) );
eingang.enqueue( new Maus(7, 6) );
eingang.enqueue( new Maus(8, 86) );
eingang.enqueue( new Maus(9, 63) );
eingang.enqueue( new Maus(10, 38) );
}
}

9
Maus.java Normal file
View File

@ -0,0 +1,9 @@
/**
* Eine Maus, die am Mäusekampf (Cheese Champion) teilnimmt, hat eine Nummer
* und eine Stärke als Attribute.
*/
public class Maus {
TODO: Implementiere die Maus nach der Beschreibung
}

142
Queue.java Normal file
View File

@ -0,0 +1,142 @@
/**
* <p>
* Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
* </p>
* <p>
* Generische Klasse Queue<ContentType>
* </p>
* <p>
* Objekte der generischen Klasse Queue (Warteschlange) verwalten beliebige
* Objekte vom Typ ContentType nach dem First-In-First-Out-Prinzip, d.h., das
* zuerst abgelegte Objekt wird als erstes wieder entnommen. Alle Methoden haben
* eine konstante Laufzeit, unabhaengig von der Anzahl der verwalteten Objekte.
* </p>
*
* @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
* @version Generisch_02 2014-02-21
*/
public class Queue<ContentType> {
/* --------- Anfang der privaten inneren Klasse -------------- */
private class QueueNode {
private ContentType content = null;
private QueueNode nextNode = null;
/**
* Ein neues Objekt vom Typ QueueNode<ContentType> wird erschaffen.
* Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
*
* @param pContent das Inhaltselement des Knotens vom Typ ContentType
*/
public QueueNode(ContentType pContent) {
content = pContent;
nextNode = null;
}
/**
* Der Verweis wird auf das Objekt, das als Parameter uebergeben wird,
* gesetzt.
*
* @param pNext der Nachfolger des Knotens
*/
public void setNext(QueueNode pNext) {
nextNode = pNext;
}
/**
* Liefert das naechste Element des aktuellen Knotens.
*
* @return das Objekt vom Typ QueueNode, auf das der aktuelle Verweis zeigt
*/
public QueueNode getNext() {
return nextNode;
}
/**
* Liefert das Inhaltsobjekt des Knotens vom Typ ContentType.
*
* @return das Inhaltsobjekt des Knotens
*/
public ContentType getContent() {
return content;
}
}
/* ----------- Ende der privaten inneren Klasse -------------- */
private QueueNode head;
private QueueNode tail;
/**
* Eine leere Schlange wird erzeugt.
* Objekte, die in dieser Schlange verwaltet werden, muessen vom Typ
* ContentType sein.
*/
public Queue() {
head = null;
tail = null;
}
/**
* Die Anfrage liefert den Wert true, wenn die Schlange keine Objekte enthaelt,
* sonst liefert sie den Wert false.
*
* @return true, falls die Schlange leer ist, sonst false
*/
public boolean isEmpty() {
return head == null;
}
/**
* Das Objekt pContentType wird an die Schlange angehaengt.
* Falls pContentType gleich null ist, bleibt die Schlange unveraendert.
*
* @param pContent
* das anzuhaengende Objekt vom Typ ContentType
*/
public void enqueue(ContentType pContent) {
if (pContent != null) {
QueueNode newNode = new QueueNode(pContent);
if (this.isEmpty()) {
head = newNode;
tail = newNode;
} else {
tail.setNext(newNode);
tail = newNode;
}
}
}
/**
* Das erste Objekt wird aus der Schlange entfernt.
* Falls die Schlange leer ist, wird sie nicht veraendert.
*/
public void dequeue() {
if (!this.isEmpty()) {
head = head.getNext();
if (this.isEmpty()) {
head = null;
tail = null;
}
}
}
/**
* Die Anfrage liefert das erste Objekt der Schlange.
* Die Schlange bleibt unveraendert.
* Falls die Schlange leer ist, wird null zurueckgegeben.
*
* @return das erste Objekt der Schlange vom Typ ContentType oder null,
* falls die Schlange leer ist
*/
public ContentType front() {
if (this.isEmpty()) {
return null;
} else {
return head.getContent();
}
}
}

4
README.TXT Normal file
View File

@ -0,0 +1,4 @@
Implementierung der push- und pop-Operationen in der Stack-Klasse (Stapel) aus
dem Zentralabitur NRW.
Version: 2020-09-09

126
Stack.java Normal file
View File

@ -0,0 +1,126 @@
/**
* <p>
* Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
* </p>
* <p>
* Generische Klasse Stack<ContentType>
* </p>
* <p>
* Objekte der generischen Klasse Stack (Keller, Stapel) verwalten beliebige
* Objekte vom Typ ContentType nach dem Last-In-First-Out-Prinzip, d.h., das
* zuletzt abgelegte Objekt wird als erstes wieder entnommen. Alle Methoden
* haben eine konstante Laufzeit, unabhaengig von der Anzahl der verwalteten
* Objekte.
* </p>
*
* @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
* @version Generisch_02 2014-02-21
*/
public class Stack<ContentType> {
/* --------- Anfang der privaten inneren Klasse -------------- */
private class StackNode {
private ContentType content = null;
private StackNode nextNode = null;
/**
* Ein neues Objekt vom Typ StackNode<ContentType> wird erschaffen. <br />
* Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
*
* @param pContent der Inhalt des Knotens
*/
public StackNode(ContentType pContent) {
content = pContent;
nextNode = null;
}
/**
* Der Verweis wird auf das Objekt, das als Parameter uebergeben wird,
* gesetzt.
*
* @param pNext der Nachfolger des Knotens
*/
public void setNext(StackNode pNext) {
nextNode = pNext;
}
/**
*
* @return das Objekt, auf das der aktuelle Verweis zeigt
*/
public StackNode getNext() {
return nextNode;
}
/**
* @return das Inhaltsobjekt vom Typ ContentType
*/
public ContentType getContent() {
return content;
}
}
/* ----------- Ende der privaten inneren Klasse -------------- */
private StackNode head;
/**
* Ein leerer Stapel wird erzeugt. Objekte, die in diesem Stapel verwaltet
* werden, muessen vom Typ ContentType sein.
*/
public Stack() {
head = null;
}
/**
* Die Anfrage liefert den Wert true, wenn der Stapel keine Objekte
* enthaelt, sonst liefert sie den Wert false.
*
* @return true, falls der Stapel leer ist, sonst false
*/
public boolean isEmpty() {
return (head == null);
}
/**
* Das Objekt pContentType wird oben auf den Stapel gelegt. Falls
* pContentType gleich null ist, bleibt der Stapel unveraendert.
*
* @param pContent
* das einzufuegende Objekt vom Typ ContentType
*/
public void push(ContentType pContent) {
if (pContent != null) {
StackNode node = new StackNode(pContent);
node.setNext(head);
head = node;
}
}
/**
* Das zuletzt eingefuegte Objekt wird von dem Stapel entfernt. Falls der
* Stapel leer ist, bleibt er unveraendert.
*/
public void pop() {
if (!isEmpty()) {
head = head.getNext();
}
}
/**
* Die Anfrage liefert das oberste Stapelobjekt. Der Stapel bleibt
* unveraendert. Falls der Stapel leer ist, wird null zurueckgegeben.
*
* @return das oberste Stackelement vom Typ ContentType oder null, falls
* der Stack leer ist
*/
public ContentType top() {
if (!this.isEmpty()) {
return head.getContent();
} else {
return null;
}
}
}

52
package.bluej Normal file
View File

@ -0,0 +1,52 @@
#BlueJ package file
dependency1.from=Stack
dependency1.to=StackNode
dependency1.type=UsesDependency
dependency2.from=StackTest
dependency2.to=Stack
dependency2.type=UsesDependency
editor.fx.0.height=777
editor.fx.0.width=1123
editor.fx.0.x=101
editor.fx.0.y=23
objectbench.height=95
objectbench.width=776
package.divider.horizontal=0.6
package.divider.vertical=0.8118081180811808
package.editor.height=433
package.editor.width=653
package.editor.x=140
package.editor.y=80
package.frame.height=600
package.frame.width=800
package.numDependencies=2
package.numTargets=3
package.showExtends=true
package.showUses=true
project.charset=UTF-8
readme.height=58
readme.name=@README
readme.width=47
readme.x=10
readme.y=10
target1.height=50
target1.name=StackNode
target1.showInterface=false
target1.type=ClassTarget
target1.width=160
target1.x=70
target1.y=60
target2.height=50
target2.name=StackTest
target2.showInterface=false
target2.type=UnitTestTargetJunit4
target2.width=90
target2.x=430
target2.y=110
target3.height=50
target3.name=Stack
target3.showInterface=false
target3.type=ClassTarget
target3.width=160
target3.x=80
target3.y=300