Erste Schritte Klausur Schrittweise Verfeinerung und Unterprgramme

[JuliaT]

Hi,

ich habe Informatik als Nebenfach belegt und bin vollkommen neu in der Thematik. Ich habe im letzten Semester leider wegen eines Unfalls sehr viel verpasst und bin dann auch direkt in der Klausur durchgefallen.

Wir durften die Klausur aber mitnehmen und nun versuche ich mich sehr intensiv damit auseinanderzusetzen. Da ich leider keine Loesungen habe und meine Freundin auch durchgefallen ist, ist es allerdings sehr schwer.

Ich hoffe das ich hier vielleicht etwas Hilfe finde.

Im Anhang habe ich die Fragen und meine bestmoeglichen Loesungen zu der ersten Aufgabe abfotografiert. Es waere klasse wenn mal jemand druebersehen koennte, da es mir sehr sehr schwer fiel.

Grundsaetzlich faende ich es auch toll wenn jemand mir diese 90 Minuten Einsteigerklausur komplett loesen koennte. Dafuer wuerde ich natuerlich auch bezahlen. Dann haette ich die richtigen Ergebnisse wenigstens immer gleich zur Hand und koennte waehrend ich es mache schonmal reinschauen. Falls ihr daran Interesse habt, koennt ihr mir gerne eine Nachricht schreiben, wieviel ihr dafuer haben wollen wuerdet.

Liebe Gruesse
Julia

 

[kneitzel]

Also ich weiss jetzt nicht ganz genau, was da jeweils verlangt wird. Aber Java Code habe ich einmal erstellt und das ist, was ich Dir hier erst einmal zur Verfügung stellen kann.

Aber es ist wohl deutlich mehr an Informationen gewünscht.

import java.util.Scanner;

/**
* Klasse die zeigt, wie man einen Teilstring finden kann.
*
* Vorgabe:
* - Gesamtstring wird von links nach rechts durchsucht
* - nur String.length, String.charAt, String.equals sowie Anlegen und Zuweisen von Zeichenketten ist erlaubt.
*
* Scanner benutzt um ein eigenes readString zu schreiben - dürfte als Library vorliegen!
*/
public class TeilstringFinden {
    /**
     * Scanner object on System.in to get input.
     */
    private static Scanner scanner = new Scanner(System.in);

    /**
     * Read a new string from System.in
     * @return The string the user typed in.
     */
    public static String readString() {
        return scanner.nextLine();
    }

    /**
     * Finden das letzte Vorkommen des Teilsteings.
     *
     * Es wrird von jedem Zeichen an geschaut, ob der Teilstring gefunden wird.
     * Es wird dabei nur so lange geprüft, bis die restlichen Zeichen kleiner sind als die Länge des Teilstrings.
     * @param gesamtString Gesamter String
     * @param teilString Teilstring.
     * @return Position des letzten Vorkommens oder -1 wenn kein Vorkommen gefunden wurde.
     */
    public static int findLastSubstring(String gesamtString, String teilString) {
        int lastPosition = -1;
        for (int position = 0; position < gesamtString.length() - teilString.length() + 1; position++) {
            if (substringMatches(gesamtString, teilString, position)) {
                lastPosition = position;
            }
        }
        return lastPosition;
    }

    /**
     * Check if the substring matches.
     *
     * Vergleicht der Reihe nach alle Zeichen des Teilstrings mit den Zeichen im Gesamtstring.
     * Sobald ein Zeichen nicht überein stimmt, wird false zurück gegeben.
     * Wurde der ganze teilstring erfolgreich geprüft, wird true zurück gegeben.
     * @param gesamtString Gesamter string.
     * @param teilString Teilstring.
     * @param startPosition Startposition im Gesamtstring.
     * @return true wenn Teilstring an der angegebenen Position gefunden wurde.
     */
    public static boolean substringMatches(String gesamtString, String teilString, int startPosition) {
        for (int position=0; position < teilString.length(); position++) {
            if (gesamtString.charAt(startPosition + position) != teilString.charAt(position)) {
                return false;
            }
        }
        return true;
    }

    /**
     * Hauptprogramm.
     * @param args Kommandozeilen-Argumente - nicht benutzt.
     */
    public static void main(String[] args) {

        System.out.println(findLastSubstring("abcabcabc", "abc"));
        System.out.println(findLastSubstring("abcdabcabc", "abcd"));
        System.out.println(findLastSubstring("abcabcabc", "abce"));


        String gesamtString = readString();
        String teilString = readString();
        System.out.println(findLastSubstring(gesamtString, teilString));

    }
}

Ich hoffe, dass Dir dies etwas hilft. Bei Fragen wie man auf das Eine oder Andere kommt, werde ich Dir auch gerne weiterhelfen.

 

[Flown]

Also ich hab mich mal auf die andere Aufgabe konzentriert, da ich die erste Aufgabe nicht ganz verstehe, da wir ja nicht wissen, wie "Verfeinerungen" durchzuführen sind.

Eine leichte Variante:

import java.util.Scanner;

public class Test {
  
  public static void main(String... args) {
    write(sum());
  }
  
