Warum ist ein Zeichenzählen nie als Funktion fest eingebaut?

  • Allgemein

Es gibt 13 Antworten in diesem Thema. Der letzte Beitrag () ist von oobdoo.

    Warum ist ein Zeichenzählen nie als Funktion fest eingebaut?

    Seit 84 sitzt ich vor Computern und programmiere auch genauso lange. Ich all den Jahrzehnten gab es immer wieder Situationen
    wo ich eine Funktionalität benötigte und feststellte das sie in der jeweiligen Sprache oder im Betriebssystem nicht vorhanden war.

    Bestes Beispiel, sofern ich micht recht erinnere, gab es nie eine fest vorhandene Möglichkeit, um festzustellen wie oft ein
    bestimmtes Zeichen in einem String vorhanden ist. Klar, so eine Schleife hat man schnell zusammen gebastelt. Aber mir ist in all
    den Jahren aufgefallen das ich oft in ähnlichen Situationen war (kann mich aber gerade nur an das Zeichenzählen erinnern). Es fällt
    mir schwer vorzustellen das ich der einzige Programmierer auf der Welt bin der sowas hin und wieder benötigt. Sollte es nicht so
    sein, dann würde es bedeuten das auf meinem Windowsrechner gefühlt 100 Programmierer für ihre Software ebenfalls so eine
    Zählfunktion eingebaut haben.

    Bei den heutige Systemen ist dieser "unnütze" Speicherverbrauch kein Thema. Bei 16 Bit Systemen sah es noch etwas anders aus. :D

    Trotzdem erscheint es mir total sinnlos zu sein, das das Rad in der Programmierung immer wieder neu erfunden wird.

    Liege ich total falsch mit meinen Gedanken?

    *Topic verschoben*
    Aktuelles Projekt: Z80 Disassembler für Schneider/Amstrad CPC :love:

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Marcus Gräfe“ ()

    Uh, 84 war ich noch nicht mal in Planung :D aber habe auch schon ein "paar" Jahre am PC verbracht und ganz ehrlich?
    In all den Jahren habe ich so eine Funktion noch nie gebraucht oder auch nur daran gedacht.

    Ich weiß nicht genau wie ich es beschreiben soll, aber am Ende läuft es für mich darauf hinaus, das das Zählen von Wörtern nicht direkt mit den grundlegenden Datentypen zusammenhängt.
    Vor allem stellt sich mir (in dem Kontext) die Frage: Wie definiert man Wort?

    Oder anders: Sieht man ein String als eigenen Datentyp an, oder ist es "nur" Syntactic sugar um ein Char-Array herum?

    Bissel OT:
    Ich muss durch die Frage gerade an die beiden npm Module "is-odd" und "is-even" denken, wo eins (glaube "is-even") das andere als Dependency hat :D
    Brauch man so was?
    Ich programmiere auch etwa so lange (Apple IIe). Da hast du wohl recht, das ist mir auch schon oft aufgefallen.
    Inzwischen gibt es ja Lösungen mit Length und Replace, aber ich finde es auch unverständlich, dass man sich immer
    erst mal alles zusammensuchen muss.
    Auch die ganzen Imports, die man erst mal wissen muss, in welcher Bibliothek man bestimmte Funktionen findet.
    Da müsste es auch einfachere Lösungen geben. Aber mich fragt ja niemand.
    Es gibt inzwischen vieles was mir bei VisualStudio gefällt, (überhaupt, wenn man solch ein schlechtes Gedächtnis wie ich hat)
    Intellisense etc. Aber dass man z.B. das Maximum zweier Zahlen erst wieder mit einem Math.Max erhält, verstehe ich nicht so ganz.
    Oder wo ist eine Swap-Funktion. In manchen Programmiersprachen gibt es das doch auch.
    Die Hilfe-Funktion könnte z.B. besser sein. Ich lese oft Antworten die so ähnlich sind wie: Ein Array ist ein Array von Arrayelementen...
    Aber das ist ein anderes Thema.
    Naja, ich denke das Problem ist einfach, wo ziehst du da die Grenze. Für dich sind es diese 47 Funktionen und für den nächsten die 21 und für den anderen noch 9 weitere. Man kann ja nicht alles einbauen und wenn dir dann das Intellisense 4926 Funktionen als Vorschlag bereitet, wäre dein Thread hier vielleicht: "Warum ist eigentlich so viel nutzloser scheiß drin. Die paar Leute, die das Brauchen, schreiben sich das dann halt selbst." :D

    Ich habe eine "Extensions"-Klasse, die ich einfach in all meine Projekte standardmäßig hinzufüge. Da ist alles drin, was ich selbst vermisse. Einiges fällt über die Jahre auch weg, wenn es dann nachgezogen wird oder einfacher zu machen ist.

    C#-Quellcode

    1. string s = "Hallo Welt!";
    2. int anzahlDerL = s.Count(x => x is 'l' or 'L');



    C#-Quellcode

    1. int a = 2;
    2. int b = 3;
    3. // Swap
    4. (a, b) = (b, a);

    Nur zur Info:

    Sowas gibts bei PowerBasic seit 1990.

    TALLY function
    Purpose
    TALLY counts the number of occurrences of specified characters or strings within a string.
    Syntax
    x = TALLY(main string, [ANY] match string)

    Remarks
    main string is the string expression in which to count characters, and match string is the string expression to count all occurrences of. If match string is not present in main string, zero is returned. If the ANY keyword is included, match string specifies a list of single characters to be searched for individually, a match on any one of which will cause the count to be incremented for each occurrence of that character. TALLY is case-sensitive.

    Example
    PRINT TALLY("abacadabra", "bac") 'prints 1, counting the string "bac"
    PRINT TALLY("abacadabra", ANY "bac") 'prints 8, counting all "b", "a", and "c" characters

    @Bluespide
    Du hast Recht mit dem Hinweis wo denn dort die Grenze sein soll.

    Und bei einem Konzern wie MS mit vielen Programmierern gibts
    genauso viele Wünsche wie Programmierer angestellt sind.

    Trotzdem sagt mir mein Gefühl das dort Verbesserungspotential
    vorhanden ist.

    Wenn fünf Coder die "gleiche" (kompliziertere) Funktion basteln,
    dann besteht die Gefahr das 3-4 davon einen Fehler haben.

    Jetzt taucht ein sicherheitsrelevanter Bug auf. Allerdings bekommt
    nur ein Coder diese Meldung. Die anderen wissen ja nicht das sie
    im Grunde das gleiche programmiert haben und an der selben Stelle
    einen Bug ausbauen müssten.

    Wie gehen professionelle Programmierer damit um? Ich code zwar
    schon sehr lange, aber nur alleine zuhause und habe keinen
    Einblick wie die echten Programmierer mit sowas umgehen.


    C#-Quellcode

    1. string s = "Hallo Welt!";
    2. int anzahlDerL = s.Count(x => x is 'l' or 'L');


    Funktioniert nicht im Konverter.

    Ein Zeichen dafür das ich mit 98% der Coder im Forum nicht auf
    Augenhöhe bin. :D
    Aktuelles Projekt: Z80 Disassembler für Schneider/Amstrad CPC :love:
    Ich finde das, was du suchst ist speziell genug, dass es das Level an Eigendenken haben darf, das es verlangt.
    Ist doch schon allein bei dem Code den man sieht die Frage: Will man wirklich die groß und klein geschriebene Version? Denn das ist mehr als ein Zeichen, entgegen dem was du eingangs schriebst.

    Am Ende ist "Hallo Welt".Count(Function(c) c = "l"c), dasselbe wie in Excel ZÄHLENWENN(Bereich, Bedingung) ein Methodenaufruf, zwei inputs, ein output.

    Und dass das LINQ sein sollte, ist auch genau richtig, denn das ist der einzige Zusammenhang zwischen char und String, dass String eine Sammlung an Char is.
    Man kann ja genauso in einem Haufen Autos die roten zählen wollen.

    Hm, und so gesehen wie soll die Funktion denn aussehen? String.CountChar(c as Char) Soviel weniger ist das nicht

    Und was professionelle Programmierer angeht, guck dir mal Jonathan Paulson an wie der Schleifen schreibt, den hat mal jemand bei AdventOfCode erwähnt, scheint auch so ziemlich das einzige zu sein, was der auf Youtube macht. Da steckt doch pure Routine drin.

    Dieser Beitrag wurde bereits 7 mal editiert, zuletzt von „Haudruferzappeltnoch“ ()

    Haudruferzappeltnoch schrieb:

    dass String eine Sammlung an Char is
    Ich bin so dreist und präzisier das zu: Des Strings Hauptinhalt ist eine Ansammlung von Chars. Aber ein String ist und kann natürlich mehr als eine einfache Ansammlung von Chars.
    Und ob man dann nun aus Bluespides Code eben das macht

    VB.NET-Quellcode

    1. Dim anzahlDerL = s.Count(Function(x) x = "l"c OrElse "L"c)
    oder

    VB.NET-Quellcode

    1. Dim anzahlDerL = s.Count(Function(x) x.ToUpper = "L"c)
    oder Groß-/Kleinschreibung beachten will - tja da geht's wieder los. Der eine so, der andere so.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.
    Ich finde gerade das ist die Herausforderung, mit der der eine wie auch der andere Programmierer während seiner Laufzeit konfrontiert wird.

    Viele Programmierer geniessen die Vorarbeit der Entwickler von z.B. Frameworks, und werden obwohl sie auch selber Entwickler sind, zu sehr guten "Anwender". Ich denke da gerade an die ASP.Net Entwickler, die sehr gute Webanwendungen erstellen, dank dem guten ASP-Framework.

    Andere Programmierer dürfen/müssen sich mit solche Problemstellungen befassen. Das hat man z.B. bei der Skriptsprache Python festgestellt. Dank den unglaublichen Bemühungen der unzähligen OpenSourceprogrammier, wie auch der anderen Gemeinschaften, ist Python so mächtig wie auch beliebt worden.

    Du siehst. Du bist lange nicht der einzige, der hin und wieder von Null anfangen oder sich Gedanken machen muss, wie gewisse Problemstellungen die schon lange bekannt sind aktuell gelöst werden.

    Freundliche Grüsse

    exc-jdbi
    Also '84 ist 5 Jahre vor meiner Zeit, keine Ahnung was die Programmiersprachen damals alles hatten oder nicht hatten^^ In vielen Sprachen gibt es aber so eine Möglichkeit bereits out of the Box, z.B. bei PHP mit substr_count("hello", "l"), in Python mit str.count("x") und in JavaScript mit str.split("x").length (ziemlich exakt so mit split und length funktioniert es auch in Java oder C#).
    Hello World
    Das mit Split habe ich jetzt getestet.

    VB.NET-Quellcode

    1. Dim testtext As String = "dies ist ein text mit leerzeichen"
    2. Dim tt() As String = testtext.Split(" "c)
    3. Dim ttl As Integer = nclStrings.Zählen(testtext, " ")


    VB.NET-Quellcode

    1. Public Function Zählen(Text As String, Zeichen As String) As Integer
    2. Dim Anzahl As Integer = 0
    3. For i = 0 To Text.Length - 1
    4. If Text.Substring(i, 1) = Zeichen Then
    5. Anzahl += 1
    6. End If
    7. Next
    8. Return Anzahl
    9. End Function


    Resulat:
    Meine Zählung ergibt 42, Split 43.

    Spoiler anzeigen


    NameWertTyp
    ◢tt{Length=43}String()
    (0)"dies"String
    (1)""String
    (2)"ist"String
    (3)"ein"String
    (4)"text"String
    (5)""String
    (6)"mit"String
    (7)""String
    (8)""String
    (9)""String
    (10)""String
    (11)""String
    (12)""String
    (13)""String
    (14)""String
    (15)""String
    (16)""String
    (17)""String
    (18)""String
    (19)""String
    (20)""String
    (21)""String
    (22)""String
    (23)""String
    (24)""String
    (25)""String
    (26)""String
    (27)""String
    (28)""String
    (29)""String
    (30)""String
    (31)""String
    (32)""String
    (33)""String
    (34)""String
    (35)""String
    (36)""String
    (37)""String
    (38)""String
    (39)""String
    (40)""String
    (41)""String
    (42)"leerzeichen"String



    Nach einer kurzen Verwirrung warum Split ein Zeichen mehr hat, meine Frage.
    Funktioniert das immer zu 100% oder können bei Split Sonderfälle auftreten
    wodurch ein Ergebnis auch mal anders aussehen könnte?
    Aktuelles Projekt: Z80 Disassembler für Schneider/Amstrad CPC :love:
    Ist die Verwirrung geklärt? Falls nicht: Split ergibt ein StringArray von 43 Einträgen. Wenn der Text so aussehen würde: "a b", ergäben sich 2 Einträge und Deine Zählen-Funktion eine 1. Beides ist richtig, genauso wie 43 und 42. Es sind aber unterschiedliche Aussagen: Anzahl der sich ergebenden Strings und Anzahl der vorhandenen Leerzeichen.
    Wenn Split richtig eingesetzt wird, kommt auch das richtige Ergebnis raus.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.