Programmieren lernen

(* Modula II: Alle Zahlen von 0 bis 1000 *)
(* 1. Als Text ausgeben *)
(* 2. Alphabetisch sortieren *)
(* Autor: Ph. Gressly Freimann 1990 *)

MODULE ONWrite;

FROM InOut IMPORT WriteString, WriteLn, WriteInt, Write;
FROM Str IMPORT Concat, Copy, Compare, Length;

CONST Max = 1000;

TYPE String255 = ARRAY[0..255] OF CHAR;
     Zahl= RECORD
              N: INTEGER;
              S: String255
           END;

VAR i: INTEGER;
    Name: String255;
    Alle: ARRAY [-1..Max+1] OF Zahl;





PROCEDURE AddZiffer(VAR Str: ARRAY OF CHAR; n: INTEGER);
BEGIN
   CASE n OF
     0: Concat(Str, "null")
   | 1: Concat(Str, "ein")
   | 2: Concat(Str, "zwei")
   | 3: Concat(Str, "drei")
   | 4: Concat(Str, "vier")
   | 5: Concat(Str, "fuenf")
   | 6: Concat(Str, "sech")
   | 7: Concat(Str, "sieben")
   | 8: Concat(Str, "acht")
   | 9: Concat(Str, "neun")
   ELSE
   END
END AddZiffer;



PROCEDURE Sonderfall(n: INTEGER; VAR Str: ARRAY OF CHAR): BOOLEAN;
VAR ZEIN: INTEGER; (* Zehner und EINER *)
BEGIN
   ZEIN := n MOD 100;
   CASE ZEIN OF
    11: Concat(Str, "elf")
   |12: Concat(Str, "zwoelf")
   |17: Concat(Str, "siebzehn")
   ELSE
      RETURN FALSE
   END;
   RETURN TRUE
END Sonderfall;


PROCEDURE NumToName(n: INTEGER; VAR Str: ARRAY OF CHAR);
VAR Str2: String255;
    HT, ZE, EI: INTEGER;