  /**
   * Summiert zehn vom Benutzer eingegebene {@code int} nach folgenden Regeln:
   * <ul>
   * <li>bei gerader Iteration wird die Eingabe addiert</li>
   * <li>bei ungerader Iteration wird die Eingabe subtrahiert</li>
   * </ul>
   * 
   * @return Ganzzahlige Summe unter Berücksichtigung gegebener Regeln
   */
  public static int sum() {
    return sum(0, 10, 0);
  }
  
  private static int sum(int index, int fence, int sum) {
    if (index < fence) {
      if (index % 2 == 0) {
        return sum(index + 1, fence, sum + readInt());
      } else {
        return sum(index + 1, fence, sum - readInt());
      }
    } else {
      return sum;
    }
  }
  
  /*
   * Utility Section
   */
  private static final Scanner SCANNER = new Scanner(System.in);
  
  private static int readInt() {
    return SCANNER.nextInt();
  }
  
  private static void write(int sum) {
    System.out.println(sum);
  }
  
}

Etwas anspruchsvoller:

import java.util.Scanner;

public class Test {
 
  public static void main(String... args) {
    write(sum());
  }
 
  /**
   * Summiert zehn vom Benutzer eingegebene {@code int} nach folgenden Regeln:
   * <ul>
   * <li>bei gerader Iteration wird die Eingabe addiert</li>
   * <li>bei ungerader Iteration wird die Eingabe subtrahiert</li>
   * </ul>
   *
   * @return Ganzzahlige Summe unter Berücksichtigung gegebener Regeln
   */
  public static int sum() {
    return sum(0, 10, 1, 0);
  }
 
  private static int sum(int index, int fence, int signum, int sum) {
    return index < fence ? sum(index + 1, fence, signum * -1, sum + signum * readInt()) : sum;
  }
 
  /*
   * Utility Section
   */
  private static final Scanner SCANNER = new Scanner(System.in);
 
  private static int readInt() {
    return SCANNER.nextInt();
  }
 
  private static void write(int sum) {
    System.out.println(sum);
  }
 
}

 

[JuliaT]

Vielen dank fuer deine Antwort kneitzel. Bin das gerade mal komplett durchgegangen. Kann es zwar nachvollziehen, aber da liegen ja wirklich Welten zwischen deiner und meiner Loesung. Glaube nicht, dass ich das ganz auf mich alleine gestellt, so hinbekommen wuerde... Du kommst nicht zufaellig aus der Naehe von Hannover?

 

[kneitzel]

Es ist klar, dass sowas am Anfang schwer fällt. Hier wäre meine Empfehlung, es immer schrittweise zu machen.

Also in diesem Fall geht es ja um die Funktion findLastSubstring(gesamtString, teilString).
Wenn Du so etwas schreiben musst, dann gehst Du hin und schreibst es erst einmal ganz allgemein auf. Also wenn ich eine erste Version schreiben müsste, wäre der Anfang folgender:

public static int findLastSubstring(String gesamtString, String teilString){
  // Beschreibung
}

Und nun wird Beschreibung verfeinert. Was könntest Du denn da machen?
Also von mir aus:

// Position auf Anfang
// Solange Position nicht am Ende angekommen:
// - prüfe, ob der Teilstring an dieser Stelle im Gesamtstring ist.
// - --> Wenn ja, dann merke Dir diese Position!
// Gib gemerkte Position zurück

Das kann man dann entweder:
a) in Java Code umschreiben (also z.B. durch ein int pos = 0; für // Position auf Anfang)
b) in eine Funktion auslagern
c) eine Mischung aus beidem (if (prüfeTeilstringInGesamtStringAnPosition(....))

Dabei darauf achten, dass die Funktionen immer klein und übersichtlich bleiben. Also keine komplexen Algorithmen schreiben, die dann Probleme mit sich bringen, sondern dann einfach immer Funktionen einführen.

Das ist eine Taktik mit der man relativ gut fährt und die auch am ehesten der Praxis entspricht. Ok, so Kommentare schreibt man nicht wirklich, aber man nutzt dann schnell Funktionen, die man noch schreiben muss, nur um es möglichst einfach und übersichtlich zu halten.

Das scheint aber nicht wirklich der in der Klausur geforderte Ansatz zu sein, denn da habe ich es so verstanden, dass da neue Unterfunktionen gewünscht werden. Kann aber auch an mir liegen und es wurde im ersten Schritt gar kein Java Code erwartet sondern lediglich eine Verfeinerung von einem sprachlich dargestellten Algorithmus? Sorry, das war leider ein Teil der Aufgabe, die ich so nicht wirklich verstanden habe, was da gewünscht ist vom Lehrer.

 

[JuliaT]

Hi Flown,
vielen dank fuer deine Antwort.
Habe ich sogar komplett verstanden

 

[JuliaT]

Danke Kneitzel. Das hilft mir schon weiter. Denke ich muss einfach noch viel ueben, damit ich Praxis kriege und mir die Denkweise angewoehne.

Eine schrittweise Verfeinerung ist im Grunde das, was du hier grad vorgeschlagen hast. Also man schreibt komplexere Schritte in Worten auf, einen nach dem anderen und direkt unter jeden Schritt die Weise wie man diesen einzelnen Schritt eingeben muss, damit der Computer ihn versteht. Also im Grunde Java code.