String analysieren

[Karlter]

Moin zusammen, wir haben folgende Aufgabe als Hausaufgabe bekommen. Leider stehe ich total auf dem Schlauch und finde nicht den richtigen Ansatz, wie ich das Problem angehe. Ich habe schon etwas mit den Schleifen rumhantiert, allerdings noch erfolgslos... Habt ihr eine Idee?

Schreiben Sie eine Klasse LieblingsZeichen, welche einen Satz einliest und alle Buchstaben und Sonderzeichen durchgeht, um auszugeben, welches die drei meistgenutzten Zeichen sind. Whitespaces (Leerzeichen, Zeilenumbruch und Tabulatoren) sollen ignoriert werden. Eingabe = Dieser Text ist ein paar Worte lang und hat sogar einen Punkt. --Ranking der Zeichen-- e = 7 n = 6 t = 5

Hinweis: Es dürfen keine String-Methoden verwendet werden. Lediglich String.charAt(int i) und String.length() sind zulässig.

Mein Code bis jetzt:

public class LieblingsZeichen { public static void main(String[] args) {

    Scanner keyboard = new Scanner(System.in);
    String satz = keyboard.nextLine();
    int satzlaenge = satz.length();
    char letter = 'a';
    int f = 0;

    while (f < satzlaenge) {
     char letter2 = 'a';
     if (letter == satz.charAt(0)) {
         int counterletter = 0;
         counterletter=+1;
         System.out.println(letter + " = " + counterletter);
     }
     letter2++;    
     f++;
    }




}

}

Vielen Dank für Eure Hilfe!

 

[Barista]

Mit der Methode java.lang.Character.isWhitespace(char c) kannst Du feststellen, ob ein Zeichen (char) ein whitepsace ist.

Zum Zählen mehrerer Zeichen benötigst Du entweder ein Array oder eine Map<Character, Integer> (eigentlich ein Bag, das gibts aber nicht im JDK, dafür findest Du sicher Code im Internet).

Bei einem Array ist der Index der Zeichencode des char, dafür musst Du dich mit den Unicode-Zeichencodes befassen, sicher reicht ein Ausschnit mit lateinischen Buchstaben und deutschen Umlauten.

In der Aufgabenstellung werden Ziffern nicht erwähnt, die würde ich in diesem Fall mit zu den Buchstaben zusammenfassen.

 

[KonradN]

Bei sowas gilt immer die gleiche Vorgehensweise:

A) Beschreibe den Lösungsweg. Sprich: Kannst Du es? Wie gehst Du vor, wenn du das machen müsstest. Beschreibe es so gut, dass jemand, der die Aufgabe nicht kennt, es machen könnte.

B) Die Lösung aus A) wird nun umgesetzt. Das kommt aber erst, wenn A) erfolgt ist.

Also: wie würdest du vorgehen?

 

[KonradN]

Zum Zählen mehrerer Zeichen benötigst Du entweder ein Array oder eine Map<Character, Integer> (eigentlich ein Bag, das gibts aber nicht im JDK, dafür findest Du sicher Code im Internet).

Nein, für diese Aufgabe braucht man nicht zwingend eine Map oder ein Array. Es geht auch ohne. Man kann es einfach mal von Hand durchspielen und dann merkt man es ganz schnell.

 

[Karlter]

Hey erstmal vielen Dank für die Antworten. @KonradN ja genau, so gehe ich auch eigentlich immer vor, aber es scheitert gerade bei der umsetzung. Ich lese ja einen String ein und möchte schauen ob es sich bei jedem einzelnen Char jeweils um einen Buchstaben, Sonderzeichen oder um ein ungültiges Zeichen (Leerzeichen, Zeilenumbruch und Tabulatoren) handelt. Das heißt also ich prüfe jeden einzelnen Fall mit jedem Index des Strings? Das heißt ich starte also mit der ersten Prüfung ob es ein Buchstabe, also z.B 'A' ist, indem ich string.charAt(0) mit der 65 (UniCode für A) vergleiche? Und das dann in eine For-Schleife bündel und alle Buchstaben einmal durchgehe?

 

[KonradN]

Ja, so in der Art.

Du kannst es Dir ja selbst mit Stift und Papier überlegen. Vergiss dabei Computer und Java.

Ich gebe Dir einen Zettel mit Zeichen drauf.
Was machst du genau? Was ich schon heraus gelesen habe:
Du gehst über alle Zeichen (Von Anfang bis Ende)

