Programmierwettbewerb Übung

ToastBrot123

Mitglied
Guten Abend ihr lieben,
meine Schule will so einen Programmierwettbewerb simulieren. Eigentlich habe ich ja paar Grundkenntnisse in Java, aber die folgende Aufgabe sagt mir einfach gar nichts. Es geht um eine Kopfgeldjägerin, die mitHilfe von Druiden Planeten besuchen muss. Das Programm soll nun die Mindestanzahl an notwendigen Druiden bestimmen. Dafür wird eine Textdatei eingelesen mit folgenden Spezifizierung : Die Textdatei beginnt mit einer ganzen Zahl 1 < N < 1000, welche die Anzahl der Planeten festlegt. Die Planeten P werden von 0 bis N -1 durchnummeriert. Die folgenden N Zeilen geben die Hyperraumrouten an. Die i-te dieser Zeilen enthält zuerst die Anzahl der Verbindungen K mit 0<= K <= N-1 vom Planeten i , gefolgt von ganzen Zahlen, welche die Zielplaneten angeben.
Bedingungen : Jeder Planet verfügt über eine Reihe von Portalen. Jedes Portal ist mit einem Portal auf einem anderen Planet verbunden und es darf nur in eine Richtung hin passiert werden ( also ein Portal ist der Eintrittspunkt und der Andere ist der Austrittspunkt). Außerdem muss dieses Netz zyklenfrei sein.

Wäre ich nicht so verzweifelt, hätte ich mir nicht extra einen Account für dieses Forum machen, aber ich hab wirklich gar nichts. Das einzige was mir bei der Aufgabe in den Kopf geht ist, dass das allen sehr Graphen ähnelt ? Aber ich hab echt sonst keinen Ansatz. Wäre absolut dankbar, wenn jemand mir einen Ansatz geben könnte oder mit mir diese Aufgabe durchgeht. Ich weiß nicht, wie starten soll und was wie modelliert werden soll
 

ToastBrot123

Mitglied
Wenn es ein Wettbewerb ist, helfe ich sicher nicht schummeln

Du hast das falsch verstanden. Die gestellte Aufgabe ist eine Übungsaufgabe für den Wettbewerb. Logischerweise findet der Wettbewerb unter Aufsicht statt, sonst wäre es naja unnötig xD Schlimmer als solche Aufgaben kann es nicht werden, deswegen haben wir die als Übung mitbekommen
 

lennero

Bekanntes Mitglied
Interessante Aufgabe. Kannst du mal einen Ausschnitt von der Inputdatei posten? Wie sieht so ein Input genau aus?

Poste auch mal den genauen Wortlaut der Aufgabe. Was genau ist gesucht und was ist mit "Mindestanzahl der Druiden" gemeint?
 
Zuletzt bearbeitet:

ToastBrot123

Mitglied
Interessante Aufgabe. Kannst du mal einen Ausschnitt von der Inputdatei posten? Wie sieht so ein Input genau aus?
Ahja hätte ich am Anfang schon tun sollen. Im Anhang hab ich ein Bild, welches ein "Tipp sein soll". Glaube das hilft zwar echt fürs Verständnis, aber die Umsetzung ist wieder was komplett anderes. Hoffe du kannst mir helfen.
Wie oben geschrieben sieht der Input so aus : "Dafür wird eine Textdatei eingelesen mit folgenden Spezifizierung : Die Textdatei beginnt mit einer ganzen Zahl 1 < N < 1000, welche die Anzahl der Planeten festlegt. Die Planeten P werden von 0 bis N -1 durchnummeriert. Die folgenden N Zeilen geben die Hyperraumrouten an. Die i-te dieser Zeilen enthält zuerst die Anzahl der Verbindungen K mit 0<= K <= N-1 vom Planeten i , gefolgt von ganzen Zahlen, welche die Zielplaneten angeben. "
IMG_1331.jpgIMG_1331.jpg
 

ToastBrot123

Mitglied
Was ich noch vergesse hatte zu erwähnen :
Die Druiden müssen von verschiedenen Planeten gleichzeitig starten , kann jedoch von einem Planeten seiner Wahl starten. Aber die Bedingungen von oben müssen eingehalten bleiben.
 

lennero

