Hi,
es gibt, so meine ich mich zu erinnern, eine Funktion, mit der man eine numerische Zahlt wie z.B. 20,50 in eine ausgeschriebene Zahl umwandeln kann. Kennt jemand von Euch diese Funktion oder kann mir jemand sagen, wo ich in der Hilfe zu diesem Thema etwas finden kann, meine Stichworte führten nicht zum gewünschten Ergebnis.
Danke u. Gruß
Wilhelm
Dim a as integer
a = 20,5
Dim b as string
b = cstr(a)
’ das c vor str bewirkt nur, dass wenn du versuchst einen String in einen String umzuwandeln die Kiste nicht abstürzt.
Hi Christian,
meine Frage war offenbar mißverständlich formuliert. Ich möchte nicht eine Zahl in eine Zeichenkette umwandeln; ich möchte erreichen, daß ich, wenn ich 20 als Zahl in eine Combobox1 eingebe, mit dem Exit-Ereignis dieser Combobox1 eine Combobox2 mit der Zeichenkette „Zwanzig“ gefüllt wird. Kennst Du oder jemand anderes dafür eine Lösung?
Gruß
Wilhelm
[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]
Das Problem ist, dass der Computer keine Wörter schreiben kann und wenn (zum Beispiel Rechtschreibüberprüfung), kann er Ihre Bedeutung nicht so komplex erfassen wie ein Mensch. Eine fertige Funktion dafür kenne ich nicht. Du kannst nur selbst eine Funktion basteln und aus einer Liste abfragen, ob die eingegebene Zahl existiert. dieser ist dann ein Wort zugeordnet. Im einfachsten Fall ein Listbox-Steuerelemente, das am Anfang mit Daten gefüttert wird. Dann entspricht der Index des Items der eingegebenen Zahl. Wenn die Visible des Controls False ist, wäre das die einfachste Lösung (da musst du erst gar keine Zusatzdateien erstellen und auch keine Funktionen schreiben mit Stringopoerationen).
Gruß Christian
Hi,
In einem Array speicherst Du Dir die Zahlwörter von 1 bis 20, die 30, 40, 50 bis 100, dann die 100, 1000, die Million, die Milliarde. Alles in allem 34 Werte, wenn mich nichts täuscht.
Dann mußt Du die Eingangszahl iterativ zerlegen und den entsprechenden Teilstring konkatenieren.
Gruß
J.
Hi José,
Danke für den Lösungsvorschlag, ist aber für mich noch zu schwierig.
Gruß
Wilhelm
[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]
Danke! o.T.
[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]
ohne Trara
Hi Wilhelm,
hier ist ein möglicher Lösungsweg. Es handelt sich um die Funktion toString:
? toString(192)
EinHundertZweiundNeunzig
Gruß
J.
Dim Zahlen(28) As String
Dim Potenzen(5) As String
Dim Suffixe(3) As String
Public Function toString(Zahl As Long) As String
Dim i As Integer
Dim Div As Long
Dim Rest As Long
Dim Temp As String
Dim Temp2 As String
Dim z As Integer
If Zahl = 0 Then toString = "Null": Exit Function
Init
i = 0
Div = Zahl
Do
Rest = Div Mod 1000
Temp = Hunderter(CInt(Rest))
If i = 0 Then
If Temp = "Ein" Then toString = "Eins"
ElseIf i \> 0 Then
If Temp = "Ein" Then
Temp = "Eine"
Temp2 = " "
Else
Temp2 = Suffixe(i)
End If
End If
toString = IIf(Temp = "", "", Temp & Potenzen(i) & Temp2) & toString
Div = (Div - Rest) \ 1000
i = i + 1
Loop While Div \> 0
End Function
Public Function Zehner(Zahl As Integer) As String
Dim Div As Long
Dim Rest As Long
Dim Temp As String
Init
If Zahl \> 99 Then
Zehner = "[Fehler: Zahl \> 99]"
Exit Function
End If
If Zahl = 0 Then
Exit Function
End If
If Zahl 0 Then Temp = Zahlen(Rest) & "und"
Temp = Temp & Zahlen(Div + 18)
End If
Zehner = Temp
End Function
Public Function Hunderter(Zahl As Long) As String
Dim Div As Long
Dim Rest As Integer
Dim Temp As String
Dim z As Integer
If Zahl \> 999 Then
Hunderter = "Zahlenüberlauf (Hunderter)"
Exit Function
End If
Rest = Zahl Mod 100
Temp = Zehner(Rest)
Rest = (Zahl - Rest) \ 100
If Rest \> 0 Then Temp = Zahlen(Rest) & Zahlen(28) & Temp
Hunderter = Temp
End Function
Public Sub Init()
Zahlen(0) = ""
Zahlen(1) = "Ein"
Zahlen(2) = "Zwei"
Zahlen(3) = "Drei"
Zahlen(4) = "Vier"
Zahlen(5) = "Fünf"
Zahlen(6) = "Sechs"
Zahlen(7) = "Sieben"
Zahlen(8) = "Acht"
Zahlen(9) = "Neun"
Zahlen(10) = "Zehn"
Zahlen(11) = "Elf"
Zahlen(12) = "Zwölf"
Zahlen(13) = "Dreizehn"
Zahlen(14) = "Vierzehn"
Zahlen(15) = "Fünfzehn"
Zahlen(16) = "Sechzehn"
Zahlen(17) = "Siebzehn"
Zahlen(18) = "Achtzehn"
Zahlen(19) = "Neunzehn"
Zahlen(20) = "Zwanzig"
Zahlen(21) = "Dreißig"
Zahlen(22) = "Vierzig"
Zahlen(23) = "Fünfzig"
Zahlen(24) = "Sechzig"
Zahlen(25) = "Siebzig"
Zahlen(26) = "Achtzig"
Zahlen(27) = "Neunzig"
Zahlen(28) = "Hundert"
Potenzen(0) = ""
Potenzen(1) = "Tausend"
Potenzen(2) = " Million"
Potenzen(3) = " Milliarde"
Suffixe(1) = " "
Suffixe(2) = "en "
Suffixe(3) = "n "
End Sub
Hi Jose,
unglaublich: ich habe von Deinem Code nichts verstanden, aber er läuft! Du bist für mich der Größte!
))
Danke und Gruß
[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]
unglaublich: ich habe von Deinem Code nichts verstanden, aber
er läuft! Du bist für mich der Größte!
Hallo,
Danke, das geht runter wie Öl 
Hier vielleicht eine kurze Erklärung.
Die Idee ist klar: Zahlwörter werden in einem Array abgespeichert, der jeweilige Index ist der Schlüssel für die Textkonvertierung: also Zahlen(3) ist „Drei“, Zahlen(7) ist „Sieben“, usw.
Wenn Du Dir die Zahlen anschaust, sieht man sofort, daß die ersten Zwanzig nicht so leicht berechnet werden können; die müssen also gespeichert werden. Damit habe ich schon Zahlen(1) bis Zahlen(20).
Ab Zwanzig gibt es eine Systematik: 43 z.B. ist Drei - und - Vierzig, 67 ist Sieben - und Sechzig, usw. Dabei muß man sich nur die Dreißig, Vierzig, usw. bis Neuinzig merken. Will man also eine Zahl kleiner 100 ausdrücken, muß man nur schauen: ist sie kleiner 20, gibt man die Zahl über den Index aus, ansonsten berechnet man die Zehner und Einser. Die Ausgabe setzt sich zusammen aus dem Zahlwort der Einser plus ein „und“ plus das Zahlwort der Zehner.
Damit kann man schon Zahlen zwischen 1 und 99 ausgeben:
Public Function Zehner(Zahl As Integer) As String
Dim Div As Long
Dim Rest As Long
Dim Temp As String
Init
If Zahl \> 99 Then
Zehner = "[Fehler: Zahl \> 99]"
Exit Function
End If
If Zahl = 0 Then
Exit Function
End If
If Zahl 0 Then Temp = Zahlen(Rest) & "und"
Temp = Temp & Zahlen(Div + 18)
End If
Zehner = Temp
End Function
Witzig ist hier nur die Berechnung der Einser und Zehner: die Zehner ist die ganzzahlige Division durch 10, die man mit dem „“ - Operator berechnet, die Einser wird mit dem Modulo-Operator geholt, der ja den Rest einer ganzzahligen Division ergibt, Beispiel 43: Rest ist 43 Mod 10, das ergibt 3. Div ist 43 \ 10, das ergibt 4. In der Funktion fangen die Zahlwörter bei 20 an, also Zahlen(20) = „Zwanzig“. Da ich schon weiß, daß Div sicher > 2 ist (die Zahlen kleiner 21 habe ich schon behandelt), muß ich 18 hinzuaddieren, um bei meinen Zehnern zu landen.
Die Funktion Hunderter macht das gleiche, sie berechnet das Zahlwort für den evtl. vorhandenen Hunderter und ruft Zehner() auf für den Rest.
Damit kann man schon Zahlen bis 999 ausgeben. Hier wiederholt sich dann die Systematik: man muß bloß „Tausend“ dahinterschreiben, die Zahlwörter sind gleich. Und bei der Million, der Milliarde und der Billion geht es nach dem gleichen Muster.
Die Funktion toString zerlegt also einfach die eingegebene Zahl in jeweils Tausenderblöcken und ruft die Funktion Hunderter auf. Dabei werden die Ausnahmen behandelt: Di 1 heißt nicht „Ein“, sondern wirklich „Eins“, die 0 heißt „Null“. Die Million und die Milliarde haben in der Mehrzahl jeweils einen Suffix (Million en , Milliarde n ). Außerdem sollen sie nur ausgegeben werden, wenn die entsprechende Zehnerpotenz auch vorkommt (also nicht etwa "Null Millionen und 23, sondern nur die 23): das erledigt dieser seltsame IIF-Ausdruck:
toString = IIf(Temp = „“, „“, Temp & Potenzen(i) & Temp2) & toString
soll heißen: wenn das Ergebnis der Hunderterberechnung leer ist, dann bleibe leer, ansonsten nimm das Ergebnis, füge die entsprechende Potenzzahl samt dem jeweiligen Suffix an und konkateniere es vor dem bereits bestehenden Ergebnis an.
Die Funktion ist beileibe nicht perfekt: zum einen fehlen ordentliche Bereichsüberprüfungen, negative Zahlen gehen hier flöten, usw. Zum anderen ist die Groß/Kleinschschreibung etwas holprig; ich weiß zwar nicht genau, was Herr Duden dazu sagt, aber bei dieser Zahlenausgabe würde er mit Sicherheit die Nase rümpfen. Hier kannst Du ansetzen: Mittels Ucase und LCase kannst Du Dir eine Capitalize-Funktion basteln, die Dir den ersten Buchstaben eines Wortes goßschreibt und den Rest klein. Diese, nach Aufruf von Hunderter() angewandt, würde das Erscheinungsbild um Längen verbessern.
Gruß
J.
Hi,
der code ist bereits im Einsatz, ich habe alle String-Zahlen klein geschrieben und die Leerschritte entfernt. Dann erfüllt er meine Vorgaben perfekt. Aber natürlich: Die ordentlichen Bereichsüberprüfungen vermisse ich natürlich sehr, genauso wie die anderen Unvollkommenheiten:wink:)) und erschrick mich nicht wieder mit so schwierigen Worten wie konkatenieren, die kaum der Findex lks unten wußte
Dank (Nr.2)
Gruß
Wilhelm
[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]