• zuerst prüfst Du, ob das Zeichen zu den zu zählenden Zeichen gehört. Wenn nicht, was dann?
• wie gehst du weiter vor?

Das kannst du durchspielen und dann bekommst du einen einfachen Ablauf.

Und formuliere immer Unteraufgaben. Die Prüfung, die ich erwähnt habe - das ist separat zu behandeln. Teile und herrsche!
Später bei derUmsetzung in Java ist das dann auch drin: das ist dann eine Methode: istZeichenZuZaehlen

So bekommst du dann ggf. schnell eine Lösung, die einfach umzusetzen ist.

 

[Barista]

package org.java_forum;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

/**
 *
 */
public class HashBag<T>
implements Iterable<HashBag.BagEntry<T>>
{
    private static class MutableInt
    {
        public int value = 0;
    }

    public static class BagEntry<T>
    implements Comparable<BagEntry<T>>
    {
        public final T key;

        public final int count;

        /**
         * Constructor.
         *
         * @param key
         * @param count
         */
        public BagEntry(
                final T key ,
                final int count )
        {
            this.key = key;
            this.count = count;
        }

        @Override
        public int compareTo(
                final BagEntry<T> o )
        {
            if ( this.count < o.count )
            {
                return -1;
            }

            if ( this.count > o.count )
            {
                return 1;
            }

            return 0;
        }

        @Override
        public String toString()
        {
            return key + " = " + count;
        }

    }

    private final HashMap<T, MutableInt> innerMap = new HashMap<>();

    public void add(
            final T key )
    {
        MutableInt counter = innerMap.get( key );

        if ( counter == null )
        {
            counter = new MutableInt();
            innerMap.put( key , counter );
        }

        counter.value++;
    }

    @Override
    public Iterator<HashBag.BagEntry<T>> iterator()
    {
        return new Iterator<BagEntry<T>>()
        {
            private final Iterator<Map.Entry<T, MutableInt>> innerIterator = HashBag.this.innerMap.entrySet().iterator();

            @Override
            public boolean hasNext()
            {
                return innerIterator.hasNext();
            }

            @Override
            public HashBag.BagEntry<T> next()
            {
                final Entry<T, MutableInt> entry = innerIterator.next();
                return
                        new BagEntry<>(
                                entry.getKey() ,
                                entry.getValue().value );
            }
        };
    }

}

 

[Barista]

package org.java_forum;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map.Entry;

import org.junit.Test;

/**
 *
 */
public class HashBagTest
{

    /**
     * Test method for {@link org.java_forum.HashBag}.
     */
    @Test
    public void test()
    {
        final HashBag<Character> charBag = new HashBag<>();

        final String satz = "Dieser Text ist ein paar Worte lang und hat sogar einen Punkt.";

        for ( int i = 0 ; i < satz.length() ; i++ )
        {
            final char c = satz.charAt( i );

            if ( ! Character.isWhitespace( c ) )
            {
                //System.out.println( c );
                charBag.add( c );
            }
        }

        final List<HashBag.BagEntry<Character>> charCountList = new ArrayList<>();

        for ( final HashBag.BagEntry<Character> charCount : charBag )
        {
            charCountList.add(
                    charCount );
        }

        charCountList.sort( Comparator.reverseOrder() );

        //System.out.println( charCountList );

        for ( final HashBag.BagEntry<Character> charCount : charCountList.subList( 0 , 3 ) )
        {
            System.out.println( charCount.key + " = " + charCount.count );
        }
    }

}

 

[Robert Zenz]

@Barista Einfacher waere es wenn man sich ein int[] mit Character.MAX_VALUE anlegt. Sind ja nur 65-tausend `int`s, dann erspart man sich das ganze Rumgefummel mit irgendwelchen Sonderklassen. Quasi Pseudo-Code:

int[] charCounters = new int[Character.MAX_VALUE];

for (char character : string.toCharArray()) {
    charCounters[character]++;
}

Dann muss man sich nur noch alles ausgeben was nicht Null ist.

Schwierig wir der Ansatz erst wenn man Unicode abdecken will, weil das waeren dann Integer.MAX_VALUE, und das ist auch die Obergrenze fuer Arrays, wenn ich mich richtig erinnere.

 

[KonradN]

Also das ganze braucht gar nicht diese komplexe Logik. Das ist eine einfache Anfänger-Aufgabe. Man kann da also ganz einfach heran gehen.

