Texte vergleichen

Finde den Unterschied zwischen zwei Textdateien

Live-Editor

Gleiches ausblenden

Zeilenumbruch aus

Ansicht

Vergleichsgenauigkeit

Syntaxhervorhebung

Diffchecker Desktop Der sicherste Weg, Diffchecker zu nutzen. Hol dir die Desktop-App: Deine Diffs verlassen nie deinen Computer!Desktop holen

Untitled diff

Erstellt vor 11 JahrenDiff läuft nie ab

8 Entfernungen

Zeilen
Gesamt
Entfernt

Zeichen
Gesamt
Entfernt

Um diese Funktion weiterhin zu nutzen, aktualisiere auf Diffchecker Pro Preise anzeigen

215 Zeilen

0 Hinzufügungen

Zeilen
Gesamt
Hinzugefügt

Zeichen
Gesamt
Hinzugefügt

Um diese Funktion weiterhin zu nutzen, aktualisiere auf Diffchecker Pro Preise anzeigen

210 Zeilen

import java.io.*;

import java.util.*;

import java.math.*;

public class TicTac implements Runnable {

private static BufferedReader in;

private static PrintWriter out;

private static StringTokenizer st;

private static Random rnd;

static class Pair {

final int x, y;

public Pair(int x, int y) {

this.x = x;

this.y = y;

}

private void solve() throws IOException {

while (true) {

char[][] field = readField();

if (isOver(field))

break;

if (!isEmpty(field))

throw new AssertionError();

field[1][1] = 'x';

printField(field);

field = readField();

Pair corner = selectCorner(field);

field[corner.x][corner.y] = 'x';

printField(field);

field = readField();

Pair opposite = new Pair(2 - corner.x, 2 - corner.y);

if (field[opposite.x][opposite.y] == '.') {

field[opposite.x][opposite.y] = 'x';

printField(field);

continue;

}

Pair support = selectSupport(field);

field[support.x][support.y] = 'x';

printField(field);

field = readField();

Pair last = selectLast(field);

field[last.x][last.y] = 'x';

printField(field);

}

private boolean isEmpty(char[][] field) {

for (int i = 0; i <= 2; i++)

for (int j = 0; j <= 2; j++)

if (field[i][j] != '.')

return false;

return true;

}

private Pair selectLast(char[][] field) {

for (int x0 = 0; x0 <= 2; x0++) {

for (int y0 = 0; y0 <= 2; y0++) {

for (int x1 = 0; x1 <= 2; x1++) {

for (int y1 = 0; y1 <= 2; y1++) {

int dx = x1 - x0;

int dy = y1 - y0;

if (Math.abs(dx) + Math.abs(dy) == 0)

continue;

if (Math.abs(dx) > 1 || Math.abs(dy) > 1)

continue;

if (field[x0][y0] != 'x')

continue;

if (field[x1][y1] != 'x')

continue;

int x2 = x1 + dx, y2 = y1 + dy;

if (x2 >= 0 && x2 <= 2 && y2 >= 0 && y2 <= 2 && field[x2][y2] == '.') {

return new Pair(x2, y2);

}

throw new AssertionError();

}

private Pair selectSupport(char[][] field) {

for (int x = 0; x <= 2; x++) {

for (int y = 0; y <= 2; y++) {

if ((x + y) % 2 == 1 && field[x][y] == '.') {

field[x][y] = 'x';

int ways = calcWays(field);

if (ways >= 2) {

return new Pair(x, y);

}

field[x][y] = '.';

}

throw new AssertionError();

}

private int calcWays(char[][] field) {

boolean[][] used = new boolean[3][3];

for (int x0 = 0; x0 <= 2; x0++) {

for (int y0 = 0; y0 <= 2; y0++) {

for (int x1 = 0; x1 <= 2; x1++) {

for (int y1 = 0; y1 <= 2; y1++) {

int dx = x1 - x0;

int dy = y1 - y0;

if (Math.abs(dx) + Math.abs(dy) == 0)

continue;

if (Math.abs(dx) > 1 || Math.abs(dy) > 1)

continue;

if (field[x0][y0] != 'x')

continue;

if (field[x1][y1] != 'x')

continue;

int x2 = x1 + dx, y2 = y1 + dy;

if (x2 >= 0 && x2 <= 2 && y2 >= 0 && y2 <= 2 && field[x2][y2] == '.') {

used[x2][y2] = true;

}

int res = 0;

for (int i = 0; i <= 2; i++)

for (int j = 0; j <= 2; j++)

if (used[i][j])

++res;

return res;

}

private Pair selectCorner(char[][] field) {

int[] xs = { 0, 2 }, ys = { 0, 2 };

for (int x : xs)

for (int y : ys) {

if (field[x][y] == '.')

return new Pair(x, y);

}

throw new AssertionError();

}

private void printField(char[][] field) {

for (int i = 0; i < 3; i++)

out.println(new String(field[i]));

out.flush();

}

private char[][] readField() throws IOException {

char[][] result = new char[3][];

for (int i = 0; i < 3; i++)

result[i] = nextToken().toCharArray();

return result;

}

private boolean isOver(char[][] field) {

for (int i = 0; i <= 2; i++)

for (int j = 0; j <= 2; j++)

if (field[i][j] != 'x')

return false;

return true;

}

public static void main(String[] args) {

new TicTac().run();

}

public void run() {

final String className = this.getClass().getName().toLowerCase();

try {

in = new BufferedReader(new InputStreamReader(System.in));

in = new BufferedReader(new FileReader("input.txt"));

out = new PrintWriter(System.out);

out = new PrintWriter(new FileWriter("output.txt"));

} catch (FileNotFoundException e) {

in = new BufferedReader(new InputStreamReader(System.in));

out = new PrintWriter(System.out);

}

rnd = new Random();

solve();

out.close();

} catch (IOException e) {

e.printStackTrace();

System.exit(1);

}

private String nextToken() throws IOException {

while (st == null || !st.hasMoreTokens()) {

String line = in.readLine();

if (line == null)

return null;

st = new StringTokenizer(line);

}

return st.nextToken();

}

private int nextInt() throws IOException {

return Integer.parseInt(nextToken());

}

private long nextLong() throws IOException {

return Long.parseLong(nextToken());

}

private double nextDouble() throws IOException {

return Double.parseDouble(nextToken());

}

Gespeicherte Diffs

Originaltext

Datei öffnen

import java.io.*;
import java.util.*;
import java.math.*;

public class TicTac implements Runnable {
	private static BufferedReader in;
	private static PrintWriter out;
	private static StringTokenizer st;
	private static Random rnd;

static class Pair {
		final int x, y;

public Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}

}

private void solve() throws IOException {
		while (true) {
			char[][] field = readField();
			if (isOver(field))
				break;
			if (!isEmpty(field))
				throw new AssertionError();
			field[1][1] = 'x';
			printField(field);
			field = readField();
			Pair corner = selectCorner(field);
			field[corner.x][corner.y] = 'x';
			printField(field);
			field = readField();
			Pair opposite = new Pair(2 - corner.x, 2 - corner.y);
			if (field[opposite.x][opposite.y] == '.') {
				field[opposite.x][opposite.y] = 'x';
				printField(field);
				continue;
			}
			Pair support = selectSupport(field);
			field[support.x][support.y] = 'x';
			printField(field);
			field = readField();
			Pair last = selectLast(field);
			field[last.x][last.y] = 'x';
			printField(field);
		}
	}

private boolean isEmpty(char[][] field) {
		for (int i = 0; i <= 2; i++)
			for (int j = 0; j <= 2; j++)
				if (field[i][j] != '.')
					return false;
		return true;
	}

private Pair selectLast(char[][] field) {
		for (int x0 = 0; x0 <= 2; x0++) {
			for (int y0 = 0; y0 <= 2; y0++) {
				for (int x1 = 0; x1 <= 2; x1++) {
					for (int y1 = 0; y1 <= 2; y1++) {
						int dx = x1 - x0;
						int dy = y1 - y0;
						if (Math.abs(dx) + Math.abs(dy) == 0)
							continue;
						if (Math.abs(dx) > 1 || Math.abs(dy) > 1)
							continue;
						if (field[x0][y0] != 'x')
							continue;
						if (field[x1][y1] != 'x')
							continue;
						int x2 = x1 + dx, y2 = y1 + dy;
						if (x2 >= 0 && x2 <= 2 && y2 >= 0 && y2 <= 2 && field[x2][y2] == '.') {
							return new Pair(x2, y2);
						}
					}
				}
			}
		}
		throw new AssertionError();
	}

private Pair selectSupport(char[][] field) {
		for (int x = 0; x <= 2; x++) {
			for (int y = 0; y <= 2; y++) {
				if ((x + y) % 2 == 1 && field[x][y] == '.') {
					field[x][y] = 'x';
					int ways = calcWays(field);
					if (ways >= 2) {
						return new Pair(x, y);
					}
					field[x][y] = '.';
				}
			}
		}
		throw new AssertionError();
	}

private int calcWays(char[][] field) {
		boolean[][] used = new boolean[3][3];
		for (int x0 = 0; x0 <= 2; x0++) {
			for (int y0 = 0; y0 <= 2; y0++) {
				for (int x1 = 0; x1 <= 2; x1++) {
					for (int y1 = 0; y1 <= 2; y1++) {
						int dx = x1 - x0;
						int dy = y1 - y0;
						if (Math.abs(dx) + Math.abs(dy) == 0)
							continue;
						if (Math.abs(dx) > 1 || Math.abs(dy) > 1)
							continue;
						if (field[x0][y0] != 'x')
							continue;
						if (field[x1][y1] != 'x')
							continue;
						int x2 = x1 + dx, y2 = y1 + dy;
						if (x2 >= 0 && x2 <= 2 && y2 >= 0 && y2 <= 2 && field[x2][y2] == '.') {
							used[x2][y2] = true;
						}
					}
				}
			}
		}
		int res = 0;
		for (int i = 0; i <= 2; i++)
			for (int j = 0; j <= 2; j++)
				if (used[i][j])
					++res;
		return res;
	}

private Pair selectCorner(char[][] field) {
		int[] xs = { 0, 2 }, ys = { 0, 2 };
		for (int x : xs)
			for (int y : ys) {
				if (field[x][y] == '.')
					return new Pair(x, y);
			}
		throw new AssertionError();
	}

private void printField(char[][] field) {
		for (int i = 0; i < 3; i++)
			out.println(new String(field[i]));
		out.flush();
	}

private char[][] readField() throws IOException {
		char[][] result = new char[3][];
		for (int i = 0; i < 3; i++)
			result[i] = nextToken().toCharArray();
		return result;
	}

private boolean isOver(char[][] field) {
		for (int i = 0; i <= 2; i++)
			for (int j = 0; j <= 2; j++)
				if (field[i][j] != 'x')
					return false;
		return true;
	}

public static void main(String[] args) {
		new TicTac().run();
	}

public void run() {
		final String className = this.getClass().getName().toLowerCase();

try {
			try {
				in = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter(new FileWriter("output.txt"));
			} catch (FileNotFoundException e) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			}

rnd = new Random();

solve();

out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

private String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			String line = in.readLine();

if (line == null)
				return null;

st = new StringTokenizer(line);
		}

return st.nextToken();
	}

private int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

private long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

private double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
}

Bearbeitung

Datei öffnen

import java.io.*;
import java.util.*;
import java.math.*;

public class TicTac implements Runnable {
	private static BufferedReader in;
	private static PrintWriter out;
	private static StringTokenizer st;
	private static Random rnd;

static class Pair {
		final int x, y;

public Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}

}

private boolean isEmpty(char[][] field) {
		for (int i = 0; i <= 2; i++)
			for (int j = 0; j <= 2; j++)
				if (field[i][j] != '.')
					return false;
		return true;
	}

private void printField(char[][] field) {
		for (int i = 0; i < 3; i++)
			out.println(new String(field[i]));
		out.flush();
	}

private char[][] readField() throws IOException {
		char[][] result = new char[3][];
		for (int i = 0; i < 3; i++)
			result[i] = nextToken().toCharArray();
		return result;
	}

private boolean isOver(char[][] field) {
		for (int i = 0; i <= 2; i++)
			for (int j = 0; j <= 2; j++)
				if (field[i][j] != 'x')
					return false;
		return true;
	}

public static void main(String[] args) {
		new TicTac().run();
	}

public void run() {
		final String className = this.getClass().getName().toLowerCase();

try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);

rnd = new Random();

solve();

out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

private String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			String line = in.readLine();

if (line == null)
				return null;

st = new StringTokenizer(line);
		}

return st.nextToken();
	}

private int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

private long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

private double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
}