Bekanntes Mitglied
Was ich noch vergesse hatte zu erwähnen :
Die Druiden müssen von verschiedenen Planeten gleichzeitig starten , kann jedoch von einem Planeten seiner Wahl starten. Aber die Bedingungen von oben müssen eingehalten bleiben.

Ohne genauen Wortlaut der Aufgabe sagt mir das nichts. Klingt aber stark nach klassischer Graphtraversierung. Die Inputdatei liefert dir genug Informationen um einen gerichteten Graphen aufzubauen. Das mit den Druiden verstehe ich allerdings nicht.
 

ToastBrot123

Mitglied
Ohne genauen Wortlaut der Aufgabe sagt mir das nichts. Klingt aber stark nach klassischer Graphtraversierung. Die Inputdatei liefert dir genug Informationen um einen gerichteten Graphen aufzubauen. Das mit den Druiden verstehe ich allerdings nicht.

Man soll die Mindestanzahl an Druiden angeben, die man braucht, um alle Planeten zu besuchen. Also die Mindestanzahl wird gesucht und anhand vom Bild sieht man ja beim 1. Versuch braucht man mindestens 2 ( einer der von Planet 0 startet und einer der von Planet 3 startet). Damit sind dann alle Planeten besuchbar, da es nur in eine Richtung geht

Bei der 2. sieht man man braucht mindestens 2 für das Kreuz und eben einen für den isolierten. Rückwärts geht ja nicht, wie man den Pfeilen sieht

Aber wie man das umsetzen soll oder kann, weiß ich nicht. Genauso wenig weiß ich der Graph gebaut wird oder wie man den implementiert. Deswegen brauch ich ja Hilfe :(
 

AndiE

Top Contributor
Man kann das erst mal analysieren:
In der ersten Zeile stehtdie Größe eines Arrays n x n, im ersten Fall n=4
In der nächsten Zeile steht, dass die erste Zeile(für Knoten 0) 0,1,0,0 ist ( nur eine 1 bei Spalte 1)
Dann folgte Zeile Zwei( Für Knoten 1) zu 0,0,1,0
Dann Zeile drei( Für Knoten 2) zu 0,0,0,0
und Zeile vier( Für Knoten 3) zu 0,1,0,0

Für Aufgabe 2 wäre das_

0,0,0,0,0,0
0,0,1,0,0,0
0,0,0,0,1,1
0,0,1,0,0,0
0,0,0,0,0,0
0,0,0,0,0,0

Soweit um 1. Schritt
 

MoxxiManagarm

Top Contributor
Letztlich ist die Mindestanzahl von Druiden doch gleich der Anzahl von Planeten, die nicht Ziel einer Route sind. Also hast du eine Liste von Planeten, eine Liste von Zielplaneten -> die Größe der Differenzliste ist dein Output. Dafür brauch man weder Graphentheorie, noch Objekte. Letztlich ist es nur ein einfaches Zählen beim Einlesen.
 

LimDul

Top Contributor
Letztlich ist die Mindestanzahl von Druiden doch gleich der Anzahl von Planeten, die nicht Ziel einer Route sind. Also hast du eine Liste von Planeten, eine Liste von Zielplaneten -> die Größe der Differenzliste ist dein Output. Dafür brauch man weder Graphentheorie, noch Objekte. Letztlich ist es nur ein einfaches Zählen beim Einlesen.
Dem wage ich zu widersprechen - das gilt nur, wenn die Routen kreisfrei sind. Wenn ich 3 Planeten (A,B,C) habe und Routen: A->B, B->C, C->A brauche ich trotzdem dafür einen Druiden.
 

MoxxiManagarm

Top Contributor
das gilt nur, wenn die Routen kreisfrei sind.
Bedingungen : Jeder Planet verfügt über eine Reihe von Portalen. Jedes Portal ist mit einem Portal auf einem anderen Planet verbunden und es darf nur in eine Richtung hin passiert werden ( also ein Portal ist der Eintrittspunkt und der Andere ist der Austrittspunkt). Außerdem muss dieses Netz zyklenfrei sein.
Siehe #1, zumindest verstehe ich das so, dass die Bedingung gegeben ist. Was anderes wäre, wenn er diese Bedingung noch sicherstellen muss.

Edit:
Ich bleibe dabei, es ist ein int-Array der Größe n (1. Zeile). Danach wird zeilenweise weiter eingelesen und der Wert an gefundenen Indexen inkrementiert. Wenn du das getan hast wertest du nur noch das int-Array aus. Die Anzahl der benötigten Druiden ist die Anzahl der noch verbliebenen Nullen im Array.
 
Zuletzt bearbeitet:

LimDul

Top Contributor
Siehe #1, zumindest verstehe ich das so, dass die Bedingung gegeben ist. Was anderes wäre, wenn er diese Bedingung noch sicherstellen muss.

Edit:
Ich bleibe dabei, es ist ein int-Array der Größe n (1. Zeile). Danach wird zeilenweise weiter eingelesen und der Wert an gefundenen Indexen inkrementiert. Wenn du das getan hast wertest du nur noch das int-Array aus. Die Anzahl der benötigten Druiden ist die Anzahl der noch verbliebenen Nullen im Array.
Tja, wenn man die Aufgabenstellung nicht genau liest :) Damit hast du natürlich Recht und ich viel zu kompliziert gedacht.
 

