#!/usr/bin/perl
use strict;
use warnings;

foreach (
    # Aufbau: Eingabe|Erwartetes_Ergebnis
    '|undef',
    '0|undef',
    '0000000|undef',
    '1|eins',
    '2|zwei',
    '3|drei',
    '4|vier',
    '5|fünf',
    '6|sechs',
    '7|sieben',
    '8|acht',
    '9|neun',
    '10|zehn',
    '11|elf',
    '12|zwölf',
    '13|drei-zehn',
    '14|vier-zehn',
    '15|fünf-zehn',
    '16|sech-zehn',
    '17|sieb-zehn',
    '18|acht-zehn',
    '19|neun-zehn',
    '20|zwanzig',
    '21|ein-und-zwanzig',
    '21.23|undef',
    '32|zwei-und-dreißig',
    '40|vierzig',
    '43|drei-und-vierzig',
    '50|fünfzig',
    '55|fünf-und-fünfzig',
    '60|sechzig',
    '70|siebzig',
    '-73|undef',
    '80|achtzig',
    '90|neunzig',
    '100|ein-hundert',
    '9999|neun-tausend-neun-hundert-neun-und-neunzig',
    '00000009999|neun-tausend-neun-hundert-neun-und-neunzig',
    '511246798152931312488625|fünf-hundert-elf-trilliarden-zwei-hundert-sechs-und-vierzig-trillionen-sieben-hundert-acht-und-neunzig-billiarden-ein-hundert-zwei-und-fünfzig-billionen-neun-hundert-ein-und-dreißig-milliarden-drei-hundert-zwölf-millionen-vier-hundert-acht-und-achtzig-tausend-sechs-hundert-fünf-und-zwanzig',
) {
    my @paras = split /\|/,$_;
    my $rueck = zifferzuwort ($paras[0]);
    print "." . ((!defined $rueck && $paras[1] eq 'undef') || (defined $rueck && $rueck eq $paras[1]) ? '' : "\n'$paras[0]' FEHLER!!!" . chr(7) . "\n$rueck\nstatt\n$paras[1]\n");
}

###############################################################################

sub zifferzuwort {
    #
    # Quelle: https://www.perl-community.de/bat/poard/thread/17058#ms_155406
    # Stellt eine Zahl als Wort dar, z.B. für Quittungen.
    # Verarbeitet nur Ziffern, keine Nachkommastellen, keine Vorzeichen!
    # Liefert undef im Fehlerfall.
    #
    # Aufruf:
    # =======
    # print "12 -> ".zifferzuwort(12);
    #
    my %conf = (
        eins                        => [qw(ein eine eins)],
        null_zwoelf                 => [qw(null ein zwei drei vier fünf sechs sieben acht neun zehn elf zwölf)],
        sonder                      => {
            16 => "sech-zehn",
            17 => "sieb-zehn"
        },
        zehn_neunzig                => [qw(null zehn zwanzig dreißig vierzig fünfzig sechzig siebzig achtzig neunzig)],
        und                         => 'und',
        hundert_billiarde           => [qw(hundert tausend million milliarde billion billiarde trillion trilliarde)],
        hundert_billiarde_anhang    => ['','',qw(en n en n en n)],
    );
    my $wert=shift;
    return undef if !defined $wert || $wert=~/[^\d]/;
    $wert=~s/^0//g while $wert=~/^0/;
    return undef if $wert eq '';
    my @list=split(/(?<=\d)(?=(?:\d{3})+$)/,$wert);
    my $back='';
    for my $cnt (0..$#list) {
        my $val=$list[$cnt];
        my $mi=$conf{hundert_billiarde}[$#list-$cnt];
        my $re='';
        if($#list-$cnt>0) {
            if($val>1) {
                $mi.=$conf{hundert_billiarde_anhang}[$#list-$cnt];
                $re=_hundert($val,\%conf)."-".$mi;
            }
            elsif($val==1) { $re=$conf{eins}[$#list-$cnt>1?1:0]."-".$mi; }
        }
        else { $re=_hundert($val,\%conf); }
        $back.="-".$re;
    }
    $back=~s/-+/-/g;
    $back=~s/^-+//g;
    $back=~s/-+$//g;
    return $back;
    sub _hundert {
        my ($val,$conf)=@_;
        my $ret='';
        if($val<99) { $ret=_zehn($val,$conf); }
        else {
            my $f=substr($val,0,1,'');
            if($f==1) { $f=$conf->{eins}[0]."-".$conf->{hundert_billiarde}[0]; }
            else { $f=$conf->{null_zwoelf}[$f]."-".$conf->{hundert_billiarde}[0]; }
            $ret=$f."-"._zehn($val,$conf);
        }
        return $ret;
    }
    sub _zehn {
        my ($val,$conf)=@_;
        my $ret='';
        return '' if($val<=0);
        if($val<13) {
            if($val==1) { $ret=$conf->{eins}[2]; }
            else { $ret=$conf->{null_zwoelf}[$val]; }
        }
        elsif(exists($conf->{sonder}{$val})) { $ret=$conf->{sonder}{$val}; }
        else {
            my $pre=substr($val,0,1,'');
            my $prepre=$conf->{null_zwoelf}[$val];
            $ret=($val?$prepre.'-'.($pre>1?$conf->{und}.'-':''):'').$conf->{zehn_neunzig}[$pre];
        }
        return $ret;
    }
}