Wie teile ich am besten ganze Strings?

  • VB.NET
  • .NET 4.5

Es gibt 11 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

    Wie teile ich am besten ganze Strings?

    Nabend zusammen,

    ich stehe zurzeit mal wieder auf dem schlauch und weiß nicht weiter. Und vor allem wie ich das richtig erklären soll.
    Ich würde gerne ein String, der so aussieht (oder aussehen könnte) >> .-..----.-.-.--.------....-.--.----. << (Bsp.: 36 Zeichen)

    So zerteilen, dass immer 12 Zeichen getrennt werden.
    Also Bspw. so >> .-..----.-.- << dann >> .--.------.. << und >> ..-.--.----. <<

    Da hatte ich ja eigentlich an "mein_string.Substring(0, 12)" gedacht.
    Doch so einfach ist das ganze dann doch wieder nicht. X/
    Da zwischendurch auch gerne mal andere Zeichen darin sind, die ich nicht "umänder".

    Kurz noch mal zur Vorgeschichte... Ich kann ein Text wie bspw. >> Hey << so hier aussehen lassen >> .-..----.-.-.--.------....-.--.----. <<
    Nun kann der Text aber auch einfach länger sein, wie bspw. >> Hallo, wie geht es dir? << dann sähe es so aus
    >> .-..----.-.--....--.-.-.-----..-...------..-...--....-----.-(komma)(leerzeichen)-........-..-...---------.---.---.-.(leerzeichen)-----.-.-...-.---.---.-.-.---------............-(leerzeichen)-.---.---.-.............(leerzeichen).-------.----...-----------------...(fragezeichen) <<
    [Die (komma),(leerzeichen) und (fragezeichen) sollen nur als sichtbares bsp. dienen, da vilt. die Zeichen , ? unter gehen würden]

    Das nun wieder rückgängig zu machen ohne vorher zu wissen was da mal Stand schon teilweise schwieriger.
    Daher möchte ich nach jedem 12 Zeichen trennen aber sowas wie "," oder "?" usw. ignorieren.

    Am ende soll halt nur wieder aus dem Kauderwelsch >> Hallo, wie geht es dir? << raus kommen.

    Wie realisiere ich das :?: ?(

    Danke für eure Zeit.

    *Thema verschoben* ~NoFear23m

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Nofear23m“ ()

    Und wie soll dann die codierte Variante von »Hallo, wie geht es dir?« getrennt aussehen?
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Häufig von mir verwendete Abkürzungen: CEs = control elements (Labels, Buttons, DGVs, ...) und tDS (typisiertes DataSet)
    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht in den Spekulatiusmodus gehen.
    Also zureit mach ich das ja so, dass A-Z und a-z sowie 0-9 in ein Kauderwelsch verpackt werden.
    Das mache ich ja so, dass bspw. "My.Settings.A_gross" und "My.Settings.A_klein" die Zeichenfolge kennen.

    Nun pack ich den Text in ein "Dim array() As Char" und prüfe es bspw. mit

    Quellcode

    1. For Each c in array
    2. If c.ToString.Contains("A") Then
    3. OutputCodeText.Text = OutputCodeText.Text & c.ToString.Replace("A", My.Settings.A_gross)
    4. ElseIf c.ToString.Contains("a") Then
    5. OutputCodeText.Text = OutputCodeText.Text & c.ToString.Replace("a", My.Settings.A_klein)
    6. Else
    7. OutputCodeText.Text = OutputCodeText.Text & c
    8. End If
    9. Next c


    Heißt also das da das ganze Alphabet von A-Z und a-z sowie 0-9 drin ist. (in dem bsp. nur das A und a)
    Kennt er also ein Zeichen nicht, wird es einfach benutzt. Bspw. dann ein ?

    Da aktuell ein Buchstabe in 12 Zeichen zersetzt wird mit punkten und strichen, sieht das ganze so aus wie ich es oben schon beschrieben hab.

    Nun komme ich zu deiner Frage:

    VaporiZed schrieb:

    Und wie soll dann die codierte Variante von »Hallo, wie geht es dir?« getrennt aussehen?


    Getrennt sollen dann immer 12 Zeichen genommen werden damit die später weiter verarbeitet werden können. (bspw. im array)
    Getrennt sieht also das hier

    PlatinSecurity schrieb:

    .-..----.-.--....--.-.-.-----..-...------..-...--....-----.-(komma)(leerzeichen)-........-..-...---------.---.---.-.(leerzeichen)-----.-.-...-.---.---.-.-.---------............-(leerzeichen)-.---.---.-.............(leerzeichen).-------.----...-----------------...(fragezeichen)
    so aus

    Brainfuck-Quellcode

    1. .-..----.-.-
    2. -....--.-.-.
    3. -----..-...-
    4. -----..-...-
    5. -....-----.-
    6. ,
    7. -........-..
    8. -...--------
    9. -.---.---.-.
    10. -----.-.-...
    11. -.---.---.-.
    12. -.---------.
    13. ...........-
    14. -.---.---.-.
    15. ............
    16. .-------.---
    17. -...--------
    18. ---------...
    19. ?


    EDIT: Komischerweise nennt er das "Brainfuck Quellcode" ... Sollte aber nicht daran angelehnt sein. :'D
    Ich frage mich gerade, wie frei du bist. Ist das etwas was vorgegeben ist, oder kannst du da selber was eigenes Entwerfen.

    Soll einfach das Geschriebene nicht gleich offensichtlich sein? Weil eine starke Codierung erreichst du so nicht, was ja vielleicht auch nicht das Ziel sein soll.

    Durch die Wahl von 2 Zeichen(Punkt und Bindestrich) und durch die Länge von 12 Zeichen pro Buchstabe hast du 4096 Kombinationsmöglichkeiten.

    Gib doch dem Punkt, dem Komma, dem Bindestrich, dem Ausrufezeichen etc auch eine 12-Zeichencodierung. Kombinationen gibt es mehr als genug. Von hier weg ist das Geschriebene (dein Text) immer eine Vielfache von 12. Mit dem Substring sehr einfach aufzulösen.

    Freundliche Grüsse

    exc-jdbi

    exc-jdbi schrieb:

    Soll einfach das Geschriebene nicht gleich offensichtlich sein?

    Richtig. Einfach nur, dass ich bspw. mein Text einfach gehalten "verschlüssel".

    Ja wenn man das 1x1 von den Zeichen kennt, kann man es nach und nach wieder sichtbar machen.
    Aber darum geht es ja nicht. Ehr um ein kleines Privates Projekt für mein home pc. ^^

    exc-jdbi schrieb:

    Gib doch dem Punkt, dem Komma, dem Bindestrich, dem Ausrufezeichen etc auch eine 12-Zeichencodierung.


    Genau das wäre ja ein Problem, da ich punkt und Bindestrich als "verschlüsselung" nutzen will. (Wie bei einem "Brainfuck-Code")
    Nur halt als eigenes Alphabet. Und alle Sonderzeichen noch eine Zeichencodierung zu geben ist wie schon erwähnt für das Private Projekt er Zeitaufwändig. Ich möchte daher gerne bei A-Z, a-z und 0-9 bleiben.

    Ich meine ich kann ja die Buchstaben und Zahlen auch Replacen und wenn er ein Zeichen nicht kennt dann setzt er es einfach in die RichTextBox mit dazu.

    Nun soll das ganze nur einmal anders rum funktionieren.
    Das geht aber nur wenn ich wirklich immer alle 12 Zeichen in ein Array packe bspw. und die Zeichen die ich nicht als Zeichencodierung habe einzeln in das Array. So das am ende halt wieder der Satz raus kommt, wie er auch Codiert wurde.
    1. Taste den Text in 12 Schritten ab und prüfe ob da andere Zeichen als "." und "-" sind. Wenn nicht der Liste zufügen.
    2. Sofern ein Zeichen vorhanden ist das unbekannt ist, ist es immer an 1. Stelle des 12 Blockes. Aussondern und der Liste zufügen
    3. Weiterfahren mit 1.

    Das Prüfen des 12-Blockes liesse sich mit Regex sehr einfach lösen.
    Man könnte auch den 12-Block kurz in Byte umwandeln und schauen ob andere Zahlen als Ascii 45 oder 46 vorhanden sind. Wenn ja ist ein Sonderzeichen vorhanden das ausgesondert werden muss.

    Sollte einfach lösbar sein.
    Das Replace würde ich nur für das Encoden (Codieren) benutzen. Für das Decoden (Entcodieren) jedoch nicht, da die Gefahr besteht, dass am Schluss was komplett falsches rauskommt.

    Freundliche Grüsse

    exc-jdbi
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!
    Der Vorschlag von @exc-jdbi funktioniert aber auch nur solange, wie ich keine Wörter mit Bindestrich benutze. Sein Name zum Beispiel würde die Entschlüsselung schon kräftig durcheinander bringen. Es würde auch schon reichen, wenn man das Leerzeichen nach dem Punkt (Satzzeichen) vergisst. Wenn du nach seiner Variante verfährst, solltest du zumindest den Punkt und den Bindestrich auch "verschlüsseln".
    Gut erkannt. Es ist genau das, was ich in #4 schon mitteilen wollte. Die gewünschten Zeichen, die als Codierung verwendet werden möchten, müssen damit sie nachher auch wieder korrekt erkennt werden können als eigenständiger 12er-Code verschlüsselt werden. Freie Kombinationsmöglichkeiten gibt es ja genug.

    Oder man kann sich ja gleich was eigenes machen. Es fehlt nur noch die Encoding und die Decoding-Funktionen
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Option Strict On
    2. Option Explicit On
    3. Imports System.Text
    4. Public Module StringCodierung
    5. Private Const CombiSize As Int32 = 12
    6. Private CPB As Dictionary(Of Char, String)
    7. Public Sub Main()
    8. 'Definiere Codezeichen
    9. CpbCode = ".:" '"-." '"-.+" '"-.+:"
    10. 'Vorzugsweise eine Dictionary für mein Beispiel
    11. '[A-Za-z0-9.-] 64 Zeichen
    12. CPB = GetRngCpb()
    13. If CPB Is Nothing Then Return
    14. Dim mytext = New StringBuilder
    15. mytext.AppendLine("Hallo, wie geht es dir? ")
    16. mytext.AppendLine("Ich war heute unterwegs. :-)")
    17. Dim cipher = Encode(mytext.ToString)
    18. Dim decipher = Decode(cipher)
    19. Stop
    20. End Sub
    21. Private Function Encode(txt As String) As String
    22. End Function
    23. Private Function Decode(cipher As String) As String
    24. End Function
    25. End Module
    26. 'Hab hier einfach mal einen Namen
    27. 'gegeben
    28. Public Module CodePunktBindestrichX
    29. Public CpbCode As String = Nothing
    30. Private ReadOnly Rand As New Random
    31. Private Const CombiSize As Int32 = 12
    32. Public Function GetRngCpb() As Dictionary(Of Char, String)
    33. If CpbCode Is Nothing Then Return Nothing
    34. Dim res = New Dictionary(Of Char, String)
    35. Dim alpha = AlphaString(), combi As String
    36. For Each c As Char In alpha
    37. While True
    38. combi = NewCombination(CombiSize)
    39. If Not res.ContainsValue(combi) Then
    40. res.Add(c, combi)
    41. Continue For
    42. End If
    43. End While
    44. Next
    45. Return res
    46. End Function
    47. Private Function NewCombination(size As Int32) As String
    48. Dim sep = CpbCode
    49. Dim res As New StringBuilder(12)
    50. For i As Int32 = 0 To size - 1
    51. res.Append(sep(Rand.Next Mod CpbCode.Length))
    52. Next
    53. Return res.ToString
    54. End Function
    55. Private Function AlphaString() As String
    56. Dim res As New StringBuilder(62)
    57. Dim z() As Byte = {48, 57, 65, 90, 97, 122}
    58. For i As Int32 = 0 To z.Length - 1 Step 2
    59. For j As Byte = z(i) To z(i + 1)
    60. res.Append(Convert.ToChar(j))
    61. Next
    62. Next
    63. res.Append(CpbCode)
    64. Return res.ToString
    65. End Function
    66. End Module



    Freundliche Grüsse

    exc-jdbi

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „exc-jdbi“ ()

    Gut dann nehme ich halt "Ook!" als bsp. und nutze pro Buchstabe 3x Ook.
    Alphabet dafür könnte dann vilt. so aussehen:
    Spoiler anzeigen

    A = Ook!Ook!Ook! | a = Ook.Ook,Ook, | 1 = Ook=Ook?Ook=

    B = Ook!Ook!Ook? | b = Ook,Ook.Ook. | 2 = Ook?Ook=Ook=

    C = Ook!Ook?Ook! | c = Ook.Ook.Ook, | 3 = Ook=Ook?Ook?

    D = Ook?Ook!Ook! | d = Ook-Ook-Ook! | 4 = Ook?Ook?Ook=

    E = Ook!Ook?Ook? | e = Ook-Ook!Ook- | 5 = Ook:Ook:Ook:

    F = Ook?Ook?Ook! | f = Ook!Ook-Ook- | 6 = Ook:Ook:Ook;

    G = Ook?Ook?Ook? | g = Ook-Ook!Ook! | 7 = Ook:Ook;Ook:

    H = Ook?Ook?Ook. | h = Ook!Ook!Ook- | 8 = Ook;Ook:Ook:

    I = Ook?Ook.Ook? | i = Ook_Ook_Ook_ | 9 = Ook:Ook;Ook;

    J = Ook.Ook?Ook? | j = Ook_Ook_Ook. | 0 = Ook;Ook;Ook:

    K = Ook?Ook.Ook. | k = Ook_Ook.Ook_

    L = Ook.Ook.Ook? | l = Ook.Ook_Ook_

    M = Ook.Ook.Ook. | m = Ook_Ook.Ook.

    N = Ook.Ook.Ook! | n = Ook.Ook.Ook_

    O = Ook.Ook!Ook. | o = Ook?Ook?Ook_

    P = Ook!Ook.Ook. | p = Ook?Ook_Ook?

    Q = Ook.Ook!Ook! | q = Ook_Ook?Ook?

    R = Ook!Ook!Ook. | r = Ook?Ook_Ook_

    S = Ook!Ook!Ook, | s = Ook_Ook_Ook?

    T = Ook!Ook,Ook! | t = Ook!Ook!Ook_

    U = Ook,Ook!Ook! | u = Ook!Ook_Ook!

    V = Ook!Ook,Ook, | v = Ook_Ook!Ook!

    W = Ook,Ook,Ook! | w = Ook!Ook_Ook_

    X = Ook,Ook,Ook, | x = Ook_Ook_Ook!

    Y = Ook,Ook,Ook. | y = Ook=Ook=Ook=

    Z = Ook,Ook.Ook, | z = Ook=Ook=Ook?

    Wie bekomme ich das dann am besten zurück in ein klaren Text ?

    EDIT: Da kommen wir dann aber wieder in Konflikt mit den Zeichen oder wie?
    Oder ist das Muster doch eigentlich immer identisch. 12-Zeichen(bsp: Ook!Ook!Ook!)
    Wenn ein einzelnes dort steht, dann ist es eine Aussage wie bspw. Lass das!
    Das bedarf eine kleine Abänderung der Funktion AlphaString() mehr nicht

    statt res.Append(CpbCode)

    VB.NET-Quellcode

    1. For Each c As Char In CpbCode
    2. If Not res.ToString.Contains(c) Then
    3. res.Append(c)
    4. End If
    5. Next


    Die Encoding-Funktion ist ja sehr einfach.
    - Deklariere dir einen Stringbuilder oder ein String als Rückgabewert
    - Erstelle eine For Each-Schleife durch deinen Text
    - Prüfe jedes Char (von deinem Text) mit ContainsKey ob es in der Dict drin ist
    - Wenn in der Dict vorhanden, dann dem Rückgabewert codiert (Valuewert der Dict) zufügen
    - Wenn nich dem Rückgabewert als uncodiert zufügen

    Das Decodieren ist auch einfach. Man muss nur ein paar Kleinigkeiten beachten
    - Erstell dir wiederum einen Stringbuilder oder String als Rückgabewert
    - Dreh die Dict um, so das alle Keys zu Values und alle Values zu Keys werden
    - Nimm eine Forschleife >> For i As Int32 = 0 To cipher.Length - 1
    - Prüfe in der For-Schleife als Erstes ob i + CombiSize kleiner cipherlänge
    - Wenn ja: Substring(i, CombiSize)
    - Wenn nein: Substring(i, cipherlänge - i)
    - Eine weitere Prüfung: Prüfen ob der erste Buchstabe (aus den 12er Block) in CpbCode enthalten ist
    - Gleichzeitig auch noch ob der 12er Block in der neuen Dict ist mit ContainsKey
    - Sofern beide Prüfungen ok, den Valuewert der neuen Dict dem Rückgabewert zufügen
    - Wenn einer der beiden Prüfungen versagt das Erste Zeichen im 12Block dem Rückgabewert zufügen

    Fertig

    Freundliche Grüsse

    exc-jdbi

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „exc-jdbi“ ()

    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!