ABC anhand eines Wertes hochzählen und ausgeben

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 23 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    ABC anhand eines Wertes hochzählen und ausgeben

    Hallo zusammen,

    Mir fehlen momentan ein paar Mathematische Denkanstöße die mein Problem beheben würden.

    Zur Situation : Ich möchte wenn man in meine Funktion einen bestimmten Wert eingibt einen String in einem bestimmten Format zurückbekommen.

    Beispiele :

    F(2) = c
    F(25) = z
    F(27) = ab
    F(626) = aab

    Sprich dass Programm soll intern dass ABC hochzählen, wenn z erreicht ist entweder ein neues a einfügen, oder wenn dass a vorhanden ist dessen Wert auf b setzten.
    Eigentlich würden 2 Stellen schon reichen(ich möchte ein Zellensystem bennen (a1,b1) ect.. Aber wenn will ich dass schon recht dynamisch bewerkstelligen.

    Dass was ich bis jetzt habe :

    VB.NET-Quellcode

    1. Public Shared Function CreateAsciiLength(ByVal Length As Integer) As String
    2. 'Nun muss zu erst die absolute Lenge herausgefunden werden
    3. Dim abc() As Char = {CChar("a"), CChar("b"), CChar("c"), CChar("d"), CChar("e"), CChar("f"), CChar("g"), CChar("h"), CChar("i"), _
    4. CChar("j"), CChar("k"), CChar("l"), CChar("m"), CChar("n"), CChar("o"), CChar("p"), CChar("q"), CChar("r"), _
    5. CChar("s"), CChar("t"), CChar("u"), CChar("v"), CChar("w"), CChar("x"), CChar("y"), CChar("z")}
    7. Dim xAnzChar As Integer
    9. For i As Integer = 0 To Integer.MaxValue - 1
    10. If (abc.Length - 1) * (abc.Length - 1) ^ i > Length Then
    11. xAnzChar = i
    12. Exit For
    13. End If
    14. Next
    16. 'Nun liegt die Anzahl der maximalen Chars in xAnzChar vor.
    17. 'Nullbasierend!
    19. For i As Integer = 0 To Length - 1
    20. 'Vorgang
    21. 'Innere schleifen ausrechnen.
    22. 'Herausfinden wie oft die Innere Iterierung ausgeführt werden sollte
    23. Dim iLoop As Integer
    24. For iL As Integer = 0 To xAnzChar
    25. If i <= (abc.Length - 1) * (abc.Length - 1) ^ iL Then
    26. iLoop = iL
    27. Exit For
    28. End If
    29. Next
    30. 'Nun ist die Innere schleife fertig
    31. 'Die Anzahl entspricht der Länge des zu ermittelnden Stringes
    32. Dim Ad As String = String.Empty
    33. For goOut As Integer = iLoop To 0 Step -1
    34. 'Von links nach rechts gehen.
    35. 'Wert des höchsten Chars ausrechnen
    36. Next
    38. Next
    40. End Function

    Im Grunde habe ich mir folgendes gedacht. Anzahl an Stellen anhand des Inputs ausrechnen. Die Stellen intern in einer schleife durchgehen. Schauen wie oft der Wert abc*abc^Stelle reinpasst, Char setzen, und der wert abc*abc^Stelle vom momentanen Gesamtwert abziehen und mit der nächsten stelle weiterrechnen. Doch so richtig will das nicht funktionieren^^

    So ungefähr nur nicht richtig war mein Ansatz :

    VB.NET-Quellcode

    1. Dim Ad As String = String.Empty
    2. Dim GesamtWert As Integer = Length
    3. For goOut As Integer = 0 To iLoop
    4. 'Von links nach rechts gehen.
    5. 'Wert des höchsten Chars ausrechnen
    6. GesamtWert -= (abc.Length - 1 * abc.Length - 1 ^ goOut)
    7. If goOut = 0 Then
    8. Ad &= abc(i)
    9. Else
    10. If GesamtWert < 0 Then
    11. Ad &= abc(0)
    12. Else
    13. Dim c As Integer = GesamtWert \ (abc.Length - 1) * (abc.Length - 1) ^ goOut
    14. Ad &= abc(c)
    15. End If
    16. End If
    17. Next

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

    @Bagplatt,

    sitze gerade am Handy, kann dir also keinen Code geben.

    Ich würde das Problem ganz anders lösen.

    Erstell dir eine Klasse welche eine Property für deine Koordinaten also z.b. a1 oder ab .... enthält sowie deine Zahl - in deinem Beispiel der Index.

    Für dein zweidimensionales Feld erstellst für jede Zelle eine neue Instanz der Klasse und legst alle in einer eindimansionalen gemerischen Liste ab.

    Bei der Koordinatensuche brauchst du nicht mehr kompliziert unzurechnen.

    Kannst mir folgen ?

    Gruss

    mikeb69

    Hey,

    Ich glaube zu verstehen was du meinst. Doch dass ganze ist nicht für die Interne Verarbeitung vorgesehen. Die Strings sollen im späteren Verlauf an bestimmten Positionen gedruckt werden.

    Kannst dir vorstellen wie Schiffe versenken. Oben die Buchstaben und am linken Rand die Zahlen.
    Sprich es soll nur für meine Optik sein. Klar, könnte ich auch alles über x:y ausgeben. Aber die Möglichkeit A1 oder ab1 fand ich ansprechender.

    Wahrscheinlich liegt dass ganze auch nur an meinen "grottenschlechten" Mathematischen Fähigkeiten ;)

    Wenn ich jetzt ein String mit einer maximalen Charlänge von 1 hab. Sind ja 2 Zeichen.
    Dann hab ich doch abc.Length*abc.Length

    Hab ich jetzt eine Charlänge von 3
    Dann würde ich jetzt abc.Length*abc.Length^3 rechnen

    Mach ich mir dass vielleicht zu kompliziert?

    Edit#

    abc*abc entspricht ja abc^2
    Also wären 3 Chars dann ganz einfach abc^3

    #Edit

    Ich habe den Quelltext nochmal überarbeitet. Doch nach z gibt er mir nur noch aa aus. Also ganz richtig ist dass noch nicht aber ich denke mal nicht ganz verkehrt.

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Shared Function CreateAsciiLength(ByVal Length As Integer) As String
    2. 'Nun muss zu erst die absolute Lenge herausgefunden werden
    3. Dim abc() As Char = {CChar("a"), CChar("b"), CChar("c"), CChar("d"), CChar("e"), CChar("f"), CChar("g"), CChar("h"), CChar("i"), _
    4. CChar("j"), CChar("k"), CChar("l"), CChar("m"), CChar("n"), CChar("o"), CChar("p"), CChar("q"), CChar("r"), _
    5. CChar("s"), CChar("t"), CChar("u"), CChar("v"), CChar("w"), CChar("x"), CChar("y"), CChar("z")}
    7. 'Neuer Versuch
    8. 'Zuerst bestimmen wir die absolute Länge an Zeichen
    9. Dim absoluteLength As Integer
    11. 'Nun suchen wir den Wert dafür
    12. For i As Integer = 0 To Integer.MaxValue - 1
    13. If (abc.Length - 1) ^ i <= Length Then
    14. 'Dieser Wert ist gleich oder größer bzw. am nächsten von der absoluten Länge
    15. absoluteLength = i
    16. 'Schleife verlassen da der Wert gefunden wurde
    17. Exit For
    18. End If
    19. Next
    21. 'Nun ist der größte Wert an Zeichen vorhanden und man kann mit der Schleife beginnen
    22. For Top As Integer = 0 To Length - 1
    23. 'Da wir nicht aaaaaa wollen, sonder immer nur die momentane Anzahl an stellen eine neue Schleife erstellen
    24. 'Zuerst schauen wieviele Stellen wir bei dem Wert von #TOP# haben
    25. Dim curStep As Integer = 0
    26. If Top <= (abc.Length - 1) Then
    27. 'Der Wert ist noch 0 sprich 1 Stelle
    28. curStep = 0
    29. Else
    30. 'Nun sind nachkommende Stellen vorhanden
    31. curStep = Top \ (abc.Length - 1)
    32. End If
    34. 'Hier ist nun die Stellenanzahl vorhanden
    35. 'Wenn curStep = 0 können wir einfach mit abc(Top) den Char setzen.
    36. Dim output As String = String.Empty
    37. If curStep = 0 Then
    38. output = abc(Top)
    39. Else
    40. 'Der Output Wert ist größer als 1 Stelle und muss in einer Schleife berechnet werden
    41. Dim Gesamtwert As Integer = curStep ^ (abc.Length - 1)
    42. For x As Integer = curStep To 0 Step -1
    43. 'Wir starten die Schleife mit dem größten Wert
    44. 'Berechnen der größten Stelle
    45. Dim tmp As Integer = x ^ (abc.Length - 1)
    46. If tmp > Gesamtwert Then
    47. 'Der Wert übersteigt den Gesamtwert und kann nicht abgezogen werden
    48. 'Entspricht dem Nullwert
    49. output &= abc(0)
    50. Else
    51. 'Der Wert kann abgezogen werden
    52. output &= abc(Gesamtwert - tmp)
    53. Gesamtwert -= tmp
    54. End If
    56. Next
    58. End If
    59. MsgBox(output)
    60. Next
    62. End Function

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Bagplatt“ ()

    mir ist leider keine flexible Lösung eingefallen aber bis zu 5 Stellen könnte dir folgendes helfen :

    VB.NET-Quellcode

    1. Private Function Calculate(ByVal Zahl As Integer) As String
    2. If Zahl > 0 Then
    3. Dim abc() As Char = {CChar("a"), CChar("b"), CChar("c"), CChar("d"), CChar("e"), CChar("f"), CChar("g"), CChar("h"), CChar("i"),
    4. CChar("j"), CChar("k"), CChar("l"), CChar("m"), CChar("n"), CChar("o"), CChar("p"), CChar("q"), CChar("r"),
    5. CChar("s"), CChar("t"), CChar("u"), CChar("v"), CChar("w"), CChar("x"), CChar("y"), CChar("z")}
    6. Select Case True
    7. Case Zahl <= 26
    8. Return abc(Zahl - 1)
    9. Case Zahl > 26 AndAlso Zahl <= 52
    10. Dim Zahl2 As Integer = Zahl - 26
    11. Return abc(25) & abc(Zahl2 - 1)
    12. Case Zahl > 52 AndAlso Zahl <= 78
    13. Dim Zahl2 As Integer = Zahl - 26
    14. Dim Zahl3 As Integer = Zahl2 - 26
    15. Return abc(25) & abc(25) & abc(Zahl3 - 1)
    16. Case Zahl > 78 AndAlso Zahl <= 104
    17. Dim Zahl2 As Integer = Zahl - 26
    18. Dim Zahl3 As Integer = Zahl2 - 26
    19. Dim Zahl4 As Integer = Zahl3 - 26
    20. Return abc(25) & abc(25) & abc(25) & abc(Zahl4 - 1)
    21. Case Zahl > 104 AndAlso Zahl <= 130
    22. Dim Zahl2 As Integer = Zahl - 26
    23. Dim Zahl3 As Integer = Zahl2 - 26
    24. Dim Zahl4 As Integer = Zahl3 - 26
    25. Dim Zahl5 As Integer = Zahl4 - 26
    26. Return abc(25) & abc(25) & abc(25) & abc(25) & abc(Zahl5 - 1)
    27. Case Else
    28. Return ""
    29. End Select
    30. Else
    31. Return ""
    32. End If
    33. End Function


    Wenn die Zahl zu hoch ist also über 130, kommt ein leerer String zurück, könnte aber theoretisch beliebig erweitert werden

    Greets

    Edit: mist ich seh grade das du 0 als a haben willst und 1 schon b ist...
    If Energy = Low Then
    Drink(aHugeCoffee)
    Else
    Drink(aHugeCoffeeToo)
    End If

    asusdk schrieb:

    0 als a



    Ist ja auch als erstes im Array :D

    Danke dir für die mühe, ich werde dass mal noch ein wenig weiter versuchen. Eigentlich würden 2 Stellen schon reichen, aber mich packt immer der Ehrgeiz ein wenig, und somit versuch ich dass weiterhin dynamisch zu lösen. Wenn nicht verwende ich dein Beispiel :)

    sry ein dynamischer weg ist mir noch nicht eingefallen ^^ ich drück dir die daumen

    Falls du doch mein Beispiel verwendest hab ichs noch auf 0 als a angepasst =)

    VB.NET-Quellcode

    1. Private Function Calculate(ByVal Zahl As Integer) As String
    2. If Zahl > -1 Then
    3. Dim abc() As Char = {CChar("a"), CChar("b"), CChar("c"), CChar("d"), CChar("e"), CChar("f"), CChar("g"), CChar("h"), CChar("i"),
    4. CChar("j"), CChar("k"), CChar("l"), CChar("m"), CChar("n"), CChar("o"), CChar("p"), CChar("q"), CChar("r"),
    5. CChar("s"), CChar("t"), CChar("u"), CChar("v"), CChar("w"), CChar("x"), CChar("y"), CChar("z")}
    6. Select Case True
    7. Case Zahl <= 25
    8. Return abc(Zahl)
    10. Case Zahl > 25 AndAlso Zahl <= 51
    11. Dim Zahl2 As Integer = Zahl - 26
    12. Return abc(25) & abc(Zahl2)
    14. Case Zahl > 51 AndAlso Zahl <= 77
    15. Dim Zahl2 As Integer = Zahl - 26
    16. Dim Zahl3 As Integer = Zahl2 - 26
    17. Return abc(25) & abc(25) & abc(Zahl3)
    19. Case Zahl > 77 AndAlso Zahl <= 103
    20. Dim Zahl2 As Integer = Zahl - 26
    21. Dim Zahl3 As Integer = Zahl2 - 26
    22. Dim Zahl4 As Integer = Zahl3 - 26
    23. Return abc(25) & abc(25) & abc(25) & abc(Zahl4)
    25. Case Zahl > 103 AndAlso Zahl <= 129
    26. Dim Zahl2 As Integer = Zahl - 26
    27. Dim Zahl3 As Integer = Zahl2 - 26
    28. Dim Zahl4 As Integer = Zahl3 - 26
    29. Dim Zahl5 As Integer = Zahl4 - 26
    30. Return abc(25) & abc(25) & abc(25) & abc(25) & abc(Zahl5)
    31. Case Else
    32. Return ""
    33. End Select
    34. Else
    35. Return ""
    36. End If
    37. End Function


    Greets
    If Energy = Low Then
    Drink(aHugeCoffee)
    Else
    Drink(aHugeCoffeeToo)
    End If

    Kurzer Einwurf: Das ganze CChar("a")... kann man zu "a"c, "b"c, ... kürzen.
    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.

    @Bagplatt,

    Die Strings sollen im späteren Verlauf an bestimmten Positionen gedruckt werden.

    Was spricht dagegen, gib der Klasse noch eine Property für X und Y dann hast du deine Koordinaten.

    Mit einer Liste bist du flexibel ohne Ende - es sei denn der Speicher geht dir irgendwann aus.

    Die Lösung von @asusdk ist unelegant und unflexibel.

    Mach ich mir dass vielleicht zu kompliziert?

    Denke ja.

    Arbeitest du mit Klassen in einer generischen Liste kannst du alle Informationen über die Zelle in die Klasse packen.
    Kein doppelter Code nichts.
    Beim Instanzieren der einzelnen Klassen (für jede Zelle eine) ordnest du deine ID's - wie immer die aussehen - zu und musst nie mehr umrechnen.
    Beim Schiffe versenken steht in der Klasse auch was sich in der Zelle befindet (Wasser, Schiff blau oder rot oder was auch immer).

    Alles easy und übersichtlich.

    Hab grad keine Zeit sonst würde ich dir schnell ein Beispiel schreiben und posten.
    Vielleicht heute Abend - mal sehen.

    Gruss

    mikeb69

    mikeb69 schrieb:

    Klassen in einer generischen Liste kannst du alle Informationen über die Zelle in die Klasse packen


    Dass ist mir ja bewusst, nur dafür muss ich sie erstmal bereitstellen.
    Ansprechen werde ich sie auch intern mit ihren Positionen im Array. Doch sobald ich die Infos auf den Schirmbringe möchte ich diese schön benannt haben :D

    Diese Funktion oben soll mir einfach nur ein paar Namen erstellen.

    VaporiZed schrieb:

    CChar("a")... kann man zu "a"c



    Hat dass denn irgendwelche Vorteile? Außer dass es gekürzt wurde?

    Hat dass denn irgendwelche Vorteile? Außer dass es gekürzt wurde?

    Ja geht nur darum es zu kürzen und übersichtlicher zu gestalten.

    ich hab meine Version der Lösung nun dynamisch gestaltet :

    VB.NET-Quellcode

    1. Private Function Calculate2(ByVal Zahl As Integer) As String
    2. Zahl += 1
    3. If Zahl > -1 Then
    4. Dim abc() As Char = {"a"c, "b"c, "c"c, "d"c, "e"c, "f"c, "g"c, "h"c, "i"c, "j"c, "k"c, "l"c, "m"c, "n"c, "o"c, "p"c, "q"c, "r"c,
    5. "s"c, "t"c, "u"c, "v"c, "w"c, "x"c, "y"c, "z"c}
    7. Dim ResultString As String = ""
    8. Dim IntList As New List(Of Integer)
    10. Do
    11. Select Case True
    12. Case Zahl >= 26
    13. IntList.Add(25)
    14. Zahl -= 26
    16. Case Zahl < 26 AndAlso Zahl > 0
    17. IntList.Add(Zahl - 1)
    18. Zahl = 0
    19. End Select
    20. Loop Until Zahl = 0
    22. For I As Integer = 0 To IntList.Count - 1
    23. ResultString = ResultString & abc(IntList.Item(I))
    24. Next
    26. Return ResultString
    28. Else
    29. Return ""
    30. End If
    31. End Function


    aber ich würde vermuten die idee von mikeb69 wäre effizienter (ich würde diese Lösung auch gerne sehen, habs bisher aufgrund der Erklärung noch nicht ganz verstanden ^^)
    und @mikeb69 ja das stimmt meine Lösung war weder flexibel noch elegant, ich hab nur bislang noch nicht so wirklich mit Klassen gearbeitet und mach das ganze hier ja nur hobbymäßig ^^

    Greets
    If Energy = Low Then
    Drink(aHugeCoffee)
    Else
    Drink(aHugeCoffeeToo)
    End If

    hehe

    @asusdk

    So weit war ich auch vor 15 minuten bis ich etwas weiteres gravierendes entdeckt habe.

    Gib mal 150 ein. Rauskommt zzzzzu richtig wäre aber ek.

    Deswegen find ich dass ja ganz "triky" :D

    #edit

    Bei einer Anzahl von 3 Bustaben hast du schon einen Zahlenbereich von 25³ = 15625 abgedeckt.

    Eigentlich sollte der Rechte wert hochgezählt werden. Bis z. Der linke wird dann z.B. b. Ist dieser auf z wird der nächste wieder b, und alle andere log. a.

    Sprich Bruteforce, o. zählen mit Bustaben wenn du dann verstehst was ich meine :)


    Wenn man den richtigen Mathematischen Ansatz hat sind dass warscheinlich 10 Zeilen Code mehr nicht.

    Die Spalten durchgehen, vom größten Wert anfangen, mit der Anzahl im ABC Potenzieren und von der gesamten Anzahl bzw. vom Input abziehen. So die spalten durchgehen bis am Schluss ein Rest bleibt. Ist dieser Rest unter bzw gleich der Anzahl vom ABC.Leng hat man richtig gerechnet. Dass was ich noch nicht tue :D

    Hier war ein (wieder) neuer Ansatz :

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Shared Function GetABC(ByVal Value As Integer) As String
    2. Dim abc() As Char = {CChar("a"), CChar("b"), CChar("c"), CChar("d"), CChar("e"), CChar("f"), CChar("g"), CChar("h"), CChar("i"), _
    3. CChar("j"), CChar("k"), CChar("l"), CChar("m"), CChar("n"), CChar("o"), CChar("p"), CChar("q"), CChar("r"), _
    4. CChar("s"), CChar("t"), CChar("u"), CChar("v"), CChar("w"), CChar("x"), CChar("y"), CChar("z")}
    6. 'Länge vom String herausfinden
    8. Dim rLength As Integer
    10. For i As Integer = 0 To Integer.MaxValue - 1
    11. If Math.Pow((abc.Length - 1), i) > Value Then
    12. rLength = i - 1
    13. Exit For
    14. End If
    15. Next
    17. 'Die Länge entspricht den Späteren Spalten vom String
    19. 'ABC berechnen. Vom Größten Wert zum kleinsten
    20. Dim OutPut As String = String.Empty
    21. For i As Integer = 0 To rLength
    22. If i = 0 Then
    23. Dim lV As Integer = Math.Pow((abc.Length - 1), rLength) - Math.Pow((abc.Length - 1), rLength)
    24. OutPut &= abc(lV)
    25. MsgBox(lV)
    26. Else
    27. Dim rV As Integer = Value - Math.Pow((abc.Length - 1), i) - Math.Pow((abc.Length - 1), rLength - 1)
    28. OutPut &= abc(rV)
    29. MsgBox(rV)
    30. End If
    32. Next
    33. MsgBox(OutPut)
    34. End Function

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „Bagplatt“ ()

    @Bagplatt ne leider muss ich gestehen das ich das dann wohl nicht ganz verstehe, wieso soll 150 = ek sein ? die 25 passt doch deutlich öfter rein als 2 x
    irgendwo hängts hier wohl an meinem verständniss dessen was du erreichen willst ^^
    If Energy = Low Then
    Drink(aHugeCoffee)
    Else
    Drink(aHugeCoffeeToo)
    End If

    Ja klar passt die öfters rein.

    Pass auf ein Beispiel

    du zählst bis 9 hoch, dann gibst du eins dazu und hast 10, dann zählst du weiter, bei 19 + 1 erhält die linke stelle dann 2. Die rechte wieder die 0. Dann geht dass so weiter bis 29. +1 = 30. sprich die 9 wird zur 0 und die 2 zur 3

    Jetzt stell dir dass mit Bustaben vor. Die Anzahl bis der höchste Betrag einer Stelle erreicht wird entspricht der Anzahl von Stellen in dem ABC Array :D Verstehst du jetzt so ungefähr?

    Und sorry. ek entspricht 136

    150 entsprich demnach fa



    Bagplatt schrieb:

    Verstehst du jetzt so ungefähr?
    Meinst Du ein Zahlen-System, dass in Buchstaben codiert wird?
    Dann rechne in Zahlen und konvertiere die Ausgabe in Deine Zeichen.
    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).
    Programmierfragen über PN / Konversation werden ignoriert!

    RodFromGermany schrieb:

    Meinst Du ein Zahlen-System, dass in Buchstaben codiert wird?



    Kann man dass so nennen? Ich weis es ehrlich gesagt nicht so genau.
    Im Grunde kann man dass ja ganz leicht ausrechnen. (So fern ich im bereich von aa - zz bleibe) Wir nehmen jetzt was weis ich : 233 / 25 = 9.
    Bedeutet die erste stelle wird zu i. Ein Rest von 9 * 25 = 225 zu 233 ist dann 8. Bedeutet dass Ergebnis müsste dann ih sein.

    @RodFromGermany Ich rechne schon die ganze Zeit in zahlen :thumbsup: dass Ergebniss hole ich mir dann über den Wert von meinem ABC. Ich griege die Anzahl an Stellen wo der String am Ende besitzt ja schon raus. Schließlich ist ja z.B. aaaa = 25^4 = 390.625 an Möglichkeiten.
    Nur die Berechnung will mir nicht gelingen wenn bzw. ich hab kein Ansatz mehr

    @Bagplatt Das sieht genau nach so was aus. Ob es genau das ist, musst Du erkennen.
    Sicherlich kennst Du das Dualsystem mit 0 und 1, das könnte man z.B. mit F und T schreiben (False, True).
    Dann gibt es das Oktalsystem (0...7), das Dezimalsystem (0...9), das Duodezimalsystem (0,1,2,3,4,5,6,7,8,9,a,b),
    das Hexadezimalsystem (0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f)
    usw.
    Natürlich kann man das Hexadezimalsystem auch mit (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) oder sonst wie darstellen.
    Gugst Du zunächst Stellenwertsystem.
    Danach gugst Du Dezimalzahl in beliebiges Zahlensystem umrechnen.
    Danach schreibst Du das Efrgebnis in Deinen Zeichen und feddich.
    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).
    Programmierfragen über PN / Konversation werden ignoriert!

    @RodFromGermany

    Ich hab hier mal was schnelles geschrieben um dass ungefähr darzustellen

    Spoiler anzeigen

    VB.NET-Quellcode

    1. ​Public Shared Function IDirty(ByVal Value As Integer) As String
    3. Dim abc() As Char = {CChar("a"), CChar("b"), CChar("c"), CChar("d"), CChar("e"), CChar("f"), CChar("g"), CChar("h"), CChar("i"), _
    4. CChar("j"), CChar("k"), CChar("l"), CChar("m"), CChar("n"), CChar("o"), CChar("p"), CChar("q"), CChar("r"), _
    5. CChar("s"), CChar("t"), CChar("u"), CChar("v"), CChar("w"), CChar("x"), CChar("y"), CChar("z")}
    7. Dim absoluteLength As Integer
    8. 'Nun suchen wir den Wert dafür
    9. For i As Integer = 0 To Integer.MaxValue - 1
    10. If Math.Pow((abc.Length - 1), i) >= Value Then
    11. 'Dieser Wert ist gleich oder größer bzw. am nächsten von der absoluten Länge
    12. absoluteLength = i
    13. 'Schleife verlassen da der Wert gefunden wurde
    14. Exit For
    15. End If
    16. Next
    18. Dim spalten As New List(Of Integer)
    19. For i As Integer = 0 To absoluteLength - 1
    20. spalten.Add(0)
    21. Next
    23. For xx As Integer = 0 To Value - 1
    24. 'xx entspricht dem rechten Wert
    25. spalten.Item(spalten.Count - 1) += 1
    26. If spalten.Item(spalten.Count - 1) = 25 Then
    27. 'Linke +1
    28. spalten.Item(spalten.Count - 2) += 1
    29. spalten.Item(spalten.Count - 1) = 0
    30. 'Schleife bis an die Spitze zum testen auf 25
    31. For t As Integer = spalten.Count - 1 To 0 Step -1
    32. If spalten.Item(t) = 25 Then
    33. spalten.Item(t) = 0
    34. spalten.Item(t - 1) += 1
    35. End If
    36. Next
    37. End If
    38. Next
    40. Dim output As String = String.Empty
    41. For i As Integer = 0 To spalten.Count - 1
    42. output &= abc(spalten(i))
    43. Next
    44. Return output
    45. End Function


    Dass was ich da oben geschrieben habe, die schöne Methode IDirty, schnell zusammengekleistert. Ist eigentlich genau dass was ich will.
    Nur halt eben "anders". Hier gehe ich wirklich jede Nummer bis zum erreichen des Maximus durch. Maximum = Input.

    Aber ich kann mir ja auch mittels Potenzieren die benötigte Anzahl an Spalten die meinen String am Ende darstellen errechnen.
    Wenn ich jetzt eine Formel erarbeite die in einer Schleife die Nur die Spalten durchgeht. Man nehme jetzt 3.
    Dann hab ich wenn ich die gegenüber stelle -> Eine Schleife mit 3 durchgängen oder Eine Schleife mit 25^3 durchgängen. Ist klar was man da wählt oder :)

    Alle Ansätze ich die habe verschwimmen mehr und mehr. Echt unglaublich.

    Hier ein kleines VBA-Programm.
    Zum Test werden die Daten in eine Datei geschrieben.
    Erzeugt die Ausgaben für 1 -> a, für 28 -> ab, für 702 -> zz

    Visual Basic-Quellcode

    1. Sub a_z()
    3. Dim i As Long, x As Long, z As Long
    4. Dim t As String
    6. Open "d:\##\az_test.txt" For Output As #1 '<--- Pfad anpassen!
    8. For i = 1 To 702
    9. x = i + 96
    11. Select Case i
    12. Case 1 To 26 'a-z
    13. t = Chr(x)
    14. Case 27 To 702 'aa -zz
    15. z = (i - 1) \ 26
    16. t = Chr(z + 96) & Chr(x - (26 * z))
    17. End Select
    19. Print #1, t, "i = "; i
    20. Next
    22. Close
    23. End Sub

    Hier eine generische Lösung:

    VB.NET-Quellcode

    1. Public Class Program
    3. Public Shared Sub Main(ParamArray args() As String)
    4. For i = 0 To 200
    5. Dim s = CharsetFormatting(i)
    6. If s <> Convert.ToString(i, 16).ToUpper Then
    7. Throw New Exception("falsch gerechnet!")
    8. End If
    9. If i <> CharsetParsing(s) Then
    10. Throw New Exception("falsch gerechnet!")
    11. End If
    12. Next
    13. End Sub
    15. Private Shared charset As String = "0123456789ABCDEF" ' Testweise mit dem Hex-Charset (Base16), weil das ist leicht gegenzutesten
    16. 'Private Shared charset As String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ' Base26 - Charset
    18. Public Shared Function CharsetFormatting(numb As Integer) As String
    19. Dim rest = 0
    20. Dim stk = New Stack(Of Integer)
    21. Do
    22. numb = Math.DivRem(numb, charset.Length, rest)
    23. stk.Push(rest)
    24. Loop Until numb = 0
    25. Return New String(stk.Select(Function(i) charset(i)).ToArray)
    26. End Function
    28. Public Shared Function CharsetParsing(s As String) As Integer
    29. Dim val = 0
    30. For i = 0 To s.Length - 1
    31. With charset
    32. val *= .Length
    33. val += .IndexOf(s(i))
    34. End With
    35. Next
    36. Return val
    37. End Function
    39. End Class
    Sub Main ist ein Test, arbeitet mit einem Hexadezimal-Charset, und prüft die Ergebnisse gegen Convert.ToString(numb, 16).
    Beachte die schnucklige DivRem-Funktion - damit erhält man den Modulo-Wert und den Rest in einem Aufruf.
    Beachte auch, dass A die 0 darstellt - nicht 1

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