BEGIN (* NumToName *)
   Str[0] := CHR(0);
   IF n = 0 THEN
      Concat(Str, "null");
      RETURN
   END;
   IF n = 1000 THEN
      Concat(Str, "tausend");
      RETURN
   END;
   HT := (n DIV 100) MOD 10;
   ZE := (n DIV 10 ) MOD 10;
   EI := n MOD 10;
   IF HT > 1 THEN
      AddZiffer(Str, HT)
   END;
   IF HT > 0 THEN
      IF HT = 6 THEN
         Concat(Str, "s")
      END;
      Concat(Str, "hundert")
   END;
   IF Sonderfall(n, Str) THEN
      RETURN
   END;
   IF EI # 0 THEN
      AddZiffer(Str, EI);
      IF ((EI = 1) AND (ZE = 0)) OR ((EI = 6) AND (ZE # 1)) THEN
         Concat(Str, "s")
      END
   END;
   IF ZE # 0 THEN
      IF (EI # 0) AND (ZE # 1) THEN
         Concat(Str, "und")
      END;
      IF ZE = 1 THEN
         Concat(Str, "zehn")
      ELSIF ZE = 2 THEN
         Concat(Str, "zwan")
      ELSIF ZE = 7 THEN
         Concat(Str, "sieb")
      ELSE
         AddZiffer(Str, ZE)
      END;
      IF ZE = 3 THEN
         Concat(Str, "ssig")
      ELSIF (ZE # 1) THEN
         Concat(Str, "zig")
      END
   END
END NumToName;


PROCEDURE BiggerEQ(VAR Str1, Str2: String255): BOOLEAN;
BEGIN
   RETURN Compare(Str1, Str2) <= 0
END BiggerEQ;


PROCEDURE LessEQ(VAR Str1, Str2: String255): BOOLEAN;
BEGIN
   RETURN Compare(Str1, Str2) >= 0
END LessEQ;



PROCEDURE Quicksort(l,r: INTEGER);
VAR T, T2, v: Zahl;
    i,j: INTEGER;
BEGIN (* Sort *)
   IF r > l THEN
      v := Alle[r]; i := l-1; j := r;
      REPEAT
         REPEAT INC(i) UNTIL BiggerEQ    (Alle[i].S, v.S);
         REPEAT DEC(j) UNTIL LessEQ (Alle[j].S, v.S);

         T := Alle[i];
         T2 := Alle[j];
         Alle[i] := T2;
         Alle[j] := T
      UNTIL j <= i;
      T2 := Alle[i];
      Alle[j] := T2;
      T2 := Alle[r];
      Alle[i] := T2;

      Alle[r] := T;

      Quicksort(l, i - 1);
      Quicksort(i + 1, r)
   END (* IF *)
END Quicksort;



VAR T, T2: Zahl;
    err: BOOLEAN;
    ch: CHAR;
    j: INTEGER; (* Hilfsvariable *)

BEGIN (* ONWrite *)
    WriteString("ALPHABETISCHE ZAHLEN"          ); WriteLn;
    WriteString("********************"          ); WriteLn;
    WriteString(""                              ); WriteLn;
    WriteString("Die Tabelle der ersten 1000"   ); WriteLn;
    WriteString("natürlichen Zahlen, zuzüglich" ); WriteLn;
    WriteString("der Null alphabetisch geord-"  ); WriteLn;
    WriteString("net."                          ); WriteLn;
    WriteString("Das komplette Nachschlagewerk" ); WriteLn;
    WriteString("steht nun auch in deutscher"   ); WriteLn;
    WriteString("Sprache den Mathematikstu-"    ); WriteLn;
    WriteString("denten zur Verfügung."         ); WriteLn;
    WriteString("In seiner Einfachheit kann es" ); WriteLn;
    WriteString("schon ab den ersten Semestern" ); WriteLn;
    WriteString("sinnvoll eingesetzt werden."   ); WriteLn;
    WriteString(""                              ); WriteLn;
    WriteString("(1990) Universität Zürich"     ); WriteLn;
    WriteString("Diplomarbeit von ph. gressly"  ); WriteLn;
    WriteString(""                              ); WriteLn;
    WriteString(""                              ); WriteLn;

    FOR i := 0 TO Max DO
       NumToName(i, Alle[i].S);
       Alle[i].N := i
    END;



    Copy(Alle[-1].S , "{");
    Copy(Alle[Max+1].S, "A");

    Quicksort(0, 1000);
    FOR i := 0 TO 499 DO
       T := Alle[i];
       T2 := Alle[Max-i];
       Alle[i] := T2;
       Alle[Max-i] := T;
    END;

    FOR i := 0 TO Max DO
       ch := CAP(Alle[i].S[0]);
       Alle[i].S[0] := ch
    END;

    FOR i := 0 TO Max DO
       WriteInt(i+1, 4);
       WriteString(". ");

       WriteString(Alle[i].S);
       FOR j := 1 TO 30 - Length(Alle[i].S) DO
          WriteString(" ");
       END;
       WriteInt(Alle[i].N, 4);
       WriteLn
    END;
    Write(CHR(12));

END ONWrite.mod
                

package com.cs.santis.strings;


import java.util.ArrayList;

/*
 * Programm, das alle Zahlen von 1 bis 1000 in den deutschen Zahlnamen ausgibt
 * Bsp: 
 * 1   -> eins
 * 10  -> zehn
 * 333 -> dreihuntertunddreiunddreissig
 * 
 * @author: Mike Wong
 * @version: 1.0
 */

public class Zahlnamen {


	ArrayList<String> einer     = new ArrayList<String>();
	ArrayList<String> zehner    = new ArrayList<String>();
	ArrayList<String> hunderter = new ArrayList<String>();
	
	String 			  output;
	
	/*
	 * Main-Methode
	 */
	public static void main(String[] args) {
		new Zahlnamen().top();
	}

	/*
	 * Top-Methode
	 */
	void top() {
		initLists();
		
		for (int i=1;i<1000;i++) {
			output = zahlnamenBisTausend(i);
			System.out.println(output);
		}
	}



	/*
	 * Initialisiert die ArrayListen mit den richtigen Zahlnamen
	 */
	private void initLists() {
		einer.add("null");
		einer.add("eins");
		einer.add("zwei");
		einer.add("drei");
		einer.add("vier");
		einer.add("fünf");
		einer.add("sechs");
		einer.add("sieben");
		einer.add("acht");
		einer.add("neun");

		zehner.add("null");
		zehner.add("zehn");
		zehner.add("zwanzig");
		zehner.add("dreissig");
		zehner.add("vierzig");
		zehner.add("fünfzig");
		zehner.add("sechzig");
		zehner.add("siebzig");
		zehner.add("achtzig");
		zehner.add("neunzig");

		hunderter.add("null");
		hunderter.add("einhundert");
		hunderter.add("zweihunder");
		hunderter.add("dreihundert");
		hunderter.add("vierhundert");
		hunderter.add("fünfhundert");
		hunderter.add("sechshundert");
		hunderter.add("siebenhundert");
		hunderter.add("achthundert");
		hunderter.add("neunhundert");
		
     }



	/*
	 * Gibt die Zahlnamen der Hunderter (1-99) zurück
	 * 
	 * @param int i: Zahl die als Zahlnamen geschrieben werden soll
	 * @return String: Zahlname von i
	 */
	private String zahlnamenBisHundert(int i) {
		int zehnerZiffer;
		int einerZiffer;
		

			if (String.valueOf(i).length() <= 1) {
				return einer.get(i);
			}
			if (i == 11) {
				return "elf";
			}
			if (i == 12) {
				return "zwölf";
			}
			zehnerZiffer = Integer.parseInt(String.valueOf(i).substring(0, 1));
			einerZiffer = Integer.parseInt(String.valueOf(i).substring(1, 2));

			if (i % 10 == 0) {
				return zehner.get(zehnerZiffer);
			}
			if (einerZiffer == 1 ) {
				return "ein" + "und" + zehner.get(zehnerZiffer);
			}
			if (i == 16) {
				return "sech" + zehner.get(zehnerZiffer);
			} 
			if (i == 17) {
				return "sieb" + zehner.get(zehnerZiffer);
			}
			if (i > 20){
				return einer.get(einerZiffer) + "und" + zehner.get(zehnerZiffer);
			}

			//Zehnerzahlen (13-19):
			return einer.get(einerZiffer) + zehner.get(zehnerZiffer);

  }

	/*
	 * Gibt die Zahlnamen der Tausender (1-999)
	 * 
	 * @param int i: Zahl die als Zahlnamen geschrieben werden soll
	 * @return String ausgabe: Zahlname von i
	 */
	private String zahlnamenBisTausend(int i) {
		String ausgabe = null;
		if (String.valueOf(i).length() > 2) {
			if (i % 100 > 0) {
				int hundert = Integer.parseInt(String.valueOf(i).substring(0, 1));
				int rest = Integer.parseInt(String.valueOf(i).substring(1,3));
				ausgabe = hunderter.get(hundert) + "und" + zahlnamenBisHundert(rest);
			} else {
				int hundert = Integer.parseInt(String.valueOf(i).substring(0, 1));				
			ausgabe = hunderter.get(hundert);
			}
		} else if (String.valueOf(i).length() == 2) {
			int rest = Integer.parseInt(String.valueOf(i).substring(0,2));
			ausgabe = zahlnamenBisHundert(rest);
		} else {
			int rest = Integer.parseInt(String.valueOf(i).substring(0,1));
			ausgabe = zahlnamenBisHundert(rest);			
		}
		return ausgabe;
	}
}
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Number.prototype.verbalDe = function() {
  if (this == 1000) return 'eintausend';
  if (this > 1000) return 'Ich geh noch zur Schule.';
  let arr = this.toString().split(''),
      out = '';

  let radices = 'null ein|s zwei drei vier fünf sech|s sieb|en acht neun zehn elf zwölf'.split(' ');

  function short(wrd) {
    if (wrd.indexOf('|') == -1) return wrd;
    return wrd.split('|')[0];
  }

  function full(wrd) {
    if (wrd.indexOf('|') == -1) return wrd;
    return wrd.split('|').join('');
  }

  function getHundreds(s) {
    s = parseInt(s);
    if (s == 1) return 'hundert';
    return full(radices[s]) + 'hundert';
  }

  function getTys(a) {
    let s = '';
    let n = parseInt(a.join(''));
    for (let i = 0; i < a.length; i++) parseInt(a[i]);

    if (n <= 12) return full(radices[n]);
    if (n >= 13 && n <= 19) return (short(radices[a[1]]) + 'zehn');

    if (a[1] == 1) s += short(radices[1]) + 'und';
    if (a[1] >= 2 && a[1] <= 9) s = full(radices[a[1]]) + 'und';

    if (a[0] == 2) s += 'zwanzig';
    if (a[0] == 3) s += 'dreißig';
    if (a[0] >= 4 && a[0] <= 9) s += short(radices[a[0]]) + 'zig';

    return s;
  }

  if (this < 10) return (full(radices[this]));
  if (this % 100 == 0) return getHundreds(arr[0]);
  if (arr.length == 3) out += getHundreds(arr.shift());
  if (arr.length == 2) out += getTys(arr.splice(0,2));

  return out;
}

// ausgabe
for (let i = 0; i <= 1001; i++) console.log(i.verbalDe());   // lissalanda@gmx.at

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// NET 6.x | C# 10.x | VS-2022

string NumberSpelling(int num) {
    var res = string.Empty;
    var lst = new List<string>() { "null", "ein|s", "zwei", "drei", "vier", "fünf", "sech|s", "sieb|en", "acht", "neun", "zehn", "elf", "zwölf" };
    var fst = (int n) => lst[n].Split("|")[0];
    var all = (int n) => lst[n].Replace("|", "");

    void _0_12(int n) => res += all(n);
    void _13_19(int n) => res += fst(n % 10) + "zehn";
    void _20_99(int n) {
        if (n % 10 != 0) res += (n % 10 == 1 ? fst(n % 10) : all(n % 10)) + "und";
        if (n / 10 == 2) res += "zwanzig";
        else if (n / 10 == 3) res += "dreißig"; 
        else res += fst(n / 10) + "zig";
    }
    void _100_999(int n) {
        res += (n / 100 == 1 ? fst(n / 100) : all(n / 100)) + "hundert";
        if (n % 100 != 0) {
            n %= 100;
            if (n < 13) _0_12(n);
            else if (n < 20) _13_19(n);
            else _20_99(n);
        }
    }
    switch (num) {
        case > 999 or < 0: return res;
        case < 13: _0_12(num); break;
        case < 20: _13_19(num); break;
        case < 100: _20_99(num); break;
        default: _100_999(num); break;
    }
    return res;
}
for (var i = 0; i < 1000; i++)
    Console.WriteLine($"{i,3} - {NumberSpelling(i)}");
                

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022
#include <iostream>
#include <vector>

std::string number_spelling(int n) {
    std::string r{};
    const std::vector<std::string>& v{ "null", "ein|s", "zwei", "drei", "vier", "fünf", "sech|s", "sieb|en", "acht", "neun", "zehn", "elf", "zwölf" };
    const auto fst{ [&v](int k) { return v[k].substr(0, v[k].find('|')); } };
    const auto all{ [&v, &fst](int k) { return fst(k) + (v[k].find('|') == -1 ? "" : v[k].substr(v[k].find('|') + 1)); } };

    const auto _0_12{ [&]() { r += all(n); } };
    const auto _13_19{ [&]() { r += fst(n % 10) + "zehn"; } };
    const auto _20_99{ [&]() {
        if (n % 10 != 0) r += (n % 10 == 1 ? fst(n % 10) : all(n % 10)) + "und";
        if (n / 10 == 2) r += "zwanzig";
        else if (n / 10 == 3) r += "dreißig";
        else r += fst(n / 10) + "zig"; }
    };
    const auto _100_999{ [&]() {
       r += (n / 100 == 1 ? fst(n / 100) : all(n / 100)) + "hundert";
       if (n % 100 != 0) {
           n %= 100;
           if (n < 13) _0_12();
           else if (n < 20) _13_19();
           else _20_99();
       } } 
    };
    if (n < 0 || n > 999) return "unknown";
    else if (n < 13) _0_12();
    else if (n < 20) _13_19();
    else if (n < 100) _20_99();
    else _100_999();
    return r;
}

int main() {
    std::locale::global(std::locale("German_germany.UTF-8"));
    for (auto i{ 0 }; i < 1000; i++)
        std::cout << number_spelling(i) << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

def zahl(x):
        zehner=['zwanzig','dreißig','vierzig','fünfzig','sechzig','siebzig','achtzig','neunzig']
        einer=['ein','zwei','drei','vier','fünf','sechs','sieben','acht','neun']
        if x>10 and str(x)[1]=='0': return zehner[int(str(x)[0])-2]
        return einer[int(str(x)[0])-1] if x<10 else einer[int(str(x)[1])-1]+'und'+zehner[int(str(x)[0])-2]
for a in ['eins']+[zahl(i) for i in range(2,10)]+['zehn','elf','zwölf','dreizehn','vierzehn','fünfzehn','sechszehn','siebzehn','achtzehn','neunzehn']+[zahl(i) for i in range(20,100)]: print(a)

                

Lösung von: rob ert (tub)