Also erst einmal die Vorgehensweise - was mache ich denn, wenn ich von Hand so etwas durchgehen will?
Ich gehe von Anfang an alle Zeichen durch:
a) Ist das Zeichen zu zählen? Wenn nicht, dann gehe ich weiter.
b) Wurde das Zeichen schon gezählt? Dann gehe ich auch weiter.
c) Ich zähle die Anzahl der Zeichen.
d) Nun schaue ich, ob das Ergebnis größer ist als der kleinste der drei gemerkten Werte. Wenn das der Fall ist, dann wird der neue Wert gespeichert.

Das ist ein einfacher Algorithmus. Das kann man durchspielen auf dem Zettel. Was musste ich mir merken?

• Die Stelle, welches Zeichen ich gerade bearbeite
• Beim Zählen und so: Wo ich gerade beim zählen bin
• Beim Zählen natürlich der Zähler
• Dann die Ergebnisse: Also 3 Zeichen mit den 3 Zählern.

Oben sind wir natürlich bei dem Algorithmus noch nicht ins Detail gegangen: Ist das Zeichen zu zählen war die Frage nach dem Whitespace.
Wurde das Zeichen schon gezählt: Da schaue ich einfach, ob ich in den bisherigen Zeichen bereits das aktuelle Zeichen hatte.
Das Zählen ist halt von der aktuellen Stelle nach hinten gehen und immer den Zähler hoch zählen, wenn ich das Zeichen finde.
Das mit dem Ergebnis ist dann: An letzter Stelle wird das neue Ergebnis gespeichert. Danach wird mit dem Ergebnis davor verglichen und ggf. getauscht. Wenn getauscht wurde, dann wird noch das höchste Ergebnis geprüft und ggf. getauscht.

Das lässt sich dann in Code umsetzen. Ich habe das mit ein paar ersten Methoden gemacht. Da ich lokale Variablen hatte, ist das mit dem Ergebnis hinterlegen etwas blöd. Das wäre alles deutlich besser, wenn man da vernünftige Datenstrukturen schaffen würde.

Damit hat man dann eine Lösung wie z.B.:

public class StringAnalyzis {

    public static void main(String[] args) {
        String toAnalyze = "Dieser Text ist ein paar Worte lang und hat sogar einen Punkt.";

        char resultChar1 = ' ';
        char resultChar2 = ' ';
        char resultChar3 = ' ';
        int resultCount1 = 0;
        int resultCount2 = 0;
        int resultCount3 = 0;

        for (int index = 0; index < toAnalyze.length(); index++) {
            if (shouldIgnoreChar(toAnalyze.charAt(index))) continue;

            if (charAlreadyCounted(index, toAnalyze)) continue;

            int count = countChar(index, toAnalyze);

            // Store result if high enough
            if (count > resultCount3) {
                resultChar3 = toAnalyze.charAt(index);
                resultCount3 = count;

                if (resultCount3 > resultCount2) {
                    char tempChar = resultChar2;
                    int tempCount = resultCount2;
                    resultCount2 = resultCount3;
                    resultChar2 = resultChar3;
                    resultCount3 = tempCount;
                    resultChar3 = tempChar;

                    if (resultCount2 > resultCount1) {
                        tempChar = resultChar1;
                        tempCount = resultCount1;
                        resultCount1 = resultCount2;
                        resultChar1 = resultChar2;
                        resultCount2 = tempCount;
                        resultChar2 = tempChar;
                    }
                }
            }
        }

        System.out.println(" 1.st: " + resultChar1 + " " + resultCount1);
        System.out.println(" 2.nd: " + resultChar2 + " " + resultCount2);
        System.out.println(" 3.rd: " + resultChar3 + " " + resultCount3);
    }

    private static int countChar(int charIndex, String toAnalyze) {
        int count = 0;
        for (int index = charIndex; index<toAnalyze.length(); index ++) {
            if (toAnalyze.charAt(charIndex) == toAnalyze.charAt(index)) {
                count++;
            }
        }
        return count;
    }

    private static boolean charAlreadyCounted(int checkIndex, String toAnalyze) {
        for (int index = 0; index < checkIndex; index++) {
            if (toAnalyze.charAt(index) == toAnalyze.charAt(checkIndex))
                return true;
        }
        return false;
    }

    private static boolean shouldIgnoreChar(char ch) {
        return Character.isWhitespace(ch);
    }
}

(Einfach mal ganz schnell herunter getippt. Bezeichner sind evtl. noch nicht schön, aber die 5 Minuten habe ich mir hier jetzt gespart.)


Wenn man von der Anfänger-Aufgabe weggehen würde, dann wäre das evtl. eine Stream Lösung. Wenn ich die Anzahl der Zeichen bräuchte, dann wäre es vermutlich eine Lösung wie:

