Buchstaben zwischen zwei Indizes entfernen

Ich hätte noch ne Frage @JustNobody wieso gibt ein Programm in Eclipse die Lösung aus die auch erwartet wird, aber die Test Umgebung gibt etwas komplett anderes aus xD

Also aus dieser Methode erhoffe ich mir ja dass er die Zeichen zwischen den zwei Indizes ignoriert, das tut er auch in Eclipse, in der Test Umgebung ignoriert er jedoch nur 1 Zeichen xD

Java:
static String delete(String s, int a, int b) {
        String result = "";
        for (int index = 0; index < s.length(); index++)
          {
            if(a <= index && index <= b ) {
                continue;
            }else {
                result += s.charAt(index);
            }
          }
        return result;
    }
 
Da bräuchte man mehr Informationen. Übliche Ursachen für so ein Verhalten:
- In der Testumgebung wird ein anderer Code ausgeführt (Code wurde nicht kopiert oder nicht übersetzt ... Ursachen können viele vorhanden sein. Prüfen, dass der Code richtig in der Testumgebung angekommen ist und dass dieser korrekt übersetzt wurde und natürlich: Das der übersetzte Code ausgeführt wird.)
- Es gibt eine andere Eingabe. Dann hätte man einfach unterschiedliche Dinge getestet.

Aus meiner Sicht ist hier immer hilfreich, wenn man ein Logging hat. Hier würde ich dir raten, Dir da mal ein Framework auszusuchen und zu nutzen. Dann hat man auf Wunsch immer ein Tracefile in dem man alles nachvollziehen kann.
Ansonsten hilft es Dir evtl., wenn Du einfach einige Ausgaben einbaust.
 
naja also ich habe mal geschaut ob vielleicht der String zu kurz ist, jedoch hat der eine Länge von 212 Zeichen, also daran liegt es schonmal nicht, das Problem mit dem Logging Tool, ich wüsste nicht ob es überhaupt möglich ist, etwas derartiges in die Testumgebung der Uni zu implementieren :( ich schicke einfach mal die Eingabe :)

Eingabe:
delete erhält als Parameter einen String, d.h. eine Zeichenkette, sowie zwei Positionsangaben, entfernt aus dem String alle Zeichen zwischen einschließlich den beiden Positionsangaben und gibt das Ergebnis zurück
Löschen:
Zwischen Index 42 und Index 65
Erwartete Ausgabe:
delete erhält als Parameter einen String, sowie zwei Positionsangaben, entfernt aus dem String alle Zeichen zwischen einschließlich den beiden Positionsangaben und gibt das Ergebnis zurück
Tatsächliche Ausgabe:
delete erhält als Parameter einen String, .h. eine Zeichenkette, sowie zwei Positionsangaben, entfernt aus dem String alle Zeichen zwischen einschließlich den beiden Positionsangaben und gibt das Ergebnis zurück
 
Hast du den Code geprüft? Stimmt der Aufruf (Also gibst Du 42 und 65 als Parameter an?) und der Code (Hast Du evtl. zwei mal den Parameter a geprüft in der if Bedingung?)?
 
Tatsächlich ließt die Testumgebung 2 mal den Wert 42 ein.... :rolleyes:

12689
und ich wundere mich die ganze Zeit woran es liegen könnte oh man da hat der Prof wahrscheinlich den falschen Parameter reingeschrieben xD
 
Jetzt ist alles richtig xD war args[3] und nicht args[2] xD

btw. danke für den Tipp :) ich habe wirklich an alles gedacht, nur nicht daran, dass die Testumgebung vielleicht spinnt, merke ich mir für das nächste mal :)
 
@Kirby_Sike noch ein paar Anmerkungen zum Code aus #20:

Java:
    public static double [] glaette(double [] arr) {
        double [] result = new double[arr.length];
        for(int i = 0; i < arr.length; i++) {
            if(i == 0 || i == arr.length-1) {
                result[i] += arr[i];
                continue;
            }
            result[i] = (arr[i-1]+arr[i]+arr[i+1])/3;
            
        }
        return result;
    }
Der Code ist schön kompakt, hat allerdings zwei Nachteile und einen diskussionswürdigen Punkt.

1. Du brauchst nicht zu result addieren (nimm einfach = statt +=)
2. Du verwendest ein GOTO (continue). Das brauchst Du nicht, wenn Du ein else verwendest.

Java:
    public static double [] glaette(double [] arr) {
        double [] result = new double[arr.length];
        for(int i = 0; i < arr.length; i++) {
            if(i == 0 || i == arr.length-1) {
                result[i] = arr[i];
            } else {
                result[i] = (arr[i-1]+arr[i]+arr[i+1])/3;
            }        
        }
        return result;
    }
Der Punkt, der diskussionswürdig ist: die Prüfung der Arraygrenzen wird in der Schleife jedesmal durchgeführt. Die Frage ist also, ob man das nicht rausziehen will.

Java:
    public static double [] glaette(double [] arr) {
        double [] result = new double[arr.length];
        if (arr.length > 0) {
            result[0] = arr[0];
            result[arr.length-1] = arr[arr.length - 1];

            for (int i = 1; i < arr.length - 1; i++) {
                result[i] = (arr[i-1] + arr[i] + arr[i+1]) / 3;
            }
        }
        return result;
    }
Alle Lösungen haben übrigens gleich viele Codezeilen. Persönlich finde ich die letzte Variante auch einfacher zu verstehen, insbesondere, wenn man ein halbes Jahr später drauf schaut, aber das ist z. T. eine subjektive Angelegenheit.
 
Du hast recht, dein Code ist Ressourcen effizienter :) Ich werde mir in einem Jahr sowieso meinen jetzigen Code anschauen und mir denken: "Was ist dass den für Spaghetti Code :)"
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben