ich muss ein programm schreiben das eine eingebene zahl als wort ausgibt.

zb. eingabe: 123
ausgabe: hundertdreiundzwanzig

ich hab bis jetzt erst ein paar arrays in denen die die wörter drinstehen, die ich für die ausgabe brauche.

kann mir jemand einen tipp geben, wie es weiter geht

danke

Bessere Lösung: Zerleg die Zahl mit % und / in einzelne Stellen und bau sie zusammen (da brauchst du vor allem eine Sonderbehandlung für den Bereich 1 bis 19).

ich muss ein programm schreiben das eine eingebene zahl als wort ausgibt.

zb. eingabe: 123
ausgabe: hundertdreiundzwanzig

In C++ geht das über die Facette num_put, die man beim gewünschten Ausgabe-Stream austauschen muss. Ich habe das früher schon mal für englische Zahlen bis 999999 gemacht.

#include <iostream>
#include "Zahlenklartext.h"

int main()
{
    using namespace std;
    cout.imbue( locale( cout.getloc(), new ZahlKlartext ) );
    for( int i = 1; i < 3000; i *= 7 )
        cout << i << endl;
    return 0;
}

Die Ausgabe ist

one
seven
fourtynine
threehoundredfourtythree
twothousandfourhoundredone

Dann fehlt 'nur noch' das Include-File 'Zahlenklartext.h' - für deutsche Zahlen muss der Algorithmus natürlich angepasst werden.

#ifndef _ZAHLENKLARTEXT_H_
#define _ZAHLENKLARTEXT_H_

#include <locale>
#include <algorithm>
#include <iterator>
#include <cstring>      // strlen

#pragma warning ( disable : 4511 4512 )     // copy constructor / assignment operator could not be generated

namespace
{
namespace text
{
    const char* minus = "minus";
    const char* numbers[] = {
        "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", 
            "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen",
            "twenty"
    };
    const char* tausend = "thousand";
    const char* hundert = "houndred";
    const char* zehner = "ty";

    template< typename I >
    I print( I out, const char* txt )
    {
        return std::copy( txt, txt + std::strlen( txt ), out );
    }
}
}

template< typename E, typename OutIt = std::ostreambuf_iterator< E > >
class basic_ZahlKlartext : public std::num_put< E, OutIt >
{
public:
    typedef std::num_put< E, OutIt > base_type;

    explicit basic_ZahlKlartext( std::size_t refs = 0 ) : base_type( refs ) {}
    virtual ~basic_ZahlKlartext() {}

protected:
    virtual iter_type do_put( iter_type out, std::ios_base& ios_, char_type fill,
        long v ) const
    {
        if( v < 0 )
        {
            out = text::print( out, text::minus );
            *(out++) = fill;
            v = -v;
        }
        return put( out, ios_, static_cast< unsigned long >( v ) );
    }
    virtual iter_type do_put( iter_type out, std::ios_base& ios_, char_type,
        unsigned long v ) const
    {
        return put( out, ios_, static_cast< unsigned long >( v ) );
    }

private:
    iter_type put( iter_type out, std::ios_base& ios_,
        unsigned long v ) const
    {
        if( v >= 1000 )
        {
            out = put( out, ios_, v / 1000 );
            out = text::print( out, text::tausend );
            v %= 1000;
            if( v == 0 ) return out;
        }
        if( v >= 100 )
        {
            unsigned long h = v / 100;
            if( h > 0 )
            {
                out = text::print( out, text::numbers[ h ] );
                out = text::print( out, text::hundert );
                v %= 100;
                if( v == 0 ) return out;
            }
        }
        if( v >= sizeof(text::numbers)/sizeof(*text::numbers) )
        {
            unsigned long z = v / 10;
            if( z == 2 )
            {
                // Sonderbehandlung für twenty
                out = text::print( out, text::numbers[ 20 ] );
            }
            else
            {
                out = text::print( out, text::numbers[ z ] );
                out = text::print( out, text::zehner );
            }
            v %= 10;
            if( v == 0 ) return out;
        }
        return text::print( out, text::numbers[ v ] );
    }
};

typedef basic_ZahlKlartext< char > ZahlKlartext;
typedef basic_ZahlKlartext< wchar_t > WZahlKlartext;

#endif  // ifndef _ZAHLENKLARTEXT_H_

Gruß
Werner

Ok, was mir so auffällt:
- Die Namen der Zahlen von 0 bis 19 sollte man sich abspeichern, da etwas speziell.
- Die Namen der Zahlen 20, 30, 40... werden gebildet durch den Namen des Einers+"zig". Ausnahmen sind zwanzig, dreißig sechzig und siebzig. Muss man sich wieder abspeichern
- 100, 1000, 1000000 usw haben wieder spezielle Namen. (wieder abspeichern) (muss also vorher festlegen bis wohimn es gehen soll)
- Für alle Zahlen <100 und >19 gilt: Erst kommt die Einer-Stelle, dann ein "und" und dann die enstsprechende 10er Stelle (22-> zwei+"und"+zwanzig) Diese lassen sich also zusammensetzen.
- Alle Zahlen >=100 sind simple Aneinanderreihungen der Namen der Ziffern+der Name der Stelle (hundert, tausend, million...)

vllt kannst du damit was anfangen. Quasi eins nach dem andern zum laufen bringen.

Hoffe ich habe nichts vergessen.

EDIT in Bezug auf den Post unter mir.

Mal n büschen klugscheissen.