Erst einmal eine Map erstellen mit Zeichen zu Anzahl:

        Map<Character, Long> charCountMap = toAnalyze.chars()
                .mapToObj(c -> (char) c)
                .filter(c -> !Character.isWhitespace(c))
                .collect(
                        Collectors.groupingBy(Function.identity(), Collectors.counting())
                );

Dann absteigend sortieren nach Anzahl und eine Ausgabe:

        charCountMap.entrySet().stream()
                .sorted(Map.Entry.<Character, Long>comparingByValue().reversed())
                .limit(3)
                .forEach(entry -> System.out.println(entry.getKey() + ": " + entry.getValue()));

Ist so noch unleserlich - das kann man noch schön auftrennen, damit es leserlicher wird, so dass man dann sowas hat wie filter(this::isNoWhitespace), .sorted(this.reverseCountComparator) und .forEach(this:rintKeyValuePair) oder so ähnlich. Nur um zu zeigen, dass mit so einfachen Refactorings der Code direkt gut lesbar werden kann. Streams zur Datenverarbeitung ist super, so diese so schön "gradlinig" sind.

 

[Barista]

Einfacher waere es wenn man sich ein int[] mit Character.MAX_VALUE anlegt.

Diese Möglichkeit hatte ich in meinem ersten Posting in diesem Thread erwähnt.

Ich hätte eher Kritiken erwartet, weil der TE eventuell was lernen sollte statt eine fertige Lösung zu bekommen.

Aber eventuell ist es für die Hausaufgabe schon zu spät.

Falls der TE ein Schüler ist, nach meiner Meinung ist Java für die Schule zu hart, aber in den 80ern haben die vielleicht C oder Pascal gemacht (oder Basic).

 

[KonradN]

Ich hätte eher Kritiken erwartet, weil der TE eventuell was lernen sollte statt eine fertige Lösung zu bekommen.

Deine Lösung dürfte als Lösung eines Schülers (der Java erst lernt) eh nicht durchgehen. Und ich halte diese Lösung auch eher für Overkill.

Und ich frage mich bei dem Code immer: Wenn man eine Klasse wie HashBag schreibt, dann sollte man doch das Java Framework komplett kennen und nutzen. Wieso wird dann noch compareTo noch selbst geschrieben und nicht einfach ein Comparator.comparingInt genutzt?

Nicht falsch verstehen: Das, was Du machst ist nicht falsch und ich will das nicht kritisieren. Ich mache es nur anders und ich sehe es auch in den Projekten eher anders. Daher ist die Frage mehr: Macht ihr das in euren Projekten auch so, dass ihr sowas selbst implementiert oder nutzt Ihr da eher fertige Methoden von Comparator? Als auch an alle (@Robert Zenz, @LimDul, @mihe7, ...) gerichtet

 

[Robert Zenz]

Daher ist die Frage mehr: Macht ihr das in euren Projekten auch so, dass ihr sowas selbst implementiert oder nutzt Ihr da eher fertige Methoden von Comparator? Als auch an alle (@Robert Zenz, @LimDul, @mihe7, ...) gerichtet

Huh, schwierige Frage. Also, hier und da vergesse ich dass es diese ganzen Hilfsfunktionen gibt und dann nehme ich was auch immer die Eclipse-comparetoequalshashcode-Generierung ausspuckt. Aber grundsaetzlich versuche ich auch die Hilfsmethoden von Comparator oder Objects zu verwenden. Was ich nicht mag sind die Objects.require*, die enthalten zu wenig Information in der Fehlermeldung fuer meine Geschmack, dswegen schreibe ich immer meine eigene Require-Klasse welche so Spielchen hat wie Parametername und Methodenname in der Meldung.

Ich habe aber auch selten den Fall dass ich compareTo/equals/hashCode brauche, um ehrlich zu sein, eine eigene Map/Iterable/Iterator Implementierung schreiben zu muessen ist auch schon echt selten gewesen.

 

[mihe7]

Macht ihr das in euren Projekten auch so, dass ihr sowas selbst implementiert oder nutzt Ihr da eher fertige Methoden von Comparator?

Ich versuche grundsätzlich, fertige Methoden der Standardbibliohtek zu nutzen. Manchmal vergisst man es aber tatsächlich, wie @Robert Zenz schon schrieb.

 

[Barista]

Wieso wird dann noch compareTo noch selbst geschrieben und nicht einfach ein Comparator.comparingInt genutzt?

Kannte ich nicht.

 

[mihe7]

Kannte ich nicht.

Ja, das ist auch eines der Probleme. Die Standard-APIs sind mittlerweile so umfangreich, dass man viele Methoden gar nicht kennt und auch nicht auf die Idee kommt, dass es mittlerweile etwas fertiges geben könnte. Kenn ich

 

[Karlter]

Hey Leute, erstmal vielen lieben Dank für Eure Einschübe in diese Diskussion. Vielleicht als kleiner Einschub - ich befinde mich im 1ten Semester Wirtschaftsinformatik, daher darf ich eh noch nicht mit HashMap, geschweige denn mit der Objektorientierung arbeiten. In der Hausaufgabe war tatsächlich ein sehr simpler Algorithmus verlangt, ungefähr genauso wie KonradN es hier beschrieben hat. Habe die Hausaufgabe allerdings schon am Montag eingereicht und tatsächlich volle Punktzahl erhalten. Geholfen hat mir der Tipp, welchen @KonradN mir gegeben hat - einfach mal weg vom Code und auf Papier schreiben wie der genaue Ablauf sein soll. Das Coden an sich war gar nicht so das problem, es hat eher an der Umsetzung gescheitert… Ich danke Euch!!

 

[Marinek]

Ehrlich gesagt finde ich die Lösung von @KonradN schon wesentlich eleganter.

Darüber hinaus ist der Unterschied marginalst.

 

[KonradN]

Continue und iwelche unsinnigen Methoden findest du eleganter? Was stimmt mit dir nicht?

Ok, bitte erkläre einmal, wieso die Aufteilung in Methoden schlecht ist. Oder konkret: warum die Methoden unsinnig sind.

Das continue dient schlicht dazu, das unnötige Einrücken zu verhindern. Das macht Code unleserlich wie man schon an Deinem Code erkennen kann.

Tatsächlich wäre die Bevorzugte Variante, dass man dies objektorientiert macht. Dann wäre das nur noch eine Schleife die eine Methode aufruft.

In der Methode wäre dann kein Continue sondern statt dessen hätte man return Anweisungen. Aber diese Unzulänglichkeit war ja von mir erwähnt worden.

Ansonsten zu deinem Code:

• c1, c2, c3, i, j, s .... Die Variablen würde ich sinnvoll benennen. Ebenso sind max1, max2 und max3 grenzwertig.
• Thema Methoden hatten wir ja schon - die Einrücktiefe ist halt etwas, das man beachten sollte (Gehört zu dem Punkt: Cyclomatic Complexity)

Aber das Thema Clean Code hast Du ja bisher immer abgelehnt. Eine Aussage wie "Clean code is simple and direct. Clean code reads like well-written prose. Clean code never obscures the designer’s intent but rather is full of crisp abstractions and straightforward lines of control." (Zitat von Grady Booch, das Robert C. Martin u.a. in seinem Buch Clean Code: A Handbook of Agile Software Craftsmanship bringt.)

Wichtig ist: Hier kann jeder die Position vertreten, die er gerne vertreten möchte. In der Praxis haben sich aber gewisse Ansichten doch recht weit durchgesetzt. Es geht hier also nicht um eine Meinung von mir sondern unter dem Strich um die Meinung von Leuten wie Robert C. Martin, Kent Beck, u.s.w.! Dabei ist Robert C. Martin der, der hier wohl am meisten dokumentiert hat, aber er war sehr gut vernetzt eben mit vielen Anderen, die bei diesen und ähnlichen Themen mitgewirkt haben. Und ich vermute, dass Du auch schon in Schule / Studium von SOLID gehört haben wirst ... Das sind also nicht nur fixe Ideen ein paar einzelner Personen sondern wurde auch in der Lehre als fester Bestandteil aufgeführt.

Grady Booch ist ansonsten einer von den drei Erfindern von UML. Grady Booch hatte ursprünglich die Booch Method entwickelt und veröffentlicht ...

Aber natürlich: Du kannst es evtl. besser wissen wie alle anderen ... das dann nur bitte mit vernünftigen Argumenten zusammen tragen und veröffentlichen.

 

[KonradN]

Was soll man bei sowas antworten? Spielt aber keine Rolle, denn die Beiträge werden wohl in Kürze eh gelöscht und dieser Account von Dir wieder gelöscht... Aber einfach nur, weil es ein interessanter Punkt ist kann ich es mal ausführen (Sozusagen etwas aus meiner "Jugend" erzählen).

Konrad wie hast du Programmieren gelernt? Hattest du eine Ausbildung oder einfach immer selber so wie du es für richtig hieltest? Weil bei letzterem entstehen oft solche Fehleinschätzungen.

Ich habe mir das Programmieren schon als Kind selbst beigebracht, z.B. mit 8 oder 9 Jahren fing es an einem Apple II+ mit Pascal an, als ich erste Weihnachtslieder "programmiert" habe (in sehr piepsigen Tönen. Mehr war damals nicht drin!). Mit 17 wurde dann C programmiert - einfach weil ich es leid war, die Pascal Bücher immer bei meinem Vater und großen Bruder zu suchen. Da wurde dann statt dessen Turbo C 2.0 von Borland von mir benutzt. Da habe ich dann auch ein erstes kommerzielles Projekt umgesetzt - da habe ich dann tatsächlich auf MS DOS in C eine Datenbank-Anwendung geschrieben. Also so richtig mit Daten in einem Datenfile und dann index Dateien und so ...
(Das lief über mehrere Jahre - da habe ich dann für eine Firma mit > 400 Mitarbeiten auch angefangen, IT Support zu leisten und so ... Das war halt zu einer Zeit, wo diese ganze Thematik "Informatik" noch im entstehen war und vor allem Quereinsteiger, Mathematiker, Physiker und E-Techniker das Feld dominiert haben)

Interessant war, dass ich trotz dieser Erfahrungen ursprünglich eben nicht Informatik studieren wollte sondern Physik (Mathe und Physik LK). Da war dann die Bundeswehr eine gute Zeit, sich zu besinnen und so habe ich dann tatsächlich Informatik studiert. Da habe ich aber dann nicht "Programmieren" gelernt sondern Software Entwicklung. Wobei ich da im Studium nur eine erste Grundlage bekommen habe. Ich habe sehr viel durch Interaktion mit anderen Software Entwicklern gelernt. Gespräche und Diskussionen sind extrem wichtig und gehören dazu. Und dabei ist es wichtig, dass man selbst seine eigene Position hinterfragt und dann offen ist für Argumente. Das ist etwas, das man hier im Forum auch massiv findet - so vor kurzem erst habe ich nach den Erfahrungen anderer gefragt in einem Thread, als ich meine Position dargestellt habe mit Argumenten und da noch bestätigen wollte, dass meine Sichtweise zumindest grob mit der Sichtweise Anderer überein stimmt.

Aber da sehe ich halt große Unterschiede: Programmieren vs. Software Entwickeln. Und ich vermute etwas, dass Du halt tatsächlich programmierst und nicht Software entwickelst.

Aber das will ich nicht weiter vertiefen, denn ich hatte es schon gesagt:

Hier kann jeder die Position vertreten, die er gerne vertreten möchte.

Und in dem Sinne hast Du Deine Meinung sehr deutlich gemacht. Leider ganz ohne Argumente. Vermutlich, weil Du von der Thematik einfach zu wenig verstehst. Das Thema "Auswendig lernen" hatten wir ja auch erst vor kurzem. Damit mag man 15 Punkte in einem Leistungskurs Informatik schaffen, aber man schafft im Abi keinen 1er Schnitt. Das Studium hast Du aber vermutlich geschafft, aber deine Position hier zeigt mir ein recht deutliches Bild.

Ansonsten Danke für deinen Versuch einer Auseinandersetzung. Leider konntest Du meinen Text nicht einmal in Ansätzen verstehen, was eine inhaltliche Auseinandersetzung unmöglich macht. Zudem wie immer keine Argumente sondern nur eigene Meinung zusammen mit Angriffen gegen meine Person. Man könnte hier noch Tipps geben, aber du bist lernresistent, daher wirst Du hier weiter das Problem haben, dass Dein Account regelmäßig gelöscht wird und im beruflichen Umfeld wirst Du weiter so anecken, wie Du es schon im Forum hast durchblicken lassen. (Und diesbezüglich mag da auch ein gewisser Frust aufkommen, der sich dann im Forum ausdrückt? Ist das evtl. der Grund, warum es Phasen gibt, in denen Du normal auftreten kannst und dann Phasen, in denen Du so "ausrastest"? Aber das sind nur Vermutungen ... gehören hier nicht hin ...)

 

[Marinek]

Mir ist egal was du würdest oder nicht, die sind sinnvoll.

Binary search to find the closest element

I wrote a binary search to find the closest element to x in an array. How can show the correctness of the algorithm for any cases? Because it handles with floating points and variable length arrays,

codereview.stackexchange.com

