[QUIZ#1] Tyler-Durden (Java)

Tyler-Durden

Grünschnabel
Benutzung des Programms über Kommandozeile:

(CLASSPATH muss auf das Verzeichnis mit der Klasse Search verweisen)
java Search <Datei> <Such-String>

Die Datei kann mit relativem oder absolutem Pfad angegeben werden.



Die grobe Vorgehensweise ist im Quelltext kommentiert:

Java:
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.Vector;

public class Search {

	public static void main(String[] args) {

		/*
		 * Hier wird die Datei, die im gleichen Verzeichnis wie die Klasse
		 * "Search" ist ausfindig gemacht. Leerzeichen im Pfadnamen (Windows)
		 * tauchen als "%20" auf und werden durch ein Leerzeichen ersetzt.
		 */

		if (args.length < 2) {
			System.out.println("Usage: Search <FILE> <SEARCH-STRING>");
			System.exit(0);
		}

		/*
		 * Benutzereingaben checken (relativer Pfad zur Datei oder absoluter)
		 */
		URL url = Search.class.getResource(args[0]);
		String path = "";
		try {
			path = url.getPath();
		} catch (NullPointerException ex) {
			path = args[0];
		}
		path = path.replace("%20", " ");
		File file = new File(path);

		/*
		 * Vektoren:
		 * strings --> eingelesene Wörter/Namen
		 * locations --> wird im Algorithmus verwendet um Positionen
		 * 				 zu speichern, wo ein Zeichen gefunden wurde
		 */
		Vector<String> strings = new Vector<String>();
		Vector<Integer> locations = new Vector<Integer>();
		String searchString = "";

		/*
		 * Einlesen der Datei mit Hilfe von BufferedReader
		 */
		BufferedReader reader = null;
		try {

			reader = new BufferedReader(new InputStreamReader(
					new FileInputStream(file)));

		} catch (FileNotFoundException e) {
			System.out.println("Could not find File " + file.getName());
			e.printStackTrace();
		}

		try {

			String str = null;
			while ((str = reader.readLine()) != null) {
				strings.add(str);
			}

		} catch (IOException e) {
			System.out.println("Could not read from File " + file.getName());
			e.printStackTrace();
		}

		/*
		 * Die Eingaben vom Benutzer (der Such-String) wird gespeichert
		 */

		for (int i = 1; i < args.length; i++) {
			searchString += args[i];
		}

		// s ist immer ein Wort aus der Liste der Datei. z.B. "Woodrow Wilson"
		for (String s : strings) {

			/*
			 * Hier kommt der eigentliche Algorithmus:
			 * 
			 * - der Such-String wird Zeichenweise durchlaufen
			 * 
			 * - wenn das Zeichen aus dem Such-String im Wort vorkommt, wird die
			 * Position in einem Vector(hier: locations) gespeichert
			 * 
			 * - sind alle Positionen gespeichert, wird das Wort durchlaufen und
			 * immer an den Positionen geteilt und entweder "<" und ">"
			 * eingefügt oder nur "<" oder nur ">"
			 * 
			 * - jedes Mal wenn Klammern eingefügt werden, werden auch die
			 * Positionen im Vector (hier: locations) verschoben
			 * 
			 * - wenn alle Klammern eingefügt sind wird der gefundene String mit
			 * geklammerten Stellen ausgegeben
			 */

			int y = 0;
			for (int i = 0; i < searchString.length(); i++) {

				char chr = searchString.charAt(i);
				boolean found = false;

				for (int n = y; n < s.length(); n++) {
					if (chr == s.charAt(n)) {
						found = true;
						locations.add(n);
						y = n + 1;
						break;
					}
				}

				if (!found) {
					break;
				}

				if (i == searchString.length() - 1) {

					for (int a = 0; a < s.length(); a++) {

						if (locations.contains(a)) {

							String part1 = s.substring(0, a);
							String part2 = s.substring(a + 1, s.length());

							if (locations.contains(a - 1)
									&& locations.contains(a + 1)) {

								s = part1 + s.charAt(a) + part2;

							} else if (!locations.contains(a - 1)
									&& !locations.contains(a + 1)) {

								s = part1 + "<" + s.charAt(a) + ">" + part2;

								for (int x = 0; x < locations.size(); x++) {
									int b;
									if ((b = locations.get(x)) == a) {
										locations.set(x, b + 1);

									} else if ((b = locations.get(x)) > a) {
										locations.set(x, b + 2);
									}

								}
								a++;

							} else if (!locations.contains(a - 1)) {
								s = part1 + "<" + s.charAt(a) + part2;

								for (int x = 0; x < locations.size(); x++) {
									int b;
									if ((b = locations.get(x)) >= a) {
										locations.set(x, b + 1);
									}

								}
								a++;

							} else if (!locations.contains(a + 1)) {

								s = part1 + s.charAt(a) + ">" + part2;

								for (int x = 0; x < locations.size(); x++) {
									int b;
									if ((b = locations.get(x)) > a) {
										locations.set(x, b + 1);
									}

								}

							}
							
						}

					}
					System.out.println(s);
				}
			}
			locations.clear();
		}

	}
}
 

Anhänge

  • Search.zip
    5,9 KB · Aufrufe: 26
Zuletzt bearbeitet:

Denfie

Mitglied
Eine recht aufwendige Lösung. Hätte zwar selber keine Vectoren-Map genommen aber ich lass mich gerne anregen.

Hab mir mal dein Anhängsel gezogen und werd mich nochmal ganz genau mit deiner Lösung beschäftigen. ;)
 

Tyler-Durden

Grünschnabel
Jo find ich gut, dass du vor hast dich mal näher damit zu beschäftigen.

Schon mal sorry im Vorraus wegen den schlecht benannten Variablen :p und man hätte sicher einiges kürzen können aber bin froh dass es einwandfrei läuft! :)

Wenn dir negatives auffällt dann nix wie raus bin dankbar für sinnvolle Kritik ...
 

Neue Beiträge