MoxxiManagarm

Top Contributor
Tja, wenn man die Aufgabenstellung nicht genau liest :) Damit hast du natürlich Recht und ich viel zu kompliziert gedacht.
Kein Ding, sowas überliest man ja schnell. Wenn er die Bedingung noch überprüfen müsste, dann müsste er auch zu Graphentheorie übergehen. Man bedenke aber auch, es geht um einen schulischen Wettbewerb. Ich glaube nicht, dass dort bereits Graphentheorie im Mittelpunkt stehen soll. Ich denke sie wollen Schüler einfach für Informatik begeistern. Und das ist ein wunderbares Beispiel für eine Aufgabe, welche erstmal komplex erscheint, sich aber dann erstaunlich leicht lösen lässt. Man muss noch die Abstraktion dieser Sachaufgabe gut hinbekommen, was in meinen Augen der Kernpunkt der Aufgabe ist im Sinne des Wettbewerbs.
 

mrBrown

Super-Moderator
Mitarbeiter
Letztlich ist die Mindestanzahl von Druiden doch gleich der Anzahl von Planeten, die nicht Ziel einer Route sind. Also hast du eine Liste von Planeten, eine Liste von Zielplaneten -> die Größe der Differenzliste ist dein Output. Dafür brauch man weder Graphentheorie, noch Objekte. Letztlich ist es nur ein einfaches Zählen beim Einlesen.

Mal als Beispiel:
Code:
0 -> 1
|
v
2
Nach deiner Rechnung bräuchte man dann einen?
 

ToastBrot123

Mitglied
Vielleicht geht es auch mit Arrays, aber ich hab heute den Tipp bekommen mir Graphen anzuschauen und zu überlegen wie man das implementiert und für die Aufgabe nutzt /: deswegen keine Ahnung ob der Array ansatz es auch tut
 

httpdigest

Top Contributor
Ich denke, das hier zu lösende Problem nennt sich "Path Cover" -> https://en.wikipedia.org/wiki/Path_cover
Die Anzahl an Pfaden in einem gerichteten Graphen, um alle Knoten (mindestens einmal) besucht zu haben.

Und es gibt wohl auch eine polynomielle Lösung:
However, if the graph is acyclic, the problem is in complexity class P and can therefore be solved in polynomial time by transforming it in a matching problem.
 

mihe7

Top Contributor
Spontan würde mir einfallen, einfach die Wurzelknoten in eine Queue zu stecken, dann von jedem Knoten aus der Queue ausgehend einen Pfad zu verfolgen, bei jedem Knoten die nicht gewählten Kanten zu entfernen und deren Zielknoten ans Ende der Queue zu setzen. Hochgezählt wird immer, wenn ein Knoten aus der Queue entfernt wird. Könnte funktionieren, muss aber nicht :)
 

lennero

Bekanntes Mitglied
Ich denke, das hier zu lösende Problem nennt sich "Path Cover" -> https://en.wikipedia.org/wiki/Path_cover
Die Anzahl an Pfaden in einem gerichteten Graphen, um alle Knoten (mindestens einmal) besucht zu haben.

Und es gibt wohl auch eine polynomielle Lösung:

Das wird hier ganz gut erklärt finde ich.


Für jemanden der noch nie was von Graphen gehört hat ist das aber zu viel auf einmal finde ich.