Könnte hier hunderte Posts dieser Art zeigen.

Ich würde auch gerne mal verstehen, wieso man sich in eine Community integrieren möchte, die deutlich gemacht hat, dass man unerwünscht ist. Würde ich mir doof bei vorkommen.

Sind es schon 10 Jahre? Vor zwei Jahren warst du bei deiner Bachelor Arbeit hast du geschrieben. Nehme an, dass an der Situation sich nichts geändert hat.

 

[KonradN]

Vor zwei Jahren warst du bei deiner Bachelor Arbeit hast du geschrieben. Nehme an, dass an der Situation sich nichts geändert hat.

Ja doch. Er hat den Einstieg ins Berufsleben geschafft und ist dabei ganz schön angeeckt. Er hat mal was von Kündigung weil klüger als Chef geschrieben und so ….

Der Thread macht ja auch deutlich, wie sowas kommen kann. Clean Code Grundlagen werden schlicht abgelehnt…

Das sollte einem ja eigentlich zu denken geben, aber wenn man von sich so überzeugt ist und alle Anderen keine Ahnung haben, dann ist das Ergebnis nun einmal so ….

 

[Marinek]

Ja doch. Er hat den Einstieg ins Berufsleben geschafft und ist dabei ganz schön angeeckt. Er hat mal was von Kündigung weil klüger als Chef geschrieben und so …

☺️😜🤪

Remote Arbeit nach Pandemie

+1. Man soll sich kein Beispiel an mir nehmen, aber für mich käme kein Homeoffice mehr gar nicht mehr infrage. Ich entwickle Angststörungen, wenn ich mit anderen in einem Büro sein muss. (Wie gesagt, nehmt euch kein Beispiel an mir…) Aber auch für die Produktivität ist im IT-Bereich Homeoffice...

forum.byte-welt.net

 

[KonradN]

Also nur um da die fachlichen Punkte noch einmal kurz aufzugreifen und klarzustellen - nicht dass da jemand verwirrt wird, wenn er über den Thread stolpert:

Ja, hier soll wieder versucht werden, falschen Code als richtig darzustellen

Warst Du nicht immer derjenige, der vertreten hat, dass Code, der das richtige Ergebnis liefert, eben kein falscher Code ist?
Der Code löst das Problem und implementiert 1:1 einen Lösungsweg, den ich auch in Worten skizziert habe.

Man sollte überall, wo möglich, continue und break einsetzen.

Und da sind wir wieder beim Thema Textverständnis. Das wurde an keiner Stelle gesagt. Es wurde sogar explizit das Gegenteil gesagt und das mehrfach:
Das erste Mal habe ich deutlich gesagt, dass die Lösung nicht optimal ist mit dem Kernsatz:

Das wäre alles deutlich besser, wenn man da vernünftige Datenstrukturen schaffen würde.

Und nach Deinem lächerlichen Vorwurf dann sogar einmal ganz ausführlich:

Das continue dient schlicht dazu, das unnötige Einrücken zu verhindern. Das macht Code unleserlich wie man schon an Deinem Code erkennen kann.

Tatsächlich wäre die Bevorzugte Variante, dass man dies objektorientiert macht. Dann wäre das nur noch eine Schleife die eine Methode aufruft.

In der Methode wäre dann kein Continue sondern statt dessen hätte man return Anweisungen. Aber diese Unzulänglichkeit war ja von mir erwähnt worden.

Und das ist die typische Alternative, um eben ganz viele verschachtelte if zu vermeiden und eine flache Struktur zu bekommen. Eine Unterteilung in Methoden wäre richtig aber das Umdrehen der if und dann ein continue zu verwenden ist da aus meiner Sicht besser weil einfach schneller lesbar. Der Code ist da halt direkt lesbar - im Gegensatz zu Deinem Code.

Dein Quatsch mit den "unnötigen Methoden" hast Du mehrfach gebracht aber bist trotz Nachfrage nicht ein kleines bisschen drauf eingegangen. Ich vermute ja, dass Du tatsächlich irgend wo irgend was gefunden hast, das Du dann in diesem Sinne interpretierst. YAGNI evtl. aber wie stark muss man das missverstehen? Denn die Methoden werden ja genutzt und werden ja auch von der Funktionalität benötigt. Du willst ja nicht die Funktionalität loswerden, weil sie nicht benötigt wird, sondern Du willst diese in der eigentlichen Hauptmethode unterbringen.... Daher kann es das eigentlich nicht sein, denn so massiv wirst Du das ja nicht missverstanden haben. Muss also irgend etwas anderes sein ... Leider kommt da aber von Dir nichts ausser Angriffen gegen die Person. (Aber da konnte ich Dir mit dem "Schmankerl aus meiner Jugend" schon den Wind aus den Segeln nehmen? ... Hatte da eigentlich weitere Hasstiraden von Dir erwartet ...)

 

