#!/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;
	}
}