diff --git a/ss2010/gdi2/p1/Project1/.classpath b/ss2010/gdi2/p1/Project1/.classpath new file mode 100644 index 00000000..3e0fb272 --- /dev/null +++ b/ss2010/gdi2/p1/Project1/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/ss2010/gdi2/p1/Project1/.project b/ss2010/gdi2/p1/Project1/.project new file mode 100644 index 00000000..627aed82 --- /dev/null +++ b/ss2010/gdi2/p1/Project1/.project @@ -0,0 +1,17 @@ + + + Project1 + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/ss2010/gdi2/p1/Project1/black.jpg b/ss2010/gdi2/p1/Project1/black.jpg new file mode 100644 index 00000000..69428633 Binary files /dev/null and b/ss2010/gdi2/p1/Project1/black.jpg differ diff --git a/ss2010/gdi2/p1/Project1/dame.jpg b/ss2010/gdi2/p1/Project1/dame.jpg new file mode 100644 index 00000000..36e31d37 Binary files /dev/null and b/ss2010/gdi2/p1/Project1/dame.jpg differ diff --git a/ss2010/gdi2/p1/Project1/src/gui/PlayFieldGUI.java b/ss2010/gdi2/p1/Project1/src/gui/PlayFieldGUI.java new file mode 100644 index 00000000..9ac22618 --- /dev/null +++ b/ss2010/gdi2/p1/Project1/src/gui/PlayFieldGUI.java @@ -0,0 +1,226 @@ +package gui; + + +import java.awt.BorderLayout; +import java.awt.Color; +import java.awt.Component; +import java.awt.Dimension; +import java.awt.Graphics; +import java.awt.GridBagLayout; +import java.awt.GridLayout; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; + +import javax.swing.Icon; +import javax.swing.ImageIcon; +import javax.swing.JButton; +import javax.swing.JFrame; +import javax.swing.JLabel; +import javax.swing.JPanel; +import javax.swing.JTextField; + +import com.sun.org.apache.bcel.internal.generic.ICONST; + + +public class PlayFieldGUI extends JFrame{ + + + + private JFrame window; + private JPanel playField; + private boolean[][] playFieldArray; + private int playFieldSize; + + + + public void initialsGUI(int playFieldSize, boolean[][] playFieldArray){ + + + int inputDelay = 0; + int intputCoQ = 0; + + + this.playFieldArray = playFieldArray; + this.playFieldSize = playFieldSize; + + window = new JFrame("Queen Problem Solver"); + JButton ge = new JButton("Generate"); + JButton so = new JButton("Solve it"); + JPanel control = new JPanel(); + + + //Build Panel + control.setLayout(new GridLayout(1, 6, 1, 1)); + control.add(new JLabel("Count of queens:")); + final JTextField coq = new JTextField(); + control.add(coq); + control.add(new JLabel("Delay:")); + + final JTextField delay = new JTextField(); + control.add(delay); + control.add(ge); + control.add(so); + + ge.addActionListener(new ActionListener() { + + @Override + public void actionPerformed(ActionEvent e) { + + System.out.println("Test"); + //String inputCoQ = coq.getText(); + int inputCoQ = Integer.parseInt(coq.getText()); + } + }); + + so.addActionListener(new ActionListener() { + + @Override + public void actionPerformed(ActionEvent e) { + + //System.out.println("Test"); + int inputDelay = Integer.parseInt(delay.getText()); + firePropertyChange("newDelay", null, inputDelay); + } + }); + + + + + + //Build playField + buildPlayField(); + + + //Build window + window.add(control, BorderLayout.NORTH); + window.add(playField, BorderLayout.CENTER); + + //window.setMinimumSize(new Dimension(400, 400)); + window.setSize(playFieldSize * 52, playFieldSize * 52); + window.setDefaultCloseOperation(EXIT_ON_CLOSE); + window.setVisible(true); + + + } + + + public void buildPlayField(){ + + //Build playField + playField = new JPanel(); + GridLayout gl = new GridLayout(playFieldSize, playFieldSize, 1, 1); + playField.setLayout(gl); + + boolean colorBlack = false; + boolean colorWhite = true; + for(int i = 0; i < playFieldSize; i++){ + for (int j = 0; j < playFieldSize; j++){ + + if(playFieldArray[i][j] == true){ // Dame ist gesetzt //TODO: kann man das weglassen? + + final JButton dame = new JButton(new ImageIcon("dame.jpg")); + dame.setLocation(i, j); + playField.add(dame); + + } + else{ + if(colorWhite){ + + final JButton bWhite = new JButton(new ImageIcon("white.jpg")); + bWhite.setLocation(i, j); + + //ActionListener für Userinteraction + bWhite.addActionListener(new ActionListener() { + + @Override + public void actionPerformed(ActionEvent e) { + bWhite.setIcon(new ImageIcon("dame.jpg")); + + } + }); + + //PropertyChangeListener für GUI-Update + bWhite.addPropertyChangeListener("setQueen", new PropertyChangeListener() { + + @Override + public void propertyChange(PropertyChangeEvent e) { + + //if(e.getPropertyName().equals("setQueen")){ + //System.out.println("" + e.getPropertyName()); //Test + //bWhite.setIcon(new ImageIcon("dame.jpg")); + //} +// if(e.getPropertyName().equals("removeQueen")){ +// System.out.println("Änderung"); //Test +// bWhite.setIcon(new ImageIcon("white.jpg")); +// } + + } + }); + playField.add(bWhite); + } + if(colorBlack){ + final JButton bBlack = new JButton(new ImageIcon("black.jpg")); + bBlack.setLocation(i, j); + //ActionListener für Userinteraction + bBlack.addActionListener(new ActionListener() { + + @Override + public void actionPerformed(ActionEvent e) { + bBlack.setIcon(new ImageIcon("dame.jpg")); + + } + }); + + //PropertyChangeListener für GUI-Update + bBlack.addPropertyChangeListener(new PropertyChangeListener() { + + @Override + public void propertyChange(PropertyChangeEvent e) { + + if(e.getPropertyName().equals("setQueen")){ + System.out.println("Änderung"); //Test + //bBlack.setIcon(new ImageIcon("dame.jpg")); + } +// if(e.getPropertyName().equals("removeQueen")){ +// System.out.println("Änderung"); //Test +// bBlack.setIcon(new ImageIcon("black.jpg")); +// } + + } + }); + playField.add(bBlack); + } + + } + colorBlack = !colorBlack; //Farben nach jedem Feld tauschen + colorWhite = !colorWhite; + + } + colorBlack = !colorBlack; //Farben nach jeder Zeile tauschen + colorWhite = !colorWhite; + } + + + + } + + +int counter = 0; + public void repaint(int[] newPos){ +// int i = newPos[0]; +// int j = newPos[1]; +// +// JButton neu = (JButton) playField.getComponentAt(i, j); + + buildPlayField(); + + + + + } + + + +} diff --git a/ss2010/gdi2/p1/Project1/src/queenProblem/Main.java b/ss2010/gdi2/p1/Project1/src/queenProblem/Main.java new file mode 100644 index 00000000..da965048 --- /dev/null +++ b/ss2010/gdi2/p1/Project1/src/queenProblem/Main.java @@ -0,0 +1,155 @@ +/** + * + */ +package queenProblem; + +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; + +import gui.PlayFieldGUI; + + +/** + * provides functionality to interact with QueenProblemSolver + * + * @author Kevin Munk, Jakob Karolus + * @version 1.0 + * + */ +public class Main { + + /** + * initializes the solver, solves the problem and prints a solution + * + * @param args unused + */ + public static void main(String[] args) { + //display the window + //TODO: Start your GUI + + //TODO: Schrittweise Anzeige der Lösung. Hierfür wird ein Timer und ein repaint der GUI benötigt + // + + + boolean[][] playField8 = new boolean[8][8]; + // set the correct values + playField8[3][6] = true; + + + + boolean[][] playField = { {false, false, false, false, false, false, false, false}, + {false, false, false, false, false, false, false, false}, + {false, false, false, false, false, false, false, false}, + {false, false, false, false, false, false, false, false}, + {false, false, false, false, false, false, false, false}, + {false, false, false, false, false, false, false, false}, + {false, false, false, false, false, false, false, false}, + {false, false, false, false, false, false, false, false}, + }; + + + boolean[][] playField4 = { {true, false, false, false, false, false}, + {false, false, false, false, false, false}, + {false, false, false, false, false, false}, + {false, false, false, false, false, false}, + {false, false, false, false, false, false}, + {false, false, false, false, false, false}, + }; + + + boolean[][] playField2 = { {false, false, false, false}, + {false, false, false, false}, + {false, false, false, false}, + {false, false, false, false}, + + }; + + + boolean[][] playField3 = { {false, false}, + {false, false}, + +}; + + //Initial GUI + final PlayFieldGUI gui = new PlayFieldGUI(); + gui.initialsGUI(8, playField); + + //new ProblemSolver + final QueenProblemSolver solver = new QueenProblemSolver(playField, 0); + + solver.setDelay(1); //default delay + + + //delay -> QueenProblemSolver + gui.addPropertyChangeListener(new PropertyChangeListener() { + + @Override + public void propertyChange(PropertyChangeEvent evt) { + if(evt.getPropertyName().equals("newDelay")){ //user delay + solver.setDelay((Integer) evt.getNewValue()); + } + solver.solve(); //start solving + } + }); + + //setQueen -> GUI. Repaint + solver.addPropertyChangeListener(new PropertyChangeListener() { + + @Override + public void propertyChange(PropertyChangeEvent evt) { + if(evt.getPropertyName().equals("setQueen")){ + //repaint button + gui.repaint((int[]) evt.getNewValue()); + } + if(evt.getPropertyName().equals("removeQueen")){ + //repaint button + gui.repaint((int[]) evt.getNewValue()); + + } + + + } + }); + + + for(int i = 0; i < solver.getPlayFieldSize(); i++){ + for(int j = 0; j < solver.getPlayFieldSize(); j++){ + + if(solver.getPlayField()[i][j]){ + System.out.print("X");} + else{ + System.out.print("O"); + } + } + System.out.println(); + } + + +// playField[0][3] = true; +// +// gui.repaint(); + + + + +// QueenProblemSolver solver = new QueenProblemSolver(playField, 0); +// solver.solve(); +// +// +// +// for (int k = 0; k < 8; k++){ +// for(int j = 0; j < 8; j++){ +// +// if(solver.getPlayField()[k][j]) +// System.out.print("O"); +// System.out.print("#"); +// +// } +// System.out.print("\n"); +// } + + + + } + +} diff --git a/ss2010/gdi2/p1/Project1/src/queenProblem/PlayField.java b/ss2010/gdi2/p1/Project1/src/queenProblem/PlayField.java new file mode 100644 index 00000000..6fd7f83a --- /dev/null +++ b/ss2010/gdi2/p1/Project1/src/queenProblem/PlayField.java @@ -0,0 +1,54 @@ +package queenProblem; + + +/** + * class which represents the playField + * + * @author Jakob Karolus, Kevin Munk + * @version 1.0 + * + */ +public class PlayField { + + private boolean[][] playField; + private int playFieldSize; + + /** + * constructor + * + * @param playField + * the playField to set + * @param delay + */ + public PlayField(boolean[][] playField) { + if (playField.length == playField[0].length) { + // Set the playFieldSize + this.playFieldSize = playField.length; + // Initiate the playField + this.playField = playField; + } else { + System.out.println("The Array must be quadratic!"); + } + } + + + //OPTIONAL TODO: Implement auxiliary methods if necessary + + + /** + * Use ONLY to get the field, do not set anything! + * + * @return the playField + */ + protected boolean[][] getPlayField() { + return playField; + } + + /** + * + * @return the playFieldSize + */ + protected int getPlayFieldSize() { + return this.playFieldSize; + } +} diff --git a/ss2010/gdi2/p1/Project1/src/queenProblem/QueenProblemSolver.java b/ss2010/gdi2/p1/Project1/src/queenProblem/QueenProblemSolver.java new file mode 100644 index 00000000..63ae2597 --- /dev/null +++ b/ss2010/gdi2/p1/Project1/src/queenProblem/QueenProblemSolver.java @@ -0,0 +1,376 @@ +package queenProblem; + +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; +import java.util.Timer; +import java.util.TimerTask; + +import javax.swing.SwingWorker; + +import sun.awt.geom.Crossings.EvenOdd; + +/** + * The solver for the QueenProblem. + * + * @author Jakob Karolus, Kevin Munk + * @version 1.0 + * + */ +public class QueenProblemSolver extends SwingWorker { + + private PlayField playField; + private int delay; + + + /** + * Initiates the Solver with the playFieldSize and initiates the playField. + * + * @param playField + * the playField to work on + * @param delay + * the delay between an solver move (should not be under 100 ms) + */ + public QueenProblemSolver(boolean[][] playField, int delay) { + this.playField = new PlayField(playField); + this.delay = delay; + } + + @Override + public Boolean doInBackground() throws Exception { + boolean solved = solve(); + + firePropertyChange("solved", null, solved); + + return solved; + } + + + //Methode nur damit man an Tests nichts ändern muss... + public boolean solve() { + + return solve(0); + } + + + /** + * starts the solve method from the upper left corner. + * + * @return true if the playField could be solved; otherwise false + */ + public boolean solve(int zeile) { + + + boolean alleDamenGesetzt = false; + + //ungerade -> von links nach rechts + if (zeile % 2 == 0) { + + for(int i = 0; i < playField.getPlayFieldSize() - 1; i++){ //iteriert über die Spalten + + if(this.playField.getPlayField()[zeile][i] == true){ //Für schon gesetzte Damen (erweiterte Funktionalität) + if(zeile < playField.getPlayFieldSize() - 1){ + if(solve(zeile + 1) == false){ + //tue nichts + } + else{ + alleDamenGesetzt = true; //liefert nächste Zeile true, so wurden alle Damen gesetzt + } + } + return alleDamenGesetzt; + } + + if(checkField(zeile, i)){ //Darf hier Dame gesetzt werden? + + setQueen(zeile, i); //dann setze sie auch + + if(zeile < playField.getPlayFieldSize() - 1){ + if(solve(zeile + 1) == false){ //prüfe durch rekursion nächste Zeile. Ist Diese nicht lösbar + removeQueen(zeile, i); //und gibt deshalb ein false zurück, so muss die Dame wieder entfernt werden + } + else{ + alleDamenGesetzt = true; //liefert nächste Zeile true, so wurde alle Damen gesetzt + } + } + } + else{ //Zähle nun alle Damen im Array und vergleiche diese mit der Größe des Spielfelds + alleDamenGesetzt = countDamen(); + } + } + + return alleDamenGesetzt; + + } + + + //gerade -> von rechts nach links + else { + + for(int i = playField.getPlayFieldSize() - 1; i > 0; i--){ //iteriert über die Spalten + + if(this.playField.getPlayField()[zeile][i] == true){ //Für schon gesetzte Damen (erweiterte Funktionalität) + if(zeile < playField.getPlayFieldSize() - 1){ + if(solve(zeile + 1) == false){ + //tue nichts + } + else{ + alleDamenGesetzt = true; //liefert nächste Zeile true, so wurden alle Damen gesetzt + } + } + return alleDamenGesetzt; + } + + if(checkField(zeile, i)){ //Darf hier Dame gesetzt werden? + + setQueen(zeile, i); //dann setze sie + + if(zeile < playField.getPlayFieldSize() - 1){ + if(solve(zeile + 1) == false){ //prüfe durch rekursion nächste Zeile. Ist Diese nicht lösbar + removeQueen(zeile, i); //und gibt deshalb ein false zurück, so muss die Dame wieder entfernt werden + } + else{ + alleDamenGesetzt = true; //liefert nächste Zeile true, so wurde alle Damen gesetzt + } + } + } + else{ //Zähle nun alle Damen im Array und vergleiche diese mit der Größe des Spielfelds + alleDamenGesetzt = countDamen(); + } + } + + return alleDamenGesetzt; + + + + } + + } + + + //TODO: Überlegen welche Funktionalitäten man sinnvoll aus Methode solve(int) auslagern kann + + + /** + * + * Rekursiver Aufruf ausgelagert (wird bisher noch nicht benutzt) + * + * @param zeile + * @param i + * @return + */ + public boolean rekursiverAufruf(int zeile, int i){ + boolean alleDamenGesetzt = false; + + if(zeile < playField.getPlayFieldSize() - 1){ + if(solve(zeile + 1) == false){ + this.playField.getPlayField()[zeile][i] = false; + } + else{ + alleDamenGesetzt = true; + } + } + return alleDamenGesetzt; + } + + + + /** + * Checkt, ob aktuelle Anzahl der Damen mit Spielfeldgröße + * übereinstimmt + * + * @return boolean + * + * + */ + public boolean countDamen(){ + int counterDamen = 0; + boolean alleDamenGesetzt = false; + + for (int k = 0; k < playField.getPlayFieldSize(); k++){ + for(int j = 0; j < playField.getPlayFieldSize(); j++){ + + if(playField.getPlayField()[k][j]){ + counterDamen++; + } + + } + } + + if(counterDamen == playField.getPlayFieldSize()){ //Lösen des Spiels erfolgreich + alleDamenGesetzt = true; + } + + if(counterDamen != playField.getPlayFieldSize()){ //Lösen des Spiels erfolglos + alleDamenGesetzt = false; + } + + return alleDamenGesetzt; + } + + + + + /** + * + * Prüft ob Dame in Feld mit angegebener Position gesetzt werden darf + * + * + * @param x + * @param y + * @return + */ + + public boolean checkField(int x, int y){ + + boolean setzerlaubnis = true; + + + + //Spalte prüfen + for(int i = 0; i < playField.getPlayFieldSize() - 1; i++){ + + if(playField.getPlayField()[i][y]){ //Dame in gleicher Spalte gefunden + return false; + } + } + + //Zeile prüfen + for(int i = 0; i < playField.getPlayFieldSize() - 1; i++){ + + if(playField.getPlayField()[x][i]){ //Dame in gleicher Zeile gefunden + return false; + } + } + + + //erste Diagonale prüfen + int zeile1 = x; + int spalte1 = y; + + while(zeile1 != -1 && spalte1 != -1){ + + if(playField.getPlayField()[zeile1][spalte1]){ //Dame in gleicher Diagonalen gefunden + return false; + } + zeile1--; + spalte1--; + } + + zeile1 = x; + spalte1 = y; + + while(zeile1 != playField.getPlayFieldSize() && spalte1 != playField.getPlayFieldSize()){ + + if(playField.getPlayField()[zeile1][spalte1]){ //Dame in gleicher Diagonalen gefunden + return false; + } + zeile1++; + spalte1++; + } + + //TODO: nochmal gedanken über diagonalenprüfung machen. Vll kann man noch + // doppelten code einsparen + + + //zweite Diagonale prüfen + int zeile2 = x; + int spalte2 = y; + + while(zeile2 != -1 && spalte2 != playField.getPlayFieldSize()){ + + if(playField.getPlayField()[zeile2][spalte2]){ //Dame in gleicher Diagonalen gefunden + return false; + } + zeile2--; + spalte2++; + } + + zeile2 = x; + spalte2 = y; + + while(zeile2 != playField.getPlayFieldSize() && spalte2 != -1){ + + if(playField.getPlayField()[zeile2][spalte2]){ //Dame in gleicher Diagonalen gefunden + return false; + } + zeile2++; + spalte2--; + } + + + + return setzerlaubnis; + + + } + + + + /** + * @return the playField + */ + public boolean[][] getPlayField() { + return this.playField.getPlayField(); + } + + + + + + /** + * Sets a queen at the specified position + * + * @param row + * @param column + */ + public void setQueen(final int row, final int column) { + + Timer timer = new Timer(); + TimerTask tk = new TimerTask() { + + @Override + public void run() { + setQueen1(row, column); + //System.out.println("" + delay); + } + }; + + timer.schedule(tk, 0, this.delay); + //this.playField.getPlayField()[row][column] = true; + + //PropertyChangeEvent setQueen = new PropertyChangeEvent(playField, "setQueen", null, null); + //firePropertyChange("setQueen", null, new int[] { row, column }); + } + + public void setQueen1(int row, int column) + { + this.playField.getPlayField()[row][column] = true; + firePropertyChange("setQueen", null, new int[] { row, column }); + } + /** + * + * Entfernt Dame an angegebener Stelle + * + * @param row + * @param column + */ + public void removeQueen(int row, int column){ + + this.playField.getPlayField()[row][column] = false; + firePropertyChange("removeQueen", null, new int[] { row, column }); + + } + + + /** + * @return the playFieldSize + */ + public int getPlayFieldSize() { + return this.playField.getPlayFieldSize(); + } + + + public void setDelay(int delay){ + + this.delay = delay; + } +} diff --git a/ss2010/gdi2/p1/Project1/src/test_public/QueenProblemTest.java b/ss2010/gdi2/p1/Project1/src/test_public/QueenProblemTest.java new file mode 100644 index 00000000..3bbde37e --- /dev/null +++ b/ss2010/gdi2/p1/Project1/src/test_public/QueenProblemTest.java @@ -0,0 +1,147 @@ +package test_public; + +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; + +import queenProblem.QueenProblemSolver; + +/** + * tests the solver for the QueenProblem; these tests are just for basic + * functionality, we strongly advise you to write your own tests! + * + * @author Jakob Karolus, Kevin Munk + * @version 1.0 + * + */ +public class QueenProblemTest { + + private boolean[][] field_2x2; + private boolean[][] field_6x6_withQueen_noSolution; + private boolean[][] field_8x8_withQueen; + private boolean[][] field_15x15; + private QueenProblemSolver solver; + private static double counter; + + /** + * inits the counter + */ + @BeforeClass + public static void init() { + counter = 0; + } + + /** + * 0,5 Points + */ + @Test + public void solve2x2() { + try { + field_2x2 = new boolean[2][2]; + solver = new QueenProblemSolver(field_2x2, 0); + Assert.assertFalse(solver.solve()); + + Assert.assertArrayEquals(new boolean[2][2], solver.getPlayField()); + + // inc counter + counter += 0.5; + } catch (AssertionError e) { + throw e; + } + } + + /** + * 1 Point + */ + @Test + public void solve6x6_noSolution() { + try { + field_6x6_withQueen_noSolution = new boolean[6][6]; + field_6x6_withQueen_noSolution[0][0] = true; + solver = new QueenProblemSolver(field_6x6_withQueen_noSolution, 0); + Assert.assertFalse(solver.solve()); + + boolean[][] expected = new boolean[6][6]; + expected[0][0] = true; + Assert.assertArrayEquals(expected, solver.getPlayField()); + + // inc counter + counter += 1; + } catch (AssertionError e) { + throw e; + } + } + + /** + * 1,5 Points + */ + @Test + public void solve8x8_withQueen() { + try { + field_8x8_withQueen = new boolean[8][8]; + field_8x8_withQueen[3][6] = true; + solver = new QueenProblemSolver(field_8x8_withQueen, 0); + Assert.assertTrue(solver.solve()); + + boolean[][] expected = new boolean[8][8]; + // set the correct values + expected[0][1] = true; + expected[1][5] = true; + expected[2][0] = true; + expected[3][6] = true; + expected[4][3] = true; + expected[5][7] = true; + expected[6][2] = true; + expected[7][4] = true; + Assert.assertArrayEquals(expected, solver.getPlayField()); + + // inc counter + counter += 1.5; + } catch (AssertionError e) { + throw e; + } + } + + /** + * 2 Points + */ + @Test + public void solve15x15() { + try { + field_15x15 = new boolean[15][15]; + solver = new QueenProblemSolver(field_15x15, 0); + Assert.assertTrue(solver.solve()); + + boolean[][] expected = new boolean[15][15]; + // set the correct values + expected[0][0] = true; + expected[1][14] = true; + expected[2][1] = true; + expected[3][13] = true; + expected[4][5] = true; + expected[5][12] = true; + expected[6][8] = true; + expected[7][3] = true; + expected[8][11] = true; + expected[9][4] = true; + expected[10][2] = true; + expected[11][9] = true; + expected[12][6] = true; + expected[13][10] = true; + expected[14][7] = true; + + Assert.assertArrayEquals(expected, solver.getPlayField()); + + // inc counter + counter += 2; + } catch (AssertionError e) { + throw e; + } + } + + @Test + public void getResult() { + System.out.println("Points in public tests: " + counter); + } + +} diff --git a/ss2010/gdi2/p1/Project1/white.jpg b/ss2010/gdi2/p1/Project1/white.jpg new file mode 100644 index 00000000..0838bf94 Binary files /dev/null and b/ss2010/gdi2/p1/Project1/white.jpg differ diff --git a/ss2011/ncs/Ergebnisse/DSCF6572.JPG b/ss2011/ncs/Ergebnisse/DSCF6572.JPG new file mode 100644 index 00000000..5e82cab8 Binary files /dev/null and b/ss2011/ncs/Ergebnisse/DSCF6572.JPG differ diff --git a/ss2011/ncs/Ergebnisse/DSCF6573.JPG b/ss2011/ncs/Ergebnisse/DSCF6573.JPG new file mode 100644 index 00000000..4fa3a279 Binary files /dev/null and b/ss2011/ncs/Ergebnisse/DSCF6573.JPG differ diff --git a/ss2011/ncs/Klausurvorbereitung/HCS Zusammenfassung.pdf b/ss2011/ncs/Klausurvorbereitung/HCS Zusammenfassung.pdf new file mode 100644 index 00000000..36df764b Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/HCS Zusammenfassung.pdf differ diff --git a/ss2011/ncs/Klausurvorbereitung/Klausurinfos.txt b/ss2011/ncs/Klausurvorbereitung/Klausurinfos.txt new file mode 100644 index 00000000..353e66ef --- /dev/null +++ b/ss2011/ncs/Klausurvorbereitung/Klausurinfos.txt @@ -0,0 +1,3 @@ +es sind keine Hilsmittel außer ein nicht-programmierbarer Taschenrechner erlaubt, +Application Layer kommt nicht dran, +die Klausur hat max. das Niveau und den Inhalt der Übungen \ No newline at end of file diff --git a/ss2011/ncs/Klausurvorbereitung/NCS Zusammenfassung.odt b/ss2011/ncs/Klausurvorbereitung/NCS Zusammenfassung.odt new file mode 100644 index 00000000..68642d19 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/NCS Zusammenfassung.odt differ diff --git a/ss2011/ncs/Klausurvorbereitung/Probeklausur/1.jpg b/ss2011/ncs/Klausurvorbereitung/Probeklausur/1.jpg new file mode 100644 index 00000000..0e814487 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/Probeklausur/1.jpg differ diff --git a/ss2011/ncs/Klausurvorbereitung/Probeklausur/10.jpg b/ss2011/ncs/Klausurvorbereitung/Probeklausur/10.jpg new file mode 100644 index 00000000..45ebd0dc Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/Probeklausur/10.jpg differ diff --git a/ss2011/ncs/Klausurvorbereitung/Probeklausur/2.jpg b/ss2011/ncs/Klausurvorbereitung/Probeklausur/2.jpg new file mode 100644 index 00000000..97cde86b Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/Probeklausur/2.jpg differ diff --git a/ss2011/ncs/Klausurvorbereitung/Probeklausur/3.jpg b/ss2011/ncs/Klausurvorbereitung/Probeklausur/3.jpg new file mode 100644 index 00000000..27736049 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/Probeklausur/3.jpg differ diff --git a/ss2011/ncs/Klausurvorbereitung/Probeklausur/4.jpg b/ss2011/ncs/Klausurvorbereitung/Probeklausur/4.jpg new file mode 100644 index 00000000..79786389 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/Probeklausur/4.jpg differ diff --git a/ss2011/ncs/Klausurvorbereitung/Probeklausur/5.jpg b/ss2011/ncs/Klausurvorbereitung/Probeklausur/5.jpg new file mode 100644 index 00000000..02e21d5d Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/Probeklausur/5.jpg differ diff --git a/ss2011/ncs/Klausurvorbereitung/Probeklausur/6.jpg b/ss2011/ncs/Klausurvorbereitung/Probeklausur/6.jpg new file mode 100644 index 00000000..4f9ef549 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/Probeklausur/6.jpg differ diff --git a/ss2011/ncs/Klausurvorbereitung/Probeklausur/7.jpg b/ss2011/ncs/Klausurvorbereitung/Probeklausur/7.jpg new file mode 100644 index 00000000..6df3e77f Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/Probeklausur/7.jpg differ diff --git a/ss2011/ncs/Klausurvorbereitung/Probeklausur/8.jpg b/ss2011/ncs/Klausurvorbereitung/Probeklausur/8.jpg new file mode 100644 index 00000000..90207044 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/Probeklausur/8.jpg differ diff --git a/ss2011/ncs/Klausurvorbereitung/Probeklausur/9.jpg b/ss2011/ncs/Klausurvorbereitung/Probeklausur/9.jpg new file mode 100644 index 00000000..d1a0eb26 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/Probeklausur/9.jpg differ diff --git a/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E01_NCS_OSI.pdf b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E01_NCS_OSI.pdf new file mode 100644 index 00000000..d11d0737 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E01_NCS_OSI.pdf differ diff --git a/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E02_NCS_Queuing.pdf b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E02_NCS_Queuing.pdf new file mode 100644 index 00000000..7fffb304 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E02_NCS_Queuing.pdf differ diff --git a/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E03_NCS_Graph_Theory.pdf b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E03_NCS_Graph_Theory.pdf new file mode 100644 index 00000000..6e012e71 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E03_NCS_Graph_Theory.pdf differ diff --git a/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E04_NCS_Routing_I.pdf b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E04_NCS_Routing_I.pdf new file mode 100644 index 00000000..5c1c8223 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E04_NCS_Routing_I.pdf differ diff --git a/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E05_NCS_Routing_II.pdf b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E05_NCS_Routing_II.pdf new file mode 100644 index 00000000..ea4f1ad7 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E05_NCS_Routing_II.pdf differ diff --git a/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E06_NCS_Recap.pdf b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E06_NCS_Recap.pdf new file mode 100644 index 00000000..82809229 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E06_NCS_Recap.pdf differ diff --git a/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E07_NCS_IP.pdf b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E07_NCS_IP.pdf new file mode 100644 index 00000000..aca958e3 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E07_NCS_IP.pdf differ diff --git a/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E08_NCS_IP_Multicast.pdf b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E08_NCS_IP_Multicast.pdf new file mode 100644 index 00000000..2b7288a8 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E08_NCS_IP_Multicast.pdf differ diff --git a/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E10_NCS_TCP_II.pdf b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E10_NCS_TCP_II.pdf new file mode 100644 index 00000000..7e6ec194 Binary files /dev/null and b/ss2011/ncs/Klausurvorbereitung/verschiedene Aufgaben mit Lösung/E10_NCS_TCP_II.pdf differ diff --git a/ss2011/ncs/u1/Exercise_1_-_Graph_Theory.pdf b/ss2011/ncs/u1/Exercise_1_-_Graph_Theory.pdf new file mode 100644 index 00000000..3c62ffb9 Binary files /dev/null and b/ss2011/ncs/u1/Exercise_1_-_Graph_Theory.pdf differ diff --git a/ss2011/ncs/u1/solution.odt b/ss2011/ncs/u1/solution.odt new file mode 100644 index 00000000..9ceaac3e Binary files /dev/null and b/ss2011/ncs/u1/solution.odt differ diff --git a/ss2011/ncs/u2/Exercise_2.pdf b/ss2011/ncs/u2/Exercise_2.pdf new file mode 100644 index 00000000..1ad255f7 Binary files /dev/null and b/ss2011/ncs/u2/Exercise_2.pdf differ diff --git a/ss2011/ncs/u3/Exercise_3.odt b/ss2011/ncs/u3/Exercise_3.odt new file mode 100644 index 00000000..e422572f Binary files /dev/null and b/ss2011/ncs/u3/Exercise_3.odt differ diff --git a/ss2011/ncs/u3/Exercise_3.pdf b/ss2011/ncs/u3/Exercise_3.pdf new file mode 100644 index 00000000..745892bd Binary files /dev/null and b/ss2011/ncs/u3/Exercise_3.pdf differ diff --git a/ss2011/ncs/u6/Exercise_6.pdf b/ss2011/ncs/u6/Exercise_6.pdf new file mode 100644 index 00000000..d792f116 Binary files /dev/null and b/ss2011/ncs/u6/Exercise_6.pdf differ diff --git a/ss2011/ncs/u6/a1_d.jpg b/ss2011/ncs/u6/a1_d.jpg new file mode 100644 index 00000000..4d9caae9 Binary files /dev/null and b/ss2011/ncs/u6/a1_d.jpg differ diff --git a/ss2011/ncs/u6/a1_d.vsd b/ss2011/ncs/u6/a1_d.vsd new file mode 100644 index 00000000..fc14c4ec Binary files /dev/null and b/ss2011/ncs/u6/a1_d.vsd differ diff --git a/ss2011/ncs/u6/ncs_10.6.txt b/ss2011/ncs/u6/ncs_10.6.txt new file mode 100644 index 00000000..f1ec38c2 --- /dev/null +++ b/ss2011/ncs/u6/ncs_10.6.txt @@ -0,0 +1,19 @@ +6.1 + + a) Wenn es viele Veränderungen in der Routingtabelle gibt und die Routingtabelle oft oder + regelmäßig aktualisiert werden muss, empfiehlt es sich, ein Link-State-Routingprotokoll + zu verwenden. Dabei werden nur die jeweiligen Änderungen unter den Routern ausgetauscht. + Beim Link-State-Routing werden bei Änderungen im Netzwerk sogenannte LSA + (Link-State-Announcement/Advertisements) per Flooding an alle benachbarten Router geschickt. + In der Topologiedatenbank jedes Routers wird auf Basis der empfangenen LSAs die gesamte + Topologie des Netzwerks generiert. Da die Änderungen verbindungsorientiert an die + benachbarten Router propagiert werden, besitzen Routing-Protokolle mit dem LSA eine + gute Konvergenz. + + Der Link-State-Algorithmus ist die praktische Umsetzung des mathematischen Dijkstra-Algorithmus. + + ->Nodes informed: Änderungen im Netzwerk ... per Flooding an alle benachbarten Router geschickt. + ->Algorithm: Link-State-Algorithmus ist die praktische Umsetzung des mathematischen + Dijkstra-Algorithmus. -> Folien + + b) \ No newline at end of file diff --git a/ss2011/ncs/u6/solution.odt b/ss2011/ncs/u6/solution.odt new file mode 100644 index 00000000..b8025cb1 Binary files /dev/null and b/ss2011/ncs/u6/solution.odt differ diff --git a/ss2011/ncs/u9/Exercise_9.pdf b/ss2011/ncs/u9/Exercise_9.pdf new file mode 100644 index 00000000..a0f256ab Binary files /dev/null and b/ss2011/ncs/u9/Exercise_9.pdf differ diff --git a/ss2011/ncs/u9/solution.odt b/ss2011/ncs/u9/solution.odt new file mode 100644 index 00000000..bd8097c4 Binary files /dev/null and b/ss2011/ncs/u9/solution.odt differ