[Marinek]

Ich weiß, du bist der Klassenclown, aber kannst du nicht mal versuchen, auch ohne Ritalin, etwas Konstruktives zum Thema beizutragen?

Geräusche/Tracks gesucht 2

Es gibt zwei Möglichkeiten: Du leidest an einer Angststörung. Du hast Angst vor Hustengeräuschen und versuchst dich mit dem ständigen Anhören von Hustengeräuschen zu sensibilisieren. In dem Fall wurde dir schon ausreichend geholfen, meine ich. Du gibst vor an einer Angststörung zu leiden und...

forum.byte-welt.net

November 2013 vs. November 2023

Wo andere zufälle sehen, sehe ich ...

Und nach Deinem lächerlichen Vorwurf dann sogar einmal ganz ausführlich:

Das ist ein 100 % Troll. Der kopiert die Sachen aus Troll Vorschlagsforen und wir schlagen uns damit rum... Wenn die Geschichte eins gezeigt hat, dass dieser Mensch irgendwo in 2013 stehengeblieben ist und seit dem einfach nur in Foren trollt. Und das mit voller absicht und nicht, weil er zu blöd ist.

 

[Marinek]

Jeder hinterlässt so seine Fußstapfen, wie er es für richtig hält . Deine sind gut dokumentiert im Internet.

 

[Nouser]

Warum darf der Scheizdreck von Apple stehenbleiben?

War der Hustengeräuschethread echt von dir? Schon irgendwie... speziell.

 

[Blender3D]

Schreiben Sie eine Klasse LieblingsZeichen, welche einen Satz einliest und alle Buchstaben und Sonderzeichen durchgeht, um auszugeben, welches die drei meistgenutzten Zeichen sind. Whitespaces (Leerzeichen, Zeilenumbruch und Tabulatoren) sollen ignoriert werden. Eingabe = Dieser Text ist ein paar Worte lang und hat sogar einen Punkt. --Ranking der Zeichen-- e = 7 n = 6 t = 5

Hinweis: Es dürfen keine String-Methoden verwendet werden. Lediglich String.charAt(int i) und String.length() sind zulässig.

public class CountCharStart {
    private final static int START_CHAR = 33; // ASCII erstes druckbare Zeichen ist SPACE
    private static int[] cnt = new int[255 - START_CHAR]; // speichert die Anzahl der druckbaren Zeichen

    public static void main(String[] args) {
        String txt = "Dieser Text ist ein paar Worte lang und hat sogar einen Punkt.";
        countCharacters(txt);// zählt die Zeichen im Text
        int[] maxId = getMaxCharIds(txt, 5); // ermittelt die ids im count Array der 5 häufigsten Buchstaben
        System.out.println(toMaxCharStr(maxId)); // wandelt ids in Ausgabestring um
    }

    private static int charToId(char c) {
        return (int) (c - START_CHAR);
    }

    private static void countCharacters(String txt) {
        for (int i = 0; i < txt.length(); i++)
            incrementChar(txt.charAt(i));
    }

    public static int[] getMaxCharIds(String txt, int num) {
        int[] maxId = new int[num];
        int[] max = new int[num];
        for (int pos = 0; pos < maxId.length; pos++) {
            max[pos] = -1;
            for (int i = 0; i < cnt.length; i++) {
                if (cnt[i] > max[pos]) {
                    maxId[pos] = i;
                    max[pos] = cnt[i];
                }
            }
            cnt[maxId[pos]] = -1;
        }
        for (int i = 0; i < maxId.length; i++)
            cnt[maxId[i]] = max[i];
        return maxId;
    }

    private static char idToChar(int id) {
        return (char) (id + START_CHAR);
    }

    private static void incrementChar(char c) {
        int id = charToId(c);
        if (id < 0)
            return;
        cnt[id]++;
    }

    public static void resetCount() {
        cnt = new int[255 - START_CHAR];
    }

    public static String toMaxCharStr(int[] maxId) {
        StringBuffer tmp = new StringBuffer();
        for (int i = 0; i < maxId.length; i++)
            tmp.append(idToChar(maxId[i]) + "=" + cnt[maxId[i]] + " ");
        return tmp.toString();
    }
}