Edit: Das ist so ziemlich das selbe Problem wie vom Threadersteller
 

JennyL

Bekanntes Mitglied
Java:
public class Terminal2 {

	private boolean[][] matrix = null;

	public Terminal2(String fileName) {
		String[] lines = Terminal.readFile(fileName);
		for (int i = 0; i < lines.length; i++) {
			String l = lines[i];
			String[] a = l.split(" ");
			if (a.length < 1) {
				throw new IllegalArgumentException("The line is empty.");
			}
			int[] b = new int[a.length];
			try {
				for (int j = 0; j < a.length; j++) {
					b[j] = Integer.parseInt(a[j]);
				}
			} catch (NumberFormatException e) {
				throw new IllegalArgumentException("Row contains invalid number: " + l);
			}
			if (i == 0) {
				if (b[0] < 1 || b[0] > 1000) {
					throw new IllegalArgumentException("Invalid number of nodes: " + b[0]);
				}
				matrix = new boolean[b[0]][b[0]];
			} else {
				if (b[0] != b.length - 1) {
					throw new IllegalArgumentException("Invalid number of edges: " + b[0]);
				}
				for (int j = 1; j < b.length; j++) {
					if (matrix[i - 1][b[j]]) {
						throw new IllegalArgumentException("Cycle discovered!: " + (i - 1) + ", " + (b[j]));
					}
					matrix[i - 1][b[j]] = true;
				}
			}
		}
	}

	public int minimalAmountOfDroids() {
		int droids = 0;
		for (int row = 0; row < matrix.length; row++) {
			if (!hasIncomingEdge(row)) {
				droids++;
			}
		}
		return droids;
	}

	private boolean hasIncomingEdge(int node) {
		for (int row = 0; row < matrix.length; row++) {
			if (matrix[row][node]) {
				return true;
			}
		}
		return false;
	}

	public static void main(String[] args) {

		Terminal2 terminal2 = new Terminal2("test1.txt");
		System.out.println(terminal2.minimalAmountOfDroids());
	}

}
 

JennyL

Bekanntes Mitglied
Ich zitiere mal gerad:
Aus offensichtlichen Sicherheitsgründen sind diese Hyperraumrouten (x,y) € R nur in eine Richtung passierbar, wobei ein Portal der Eintrittspunkt x und das andere Portal der Austrittspunkt y aus dem Hyperraum ist.
 

mrBrown

Super-Moderator
Mitarbeiter
Ich zitiere mal gerad:
Aus offensichtlichen Sicherheitsgründen sind diese Hyperraumrouten (x,y) € R nur in eine Richtung passierbar, wobei ein Portal der Eintrittspunkt x und das andere Portal der Austrittspunkt y aus dem Hyperraum ist.
Die Bedingung steht schon im ersten Post:

Bedingungen : Jeder Planet verfügt über eine Reihe von Portalen. Jedes Portal ist mit einem Portal auf einem anderen Planet verbunden und es darf nur in eine Richtung hin passiert werden ( also ein Portal ist der Eintrittspunkt und der Andere ist der Austrittspunkt). Außerdem muss dieses Netz zyklenfrei sein.

Und weiter: Die Anzahl der Austrittspunkte kann nicht größer sein als die Anzahl der Eintrittspunkte. ;)
Das fehlt bisher. In der Form wird das aber schon von 0 -> 1 nicht erfüllt, da fehlt also zumindest noch eine Einschränkung.
 

httpdigest

Top Contributor
Das wird hier ganz gut erklärt finde ich.
Ja, ich habe den Algorithmus dort mal etwas durchgespielt und ein wichtiger Satz, bzw. eine Einschränkung, die hier aber nicht gilt, ist:
MPC of a graph is a set of vertex-disjoint paths
Diese Einschränkung gilt hier nicht, und tatsächlich kommt man mit dem Bipartite Graph Matching hier nicht weit, weil man in einigen Fällen einen Knoten mehrfach besuchen muss (die Pfade also nicht vertex-disjoint sind).
 

MoxxiManagarm

Top Contributor
Für jemanden der noch nie was von Graphen gehört hat ist das aber zu viel auf einmal finde ich
Finde ich irgendwie auch. Selbst wenn es ein Programmierwettbewerb ist, es befindet sich ja anscheinend in einem schulischen Rahmen.

Aus offensichtlichen Sicherheitsgründen sind diese Hyperraumrouten (x,y) € R nur in eine Richtung passierbar, wobei ein Portal der Eintrittspunkt x und das andere Portal der Austrittspunkt y aus dem Hyperraum ist.

Gibt es für die Aufgabenstellung eine frei verfügbare Quelle? Aus diesem Thread stammt die Aussage offensichtlich nicht

Und weiter: Die Anzahl der Austrittspunkte kann nicht größer sein als die Anzahl der Eintrittspunkte. ;)

Wenn damit gemeint ist, dass 1 <- 0 -> 2 nicht erlaubt ist, dann wäre mein Ansatz wieder gültig. Der wird nämlich nur dann ungültig, wenn
outgoing > incoming für incoming > 0 bzw. outgoing > 1 für incoming = 0
 

temi

Top Contributor
Wenn damit gemeint ist, dass 1 <- 0 -> 2 nicht erlaubt ist, dann wäre mein Ansatz wieder gültig.
Kann ja eigentlich nicht sein, denn sonst wären die Beispiele aus #5 auch nicht möglich. Im zweiten Beispiel gehen von Planet 2 auch zwei Routen aus. Außerdem macht die Vorgabe in der Datei keinen Sinn "Die i-te dieser Zeilen enthält zuerst die Anzahl der Verbindungen..."
 

JennyL

Bekanntes Mitglied
kopfgeld.png

Nach meiner Meinung ist "vertex-disjoint" ja/nein nicht eindeutig...

(Und eigentlich ist es kein Programmierwettbewerb ;) )
 

httpdigest

Top Contributor
Hab mal ein bisschen probiert. Idee: Besuche einmal alle Knoten im Graphen und bilde einen Pfad durch diesen Knoten. Wenn es der letzte mögliche Pfad war, markiere den Knoten als gelöscht. Am Ende schaue, wie viele Vertices tatsächlich besucht werden mussten und Pfade bilden konnten:
Code:
Java:
import static java.util.stream.IntStream.range;
import static java.util.stream.Stream.of;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.function.Function;
public class PathCover {
  static class Vertex {
    List<Vertex> incoming = new ArrayList<>();
    List<Vertex> outgoing = new ArrayList<>();
    boolean deleted;
    List<Vertex> getOutgoing() {
      return outgoing;
    }
    List<Vertex> getIncoming() {
      return incoming;
    }
    boolean delete() {
      deleted = true;
      incoming.forEach(v -> v.outgoing.remove(this));
      outgoing.forEach(v -> v.incoming.remove(this));
      return true;
    }
  }
  private static void walk(Vertex v) {
    walk(v, Vertex::getOutgoing);
    walk(v, Vertex::getIncoming);
  }
  private static boolean walk(Vertex v, Function<Vertex, List<Vertex>> whichList) {
    List<Vertex> l = whichList.apply(v);
    return (l.isEmpty() || walk(l.get(0), whichList) && l.isEmpty()) && v.delete();
  }
  public static int countPaths(Vertex[] vs) {
    return (int) of(vs).filter(v -> !v.deleted).peek(PathCover::walk).count();
  }
  public static Vertex[] readGraph(Reader r) throws IOException {
    BufferedReader br = new BufferedReader(r);
    int numVertices = Integer.valueOf(br.readLine());
    Vertex[] vs = range(0, numVertices).mapToObj(__ -> new Vertex()).toArray(Vertex[]::new);
    for (int i = 0; i < numVertices; i++) {
      try (Scanner s = new Scanner(br.readLine())) {
        int numOut = s.nextInt();
        for (int j = 0; j < numOut; j++) {
          int o = s.nextInt();
          vs[i].outgoing.add(vs[o]);
          vs[o].incoming.add(vs[i]);
        }
      }
    }
    return vs;
  }
}

Tests:
Java:
// Tests
public static void main(String[] args) throws IOException {
  // Erstes Beispiel in der Aufgabe
  System.out.println(countPaths(readGraph(new StringReader(
      "4\n" +
      "1 1\n" +
      "1 2\n" +
      "0\n" +
      "1 1"
  )))); // <- 2

  // Zweites Beispiel in der Aufgabe
  System.out.println(countPaths(readGraph(new StringReader(
      "6\n" +
      "0\n" +
      "1 2\n" +
      "2 4 5\n" +
      "1 2\n" +
      "0\n" +
      "0"
  )))); // <- 3

  // Eigenes Beispiel
  System.out.println(countPaths(readGraph(new StringReader(
      "10\n" +
      "1 4\n" +
      "1 4\n" +
      "1 4\n" +
      "1 4\n" +
      "1 5\n" +
      "1 6\n" +
      "3 7 8 9\n" +
      "0\n" +
      "0\n" +
      "0\n"
  )))); // <- 4
}
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
E Programmierwettbewerb Java Basics - Anfänger-Themen 15
J Übung Zahlworte Java Basics - Anfänger-Themen 14
M Array - Übung Java Basics - Anfänger-Themen 3
Der Grütz Verständnisfrage zu Übung aus Java Kurs - Schaltjahr bestimmen Java Basics - Anfänger-Themen 2
A Vererbung Vererbung Übung Java Basics - Anfänger-Themen 5
Kawastori Hilfe bei Methoden Übung Java Basics - Anfänger-Themen 6
T OOP Klausur-Übung Öpnv Java Basics - Anfänger-Themen 17
A Übung Else if Java Basics - Anfänger-Themen 2
M Code nur für Cracks? Crack the Passwort Übung Java Basics - Anfänger-Themen 7
parrot Array Übung Java Basics - Anfänger-Themen 25
G "Ladebalken" erstellen - Übung Java Basics - Anfänger-Themen 3
M JavaFX-Übung Autospiel Java Basics - Anfänger-Themen 4
B ShuttleBus - Übung Java Basics - Anfänger-Themen 3
Zrebna Compiler-Fehler Java-Compiler wird nach 'javac' keyword-Eingabe nicht gestartet (Erste Übung) Java Basics - Anfänger-Themen 18
B Rekursion - Übung Java Basics - Anfänger-Themen 2
T Klassen Kleine Übung zum Thema Klassen Java Basics - Anfänger-Themen 3
D Übung Felder java Error kompilieren Java Basics - Anfänger-Themen 4
F Erste Schritte Hilfe bei Übung zu String equals() und Schleifen Java Basics - Anfänger-Themen 8
M Übung Ausgabewerte kapier ich nicht ... Java Basics - Anfänger-Themen 1
D Übung zur Klausuraufgabe Java Basics - Anfänger-Themen 18
D OOP Hilfe zu Übung Laufzeitberechnung in Big O Java Basics - Anfänger-Themen 2
F Erste Schritte Übung zu Exceptions Java Basics - Anfänger-Themen 24
F Problem mit selbstprogrammierten Kalender (als Übung) Java Basics - Anfänger-Themen 4
B GUI- JTextField - Übung Java Basics - Anfänger-Themen 5
A Vererbung Verständnisproblem bei Übung Java Basics - Anfänger-Themen 5
EnHancEd[] OOP-Übung Java Basics - Anfänger-Themen 18
EnHancEd[] Exception Übung für Einsteiger Java Basics - Anfänger-Themen 14
T Methoden Array Übung Java Basics - Anfänger-Themen 7
F Übung: Ratespiel aus dem Buch Java von Kopf bis Fuß Java Basics - Anfänger-Themen 14
F Übung 99 Flaschen Bier aus dem Buch Java von Kopf bis Fuß Java Basics - Anfänger-Themen 10
Dit_ Thread Synchronisation | Übung Java Basics - Anfänger-Themen 5
K Anfänger-Übung für Arrays Java Basics - Anfänger-Themen 2
C Java Übung Fragen Java Basics - Anfänger-Themen 3
E BlueJ und Zeichenketten. S83 Übung 2.72 Java Basics - Anfänger-Themen 3
F Upper Case Übung Java Basics - Anfänger-Themen 10
G Frage zu einer Übung Java Basics - Anfänger-Themen 11
A JSP - Probleme mit einer Übung Java Basics - Anfänger-Themen 3
G Problem mit Übung Java Basics - Anfänger-Themen 5
D Problem mit objektorientierter Übung Java Basics - Anfänger-Themen 2
A Java Übung Java Basics - Anfänger-Themen 14
C Bitte Hilfe bei Übung zu Verzweigungen Java Basics - Anfänger-Themen 16

Ähnliche Java Themen

Neue Themen


Oben