130 Zeilen Java nach Delphi gegen Bezahlung

[BlueStarHH]

Hallo zusammen,

ich benötigen jemanden, der mir einen Java-Code (130 Zeilen) nach Delphi übersetzt. Schreibt mir bitte per PN, was ihr dafür haben wollt.

Der Java-Code erzeugt aus einem Intervall (wie z.B. 45 bis 583) einen RegEx-Ausdruck. Hier
4[5-9]
[5-9][0-9]
[1-4][0-9][0-9]
5[0-7][0-9]
58[0-3]

Das setze ich dann zu \b(4[5-9]|[5-9][0-9]|[1-4][0-9][0-9]|5[0-7][0-9]|58[0-3])\b zusammen und fertig.
(Einfach [45-583] im RegEx-Ausdruck zu verwenden funktioniert leider nicht.)

Die Diskussion findet sich dazu unter https://stackoverflow.com/questions/...-number-ranges ist aber für diese Aufgabe nicht nötig. Es geht nur darum den Code nach Delphi umzusetzen. Unter https://ideone.com/j1Mh4c kann man den Java-Code mit verschiedenen Eingaben ausführen und sich das Resultat anschauen.

Code:

import java.util.*;

class Ideone {
    public static void main(String[] args) {
        final Scanner scanner = new Scanner(System.in);
        int start = scanner.nextInt();
        int end = scanner.nextInt();

        final LinkedList<Range> left = leftBounds(start, end);
        final Range lastLeft = left.removeLast();

        final LinkedList<Range> right = rightBounds(lastLeft.getStart(), end);
        final Range firstRight = right.removeFirst();

        LinkedList<Range> merged = new LinkedList<>();
        merged.addAll(left);
        if (!lastLeft.overlaps(firstRight)) {
            merged.add(lastLeft);
            merged.add(firstRight);
        } else {
            merged.add(Range.join(lastLeft, firstRight));
        }
        merged.addAll(right);

        merged.stream()
              .map(Range::toRegex)
              .forEach(System.out::println);
    }

    private static LinkedList<Range> leftBounds(int start, int end) {
        final LinkedList<Range> result = new LinkedList<>();
        while (start < end) {
            final Range range = Range.fromStart(start);
            result.add(range);
            start = range.getEnd()+1;
        }
        return result;
    }

    private static LinkedList<Range> rightBounds(int start, int end) {
        final LinkedList<Range> result = new LinkedList<>();
        while (start < end) {
            final Range range = Range.fromEnd(end);
            result.add(range);
            end = range.getStart()-1;
        }
        Collections.reverse(result);
        return result;
    }

}

class Range {
    private final int start;
    private final int end;

    public static Range fromEnd(int end) {
        final char[] chars = String.valueOf(end).toCharArray();
        for (int i=chars.length-1; i>=0;i--) {
            if (chars[i] == '9') {
                chars[i] = '0';
            } else {
                chars[i] = '0';
                break;
            }
        }

        return new Range(Integer.parseInt(String.valueOf(chars)), end);
    }

    public static Range fromStart(int start) {
        final char[] chars = String.valueOf(start).toCharArray();
        for (int i=chars.length-1; i>=0;i--) {
            if (chars[i]=='0') {
                chars[i] = '9';
            } else {
                chars[i] = '9';
                break;
            }
        }

        return new Range(start, Integer.parseInt(String.valueOf(chars)));
    }

    public static Range join(Range a, Range b) {
        return new Range(a.start, b.end);
    }

    private Range(int start, int end) {
        this.start = start;
        this.end = end;
    }

    public int getStart() {
        return start;
    }

    public int getEnd() {
        return end;
    }

    public boolean overlaps(Range r) {
        return end > r.start && r.end > start;
    }

    @Override
    public String toString() {
        return String.format("Range{start=%d, end=%d}", start, end);
    }

    public String toRegex() {
        String startStr = String.valueOf(getStart());
        String endStr = String.valueOf(getEnd());

        final StringBuilder result = new StringBuilder();

        for (int pos = 0; pos < startStr.length(); pos++) {
            if (startStr.charAt(pos) == endStr.charAt(pos)) {
                result.append(startStr.charAt(pos));
            } else {
                result.append('[')
                      .append(startStr.charAt(pos))
                      .append('-')
                      .append(endStr.charAt(pos))
                      .append(']');
            }
        }
        return result.toString();
    }
}

[mensch72]

Deine Vorgabe
4[5-9]
[5-9][0-9]
[1-4][0-9][0-9]
5[0-7][0-9]
58[0-3]


Mein aktuelles Schnellschuss Resultat... Angang gut, Mitte ?, Ende gut:)
4[5-9]
[5-9][0-9]
0
0
5[0-7][0-9]
58[0-3]

Für nur mal blind ohne Nachdenken umformatiert sieht das schon gut aus... jetzt wenn ich Lust habe guck ich heute nochmal genau wo mein Umsetzungsfehler für die Mitte da ist gerade noch ist

[BlueStarHH]

Zitat:

Zitat von mensch72 (Beitrag 1386630)

jetzt wenn ich Lust habe guck ich heute nochmal genau wo mein Umsetzungsfehler für die Mitte da ist gerade noch ist

Das wäre super!

[mensch72]

ok, fehlte nur ne Kleinigkeit in einer Bedingung... ich hätte nun die gewünschte Lösung für dich... schreib wenn du willst ne PN:)

[BlueStarHH]

Zitat:

Zitat von mensch72 (Beitrag 1386632)

schreib wenn du willst ne PN:)

Danke, hast eine PN.

[mensch72]

Wie per PN geklärt: hier der Source für dich und morgen viel Erfolg bei der Lösung für deinen Kunden:)