3010261
/
PR1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Stand 19.12.2023

main
leonl 2023-12-19 14:21:25 +01:00
parent 7827ec4069
commit 94b00488ca
6 changed files with 212 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Programmieren/.classpath
View File

@ -6,5 +6,7 @@
</attributes> </attributes>
</classpathentry> </classpathentry>
<classpathentry kind="src" path="src"/> <classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="Resources"/>
<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5"/>
<classpathentry kind="output" path="bin"/> <classpathentry kind="output" path="bin"/>
</classpath> </classpath>

2
Programmieren/src/Lernen/BinSuche.java
View File

@ -5,7 +5,7 @@ public class BinSuche {
public static void main(String[] args) { public static void main(String[] args) {
int[] arr = {17, 4, 3, 8, 7, 2, 5, 9, 12, 25, 0, 6, 19, 16, 42, 21}; int[] arr = {17, 4, 3, 8, 7, 2, 5, 9, 12, 25, 0, 6, 19, 16, 42, 21};
BubbleSort.bubblesort(arr); BubbleSort.bubbleSort(arr);
int ergebnis = binaereSuche(arr, 42); int ergebnis = binaereSuche(arr, 42);
if (ergebnis != -1) { if (ergebnis != -1) {

33
Programmieren/src/Lernen/BubbleSort.java
View File

@ -1,3 +1,5 @@
package Lernen;
import java.util.Arrays; import java.util.Arrays;
public class BubbleSort { public class BubbleSort {
@ -18,36 +20,41 @@ public class BubbleSort {
public static void main(String[] args) { public static void main(String[] args) {
// int[] arr = {1,2,3,4,5,6,7,8}; // best case
// int[] arr = {1,2,3,4,5,6,7,8}; // best case
int[] arr = {17, 4, 3, 8, 7, 2, 5, 9, 12}; // *some* average case int[] arr = {17, 4, 3, 8, 7, 2, 5, 9, 12}; // *some* average case
// int[] arr = {17, 8, 6, 5, 4, 3, 2, 1}; // worst case // int[] arr = {17, 8, 6, 5, 4, 3, 2, 1}; // worst case
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int[] arr) {
int zähler = 0; int zähler = 0;
boolean sortiert; boolean sortiert;
do { do {
sortiert = true; sortiert = true;
for (int x = 0; x < arr.length-1; x++) { for (int x = 0; x < arr.length - 1; x++) {
if (arr[x] > arr[x+1]) { if (arr[x] > arr[x + 1]) {
swap(arr, x, x+1); swap(arr, x, x + 1);
sortiert = false; sortiert = false;
} }
zähler++; zähler++;
} // for } // for
} while(!sortiert); } while (!sortiert);
System.out.println("Anzahl der Vergleiche: " + zähler);
System.out.println(Arrays.toString(arr));
System.out.println(zähler);
} }
public static void swap(int[] brr, int ei, int zi ) { public static void swap(int[] brr, int ei, int zi) {
int merker = brr[ei]; int merker = brr[ei];
brr[ei] = brr[zi]; brr[ei] = brr[zi];
brr[zi] = merker; brr[zi] = merker;
} }
}
}

232
Programmieren/src/Lernen/VierGewinnt.java
View File

@ -1,132 +1,154 @@
package Lernen;
import java.util.Scanner; import java.util.Scanner;
public class VierGewinnt { public class VierGewinnt {
public static void main(String[] args) {
System.out.println("Willkommen zu 4 Gewinnt!");
// Game Loop
Scanner kb = new Scanner(System.in);
boolean weiter = false;
char spieler = 'x';
do {
char[][] spielfeld = spielfeldInitialisieren();
int steineZähler = 0;
spielfeldAusgeben(spielfeld);
// Gewinner Loop
boolean gewonnen = false;
do {
if (spieler == 'o')
spieler = 'x';
else
spieler = 'o';
// Spielstein einwerfen
int spalte, zeile;
do {
System.out.print("Spieler " + spieler + ", bitte wählen Sie eine Spalte aus: ");
spalte = kb.nextInt() - 1; // da Spalte eins verschoben
if ((zeile = einwurfVerarbeiten(spielfeld, spalte, spieler)) == -1)
System.err.println("Ungültige Auswahl!");
else
break;
} while(true);
steineZähler++;
spielfeldAusgeben(spielfeld);
gewonnen = gewinnerPrüfung(spielfeld, zeile, spalte);
} while(!gewonnen && steineZähler < 42);
if (!gewonnen && steineZähler == 42) {
System.out.println("Das Spiel endet unentschieden.");
} else {
System.out.println("Es gewinnt Spieler " + spieler);
}
} while (weiter);
System.out.println("Auf Wiedersehen!");
} // main
public static char[][] spielfeldInitialisieren() { public static char[][] spielfeldInitialisieren() {
char[][] spielfeld = new char[6][7]; char[][] spielfeld = new char[6][7];
for (int z = 0; z < spielfeld.length; z++) {
for (int s = 0; s < spielfeld[z].length; s++) {
spielfeld[z][s] = '_';
}
}
return spielfeld; return spielfeld;
} }
public static void spielfeldAusgeben(char[][] spielfeld) { public static void spielfeldAusgeben(char[][] spielfeld) {
System.out.println();
// Alle Zeilen ausgeben
for (int z = 0; z < spielfeld.length; z++) { for (int z = 0; z < spielfeld.length; z++) {
// Alle Spalten der z-ten Zeile ausgeben
for (int s = 0; s < spielfeld[z].length; s++) { for (int s = 0; s < spielfeld[z].length; s++) {
System.out.print(spielfeld[z][s] + " "); System.out.print("| " + spielfeld[z][s] + " " );
} }
System.out.println("|");
}
System.out.println();
for (int s = 0; s < spielfeld[0].length; s++) {
System.out.print("| " + (s+1) + " " );
}
System.out.println("|");
System.out.println(); System.out.println();
} }
public static int einwurfVerarbeiten(char[][] spielfeld, int spalte, char stein) {
if (spalte < 0 || spalte > 6)
return -1;
for (int z = spielfeld.length - 1; z >= 0 ; z--) {
if (spielfeld[z][spalte] != '_' && z == 0) // Spalte voll?
return -1;
if (spielfeld[z][spalte] == '_') {
spielfeld[z][spalte] = stein;
return z;
}
} }
public static boolean gewinnpruefung(char[][] spielfeld, char spieler) { return -1;
// Check for horizontal win }
for (int z = 0; z < spielfeld.length; z++) {
for (int s = 0; s <= spielfeld[z].length - 4; s++) { public static boolean gewinnerPrüfung(char[][] spielfeld, int zeile, int spalte) {
if (spielfeld[z][s] == spieler &&
spielfeld[z][s + 1] == spieler && // vertikale Prüfung
spielfeld[z][s + 2] == spieler && for (int i = 0; i < 3; i++) {
spielfeld[z][s + 3] == spieler) { if (spielfeld[0 + i][spalte] == spielfeld[1 + i][spalte]
&& spielfeld[0 + i][spalte] == spielfeld[2 + i][spalte]
&& spielfeld[0 + i][spalte] == spielfeld[3 + i][spalte]
&& spielfeld[0 + i][spalte] != '_')
return true;
}
// horizontale Prüfung
for (int i = 0; i < 4; i++) {
if (spielfeld[zeile][0 + i] == spielfeld[zeile][1 + i]
&& spielfeld[zeile][0 + i] == spielfeld[zeile][2 + i]
&& spielfeld[zeile][0 + i] == spielfeld[zeile][3 + i]
&& spielfeld[zeile][0 + i] != '_')
return true;
}
// diagonale Prüfung 1: "Plusplus-Fall", z.B. spielfeld[z+1][s+1]
for (int z = 0; z < 3; z++) {
for (int s = 0; s < 4; s++) {
if (spielfeld[z][s] == spielfeld[z+1][s+1]
&& spielfeld[z][s] == spielfeld[z+2][s+2]
&& spielfeld[z][s] == spielfeld[z+3][s+3]
&& spielfeld[z][s] != '_')
return true; return true;
} }
} }
}
// Check for vertical win // diagonale Prüfung 2: "Minusplus-Fall", z.B. spielfeld[z-1][s+1]
for (int s = 0; s < spielfeld[0].length; s++) { for (int z = spielfeld.length-1; z > spielfeld.length-4; z--) {
for (int z = 0; z <= spielfeld.length - 4; z++) { for (int s = 0; s < 4; s++) {
if (spielfeld[z][s] == spieler && if (spielfeld[z][s] == spielfeld[z-1][s+1]
spielfeld[z + 1][s] == spieler && && spielfeld[z][s] == spielfeld[z-2][s+2]
spielfeld[z + 2][s] == spieler && && spielfeld[z][s] == spielfeld[z-3][s+3]
spielfeld[z + 3][s] == spieler) { && spielfeld[z][s] != '_')
return true; return true;
} }
} }
}
// Check for diagonal win (from top-left to bottom-right)
for (int z = 0; z <= spielfeld.length - 4; z++) {
for (int s = 0; s <= spielfeld[z].length - 4; s++) {
if (spielfeld[z][s] == spieler &&
spielfeld[z + 1][s + 1] == spieler &&
spielfeld[z + 2][s + 2] == spieler &&
spielfeld[z + 3][s + 3] == spieler) {
return true;
}
}
}
// Check for diagonal win (from top-right to bottom-left)
for (int z = 0; z <= spielfeld.length - 4; z++) {
for (int s = 3; s < spielfeld[z].length; s++) {
if (spielfeld[z][s] == spieler &&
spielfeld[z + 1][s - 1] == spieler &&
spielfeld[z + 2][s - 2] == spieler &&
spielfeld[z + 3][s - 3] == spieler) {
return true;
}
}
}
// No winning condition found
return false; return false;
} }
public static void main(String[] args) {
System.out.println("Willkommen beim 4 Gewinnt der PR1");
boolean weiter = true;
Scanner scanner = new Scanner(System.in);
// Game loop
do {
char[][] spielfeld = spielfeldInitialisieren();
// Gewinner loop
boolean gewonnen = false;
char aktuellerSpieler = 'X';
// Game loop
do {
// Spielfeld ausgeben
spielfeldAusgeben(spielfeld);
// Spielstein einwurf
System.out.println("Spieler " + aktuellerSpieler + " ist am Zug. Bitte Spalte wählen (1-7): ");
int spalte = scanner.nextInt() - 1;
// Überprüfen, ob die gewählte Spalte gültig ist
if (spalte < 0 || spalte >= spielfeld[0].length || spielfeld[0][spalte] != ' ') {
System.out.println("Ungültige Eingabe. Bitte erneut versuchen.");
continue;
}
// Spielstein setzen
for (int z = spielfeld.length - 1; z >= 0; z--) {
if (spielfeld[z][spalte] == ' ') {
spielfeld[z][spalte] = aktuellerSpieler;
break;
}
}
// Gewinnprüfung
gewonnen = gewinnpruefung(spielfeld, aktuellerSpieler);
// Wechsel zum anderen Spieler
aktuellerSpieler = (aktuellerSpieler == 'X') ? 'O' : 'X';
} while (!gewonnen);
// Spielfeld am Ende nochmal ausgeben
spielfeldAusgeben(spielfeld);
// Gewinner ausgabe bzw. Unentschieden
System.out.println("Spieler " + aktuellerSpieler + " hat gewonnen!");
// Spiel nochmal spielen?
System.out.println("Möchten Sie nochmal spielen? (ja/nein): ");
String wiederholen = scanner.next();
weiter = wiederholen.equalsIgnoreCase("ja");
} while (weiter);
scanner.close();
}
} }

2
Programmieren/src/Lernen/ZaehlSchleife.java
View File

@ -3,7 +3,7 @@ package Lernen;
public class ZaehlSchleife { public class ZaehlSchleife {
public static void main (String[]args) { public static void main (String[]args) {
for(int i=1; i<10; i++) { for(int i=1; i<10; i++) {
System.out.println("%2d%n",i); System.out.printf("%2d%n",i);
} }
} }
} }