ncs

ss2010/gdi2/p1/Project1/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

ss2010/gdi2/p1/Project1/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Project1</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

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();
+		
+		
+		
+		
+	}
+	
+
+
+}

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");
+//		}
+		
+		
+		
+	}
+
+}

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;
+	}
+}

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<Boolean, int[]> {
+
+	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;
+	}
+}

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);
+	}
+
+}

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

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)