Übersetzen Sie Ihren englischen Quellcode in eine Fremdsprache [geschlossen]

66

Mir ist aufgefallen, dass es überproportional viele Computersprachen gibt, die auf Englisch basieren. Ich schlage vor, dies zu beheben, indem ich vorhandene Computersprachen in Fremdsprachen übersetze!

  • Wählen Sie eine Computersprache, die englische Schlüsselwörter / Funktionen verwendet
  • Wählen Sie eine andere natürliche Sprache als Englisch
  • Schreiben Sie ein Programm, das seinen eigenen Quellcode oder ein beliebiges anderes Programm, das mit derselben Teilmenge von Schlüsselwörtern / Funktionen geschrieben wurde, in die andere Sprache übersetzt
  • Veröffentlichen Sie den Quellcode und die Ausgabe (den übersetzten Code)

Beginnen Sie Ihren Beitrag mit etwas wie:

BASIC, Französisch

oder

BASIC, Französisch - FONDAMENTAL

Sie müssen den Namen der Sprache nicht übersetzen, wenn Sie nicht möchten, es ist nur zum Spaß!

Sie müssen nicht alle Schlüsselwörter / Funktionen in die von Ihnen gewählte Sprache übersetzen, sondern nur die, die Sie tatsächlich in Ihrem Quellcode verwenden. Zum Beispiel hat PHP Tausende, so dass Sie definitiv nicht alle übersetzen müssen! Wenn Sie Kommentare verwenden, tun Sie bitte auch Ihr Bestes, um diese zu übersetzen! Nach Abschluss Ihres Programms sollten keine englischen Wörter mehr erkennbar sein, es sei denn, sie sind für die Fremdsprache geeignet. Wörter in Strings sollten ebenfalls übersetzt werden (was bedeutet, dass Ihr übersetztes Programm nicht mehr mit englischem Quellcode funktioniert, auch wenn es ausgeführt werden könnte!). Hoffentlich ergibt Ihr Programm für einen Programmierer, der die andere Sprache spricht, einen Sinn!

Zum Beispiel if () {} elseif () {} else {}könnte si () {} sinonsi () {} sinon {}in Französisch werden! Wenn Sie wurden zu übersetzen Perl elsifin Französisch, vielleicht würden Sie die zweite fallen ndie Art und Weise der zweite eauf Englisch fallen gelassen wird: sinosi. In Französisch sonst wäre eher autre aber die Alternative sinon ( oder sonst , sonst ) fühlt sich schöner zu mir!

Seien Sie kreativ! Versuchen Sie, das Gefühl des Computers und der natürlichen Sprachen einzufangen! Sprachen wie Brainfuck, CJam usw., die keine englischen Token haben, können nicht verwendet werden. Sprachen wie BASIC oder COBOL sind viel besser geeignet. Verwenden Sie aussagekräftige Variablennamen und übersetzen Sie diese auch, sofern Ihre Sprache keine Variablennamen unterstützt, bei denen es sich um englische Wörter handeln kann.

Sie können mehrere Antworten veröffentlichen, eine für jede Kombination aus Computer und natürlicher Sprache. Sie dürfen keine Bibliothek oder ein externes Tool für die Übersetzung verwenden! Ihr Code sollte die Übersetzung selbst ausführen und nicht etwas anderes aufrufen, das die Übersetzung ausführt! Dies ist kein Code Golf! Wenn Ihr Programm Eingaben macht, muss es nur sein eigener Quellcode sein. Wenn es von der Disc liest, kann es nur die Quelldatei usw. sein.

* Für die Zwecke dieser Herausforderung betrachte ich Esperanto, Lojban, Volapük, Interlingua usw. als natürliche Sprachen. Möglicherweise erfinden Sie für diese Herausforderung keine eigene Sprache!

Ich habe eine Regel hinzugefügt, um explizite Quines zu verhindern. Sie können eine beliebige Untergruppe von Schlüsselwörtern / Funktionen - auch alle - zum Übersetzen auswählen. Ihr Programm muss in der Lage sein, sich selbst zu übersetzen, dh wenn Ihre ursprüngliche Quelle das Wort enthält, sollte das printHinzufügen eines print(42)beliebigen Punkts zum Eingabecode (nicht Ihr Programm selbst) dennoch zu den richtigen Ergebnissen führen.

Zum Beispiel:

function translate() {
  ...
}
print(translate());

könnte werden

fonction traduire() {
  ...
}
imprimer(traduire());

Wenn die Eingabe in geändert wird

print(42);
function translate() {
  ...
}
print(translate());
print(42);

der ausgang sollte dann werden

imprimer(42);
fonction traduire() {
  ...
}
imprimer(traduire());
imprimer(42);
CJ Dennis
quelle
4
"print" wird zu "imprimer" (wie bei "printer"), nicht zu "empreinte" (wie bei "footprint") :)
Quentin
4
@Quentin Ich habe nie behauptet, es sei gutes Französisch!
CJ Dennis
13
Ich denke , es ist schlecht genug , dass Excel Muttersprache Unterstützung hat .. :( Debuggen macht Formeln so viel schwieriger.
Mave
1
@Quentin Ich frage mich jetzt, ob die französischen Verben den Imperativ anstelle des Infinitivs verwenden sollen. Das einzige Problem ist, dass mein Französisch dafür nicht gut genug ist!
CJ Dennis
3
@CJDennis Im französischen Pseudocode habe ich immer den Infinitiv gesehen, aber ich kann bei Bedarf
Quentin

Antworten:

67

Python, Koine Griechisch - Πύθων

Meine Lieblingsprogrammiersprache, in meiner Lieblingsfremdsprache - perfekt! Und es tut nicht weh, dass der Name bereits griechisch ist .

Das Übersetzerprogramm in Python 3 (Gott sei Dank für die native Unicode-Unterstützung):

with open(__file__, encoding="utf-8") as f:
    code = f.read()

replacements = [
    ("print", "γραψάτω"),
    ("input", "λαβέτω"),
    ("read", "ἀναγνώτω"),
    ("open", "ἀνεῳξάτω"),
    ("file", "βιβλίον"),
    ("import", "εἰσενεγκάτω"),
    ("encoding", "τύπος"),
    ("code", "λόγοι"),
    ("replacements", "νεόλογοι"),
    ("location", "τόπος"),
    ("old", "παλαιόν"),
    ("new", "νέον"),
    ("find", "εὑρέτω"),
    ("replace", "ἀλλαξάτω"),
    ("for", "ἕκαστον"),
    ("while", "ἐν τῷ"),
    ("elif", "εἰ δὲ"),
    ("if", "εἰ"),
    ("else", "εἰ δὲ μή"),
    ("is not", "οὐκ ἔστιν"),
    ("is", "ἔστιν"),
    ("not in", "οὐκ ἐν"),
    ("in", "ἐν"),
    ("and", "καὶ"),
    ("or", "ἢ"),
    ("not", "οὐ"),
    ("with", "μετὰ"),
    ("as", "ὡς"),
    ("re", "ῥλ"),
    ("sys", "σύς"),
    (":", "·"),
    ("ph", "φ"),
    ("th", "θ"),
    ("ch", "χ"),
    ("ps", "ψ"),
    ("a", "α"),
    ("b", "β"),
    ("c", "κ"),
    ("d", "δ"),
    ("e", "ε"),
    ("f", "φ"),
    ("g", "γ"),
    ("h", ""),
    ("i", "ι"),
    ("j", "ι"),
    ("k", "κ"),
    ("l", "λ"),
    ("m", "μ"),
    ("n", "ν"),
    ("o", "ο"),
    ("p", "π"),
    ("r", "ρ"),
    ("s ", "ς "),
    ("s.", "ς."),
    ("s,", "ς,"),
    ("s·", "ς·"),
    ("s", "σ"),
    ("t", "τ"),
    ("u", "ου"),
    ("v", "ου"),
    ("w", "ου"),
    ("x", "ξ"),
    ("y", "υ"),
    ("z", "ζ")
    ]

for old, new in replacements:
    if old == "for":
        location = 0
        while old in code[location:]:
            location = code.find(old, location)
            if code[location+3] != '"':
                location = code.find("in", location)
                code = code[:location] + "ἐκ" + code[location+2:]
            else:
                location += 1
    code = code.replace(old, new)

print(code)

Ergebnisse der Ausführung des Codes auf sich selbst (mit der großen Übersetzungsliste überarbeitet):

μετὰ ἀνεῳξάτω(__βιβλίον__, τύπος="ουτφ-8") ὡς φ·
    λόγοι = φ.ἀναγνώτω()

νεόλογοι = [
    ("γραψάτω", "γραψάτω"),
    ("λαβέτω", "λαβέτω"),
    ("ἀναγνώτω", "ἀναγνώτω"),
    ...
    ]

ἕκαστον παλαιόν, νέον ἐκ νεόλογοι·
    εἰ παλαιόν == "ἕκαστον"·
        τόπος = 0
        ἐν τῷ παλαιόν ἐν λόγοι[τόπος·]·
            τόπος = λόγοι.εὑρέτω(παλαιόν, τόπος)
            εἰ λόγοι[τόπος+3] != '"'·
                τόπος = λόγοι.εὑρέτω("ἐν", τόπος)
                λόγοι = λόγοι[·τόπος] + "ἐκ" + λόγοι[τόπος+2·]
            εἰ δὲ μή·
                τόπος += 1
    λόγοι = λόγοι.ἀλλαξάτω(παλαιόν, νέον)

γραψάτω(λόγοι)

Koine Greek ist 2000 Jahre alt, es hat also Spaß gemacht, Programmierbegriffe zu übersetzen. Hier sind einige meiner Favoriten:

  • βιβλίον = "Schriftrolle" ( file)
  • γραψάτω = "schreiben" ( print)
  • λαβέτω = "take" ( input)
  • εἰσενεγκάτω = "einbringen" ( import)
  • τύπος = "Muster, Typ" ( encoding)
  • λόγοι / νεόλογοι = "Wörter" / "neue Wörter" ( code/ replacements)
  • ἕκαστον ... ἐκ = "jeder ... von" ( for ... in)
  • εἰ ... εἰ δὲ ... εἰ δὲ μή = "wenn ... aber wenn ... aber wenn nicht" ( if ... elif ... else)
  • ἐν τῷ bedeutet wörtlich "im", aber in bestimmten Zusammenhängen kann es eine Redewendung für "wann, während" sein.
  • "Regulärer Ausdruck" wurde zu rationalμα λογικόν , "vernünftiges / vernünftiges Sprichwort"; somit ist die Abkürzung reist ῥλ

Die meisten Wörter finden Sie auch in Wiktionary .

Einige andere herausragende Merkmale:

  • Englische Programmierung verwendet eine Reihe von zwingenden Verben ( print, read, replace). Ich vermute, die alten Griechen würden sich ein bisschen dumm fühlen, wenn sie so mit dem Computer sprechen. Deshalb habe ich sie alle zu Geboten der dritten Person gemacht : "Es muss gedruckt werden", "Es muss gelesen werden", "Es muss ersetzt werden".
  • Griechische Zeichensetzung ist ein bisschen anders als Englisch. Ich bin dabei nicht über Bord gegangen, weil ich nicht sicher bin, durch was die eckigen Klammern und Unterstriche ersetzt werden sollen, aber ich habe Doppelpunkte gegen Ano Teleia oder "High Period" ausgetauscht ( ·).
  • Bei Wörtern, die nicht in der Liste enthalten sind, habe ich darauf geachtet, auch alle Kleinbuchstaben zu transliterieren. Es gibt nicht immer eine direkte Eins-zu-Eins-Korrespondenz. so zum Beispiel utfverwandelt sich in ουτφ--which klingt ungefähr wie „ootf“ , wenn Sie versuchen , es auszusprechen.

Dies lässt grammatikalisch noch viel zu wünschen übrig. Griechisch ist eine viel stärker eingebogene Sprache als Englisch, und mein Code ist bei weitem nicht ausgefeilt genug, um alle Fälle und Zahlen richtig zu machen. Zum Beispiel sollte ἕκαστον παλαιόν, νέον ἐκ νεόλογοι ἐκ νεολόγ ων mit dem Ziel der Präposition im Genitiv lesen . Aber ich bin nicht daran zu setzen , dass viel Zeit in dieser! Der Look ist ausreichend griechisch (zumindest für das ungeübte Auge) und die hohen Perioden fügen eine nette Note hinzu. Alles in allem bin ich ziemlich zufrieden mit dem Ergebnis.

DLosc
quelle
4
Es sieht aus wie Griechisch für mich! Ich verstehe kein Griechisch, aber es sieht so aus, als ob Sie sich Mühe gegeben haben, die richtige Grammatik zu finden, also gut gemacht! Würde es Ihnen etwas ausmachen, ein paar Zeilen aus Ihrer Übersetzungsliste aufzunehmen?
CJ Dennis
Ich sehe immer noch nur νεόλογοι = [...]. Können Sie nur ein paar Zeilen einfügen? Keine Notwendigkeit für die ganze Liste!
CJ Dennis
Es ist zwar nicht sonderlich interessant, aber es gibt einen Hinweis auf die gesamte Ausgabe!
CJ Dennis
Soll die Übersetzung nicht die String-Konstanten in Ruhe lassen und nur Schlüsselwörter (und möglicherweise Variablennamen) übersetzen?
Kasperd
@kasperd Au contraire : Words in strings should be translated too.
DLosc,
65

Huhn , Chinesisch - 鸡

Hühnchen ist viel schwerer zu gebrauchen als ich dachte.

Es gibt keinen nachgestellten Zeilenumbruch. Das Finale chickenmarkiert jedoch nur das Ende dieses Programms, das durch eine leere Zeile ersetzt werden kann.

Ich verwende diesen Interpreter , der einen zusätzlichen Zeilenumbruch ausgibt und nicht unterdrückt werden kann. Die Ausgabe hat also eine Zeile mehr als das Original, und das kann dazu führen, dass ein Chicken-Programm kaputt geht. Ich hoffe das macht es nicht ungültig.

Es wurden einige Tricks angewendet, beispielsweise das Abrufen leerer Zeichenfolgen aus dem Index -1 der Eingabe und das Erkennen von EOF durch Vergleichen mit leeren Zeichenfolgen. Ich habe den compareBefehl auch verwendet , um nicht verwendete Elemente im Stapel zu verwerfen, ohne mich um den Typ zu kümmern. Sie dürfen nicht in anderen Dolmetschern arbeiten. Die Zeichenfolge wird als UTF-8-Byte gedruckt, wobei andere Interpreter möglicherweise das direkte Drucken von Unicode-Zeichen unterstützen.

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken
chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken


chicken

Verwenden Sie diesen Befehl, um diesen Code auszuführen:

bin/chicken "`<file`" <file

wo seltsamerweise ist die erste filefür die Eingabe und die zweite für den Code.

Die Ausgabe (Chinesisch verwendet keine Leerzeichen zwischen Wörtern):

鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡
鸡鸡鸡鸡鸡鸡
鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡

鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡

鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡
鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡

鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡

鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡
鸡鸡鸡鸡鸡鸡
鸡
鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡

鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡

鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡鸡
鸡鸡鸡鸡鸡鸡


鸡

Dieses Programm ersetzt hmit , lässt Zeilenumbrüche unberührt und ignoriert alles andere.

Und wie Sie sehen, kann es jedes gültige Chicken-Programm übersetzen.

jimmy23013
quelle
3
Sie wissen, woran ich denke - youtu.be/vExjnn_3ep4
DLosc
5
Mmm! Chinesisches Hühnchen! Ich denke die Ausgabe ist leichter zu verstehen als das Originalprogramm! Fühlt sich jetzt noch jemand zum Mitnehmen?
CJ Dennis
2
Gute Arbeit, Jimmy .
Alex A.
18
@AlexA. Dann habe ich meinen Benutzernamen geändert.
jimmy23013
6
季 季 击 鸡 记
Alephalpha
36

C ++, Lateinisch - C Plus Plus

Ja, das ist eine tatsächliche Übersetzung des Sprachnamens. Sie hatten kein Pluszeichen, aber sie gaben uns das Wort Plus.

#include <iostream>
#include <fstream>

using namespace std;

static const char *reposita[][2] = {
    // Miscellanea
    {"iostream",    "flumineie"},       // flumine inducto/educto
    {"ofstream",    "fluminele"},       // flumine limae educto
    {"ifstream",    "flumineli"},       // flumine limae inducto
    {"fstream",     "fluminel"},        // flumine limae
    {"std",         "cmn"},             // commune
    {"string",      "chorda"},
    {"empty",       "vacuum"},
    {"size_t",      "t·amplitudinis"},  // typus amplitudinis
    {"find",        "inveni"},
    {"npos",        "posn"},            // positio nulla
    {"replace",     "repone"},
    {"main",        "primor"},
    {"getline",     "sumelinea"},

    // Verba gravia
    {"alignas",             "ordinasicut"},
    {"alignof",             "ordinatio"},
    {"asm",                 "cns"},             // construere
    {"auto",                "modic"},           // modicum
    {"bool",                "bic"},             // bicolore
    {"break",               "erumpe"},
    {"case",                "res"},
    {"catch",               "capta"},
    {"char16_t",            "t·littxvi"},       // typus litterae
    {"char32_t",            "t·littxxxii"},
    {"wchar_t",             "t·littv"},         // typus litterae vadae
    {"char",                "litt"},            // littera
    {"class",               "genus"},
    {"constexpr",           "dictconst"},       // dictum constante
    {"const_cast",          "funde·const"},     // funde constanter
    {"continue",            "procede"},
    {"decltype",            "typusdecl"},       // typus declaratus
    {"default",             "ultima"},
    {"delete",              "abole"},
    {"for",                 "cum"},
    {"if",                  "si"},
    {"struct",              "aedif"},           // aedificium
    {"double",              "biforme"},
    {"do",                  "fac"},
    {"dynamic_cast",        "funde·impigre"},
    {"else",                "alter"},
    {"explicit",            "directum"},
    {"export",              "expone"},
    {"false",               "falsum"},
    {"float",               "nante"},
    {"friend",              "amicus"},
    {"goto",                "iad"},
    {"inline",              "inlinea"},
    {"long",                "longum"},
    {"mutable",             "mutabilis"},
    {"namespace",           "plaganominis"},
    {"new",                 "novum"},
    {"noexcept",            "sineexim"},        // sine eximibus
    {"nullptr",             "sgnnullum"},       // signum nullum
    {"private",             "privata"},
    {"protected",           "protecta"},
    {"public",              "publica"},
    {"register",            "arca"},
    {"reinterpret_cast",    "funde·revertendo"},
    {"return",              "redde"},
    {"short",               "breve"},
    {"unsigned",            "sine·signo"},
    {"signed",              "signo"},
    {"sizeof",              "amplitudo"},
    {"static_assert",       "autuma·stant"},    // autuma stantiter
    {"static_cast",         "funde·stant"},     // funde stantiter
    {"static",              "stante"},
    {"switch",              "furca"},
    {"template",            "exemplar"},
    {"this",                "hoc"},
    {"thread_local",        "ligamen·loci"},
    {"throw",               "iaci"},
    {"true",                "verum"},
    {"try",                 "tempta"},
    {"typedef",             "typumdes"},        // typum designa
    {"typeid",              "signumtypi"},
    {"typename",            "nomentypi"},
    {"union",               "iugum"},
    {"using",               "utente"},
    {"virtual",             "virtuale"},
    {"void",                "inane"},
    {"volatile",            "volatilis"},
    {"while",               "dum"},

    // Numeri
    {"0",   "nihil"},
    {"1",   "i"},
    {"2",   "ii"},

    // Miscellanea
    {"length",      "longitudo"}
};

static void omnesRepone(string& chorda, const string& de, const string& ad) {
    if (de.empty()) {
        return;
    }
    size_t index = 0;
    while ((index = chorda.find(de, index)) != string::npos) {
        chorda.replace(index, de.length(), ad);
        index += ad.length();
    }
}

int main(int narg, const char * varg[]) {

    ifstream limaArchetypa(varg[1]);
    ofstream limaTransferenda(varg[2]);

    int elementa = sizeof(reposita) / sizeof(reposita[0]);
    string linea;
    while (getline(limaArchetypa, linea)) {
        for (int index = 0; index < elementa; ++index) {
            omnesRepone(linea, reposita[index][0], reposita[index][1]);
        }
        limaTransferenda << linea << "\n";
    }
    return 0;
}

Anmerkungen:

  • Übernimmt eine Eingabe- und Ausgabedatei in der Befehlszeile
  • Übersetzt alle Schlüsselwörter
  • Ich habe keinen vollständigen Parser für römische Zahlen geschrieben, aber ich dachte, es wäre schön, zumindest die in der Quelle vorhandenen Zahlen zu übersetzen ( nihil , i und ii ).
  • Ich bin nicht die Straße der Übersetzung von in C ++ verwendeten Symbolen gegangen, die wie eine riesige Dose Würmer wirkten
  • Die Schlüsselwörter const, enum, int, und operatorändern sich nicht. Sie stehen jetzt für constante , enumeratum , integrum und operator .
  • Ich hätte nicht gedacht, dass die Römer _als Worttrenner stehen würden, also habe ich Interpuncts verwendet .
  • Die Übersetzung ist sehr dumm und ineffizient und ignoriert Wortgrenzen usw.

Ausgabe:

#include <flumineie>
#include <fluminel>

utente plaganominis cmn;

stante const litt *reposita[][ii] = {
    // (redacta)
};

stante inane omnesRepone(chorda& chorda, const chorda& de, const chorda& ad) {
    si (de.vacuum()) {
        redde;
    }
    t·amplitudinis index = nihil;
    dum ((index = chorda.inveni(de, index)) != chorda::posn) {
        chorda.repone(index, de.longitudo(), ad);
        index += ad.longitudo();
    }
}

int primor(int narg, const litt * varg[]) {

    flumineli limaArchetypa(varg[i]);
    fluminele limaTransferenda(varg[ii]);

    int elementa = amplitudo(reposita) / amplitudo(reposita[nihil]);
    chorda linea;
    dum (sumelinea(limaArchetypa, linea)) {
        cum (int index = nihil; index < elementa; ++index) {
            omnesRepone(linea, reposita[index][nihil], reposita[index][i]);
        }
        limaTransferenda << linea << "\n";
    }
    redde nihil;
}
Luke
quelle
Sollte "string" nicht wie in modernen romanischen Sprachen als "catena" übersetzt werden?
200_success
Kommt darauf an, wie wörtlich du dich fühlst.
Luke,
6
Oder eher, wie romantisch du dich fühlst.
Alex A.
1
Ich denke du hast "leer" verpasst.
Pakk
1
Vielen Dank. Ich habe ein Blatt aus @ Vioz-s Buch genommen und 'inane' für void verwendet, damit ich 'vacuum' für empty verwenden kann.
Luke
25

JavaScript (NodeJS) - Hebräisch

Meine Codierungsmethode ist der von DLoscs Python-Programm ziemlich ähnlich : Es liest den Quellcode, verfügt über eine Liste von Token und führt das Suchen und Ersetzen aus.

var file_system = require('fs');
file_system.readFile(__filename, function(error,code){
    if (error) {throw error;}
    code = code.toString();
    var words = {
        'var': 'מש׳',
        'file_system': 'מערכת_קבצים',
        'require': 'דרוש',
        'fs': 'מ״ק',
        'readFile': 'קראקובץ',
        'filename': 'שםקובץ',
        'function': 'תפקיד',
        'error': 'שבוש',
        'code': 'צופן',
        'if': 'אם',
        'throw': 'זרוק',
        'toString': 'למחרוזת',
        'words': 'מילים',
        'word': 'מילה',
        'for': 'לכל',
        'in ': 'ב',
        'replace': 'החלף',
        'RegExp': 'ביטס״ד',
        'console': 'מסוף',
        'log': 'רשום',
        'new (.+)\\(': '$1 חדש(',
        'g': 'ע׳',
        '\'': '',
        ';': '׃'
    }, word;

    for (word in words) {
        code = code.replace(new RegExp(word,'g'), words[word]);
    }
    console.log(code);
});

Dies ergibt die folgende Ausgabe:

מש׳ מערכת_קבצים = דרוש(מ״ק)׃
מערכת_קבצים.קראקובץ(__שםקובץ, תפקיד(שבוש,צופן){
    אם (שבוש) {זרוק שבוש׃}
    צופן = צופן.למחרוזת()׃
    מש׳ מילים = {
        מש׳: מש׳,
        מערכת_קבצים: מערכת_קבצים,
        דרוש: דרוש,
        מ״ק: מ״ק,
        קראקובץ: קראקובץ,
        שםקובץ: שםקובץ,
        תפקיד: תפקיד,
        שבוש: שבוש,
        צופן: צופן,
        אם: אם,
        זרוק: זרוק,
        למחרוזת: למחרוזת,
        מילים: מילים,
        מילה: מילה,
        לכל: לכל,
        ב: ב,
        החלף: החלף,
        ביטס״ד: ביטס״ד,
        מסוף: מסוף,
        רשום: רשום,
        (.+)\\(: $1 חדש חדש(,
        ע׳: ע׳,
        \: ,
        ׃: ׃
    }, מילה׃

    לכל (מילה במילים) {
        צופן = צופן.החלף(ביטס״ד חדש(מילה,ע׳), מילים[מילה])׃
    }
    מסוף.רשום(צופן)׃
})׃

Leider scheint SE RTL-Text nicht zu mögen. Ich habe versucht, den obigen Codeblock manuell einzuwickeln <pre dir="rtl">, aber er wurde gerade entfernt. :( Der Code soll eigentlich so aussehen: (Screenshot von gedit)

Code wird mit RTL-Formatierung korrekt angezeigt

Einige Anmerkungen zum hebräischen Text:

  • Die hebräische Methode für Abkürzungen (die in diesem Code mehrfach verwendet wird) besteht darin, am Ende ein einfaches Anführungszeichen für ein einzelnes Wort und doppelte Anführungszeichen vor dem letzten Buchstaben zu verwenden, wenn es sich um mehrere Wörter handelt. Für ein einzelnes Wort haben wir var, was ich übersetzt habe , die מש'Abkürzung für "משתנה" (Variable). fs, eine Abkürzung für "Dateisystem", wurde übersetzt als מ"ק, die ersten Buchstaben von "מערעת קבציצ", siehe oben.
  • Hebräisch hat keine Groß- / Kleinbuchstaben. Einige Buchstaben haben normale / endgültige Formen (כמכ bzw. ךםןףץ), aber das war's. Also habe ich in Mashup-Wörtern wie "readFile" und "filename" auch die hebräischen Wörter "קרא קובץ" und "שם שםובץ" zusammengefasst, obwohl das zweite Wort mit einem letzten Buchstaben in der Wortmitte endet.
  • Dies gilt nicht für toString. Präpositionen sind im Hebräischen einzelne Buchstaben, die dem Wort vorangestellt werden. Wenn also "string" "מחרוזת" ist, ist "to string" "למחרוזת". Das ist auch der Grund, warum for..indas inToken im Block das Leerzeichen enthält, damit es mit dem nächsten Wort verbunden wird ( word in wordswird מילה במילים).
  • Ich kann das nicht von meinem Computer reproduzieren, aber als ich von meinem iPad zu translate.google.com ging und regexes einfügte, gab es mir ביטוי סדיר zurück, was wörtlich "geordneter Ausdruck" bedeutet. Beeindruckend! Ich habe es auf ביטס"טס abgekürzt, so wie es JS RegExpist.
  • Die gRegex-Flagge habe ich als as 'übersetzt, was für עולמי, global steht.
  • Beachten Sie das komplizierte Regex-Formular zum Ersetzen new. Das liegt daran, dass im Hebräischen Adjektive (wie "new" - "חדש") hinter dem Substantiv (wie "regex") stehen. Stattdessen new RegExp()wäre es also "RegExp [das ist] new ()".
  • Ich habe die Anführungszeichen entfernt, da sie im klassischen Hebräisch nicht existieren. Das macht die Grammatik sicher viel schwieriger! Ich bin mir immer noch nicht sicher, ob es eine gute Entscheidung war oder nicht.
  • Es sieht so aus, als würde ich alle abschließenden Semikolons durch Doppelpunkte ersetzen. Es ist eigentlich ein U + 05C3 SOF PASUQ , ein Interpunktionszeichen, das einen Vers in der Bibel beendet.

Dieser Code übersetzt sicherlich nicht jedes gültige JS-Programm. In der Tat übersetzt es wahrscheinlich nur dieses. Aber das ist gut genug für diese Herausforderung. ;)

Übrigens, wenn Sie sich für Hebräisch interessieren, folgen Sie dem Vorschlag von Hebrew.SE (und stimmen Sie über Fragen mit einer Punktzahl von <10 ab)! (Quelle: stackexchange.com )
Vorschlag für eine Website für Fragen und Antworten zu Stack Exchange: Hebräische Sprache

Scimonster
quelle
9
Sollte mit PHP gegangen sein - sie haben bereits T_PAAMAYIM_NEKUDOTAYIMabgedeckt !
wchargin
2
Die letzte Zeile der RTL-Quelle sieht aus wie ein Mann mit traurigem Gesicht und Bart. :)
Matt Lyons
(aus irgendeinem Grund habe ich es in der LTR-Quelle auch nicht bemerkt)
Matt Lyons
@MattLyons Wahrscheinlich haben Sie es auf Englisch nicht bemerkt, weil es nicht wirklich so aussieht.
Scimonster
1
מה קורה @proudhaskeller
sagiksp
22

Perl, PigLatin - erlPay

Erstens ist das eigentliche Programm sehr kurz. Um zu veranschaulichen, wie es sich für längere Textabschnitte verhält, habe ich einige Perl-Gedichte als weiteres Beispiel für die Ein- / Ausgabe eingefügt. Da die Poesie nach der END- Zeile eingefügt wird , wird sie nicht ausgeführt.

Der eigentliche Algorithmus ist ziemlich einfach:

  • Teilen Sie die Eingabe an Wortgrenzen in Token auf
  • Für jedes Wort mit mindestens zwei Buchstaben wird das lateinische Wort "Schwein" übersetzt
    • Finden Sie die führenden Konsonanten im Wort
    • Bewegen Sie sie ans Ende und setzen Sie das Suffix 'ay' auf sie
  • Alles drucken. Nicht-Alpha-Eingaben (und Einzelzeichen) werden nicht übersetzt

#!/usr/bin/perl

while (<>) {
    print map { 
        s/^([bcdfghjklmnpqrstvwxyz]*)([a-z]+)/$2$1ay/i if /[a-z][a-z]/i; $_ 
    } split(/\b/);
}
__END__
# listen (a perl poem)
# Sharon Hopkins
# rev. June 19, 1995
# Found in the "Perl Poetry" section of the Camel book
APPEAL:

listen(please, please);

open yourself, wide;
    join (you, me),
connect (us, together),

tell me.

do something if distressed;

    @dawn, dance;
    @evening, sing;
    read (books, $poems, stories) until peaceful;
    study if able;

    write me if-you-please;

sort your feelings, reset goals, seek (friends, family, anyone);

    do*not*die (like this)
    if sin abounds;

keys (hidden), open (locks, doors), tell secrets;
do not, I-beg-you, close them, yet.

        accept (yourself, changes),
        bind (grief, despair);

require truth, goodness if-you-will, each moment;

select (always), length (of-days)

Ausgabe vom Ausführen des Programms auf sich selbst:

#!/usray/inbay/erlpay

ilewhay (<>) {
    intpray apmay { 
        s/^([zbcdfghjklmnpqrstvwxyay]*)([a-z]+)/$2$1ay/i ifay /[a-z][a-z]/i; $_ 
    } itsplay(/\b/);
}
__END__
# istenlay (a erlpay oempay)
# aronShay opkinsHay
# evray. uneJay 19, 1995
# oundFay inay ethay "erlPay oetryPay" ectionsay ofay ethay amelCay ookbay
APPEALay:

istenlay(easeplay, easeplay);

openay ourselfyay, ideway;
    oinjay (ouyay, emay),
onnectcay (usay, ogethertay),

elltay emay.

oday omethingsay ifay istressedday;

    @awnday, anceday;
    @eveningay, ingsay;
    eadray (ooksbay, $oemspay, oriesstay) untilay eacefulpay;
    udystay ifay ableay;

    itewray emay ifay-ouyay-easeplay;

ortsay ouryay eelingsfay, esetray oalsgay, eeksay (iendsfray, amilyfay, anyoneay);

    oday*otnay*ieday (ikelay isthay)
    ifay insay aboundsay;

eyskay (iddenhay), openay (ockslay, oorsday), elltay ecretssay;
oday otnay, I-egbay-ouyay, oseclay emthay, etyay.

        acceptay (ourselfyay, angeschay),
        indbay (iefgray, espairday);

equireray uthtray, oodnessgay ifay-ouyay-illway, eachay omentmay;

electsay (alwaysay), engthlay (ofay-aysday)
Ralph Marshall
quelle
2
Schweinelatein gilt als Sprachspiel, nicht als natürliche Sprache. Siehe die Pig Latin Wikipedia Seite .
Alex A.
5
Ich nehme an, Sie könnten es so nennen, obwohl ich mir nicht sicher bin, ob diese Herausforderung in Bezug auf die Formalität auf das Niveau eines Bundes-RFP ansteigt.
Ralph Marshall
3
Der Name der übersetzten Sprache sollte ErlPay sein und ich würde es lieben, wenn es auch ausgegeben wird __DENAY__. Soll openayund acceptaysoll nicht enopayund ceptacay?
CJ Dennis
1
Die Herausforderung spezifiziert "Fremdsprache". Schweinelatein zählt nicht.
mbomb007
6
Ich denke, ich schlage vor, dass Sie alle über die Akzeptanz von PigLatin als Fremdsprache nachdenken. Wenn Ihnen meine Lösung nicht gefällt, stimmen Sie nicht dafür. Ich glaube, dass CJ damit glücklich genug ist, und da dies nur eine lustige kleine Übung ist, bleibe ich bei meinem Input.
Ralph Marshall
17

Visual Basic .Net, Persisch

Ich habe eine ausführliche Sprache gewählt, damit es schwieriger wird. Es stellte sich heraus, dass ich die Grammatik nicht ändern musste. Die persische Form des Codes ist ebenso ausführlich.

Imports System.Collections.Generic
Module Translator

Sub Main()
    Dim translation As New Dictionary(Of String, String)
    With translation
        .Add("imports", "وارد‌کردن")
        .Add("system", "دستگاه")
        .Add("collections", "مجموعه")
        .Add("generic", "عمومی")
        .Add("module", "واحد")
        .Add("translator", "مترجم")
        .Add("sub", "زیرروال")
        .Add("main", "اصلی")
        .Add("dim", "بعد")
        .Add("translation", "ترجمه")
        .Add("new", "نو")
        .Add("dictionary", "دیکشنری")
        .Add("string", "رشته")
        .Add("with", "با")
        .Add("add", "افزودن")
        .Add("end", "پایان")
        .Add("file", "فایل")
        .Add("create", "درست‌کردن")
        .Add("readalltext", "خواندن‌کل‌متن")
        .Add("writealltext", "نوشتن‌کل‌متن")
        .Add("io", "ورودی‌خروجی")
        .Add("for", "برای")
        .Add("each", "هر")
        .Add("next", "بعدی")
        .Add("tolower", "به‌کوچک")
        .Add("key", "کلید")
        .Add("value", "مقدار")
        .Add("replace", "جایگزین‌کردن")
        .Add("code", "کد")
        .Add("dispose", "رها‌کردن")
        .Add("and", "و")
        .Add("andalso", "و‌همچنین")
        .Add("byte", "بیت")
        .Add("call", "صدا‌کردن")
        .Add("case", "صورت")
        .Add("catch", "گرفتن")
        .Add("object", "شئ")
        .Add("integer", "عدد")
        .Add("if", "اگر")
        .Add("then", "سپس")
        .Add("goto", "برو‌به")
        .Add("true", "درست")
        .Add("false", "نادرست")
        .Add("exit", "خارج‌شدن")
        .Add("loop", "حلقه")
        .Add("function", "تابع")
        .Add("nothing", "هیچی")
        .Add("else", "در‌غیر‌این‌صورت")
        .Add("try", "سعی‌کردن")
        .Add("or", "یا")
        .Add("orelse", "یا")
        .Add("as", "به‌عنوان")
        .Add("of", "از")
        .Add("in", "در")
    End With
    Dim code As String = System.IO.File.ReadAllText("Code.txt").ToLower()
    For Each k In translation
        code = code.Replace(k.Key, k.Value)
    Next
    System.IO.File.Create("Persian.txt").Dispose()
    System.IO.File.WriteAllText("Persian.txt", code)
End Sub

End Module

Das Ergebnis erfordert einen Texteditor von rechts nach links. Ich konnte es hier nicht richtig anzeigen lassen. Aber wenn ich es anzeigen muss, ist es hier. Hier ist ein Bild:

Code

Hinweis: Es liest aus einer Datei mit dem Namen Persian.txt und gibt Code.txt aus. Ich konnte das Konsolenfenster nicht dazu bringen, Persisch zu schreiben oder zu lesen, ohne dass es sich in Fragezeichen verwandelte. (zB ein Wort mit vier Buchstaben wird zu ????)

Hinweis: Wenn Sie Wörter auf Persisch miteinander verbinden, ist dies fast unlesbar, da Buchstaben miteinander verbunden werden und eine andere Form erhalten. Also musste ich sie durch Leerzeichen trennen, was dazu führte, dass Wörter Leerzeichen hatten. Aus einem Wort wie Imports wurde وارد کردن, das aus zwei Wörtern besteht.

JNV
quelle
In meinem hebräischen Post füge ich einen Screenshot hinzu, der in einem Editor, der RTL unterstützt, richtig angezeigt wird.
Scimonster
@Scimonster Gute Idee. Das mache ich gleich. Vielen Dank.
JNV,
2
Sie können "درست کردن" ohne Leerzeichen haben, ohne dass daraus "درستکردن" wird. Verwenden Sie dazu ein Unicode-Nicht-Joiner-Zeichen mit der Breite Null (U + 200C): "درست‌کردن" - dies zwingt die Buchstaben, nebeneinander zu stehen ohne lücke, ohne sie zusammenzufügen - ob die ergebnisse jedoch gut aussehen, hängt von der schriftart ab!
Psmears
@psmears Du hast recht; Ich habe es vergessen. Vielen Dank!
4.
14

Java, Deutsch - Java

Dieses Programm ist wirklich einfach.
Es liest nur die als erstes Argument angegebene Datei und ersetzt alle Vorkommen eines englischen Wortes durch die jeweilige deutsche Übersetzung.

Ich verwende einen regulären Ausdruck mit zwei Gruppen ( ([^a-zA-Z\\d:])*), um einzelnen Elementen ein nicht-alphanumerisches Zeichen vorangestellt / gefolgt zuzuordnen . Dies löste das Problem mit überlappenden Übersetzungen (dt. List-> dt. Würde Listedann Listeaber werden Listee). Die Verwendung von $1/ $2fügt diese Zeichen wieder hinzu und hinterlässt einen übersetzten Quellcode.

Update 1:

Verwenden Sie Abkürzungen wie ea, nbeausw. zu folgen Konventionen von Java in deutscher Sprache zu benennen.

Update 2:

Verwendet nun eine dritte Komponente im Array, um nach ihrem ersten Austausch zu brechen. Dies ist notwendig für meinen betrügerischen Deklinations- / Konjugationsansatz. class/ Klasseist weiblich in Deutsch und void/ nichtsist neutral, also habe ich gerade das Ersetzen des letzteren übersprungen und später ersetzt. Eine andere Bearbeitung ist newdie Übersetzung, die neueich verwendet habe String, weil sie weiblich ist.

Update 3:

Behandeln Sie die Groß- und Kleinschreibung richtig, indem Sie reguläre Ausdrücke hinzufügen.

import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.util.regex.Pattern;

    public class Main {

        public static void main(String[] args) throws IOException {
            String[][] array = new String[][]{
                    {"import", "importiere", ""},
                    {"public", "öffentliche", "break"},
                    {"public", "öffentliches", ""},
                    {"class", "klasse", ""},
                    {"Main", "Haupt", ""},
                    {"main", "haupt", ""},
                    {"static", "statisches", ""},
                    {"void", "nichts", ""},
                    {"String", "Zeichenkette", ""},
                    {"args", "argumente", ""},
                    {"throws", "wirft", ""},
                    {"IOException", "EAAusnahme", ""},
                    {"FileSystems", "Dateisysteme", ""},
                    {"new", "neue", ""},
                    {"Files", "Dateien", ""},
                    {"readAllBytes", "leseAlleBytes", ""},
                    {"getDefault", "holeStandard", ""},
                    {"getPath", "holePfad", ""},
                    {"array", "ansammlung", ""},
                    {"replaceFirst", "ersetzeErstes", ""},
                    {"find", "finde", ""},
                    {"out", "ausgabe", ""},
                    {"println", "druckeZeile", ""},
                    {"pattern", "muster", ""},
                    {"Pattern", "Muster", ""},
                    {"compile", "zusammenstellen", ""},
                    {"matcher", "abgleicher", ""},
                    {"util", "werkzeug", ""},
                    {"regex", "regaus", ""},
                    {"while", "solange", ""},
                    {"nio", "nbea", ""},
                    {"io", "ea", ""},
                    {"for", "für", ""},
                    {"if", "wenn", ""},
                    {"equals", "gleicht", ""},
                    {"break", "unterbrechen", ""}

            };
            String str = new String(Files.readAllBytes(FileSystems.getDefault().getPath(args[0])));
            for (String[] s : array) {
                Pattern pattern = Pattern.compile("(^|[^a-zA-Z\\d]+)" + s[0] + "([^a-zA-Z\\d]+)");
                while(pattern.matcher(str).find(0)) {
                    str = pattern.matcher(str).replaceFirst("$1" + s[1] + "$2");
                    if(s[2].equals("break")) {
                        break;
                    }
                }
            }
            System.out.println(str);
        }
    }

Dies gibt Folgendes aus System.out:

importiere java.ea.EAAusnahme;
importiere java.nbea.file.Dateisysteme;
importiere java.nbea.file.Dateien;
importiere java.werkzeug.regaus.Muster;

    öffentliche klasse Haupt {

        öffentliches statisches nichts haupt(Zeichenkette[] argumente) wirft EAAusnahme {
            Zeichenkette[][] ansammlung = neue Zeichenkette[][]{
                    {"importiere", "importiere", ""},
                    {"öffentliches", "öffentliche", "unterbrechen"},
                    {"öffentliches", "öffentliches", ""},
                    {"klasse", "klasse", ""},
                    {"Haupt", "Haupt", ""},
                    {"haupt", "haupt", ""},
                    {"statisches", "statisches", ""},
                    {"nichts", "nichts", ""},
                    {"Zeichenkette", "Zeichenkette", ""},
                    {"argumente", "argumente", ""},
                    {"wirft", "wirft", ""},
                    {"EAAusnahme", "EAAusnahme", ""},
                    {"Dateisysteme", "Dateisysteme", ""},
                    {"neue", "neue", ""},
                    {"Dateien", "Dateien", ""},
                    {"leseAlleBytes", "leseAlleBytes", ""},
                    {"holeStandard", "holeStandard", ""},
                    {"holePfad", "holePfad", ""},
                    {"ansammlung", "ansammlung", ""},
                    {"ersetzeErstes", "ersetzeErstes", ""},
                    {"finde", "finde", ""},
                    {"ausgabe", "ausgabe", ""},
                    {"druckeZeile", "druckeZeile", ""},
                    {"muster", "muster", ""},
                    {"Muster", "Muster", ""},
                    {"zusammenstellen", "zusammenstellen", ""},
                    {"abgleicher", "abgleicher", ""},
                    {"werkzeug", "werkzeug", ""},
                    {"regaus", "regaus", ""},
                    {"solange", "solange", ""},
                    {"nbea", "nbea", ""},
                    {"ea", "ea", ""},
                    {"für", "für", ""},
                    {"wenn", "wenn", ""},
                    {"gleicht", "gleicht", ""},
                    {"unterbrechen", "unterbrechen", ""}

            };
            Zeichenkette str = neue Zeichenkette(Dateien.leseAlleBytes(Dateisysteme.holeStandard().holePfad(argumente[0])));
            für (Zeichenkette[] s : ansammlung) {
                Muster muster = Muster.zusammenstellen("(^|[^a-zA-Z\\d]+)" + s[0] + "([^a-zA-Z\\d]+)");
                solange(muster.abgleicher(str).finde(0)) {
                    str = muster.abgleicher(str).ersetzeErstes("$1" + s[1] + "$2");
                    wenn(s[2].gleicht("unterbrechen")) {
                        unterbrechen;
                    }
                }
            }
            System.ausgabe.druckeZeile(str);
        }
    }

Wenn Sie Verbesserungen am Code oder an der Übersetzung haben, lassen Sie es mich wissen und ich sehe, ob ich sie implementieren kann.

GiantTree
quelle
/, 󠀠 Und -sind wahrscheinlich in Bezeichnern nicht gut.
Vi.
6
Ich liebe die Korrespondenz zwischen den beiden Sprachen - beide verwenden für alles riesige zusammengesetzte Wörter. ;) Aber ich vermute die Deutschen würden trotzdem Eingabe/Ausgabeirgendwie abkürzen - vielleicht Einaus?
DLosc
1
@DLosc I / O (Input / Output) wird normalerweise mit E / A (Eingabe / Ausgabe) abgekürzt. Einauswäre auch möglich, denke ich aber es fühlt sich nicht richtig an. Rein/RausDas scheint auch möglich, fühlt sich aber einfach nicht nach einer guten Übersetzung an.
GiantTree
@Vi. du meinst als zeichen in der zeichenkette zu ersetzen (linke seite)? Diese werden nicht benötigt, da Java nicht zulässt, dass solche Zeichen Teil eines Namens / Bezeichners sind. Ich denke, Sie meinen, weil ich die gesamte Zeichenfolge immer wieder überprüfe und Sie denken, dass dies E/Aoder ähnliches Probleme verursachen könnte, aber sie werden nicht als regulärer Ausdruck interpretiert, sondern nur abgeglichen und lassen den regulären Ausdruck daher unberührt. (Ich könnte mich irren, aber das ist, was ich mit regulären Ausdrücken erlebt habe)
GiantTree
@GiantTree, ich meine, der Code wäre für einen hypothetischen deutschen Java-Compiler schwer zu analysieren.
Vi.
14

Julia, Tatar - Julia

Dabei wird das inoffizielle lateinische Zamanälif-Alphabet für İdel-Ural Tatar verwendet, das 2001 eingeführt wurde. Im Jahr 2002 schlug die Russische Föderation jedoch Tatarstans Antrag zurück, Zamanälif zum offiziellen Alphabet für die tatarische Sprache zu machen, wodurch die offizielle Verwendung von Tatarisch unter Strafe gestellt wurde anderes Alphabet als Kyrillisch.

Im vergangenen Jahrhundert gab es 5 Buchstaben für die tatarische Sprache:

  • İske imlâ, eine Variante des arabischen Alphabets, 1870-1920
  • Yaña imlâ, eine andere arabische Variante, 1920er und 30er Jahre
  • Jaᶇalif, eine Variante des lateinischen Alphabets, 1930er Jahre
  • Kyrillisch, Bekehrung von Joseph Stalin, seit den 1940er Jahren
  • Zamanälif, inoffiziell, seit 2001

Ich habe mich für Zamanälif entschieden, weil ich glaube, mein Opa wäre enttäuscht, wenn ich Kyrillisch verwenden würde. Seine Muttersprache ist Tatarisch. Er wurde in den 1920er Jahren geboren und lernte das Lesen und Schreiben im iske imlâ-Alphabet.

Englisch:

function translate(source)
    words = Dict([("function", "funktsiya"),
                  ("if",gär"),
                  ("else", "başkaça"),
                  ("elif", "başägär"),
                  ("end", "axır"),
                  ("for", "saen"),
                  ("print", "bastırırga"),
                  ("english", "ingliz"),
                  ("tatar", "tatarça"),
                  ("translate", "tärcemä"),
                  ("words", "süzlär"),
                  ("replace", "alıştıru"),
                  ("Dict", "Süzlek"),
                  ("keys", "açkıçlär"),
                  ("get", "alırga"),
                  ("readall", "ukırgaböten"),
                  ("source", "çıganak")])

    tatar = readall(source)

    for english = keys(words)
        tatar = replace(tatar, english, get(words, english, ""))
    end

    tatar
end

print(translate("tatar.jl"))

Tatar:

funktsiya tärcemä(çıganak)
    süzlär = Süzlek([("funktsiya", "funktsiya"),
                  (gär",gär"),
                  ("başkaça", "başkaça"),
                  ("başägär", "başägär"),
                  ("axır", "axır"),
                  ("saen", "saen"),
                  ("bastırırga", "bastırırga"),
                  ("ingliz", "ingliz"),
                  ("tatarça", "tatarça"),
                  ("tärcemä", "tärcemä"),
                  ("süzlär", "süzlär"),
                  ("alıştıru", "alıştıru"),
                  ("Süzlek", "Süzlek"),
                  ("açkıçlär", "açkıçlär"),
                  ("alırga", "alırga"),
                  ("ukırgaböten", "ukırgaböten"),
                  ("çıganak", "çıganak")])

    tatarça = ukırgaböten(çıganak)

    saen ingliz = açkıçlär(süzlär)
        tatarça = alıştıru(tatarça, ingliz, alırga(süzlär, ingliz, ""))
    axır

    tatarça
axır

bastırırga(tärcemä("~/tatarça.jl"))

Ich habe mir ein paar Freiheiten genommen, um die Übersetzung ein wenig sauberer zu machen. Zum Beispiel forwurde saen, was wörtlicher übersetzt "jeder". Ich habe auch nicht abgekürzt Süzlek, was "Wörterbuch" bedeutet. ukırgabötenMeine Übersetzung für readalllautet ukırga(read) + böten(all / every). başägär, meine Übersetzung für elseif, ist baş(eine Abkürzung für başkaça, bedeutet "else / else") + ägär(if).

Wenn jemand auf PPCG Tatar kennt, wissen Sie wahrscheinlich mehr als ich. Anregungen wären willkommen.

Alex A.
quelle
13

Rust , Weißrussisch (Ржа)

Programm:

#![feature(non_ascii_idents)]

use std::io::stdin;
use std::io::Read;

static ЗАМЕНЫ: &'static [(&'static str, &'static str)] =  &[
    ("match", "супастаўленьне"),
    (" if ", " калі "),
    ("else", "інакш"),
    (" as ", " як "),
    ("panic!", "паніка!"),
    ("assert!", "праверыць!"),
    ("box ", "пак "),
    ("break", "перапыніць"),
    ("continue", "працягнуць"),
    ("fn ", "фн "),
    ("extern", "знешняе"),
    (" for ", " кожная "),
    (" in ", " ў "),
    ("impl ", " увасобіць "),
    ("let ", "хай "),
    ("loop ", "цыкл "),
    ("once", "аднойчы"),
    ("pub ", "адкр"),
    ("return", "выйсці"),
    ("super", "бацькоўскі_модуль"),
    ("unsafe ", "непяспечнае "),
    (" where", " дзе"),
    ("while", "пакуль"),
    ("use ", "вык "),
    ("mod ", "модуль "),
    ("trait ", "рыса "),
    ("struct ", "структура "),
    ("enum ", "пералік"),
    ("type ", "тып "),
    ("move ", "перанесьці"),
    ("mut ", "зьмян "),
    ("ref ", "спасыл "),
    ("static ", "статычнае "),
    ("const ", "нязменнае "),
    ("crate ", "скрыня "),
    ("Copy", "МожнаКапіяваць"),
    ("Send", "МожнаПерадаваць"),
    ("Sized", "МаеПамер"),
    ("Sync", "БяспечнаНаПатокі"),
    ("Drop", "МаеЗавяршальнік"),
    ("FnMut", "ЯкЗьмяняемаяФункцыя"),
    ("FnOnce", "ЯкАднаразоваяФункцыя"),
    ("Fn", "ЯкФункцыя"),
    ("macro_rules!", "новы_макрас!"),
    ("alignof", "выраўненьеяку"),
    ("become", "стала"),
    ("do ", "рабі"),
    ("offsetof", "пазіцыяяку"),
    ("priv", "прыватнае"),
    ("pure", "чыстае"),
    ("sizeof", "памер_ад"),
    ("typeof", "тып_ад"),
    ("unsized", "безпамеравы"),
    ("yield", "вырабіць"),
    ("abstract", "абстрактны"),
    ("virtual", "віртуальны"),
    ("final", "канчатковае"),
    ("override", "перавызначыць"),
    ("macro", "макрас"),
    ("Box", "Каробка"),
    ("ToOwned", "МожнаНабыцьУладара"),
    ("Clone", "МожнаКланаваць"),
    ("PartialOrd", "МаеЧастковыПарадак"),
    ("PartialEq", "ЧастковаПараўнальны"),
    ("Eq", "Параўнальны"),
    ("Ord", "МаеПарадак"),
    ("AsRef", "МожнаЯкСпасылку"),
    ("AsMut", "МожнаЯкЗьмяняемые"),
    ("Into", "МожнаУ"),
    ("From", "МожнаЗ"),
    ("Default", "МаеЗначеньнеПаЗмаўчаньні"),
    ("Extend", "Пашырыць"),
    ("IntoIterator", "МожнаУПаўторнік"),
    ("DoubleEndedIterator", "ДвубаковыПаўторнік"),
    ("ExactSizeIterator", "ПаўторнікЗДакладнымПамерам"),
    ("Iterator", "Паўторнік"),
    ("Option", "Недакладна"),
    ("Some", "Ёсць"),
    ("None", "Нічога"),
    ("Result", "Вынік"),
    ("Ok", "Ок"),
    ("Err", "Збой"),
    ("SliceConcatExt", "АбянднальнікЛустаў"),
    ("ToString", "УРадок"),
    ("String", "Радок"),
    ("Vec", "Вэктар"),
    ("vec!", "вэкрар!"),
    ("self", "сам"),
    ("true", "так"),
    ("false", "не"),
    ("feature", "магчымасьць"),

    ("main", "галоўная"),
    ("replace", "замяніць"),
    ("iter","пераліч"),
    ("print!","друк!"),
    ("println!","друкрад!"),
    ("stdin","звыч_уваход"),
    ("stdout","звыч_выхад"),
    ("stderr","звыч_павед"),
    ("Read", "Чытальнік"),
    ("Write", "Пісальнік"),
    ("read_to_string", "чытаць_у_радок"),
    ("to_string", "у_радок"),
    ("std", "стд"),
    ("io", "ув"),
    ("non_ascii_idents", "ідентыфікатары_з_юнікоду"),

    ("str", "радок"),
];


fn main() {
    let mut зьмест : String = "".to_string();
    match stdin().read_to_string(&mut зьмест) {
        Ok(_) => (),
        Err(памылка) => panic!(памылка),
    }
    for замена in ЗАМЕНЫ.iter() {
        зьмест = зьмест.replace(замена.0, замена.1);
    }
    println!("{}", зьмест);
}

Ausgabe:

#![магчымасьць(ідентыфікатары_з_юнікоду)]

вык стд::ув::звыч_уваход;
вык стд::ув::Чытальнік;

статычнае ЗАМЕНЫ: &'статычнае [(&'статычнае радок, &'статычнае радок)] =  &[
    ("супастаўленьне", "супастаўленьне"),
    (" калі ", " калі "),
    ("інакш", "інакш"),
    (" як ", " як "),
    ("паніка!", "паніка!"),
    ("праверыць!", "праверыць!"),
    ("пак ", "пак "),
    ("перапыніць", "перапыніць"),
    ("працягнуць", "працягнуць"),
    ("фн ", "фн "),
    ("знешняе", "знешняе"),
    (" кожная ", " кожная "),
    (" ў ", " ў "),
    (" увасобіць ", " увасобіць "),
    ("хай ", "хай "),
    ("цыкл ", "цыкл "),
    ("аднойчы", "аднойчы"),
    ("адкр", "адкр"),
    ("выйсці", "выйсці"),
    ("бацькоўскі_модуль", "бацькоўскі_модуль"),
    ("непяспечнае ", "непяспечнае "),
    (" дзе", " дзе"),
    ("пакуль", "пакуль"),
    ("вык ", "вык "),
    ("модуль ", "модуль "),
    ("рыса ", "рыса "),
    ("структура ", "структура "),
    ("пералік", "пералік"),
    ("тып ", "тып "),
    ("перанесьці", "перанесьці"),
    ("зьмян ", "зьмян "),
    ("спасыл ", "спасыл "),
    ("статычнае ", "статычнае "),
    ("нязменнае ", "нязменнае "),
    ("скрыня ", "скрыня "),
    ("МожнаКапіяваць", "МожнаКапіяваць"),
    ("МожнаПерадаваць", "МожнаПерадаваць"),
    ("МаеПамер", "МаеПамер"),
    ("БяспечнаНаПатокі", "БяспечнаНаПатокі"),
    ("МаеЗавяршальнік", "МаеЗавяршальнік"),
    ("ЯкЗьмяняемаяФункцыя", "ЯкЗьмяняемаяФункцыя"),
    ("ЯкАднаразоваяФункцыя", "ЯкАднаразоваяФункцыя"),
    ("ЯкФункцыя", "ЯкФункцыя"),
    ("новы_макрас!", "новы_макрас!"),
    ("выраўненьеяку", "выраўненьеяку"),
    ("стала", "стала"),
    ("рабі", "рабі"),
    ("пазіцыяяку", "пазіцыяяку"),
    ("прыватнае", "прыватнае"),
    ("чыстае", "чыстае"),
    ("памер_ад", "памер_ад"),
    ("тып_ад", "тып_ад"),
    ("безпамеравы", "безпамеравы"),
    ("вырабіць", "вырабіць"),
    ("абстрактны", "абстрактны"),
    ("віртуальны", "віртуальны"),
    ("канчатковае", "канчатковае"),
    ("перавызначыць", "перавызначыць"),
    ("макрас", "макрас"),
    ("Каробка", "Каробка"),
    ("МожнаНабыцьУладара", "МожнаНабыцьУладара"),
    ("МожнаКланаваць", "МожнаКланаваць"),
    ("МаеЧастковыПарадак", "МаеЧастковыПарадак"),
    ("ЧастковаПараўнальны", "ЧастковаПараўнальны"),
    ("Параўнальны", "Параўнальны"),
    ("МаеПарадак", "МаеПарадак"),
    ("МожнаЯкСпасылку", "МожнаЯкСпасылку"),
    ("МожнаЯкЗьмяняемые", "МожнаЯкЗьмяняемые"),
    ("МожнаУ", "МожнаУ"),
    ("МожнаЗ", "МожнаЗ"),
    ("МаеЗначеньнеПаЗмаўчаньні", "МаеЗначеньнеПаЗмаўчаньні"),
    ("Пашырыць", "Пашырыць"),
    ("МожнаУПаўторнік", "МожнаУПаўторнік"),
    ("ДвубаковыПаўторнік", "ДвубаковыПаўторнік"),
    ("ПаўторнікЗДакладнымПамерам", "ПаўторнікЗДакладнымПамерам"),
    ("Паўторнік", "Паўторнік"),
    ("Недакладна", "Недакладна"),
    ("Ёсць", "Ёсць"),
    ("Нічога", "Нічога"),
    ("Вынік", "Вынік"),
    ("Ок", "Ок"),
    ("Збой", "Збой"),
    ("АбянднальнікЛустаў", "АбянднальнікЛустаў"),
    ("УРадок", "УРадок"),
    ("Радок", "Радок"),
    ("Вэктар", "Вэктар"),
    ("вэкрар!", "вэкрар!"),
    ("сам", "сам"),
    ("так", "так"),
    ("не", "не"),
    ("магчымасьць", "магчымасьць"),

    ("галоўная", "галоўная"),
    ("замяніць", "замяніць"),
    ("пераліч","пераліч"),
    ("друк!","друк!"),
    ("друкрад!","друкрад!"),
    ("звыч_уваход","звыч_уваход"),
    ("звыч_выхад","звыч_выхад"),
    ("звыч_павед","звыч_павед"),
    ("Чытальнік", "Чытальнік"),
    ("Пісальнік", "Пісальнік"),
    ("чытаць_у_радок", "чытаць_у_радок"),
    ("у_радок", "у_радок"),
    ("стд", "стд"),
    ("ув", "ув"),
    ("ідентыфікатары_з_юнікоду", "ідентыфікатары_з_юнікоду"),

    ("радок", "радок"),
];


фн галоўная() {
    хай зьмян зьмест : Радок = "".у_радок();
    супастаўленьне звыч_уваход().чытаць_у_радок(&зьмян зьмест) {
        Ок(_) => (),
        Збой(памылка) => паніка!(памылка),
    }
    кожная замена ў ЗАМЕНЫ.пераліч() {
        зьмест = зьмест.замяніць(замена.0, замена.1);
    }
    друкрад!("{}", зьмест);
}
Vi.
quelle
Nein.
Vi.
Russisch und C ++?
GamrCorps
@IonLee, Nein. Hinweis: Die erste Vermutung war näher.
Vi.
@IonLee: Die natürliche Sprache ist Weißrussisch.
Alex A.
1
Rust und Weißrussisch?
ProgramFOX
12

DogeScript , Spanisch - El Código del Perro

DogeScript wird in JavaScript interpretiert, sodass jedes gültige JS ein gültiges DogeScript ist. Die Übersetzung, die ich hier gegeben habe, umfasst tatsächlich die gesamte Schlüsselwortspezifikation (plus einige mehr, um die im Programm verwendeten Wörter abzudecken).

"Englisch":

 trained

   very speak is prompt()

very doge is {
    'console': 'consola',
    'doge': 'perro',
    'very': 'muy',
    'concern': 'preocupación',
    'word': 'palabra',
    'much': 'mucho',
    'trained': 'entrenado',
    'with': 'con',
    'doge': 'perro',
    'very': 'muy',
    'much': 'mucho',
    'with': 'con',
    'is': 'es',
    'trained': 'entrenado',
    'such': 'tan',
    'wow': 'guau',
    'plz': 'porFavor',
    'but': 'pero',
    'maybe': 'quizás',
    'rly': 'enserio',
    'many': 'muchos',
    'so': 'tanto',
    'not': 'no',
    'and': 'y',
    'or': 'o',
    'next': 'siguiente',
    'as': 'como',
    'more': 'más',
    'less': 'menos',
    'lots': 'montones',
    'few': 'pocos',
    'bigger': 'másGrande',
    'smaller': 'menor',
    'biggerish': 'unPocoMásGrande',
    'smallerish': 'unPocoMásPequeño',
    'prompt': 'preguntar',
    'in': 'en',
    'replace': 'reemplazar',
    'new': 'nuevo',
    'RegExp': 'ExpReg',
    'loge': 'registro',
    'dose': 'punta',
    'speak': 'habla'
}

much very word in doge
         very concern is new RegExp with word 'g'
 doge is speak dose replace with concern doge[word]
      wow

console dose loge with speak

Spanisch:

 entrenado

   muy habla es preguntar()

muy perro es {...}

mucho muy palabra en perro
         muy preocupación es nuevo ExpReg con palabra 'g'
 perro es habla punta reemplazar con preocupación perro[palabra]
      guau

consola punta registro con habla

Sie werden vielleicht bemerken, dass ich mir bei der Übersetzung ein paar Freiheiten genommen habe. Dies liegt zum Teil daran, dass mein Spanisch ziemlich schlecht ist, und zum Teil daran, dass meine Kenntnisse der spanischen Sprache fehlen.

Bildbeschreibung hier eingeben

Alex A.
quelle
11

C #, Lateinisch - C Acutus

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace ToLatin
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<string, string> dx = new Dictionary<string, string>();
            dx.Add("using", "usura");
            dx.Add("System", "Ratio");
            dx.Add("Collections", "Comprensio");
            dx.Add("Text", "Scriptum");
            dx.Add("txt", "scrptm");
            dx.Add("output", "scribo");
            dx.Add("namespace", "nomenspatium");
            dx.Add("class", "classis");
            dx.Add("Program", "Libellus");
            dx.Add("static", "immotus");
            dx.Add("void", "inane");
            dx.Add("Main", "Paelagus");
            dx.Add("string", "chorda");
            dx.Add("args", "argumenta");
            dx.Add("Dictionary", "Lexicon");
            dx.Add("new", "novus");
            dx.Add("Add", "Adaugeo");
            dx.Add("IO", "LecticoScribo");
            dx.Add("abstract", "abstracto");
            dx.Add("break", "confractus");
            dx.Add("Math", "Mathematica");
            dx.Add("File", "Ordo");
            dx.Add("file", "ordo");
            dx.Add("foreach", "prosingulus");
            dx.Add("Read", "Lectico");
            dx.Add("Write", "Scribo");
            dx.Add("All", "Omnes");
            dx.Add("translation", "interpretatio");
            dx.Add("bool", "verumfalsus");
            dx.Add("true", "verum");
            dx.Add("false", "falsus");
            dx.Add("0", "nil");
            dx.Add("||", "aut");
            dx.Add("&&", "et");
            dx.Add("Key", "Clavis");
            dx.Add("Value", "Pretium");
            dx.Add("Replace", "Restituo");
            dx.Add("Generic", "Ordinarius");
            dx.Add("ToLatin", "AdLatinam");
            string file = File.ReadAllText(args[0]);
            foreach (var translation in dx )
            {
                file = file.Replace(translation.Key, translation.Value);
            }
            File.WriteAllText("output.txt", file);
        }
    }
}

Liest die Datei von Befehlszeilenargumenten und schreibt sie in die Datei output.txt.

Beispiel:

usura Ratio;
usura Ratio.Comprensio.Ordinarius;
usura Ratio.Scriptum;
usura Ratio.LecticoScribo;

nomenspatium AdLatinam
{
    classis Libellus
    {
        immotus inane Paelagus(chorda[] argumenta)
        {
            Lexicon<chorda, chorda> dx = novus Lexicon<chorda, chorda>();
            dx.Adaugeo("usura", "usura");
            dx.Adaugeo("Ratio", "Ratio");
            dx.Adaugeo("Comprensio", "Comprensio");
            dx.Adaugeo("Scriptum", "Scriptum");
            dx.Adaugeo("scrptm", "scrptm");
            dx.Adaugeo("scribo", "scribo");
            dx.Adaugeo("nomenspatium", "nomenspatium");
            dx.Adaugeo("classis", "classisis");
            dx.Adaugeo("Libellus", "Libellus");
            dx.Adaugeo("immotus", "immotus");
            dx.Adaugeo("inane", "inane");
            dx.Adaugeo("Paelagus", "Paelagus");
            dx.Adaugeo("chorda", "chorda");
            dx.Adaugeo("argumenta", "argumenta");
            dx.Adaugeo("Lexicon", "Lexicon");
            dx.Adaugeo("novus", "novus");
            dx.Adaugeo("Adaugeo", "Adaugeo");
            dx.Adaugeo("LecticoScribo", "LecticoScribo");
            dx.Adaugeo("abstracto", "abstractoo");
            dx.Adaugeo("confractus", "confractus");
            dx.Adaugeo("Mathematica", "Mathematicaematica");
            dx.Adaugeo("Ordo", "Ordo");
            dx.Adaugeo("ordo", "ordo");
            dx.Adaugeo("prosingulus", "prosingulus");
            dx.Adaugeo("Lectico", "Lectico");
            dx.Adaugeo("Scribo", "Scribo");
            dx.Adaugeo("Omnes", "Omnes");
            dx.Adaugeo("interpretatio", "interpretatio");
            dx.Adaugeo("verumfalsus", "verumfalsus");
            dx.Adaugeo("verum", "verum");
            dx.Adaugeo("falsus", "falsus");
            dx.Adaugeo("nil", "nil");
            dx.Adaugeo("aut", "aut");
            dx.Adaugeo("et", "et");
            dx.Adaugeo("Clavis", "Clavis");
            dx.Adaugeo("Pretium", "Pretium");
            dx.Adaugeo("Restituo", "Restituo");
            dx.Adaugeo("Ordinarius", "Ordinarius");
            dx.Adaugeo("ToLatin", "AdLatinam");
            chorda ordo = Ordo.LecticoOmnesScriptum(argumenta[nil]);
            prosingulus (var interpretatio in dx )
            {
                ordo = ordo.Restituo(interpretatio.Clavis, interpretatio.Pretium);
            }
            Ordo.ScriboOmnesScriptum("scribo.scrptm", ordo);
        }
    }
}

Verdammt, habe gerade die lateinische Version von C ++ gesehen.

Kade
quelle
s/ToLatin/AdLatinam/... auch sollte nicht argssein argumenta(Neutrum Plural)?
DLosc
@ DLosc Ich weiß nicht, ob es sollte, ich kann kein Latein, aber ich nehme dein Wort dafür.
Kade,
Gut, ich vergleiche unsere Übersetzungen nach gängigen Begriffen. "oder" sollte "aut" sein.
Luke,
Warum ist System Ratioin Latein? Was heißt dann Verhältnis auf Latein?
Phuclv
@ LưuVĩnhPhúc ratio->ratione/proportio
Kade
8

Ruby, Japanisch - AkaDama

Ruby auf Japanisch ist rubii (ル ル ビ), was langweilig ist, also habe ich es wörtlich rotes Juwel genannt .

In Ruby sind Variablen und Methoden nicht auf ASCII beschränkt, so etwas wie

def フロートの文字化(フロート)
     = フロート.to_s.split(?.)
    甲[0] = 整数の文字化(甲[0])
    甲[1] = 甲[1].chars.map{|乙|R数字行列[乙]}.join
    甲.join(?点)
end

ist gültiger Rubin. Ich benutze dies so oft wie möglich zur Verschleierung all deiner Basen.

Ich hoffe, es ist in Ordnung, die Edelsteine ​​zum Parsen von Rubinen zu verwenden.

Sie können das erweitern TRANS_TABLE, um die Übersetzung für weitere Methoden hinzuzufügen. Alles, was nicht in der Tabelle steht, wird lose auf der Grundlage der Aussprache (oder eher der Schreibweise) ins Japanische "übersetzt". Essen wird also zu becomes あ と ("a-ah-toe").

Konvertiert Ganzzahlen in eine "sehr" praktische Notation .

# encoding:utf-8

require 'parser/current'

# super hack, don't try this at home!!
class Array
    def freeze
        self
    end
end
class Hash
    def freeze
        self
    end
end
class Parser::AST::Node
    def freeze
        self
    end
end
require 'unparser'
class Parser::Source::Comment
    def freeze
        self
    end
end

# translation memory
R翻訳メモリー = {}

# keyword translation
R鍵文字 = {
    :BEGIN => [:K_PREEXE, :"コンパイル時に最初に登録"],
    :END => [:K_POSTEXE, :"コンパイル時に最後に登録"],
    :__ENCODING__ => [:K_ENCODING, :"__エンコーディング__"],
    :__END__ => [:K_EEND, :"__終__"],
    :__FILE__ => [:K_FILE, :"__ソースファイル名__"],
    :alias => [:K_ALIAS, :"別名"],
    :and => [:K_AND, :"且つ"],
    :begin => [:K_BEGIN, :"開始"],
    :break => [:K_BREAK, :"抜ける"],
    :case => [:K_CASE, :"条件分岐"],
    :class => [:K_CLASS, :"クラス"],
    :def => [:K_DEF, :"定義"],
    :define => [:K_DEFINE, :""],
    :defined? => [:K_DEFINED, :"若し定義されたら"],
    :do => [:K_DO, :"実行"],
    :else => [:K_ELSE, :"違えば"],
    :elsif => [:K_ELSIF, :"それとも"],
    :end => [:K_END, :"此処迄"],
    :ensure => [:K_ENSURE, :"必ず実行"],
    :false => [:K_FALSE, :"偽"],
    :for => [:K_FOR, :"変数"],
    :if => [:K_IF, :"若し"],
    :in => [:K_IN, :"の次の値ごとに"],
    :module => [:K_MODULE, :"モジュール"],
    :next => [:K_NEXT, :"次"],
    :nil => [:K_NIL, :"無"],
    :not => [:K_NOT, :"ノット"],
    :or => [:K_OR, :"又は"],
    :redo => [:K_REDO, :"遣り直す"],
    :rescue => [:K_RESCUE, :"救出"],
    :retry => [:K_RETRY, :"再び試みる"],
    :return => [:K_RETURN, :"戻る"],
    :self => [:K_SELF, :"自身"],
    :super => [:K_SUPER, :"スーパー"],
    :then => [:K_THEN, :"成らば"],
    :true => [:K_TRUE, :"真"],
    :undef => [:K_UNDEF, :"定義を取消す"],
    :unless => [:K_UNLESS, :"若し違えば"],
    :until => [:K_UNTIL, :"次の通りである限り"],
    :when => [:K_WHEN, :"場合"],
    :while => [:K_WHILE, :"次の通りで無い限り"],
    :yield => [:K_YIELD, :"ブロックを呼び出す"],
}

R数字行列 = {
"0" => "零",
"1" => "壹",
"2" => "貮",
"3" => "參",
"4" => "肆",
"5" => "伍",
"6" => "陸",
"7" => "漆",
"8" => "捌",
"9" => "玖",
}

R翻訳行列 = {
# Symbols
:+ => :+,
:- => :-,
:/ => :/,
:* => :*,
:** => :**,
:! => :!,
:^ => :^,
:& => :&,
:| => :|,
:~ => :~,
:> => :>,
:< => :<,
:<< => :<<,
:% => :%,
:"!=" => :"!=",
:"=~" => :"=~",
:"~=" => :"~=",
:">=" => :">=",
:"<=" => :"<=",
:"=" => :"=",
:"==" => :"==",
:"===" => :"===",
:"<=>" => :"<=>",
:"[]" => :"[]",
:"[]=" => :"[]=",
:"!~" => :"!~",
# Errors
:ArgumentError => :引数エラー,
:EncodingError => :文字コードエラー,
:FiberError => :ファイバーエラー,
:IOError => :入出エラー,
:IndexError => :添字エラー,
:LoadError => :読込エラー,
:LocalJumpError => :エラー,
:NameError => :未定義エラー,
:NoMemoryError => :メモリー不足エラー,
:NotImplementedError => :未実装エラー,
:RangeError => :範囲エラー,
:RegexpError => :正規表現エラー,
:RuntimeError => :実行時エラー,
:ScriptError => :スクリプトエラー,
:SecurityError => :セキュリティエラー,
:StandardError => :通常エラー,
:SyntaxError => :シンタクスエラー,
:ThreadError => :スレッドエラー,
:TypeError => :タイプエラー,
:ZeroDivisionError => :零除算エラー,
# Constants
:Array => :配列,
:BasicObject => :基本オブジェクト,
:Bignum => :多倍長整数,
:Class => :クラス,
:Complex => :複素数,
:Exception => :例外,
:FalseClass => :偽クラス,
:File => :ファイル,
:Fiber => :ファイバー,
:Fixnum => :固定長整数,
:Float => :浮動小数点数,
:Hash => :ハッシュ表,
:Integer => :整数,
:IO => :入出,
:Kernel => :中核,
:Marshal => :元帥,
:Math => :数学,
:Module => :モジュール,
:NilClass => :無クラス,
:Numeric => :数値,
:Object => :オブジェクト,
:Prime => :素数,
:Proc => :プロック,
:Process => :プロセス,
:Random => :乱数,
:Range => :範囲,
:Rational => :有理数,
:Regexp => :正規表現,
:Set => :集合,
:Socket => :ソケット,
:String => :文字列,
:Symbol => :シンボル,
:Time => :時刻,
:Thread => :スレッド,
:TrueClass => :真クラス,
# Kernel
:inspect => :検査,
:p => :表示,
:print => :書く,
:puts => :言う,
:require => :取り込む,
# Object
:freeze => :凍結,
# String
:gsub => :全文字列置換,
:gsub! => :全文字列置換せよ,
}


INT_TABLE = [
    [7, "倶胝"],
    [14, "阿庾多"],
    [28, "那由他"],
    [56, "頻波羅"],
    [112, "矜羯羅"],
    [224, "阿伽羅"],
    [448, "最勝"],
    [896, "摩婆羅"],
    [1792, "阿婆羅"],
    [3584, "多婆羅"],
    [7168, "界分"],
    [14336, "普摩"],
    [28672, "禰摩"],
    [57344, "阿婆鈐"],
    [114688, "弥伽婆"],
    [229376, "毘攞伽"],
    [458752, "毘伽婆"],
    [917504, "僧羯邏摩"],
    [1835008, "毘薩羅"],
    [3670016, "毘贍婆"],
    [7340032, "毘盛伽"],
    [14680064, "毘素陀"],
    [29360128, "毘婆訶"],
    [58720256, "毘薄底"],
    [117440512, "毘佉擔"],
    [234881024, "称量"],
    [469762048, "一持"],
    [939524096, "異路"],
    [1879048192, "顛倒"],
    [3758096384, "三末耶"],
    [7516192768, "毘睹羅"],
    [15032385536, "奚婆羅"],
    [30064771072, "伺察"],
    [60129542144, "周広"],
    [120259084288, "高出"],
    [240518168576, "最妙"],
    [481036337152, "泥羅婆"],
    [962072674304, "訶理婆"],
    [1924145348608, "一動"],
    [3848290697216, "訶理蒲"],
    [7696581394432, "訶理三"],
    [15393162788864, "奚魯伽"],
    [30786325577728, "達攞歩陀"],
    [61572651155456, "訶魯那"],
    [123145302310912, "摩魯陀"],
    [246290604621824, "懺慕陀"],
    [492581209243648, "瑿攞陀"],
    [985162418487296, "摩魯摩"],
    [1970324836974592, "調伏"],
    [3940649673949184, "離憍慢"],
    [7881299347898368, "不動"],
    [15762598695796736, "極量"],
    [31525197391593472, "阿麼怛羅"],
    [63050394783186944, "勃麼怛羅"],
    [126100789566373888, "伽麼怛羅"],
    [252201579132747776, "那麼怛羅"],
    [504403158265495552, "奚麼怛羅"],
    [1008806316530991104, "鞞麼怛羅"],
    [2017612633061982208, "鉢羅麼怛羅"],
    [4035225266123964416, "尸婆麼怛羅"],
    [8070450532247928832, "翳羅"],
    [16140901064495857664, "薜羅"],
    [32281802128991715328, "諦羅"],
    [64563604257983430656, "偈羅"],
    [129127208515966861312, "窣歩羅"],
    [258254417031933722624, "泥羅"],
    [516508834063867445248, "計羅"],
    [1033017668127734890496, "細羅"],
    [2066035336255469780992, "睥羅"],
    [4132070672510939561984, "謎羅"],
    [8264141345021879123968, "娑攞荼"],
    [16528282690043758247936, "謎魯陀"],
    [33056565380087516495872, "契魯陀"],
    [66113130760175032991744, "摩睹羅"],
    [132226261520350065983488, "娑母羅"],
    [264452523040700131966976, "阿野娑"],
    [528905046081400263933952, "迦麼羅"],
    [1057810092162800527867904, "摩伽婆"],
    [2115620184325601055735808, "阿怛羅"],
    [4231240368651202111471616, "醯魯耶"],
    [8462480737302404222943232, "薜魯婆"],
    [16924961474604808445886464, "羯羅波"],
    [33849922949209616891772928, "訶婆婆"],
    [67699845898419233783545856, "毘婆羅"],
    [135399691796838467567091712, "那婆羅"],
    [270799383593676935134183424, "摩攞羅"],
    [541598767187353870268366848, "娑婆羅"],
    [1083197534374707740536733696, "迷攞普"],
    [2166395068749415481073467392, "者麼羅"],
    [4332790137498830962146934784, "駄麼羅"],
    [8665580274997661924293869568, "鉢攞麼陀"],
    [17331160549995323848587739136, "毘迦摩"],
    [34662321099990647697175478272, "烏波跋多"],
    [69324642199981295394350956544, "演説"],
    [138649284399962590788701913088, "無尽"],
    [277298568799925181577403826176, "出生"],
    [554597137599850363154807652352, "無我"],
    [1109194275199700726309615304704, "阿畔多"],
    [2218388550399401452619230609408, "青蓮華"],
    [4436777100798802905238461218816, "鉢頭摩"],
    [8873554201597605810476922437632, "僧祇"],
    [17747108403195211620953844875264, "趣"],
    [35494216806390423241907689750528, "至"],
    [70988433612780846483815379501056, "阿僧祇"],
    [141976867225561692967630759002112, "阿僧祇転"],
    [283953734451123385935261518004224, "無量"],
    [567907468902246771870523036008448, "無量転"],
    [1135814937804493543741046072016896, "無辺"],
    [2271629875608987087482092144033792, "無辺転"],
    [4543259751217974174964184288067584, "無等"],
    [9086519502435948349928368576135168, "無等転"],
    [18173039004871896699856737152270336, "不可数"],
    [36346078009743793399713474304540672, "不可数転"],
    [72692156019487586799426948609081344, "不可称"],
    [145384312038975173598853897218162688, "不可称転"],
    [290768624077950347197707794436325376, "不可思"],
    [581537248155900694395415588872650752, "不可思転"],
    [1163074496311801388790831177745301504, "不可量"],
    [2326148992623602777581662355490603008, "不可量転"],
    [4652297985247205555163324710981206016, "不可説"],
    [9304595970494411110326649421962412032, "不可説転"],
    [18609191940988822220653298843924824064, "不可説不可説"],
    [37218383881977644441306597687849648128, "不可説不可説転"],
].reverse

Rしヴぁう = {
    :b => :u,
    :c => :u,
    :d => :o,
    :f => :u,
    :g => :u,
    :h => :u,
    :j => :u,
    :k => :u,
    :l => :u,
    :m => :u,
    :n => :u,
    :p => :u,
    :q => :u,
    :r => :u,
    :s => :u,
    :t => :o,
    :v => :u,
    :w => :u,
    :x => :u,
    :y => :u,
    :z => :u,
}

R = {
    :a  => :あ, :i  => :い, :u  => :う, :e  => :え, :o  => :お,
    :ba => :ば, :bi => :び, :bu => :ぶ, :be => :べ, :bo => :ぼ,
    :ca => :か, :ci => :き, :cu => :く, :ce => :け, :co => :こ,
    :da => :だ, :di => :どぃ, :du => :どぅ, :de => :で, :do => :ど,
    :fa => :ふぁ, :fi => :ふぃ, :fu => :ふ, :fe => :ふぇ, :fo => :ふぉ,
    :ga => :が, :gi => :ぎ, :gu => :ぐ, :ge => :げ, :go => :ご,
    :ha => :は, :hi => :ひ, :hu => :ふ, :he => :へ, :ho => :ほ,
    :ja => :じぁ, :ji => :じ, :ju => :じぅ, :je => :じぇ, :jo => :じぉ,
    :ka => :か, :ki => :き, :ku => :く, :ke => :け, :ko => :こ,
    :la => :ら, :li => :り, :lu => :る, :le => :れ, :lo => :ろ,
    :ma => :ま, :mi => :み, :mu => :む, :me => :め, :mo => :も,
    :na => :な, :ni => :に, :nu => :ぬ, :ne => :ね, :no => :の,
    :pa => :ぱ, :pi => :ぴ, :pu => :ぷ, :pe => :ぺ, :po => :ぽ,
    :qa => :か, :qi => :き, :qu => :く, :qe => :け, :qo => :こ,
    :ra => :ら, :ri => :り, :ru => :る, :re => :れ, :ro => :ろ,
    :sa => :さ, :si => :すぃ, :su => :す, :se => :せ, :so => :そ,
    :ta => :た, :ti => :てぃ, :tu => :とぅ, :te => :て, :to => :と,
    :va => :ヴぁ, :vi => :ヴぃ, :vu => :ヴぅ, :ve => :ヴぇ, :vo => :ヴぉ,
    :wa => :わ, :wi => :ゐ, :wu => :ゐぅ, :we => :ゑ, :wo => :を,
    :xa => :くさ, :xi => :くすぃ, :xu => :くす, :xe => :くせ, :xo => :くそ,
    :ya => :いぁ, :yi => :いぃ, :yu => :いぅ, :ye => :いぇ, :yo => :いぉ,
    :za => :ざ, :zi => :ずぃ, :zu => :ず, :ze => :ぜ, :zo => :ぞ,
}

R = {
:が => :ガ,:ぎ => :ギ,:ぐ => :グ,:げ => :ゲ,:ご => :ゴ,
:ざ => :ザ,:じ => :ジ,:ず => :ズ,:ぜ => :ゼ,:ぞ => :ゾ,
:だ => :ダ,:ぢ => :ヂ,:づ => :ヅ,:で => :デ,:ど => :ド,
:ば => :バ,:び => :ビ,:ぶ => :ブ,:べ => :ベ,:ぼ => :ボ,
:ぱ => :パ,:ぴ => :ピ,:ぷ => :プ,:ぺ => :ペ,:ぽ => :ポ,
:あ => :ア,:い => :イ,:う => :ウ,:え => :エ,:お => :オ,
:か => :カ,:き => :キ,:く => :ク,:け => :ケ,:こ => :コ,
:さ => :サ,:し => :シ,:す => :ス,:せ => :セ,:そ => :ソ,
:た => :タ,:ち => :チ,:つ => :ツ,:て => :テ,:と => :ト,
:な => :ナ,:に => :ニ,:ぬ => :ヌ,:ね => :ネ,:の => :ノ,
:は => :ハ,:ひ => :ヒ,:ふ => :フ,:へ => :ヘ,:ほ => :ホ,
:ま => :マ,:み => :ミ,:む => :ム,:め => :メ,:も => :モ,
:ら => :ラ,:り => :リ,:る => :ル,:れ => :レ,:ろ => :ロ,
:わ => :ワ,:を => :ヲ,:ゑ => :ヱ,:ゐ => :ヰ,:ヴ => :ヴ,
:ぁ => :ァ,:ぃ => :ィ,:ぅ => :ゥ,:ぇ => :ェ,:ぉ => :ォ,
:ゃ => :ャ,:ゅ => :ュ,:ょ => :ョ,
:や => :ヤ,:ゆ => :ユ,:よ => :ヨ,
:ん => :ン,:っ => :ッ,:ゎ => :ヮ,
}


def 鍵文字を登録
    R鍵文字.each_pair do |甲,乙|
        Unparser::Constants.const_set 乙[0], 乙[1].to_s
        Unparser::Emitter::REGISTRY[乙[1].to_sym] = Unparser::Emitter::REGISTRY[甲.to_sym]
    end
    Unparser::Emitter::Repetition::MAP[:while] = R鍵文字[:while][1].to_s
    Unparser::Emitter::Repetition::MAP[:until] = R鍵文字[:until][1].to_s
    Unparser::Emitter::FlowModifier::MAP[:return] = R鍵文字[:return][1].to_s
    Unparser::Emitter::FlowModifier::MAP[:next] = R鍵文字[:next][1].to_s
    Unparser::Emitter::FlowModifier::MAP[:break] = R鍵文字[:break][1].to_s
    Unparser::Emitter::FlowModifier::MAP[:or] = R鍵文字[:or][1].to_s
    Unparser::Emitter::FlowModifier::MAP[:and] = R鍵文字[:and][1].to_s
    Unparser::Emitter::FlowModifier::MAP[:BEGIN] = R鍵文字[:BEGIN][1].to_s
    Unparser::Emitter::FlowModifier::MAP[:END] = R鍵文字[:END][1].to_s
end

class Float
    def inspect
        フロートの文字化(self)
    end
end
class BigDecimal
    def inspect
        フロートの文字化(self.to_s('F'))
    end
end
class Integer
    def inspect
        整数の文字化(self)
    end
end
class Fixnum
    def inspect
        整数の文字化(self)
    end
end
class Bignum
    def inspect
        整数の文字化(self)
    end
end

def 整数の文字化(整数)
    数字 = 整数.to_s
    if 数字.size <= 7
        return 数字.chars.map{|甲|R数字行列[甲]}.join
    else
         = INT_TABLE.find{|甲|甲[0] < 数字.size}
        整数の文字化(数字[0...-乙[0]]) + 乙[1] +  整数の文字化(数字[(-乙[0])..-1])
    end
end
def フロートの文字化(フロート)
     = フロート.to_s.split(?.)
    甲[0] = 整数の文字化(甲[0])
    甲[1] = 甲[1].chars.map{|乙|R数字行列[乙]}.join
    甲.join(?点)
end

def 文字を翻訳(文字)
    平片 = :hira
    文字.scan(/([^aeiou])?(\1)?([yj])?([aeiou])?/i).map do |子音甲,子音乙,子音丙,母音|
        母音 = 母音.to_s
        if 子音甲.nil? && 母音.empty?
            nil
        else
            平片 = :kata if (子音甲||母音).downcase!=(子音甲||母音)
            子音甲,子音乙,子音丙,母音 = [子音甲,子音乙,子音丙,母音].map{|x| x ? x.downcase : x }
            if 母音.empty?
                母音 = Rしヴぁう[子音甲.to_sym].to_s
            end
            # hu => ひゅ, qu => きゅ
            if 母音=="u" && (子音甲=="h"||子音甲=="q")
                子音丙 = "y"
            end
            # ja,ju,jo => じゃ、じゅ,じょ
            if (母音=="a"||母音=="u"||母音=="o") && 子音甲 == "j"
                子音丙 = "y"
            end
            # 拗音
            if 子音丙
                if [:a,:u,:o].include?(母音)
                    子音丙 = case 母音
                    when :a ; :ゃ
                    when :u ; :ゅ
                    when :o ; :ょ
                    end
                    母音 = :i
                else
                    子音丙 = nil
                end
            end
            # basic syllable
            仮名 = R平[(子音甲.to_s+母音).to_sym].to_s
            # 促音
            if 子音乙
                if %w[ま         の].include?(子音乙)
                    仮名 = "ん" + 仮名
                else
                    仮名 = "っ" + 仮名
                end
            end
            # 拗音
            if 子音丙
                仮名 = 仮名 + 子音丙
            end
            # lowercase => hiragana, uppercase => katakana
            if 平片==:kata
                仮名 = 仮名.gsub(/./){|丁|R片[丁.to_sym]}.to_s
            end
            仮名
        end
    end.compact.join
end

def 文を翻訳(文)
    文.scan(/(([a-z]+|[0-9]+|[^a-z0-9]+))/i).map do |文字,_|
        if 文字.index(/[a-z]/i)
            文字を翻訳(文字)
        elsif 文字.index(/[0-9]/)
            整数の文字化(文字)
        else
            文字
        end
    end.compact.join
end

def 翻訳(文章=nil)
    if 文章.empty? || 文章.nil?
        文章
    else
        if  = R翻訳行列[文章.to_sym]
             
        elsif  = R翻訳メモリー[文章]
            
        else   
             = 文を翻訳(文章.to_s)        
            R翻訳メモリー[文章] = 
        end
    end
end

def ノード毎に(幹,&塊)
    if 幹.is_a? Parser::AST::Node
        子供 = 幹.children
        yield 幹.type,子供
        幹.children.each{|甲|ノード毎に(甲,&塊)}
        if  = R鍵文字[幹.type] 
            幹.instance_variable_set(:@type,甲[1]) if [:self,:true,:false,:nil].include?(幹.type)
        end
    end
end

def 幹を翻訳(幹)
    ノード毎に(幹) do |類,子|
        case 
        when :arg
            子[0] = 翻訳(子[0]).to_sym
        when :blockarg
            子[0] = 翻訳(子[0]).to_sym
        when :casgn
            子[1] = ('C_'+翻訳(子[1]).to_s).to_sym
        when :const
            子[1] = 翻訳(子[1]).to_sym
        when :def
            子[0] = 翻訳(子[0]).to_sym      
        when :int
        when :kwoptarg
            子[0] = 翻訳(子[0]).to_sym
        when :lvar
            子[0] = 翻訳(子[0]).to_sym
        when :lvasgn
            子[0] = 翻訳(子[0]).to_sym
        when :optarg
            子[0] = 翻訳(子[0]).to_sym
        when :restarg
            子[0] = 翻訳(子[0]).to_sym
        when :send
            子[1] = 翻訳(子[1]).to_sym
        when :str
            子[0] = 翻訳(子[0]).to_s
        when :sym
            子[0] = 翻訳(子[0]).to_sym
        end
    end
end

def ノートを翻訳(ノート)
    ノート.each do |子|
        テキスト = 子.text
        if テキスト[0] == '#'
            子.instance_variable_set(:@text,"#" + 翻訳(テキスト[1..-1]))
        else
            子.instance_variable_set(:@text,"=開始\n" + 翻訳(テキスト[6..-6]) + "\n=此処迄\n")
        end
    end
end

########
# main #
########

# register keywords
鍵文字を登録
# read input, translate, and print result
コード = STDIN.read
コード.encode(Encoding::UTF_8)
コード = "#encoding:utf-8\n" + コード
幹, ノート = Parser::CurrentRuby.parse_with_comments(コード)
幹を翻訳(幹)
ノートを翻訳(ノート)
STDOUT.write Unparser.unparse(幹,ノート)

Führen Sie es selbst aus und lassen Sie einige Übersetzungstabellen usw. weg:

#えぬこどぃぬぐ:うとふ-捌
# えぬこどぃぬぐ:うとふ-捌
取り込む("ぱるせる/くっれぬと")
# すぺる はくく, どぬ'と とる とひす あと ほめ!!
クラス 配列
  定義 凍結
    自身
  此処迄
此処迄
クラス ハッシュ表
  定義 凍結
    自身
  此処迄
此処迄
クラス パルセル::アスト::ノデ
  定義 凍結
    自身
  此処迄
此処迄
取り込む("うぬぱるせる")
クラス パルセル::ソウルケ::コッメヌト
  定義 凍結
    自身
  此処迄
此処迄
定義 鍵文字を登録
  ル鍵文字.えあくふ_ぱいる 実行 |甲, 乙|
    ウヌパルセル::コヌスタヌトス.こぬすと_せと(乙[零], 乙[壹].と_す)
    ウヌパルセル::エミッテル::レギストル[乙[壹].と_すむ] = ウヌパルセル::エミッテル::レギストル[甲.と_すむ]
  此処迄
  ウヌパルセル::エミッテル::レペティティオヌ::マプ[:ゐぅひれ] = ル鍵文字[:ゐぅひれ][壹].と_す
  ウヌパルセル::エミッテル::レペティティオヌ::マプ[:うぬてぃる] = ル鍵文字[:うぬてぃる][壹].と_す
  ウヌパルセル::エミッテル::フロヰゥモドィフィエル::マプ[:れとぅるぬ] = ル鍵文字[:れとぅるぬ][壹].と_す
  ウヌパルセル::エミッテル::フロヰゥモドィフィエル::マプ[:ねくすと] = ル鍵文字[:ねくすと][壹].と_す
  ウヌパルセル::エミッテル::フロヰゥモドィフィエル::マプ[:ぶれあく] = ル鍵文字[:ぶれあく][壹].と_す
  ウヌパルセル::エミッテル::フロヰゥモドィフィエル::マプ[:おる] = ル鍵文字[:おる][壹].と_す
  ウヌパルセル::エミッテル::フロヰゥモドィフィエル::マプ[:あぬど] = ル鍵文字[:あぬど][壹].と_す
  ウヌパルセル::エミッテル::フロヰゥモドィフィエル::マプ[:ベギヌ] = ル鍵文字[:ベギヌ][壹].と_す
  ウヌパルセル::エミッテル::フロヰゥモドィフィエル::マプ[:エヌド] = ル鍵文字[:エヌド][壹].と_す
此処迄
クラス 浮動小数点数
  定義 検査
    フロートの文字化(自身)
  此処迄
此処迄
クラス ビグデキマル
  定義 検査
    フロートの文字化(自身.と_す("フ"))
  此処迄
此処迄
クラス 整数
  定義 検査
    整数の文字化(自身)
  此処迄
此処迄
クラス 固定長整数
  定義 検査
    整数の文字化(自身)
  此処迄
此処迄
クラス 多倍長整数
  定義 検査
    整数の文字化(自身)
  此処迄
此処迄
定義 整数の文字化(整数)
  数字 = 整数.と_す
  若し (数字.すぃぜ <= 漆)
    戻る 数字.くはるす.まぷ 実行 |甲|
      ル数字行列[甲]
    此処迄.じぉいぬ
  違えば
    乙 = イヌト_タブレ.ふぃぬど 実行 |甲|
      甲[零] < 数字.すぃぜ
    此処迄
    (整数の文字化(数字[零...(-乙[零])]) + 乙[壹]) + 整数の文字化(数字[(-乙[零])..壹])
  此処迄
此処迄
定義 フロートの文字化(フロート)
  甲 = フロート.と_す.すぷりと(".")
  甲[零] = 整数の文字化(甲[零])
  甲[壹] = 甲[壹].くはるす.まぷ 実行 |乙|
    ル数字行列[乙]
  此処迄.じぉいぬ
  甲.じぉいぬ("点")
此処迄
定義 文字を翻訳(文字)
  平片 = :ひら
  文字.すかぬ(/([^あえいおう])?(\壹)?([いぅ])?([あえいおう])?/i).まぷ 実行 |子音甲, 子音乙, 子音丙, 母音|
    母音 = 母音.と_す
    若し (子音甲.にる? && 母音.えむぷと?)
      無
    違えば
      若し ((子音甲 || 母音).どゐぅぬかせ != (子音甲 || 母音))
        平片 = :かた
      此処迄
      子音甲, 子音乙, 子音丙, 母音 = [子音甲, 子音乙, 子音丙, 母音].まぷ 実行 |くす|
        若し くす
          くす.どゐぅぬかせ
        違えば
          くす
        此処迄
      此処迄
      若し 母音.えむぷと?
        母音 = ルしヴぁう[子音甲.と_すむ].と_す
      此処迄
      # ふ => ひゅ, く => きゅ
      若し ((母音 == "う") && ((子音甲 == "ふ") || (子音甲 == "く")))
        子音丙 = "いぅ"
      此処迄
      # じぁ,じぅ,じぉ => じゃ、じゅ,じょ
      若し ((((母音 == "あ") || (母音 == "う")) || (母音 == "お")) && (子音甲 == "じぅ"))
        子音丙 = "いぅ"
      此処迄
      # 拗音
      若し 子音丙
        若し [:あ, :う, :お].いぬくるで?(母音)
          子音丙 = 条件分岐 母音
          場合 :あ
            :ゃ
          場合 :う
            :ゅ
          場合 :お
            :ょ
          此処迄
          母音 = :い
        違えば
          子音丙 = 無
        此処迄
      此処迄
      # ばすぃく すっらぶれ
      仮名 = ル平[(子音甲.と_す + 母音).と_すむ].と_す
      # 促音
      若し 子音乙
        若し ["ま", "み", "む", "め", "も", "な", "に", "ぬ", "ね", "の"].いぬくるで?(子音乙)
          仮名 = ("ん" + 仮名)
        違えば
          仮名 = ("っ" + 仮名)
        此処迄
      此処迄
      # 拗音
      若し 子音丙
        仮名 = (仮名 + 子音丙)
      此処迄
      # ろゑるかせ => ひらがな, うっぺるかせ => かたかな
      若し (平片 == :かた)
        仮名 = 仮名.全文字列置換(/./) 実行 |丁|
          ル片[丁.と_すむ]
        此処迄.と_す
      此処迄
      仮名
    此処迄
  此処迄.こむぱくと.じぉいぬ
此処迄
定義 文を翻訳(文)
  文.すかぬ(/(([あ-ず]+|[零-玖]+|[^あ-ず零-玖]+))/i).まぷ 実行 |文字, _|
    若し 文字.いぬでくす(/[あ-ず]/i)
      文字を翻訳(文字)
    違えば
      若し 文字.いぬでくす(/[零-玖]/)
        整数の文字化(文字)
      違えば
        文字
      此処迄
    此処迄
  此処迄.こむぱくと.じぉいぬ
此処迄
定義 翻訳(文章 = 無)
  若し (文章.えむぷと? || 文章.にる?)
    文章
  違えば
    若し (甲 = ル翻訳行列[文章.と_すむ])
      甲
    違えば
      若し (甲 = ル翻訳メモリー[文章])
        甲
      違えば
        甲 = 文を翻訳(文章.と_す)
        ル翻訳メモリー[文章] = 甲
      此処迄
    此処迄
  此処迄
此処迄
定義 ノード毎に(幹, &塊)
  若し 幹.いす_あ?(パルセル::アスト::ノデ)
    子供 = 幹.くひるどれぬ
    ブロックを呼び出す(幹.とぺ, 子供)
    幹.くひるどれぬ.えあくふ 実行 |甲|
      ノード毎に(甲, &塊)
    此処迄
    若し (甲 = ル鍵文字[幹.とぺ])
      若し [:せるふ, :とるえ, :ふぁるせ, :にる].いぬくるで?(幹.とぺ)
        幹.いぬすたぬけ_ヴぁりあぶれ_せと(:@とぺ, 甲[壹])
      此処迄
    此処迄
  此処迄
此処迄
定義 幹を翻訳(幹)
  ノード毎に(幹) 実行 |類, 子|
    条件分岐 類
    場合 :あるぐ
      子[零] = 翻訳(子[零]).と_すむ
    場合 :ぶろくかるぐ
      子[零] = 翻訳(子[零]).と_すむ
    場合 :かすぐぬ
      子[壹] = ("ク_" + 翻訳(子[壹]).と_す).と_すむ
    場合 :こぬすと
      子[壹] = 翻訳(子[壹]).と_すむ
    場合 :でふ
      子[零] = 翻訳(子[零]).と_すむ
    場合 :いぬと
    場合 :くをぷたるぐ
      子[零] = 翻訳(子[零]).と_すむ
    場合 :るヴぁる
      子[零] = 翻訳(子[零]).と_すむ
    場合 :るヴぁすぐぬ
      子[零] = 翻訳(子[零]).と_すむ
    場合 :おぷたるぐ
      子[零] = 翻訳(子[零]).と_すむ
    場合 :れすたるぐ
      子[零] = 翻訳(子[零]).と_すむ
    場合 :せぬど
      子[壹] = 翻訳(子[壹]).と_すむ
    場合 :すとる
      子[零] = 翻訳(子[零]).と_す
    場合 :すむ
      子[零] = 翻訳(子[零]).と_すむ
    此処迄
  此処迄
此処迄
定義 ノートを翻訳(ノート)
  ノート.えあくふ 実行 |子|
    テキスト = 子.てくすと
    若し (テキスト[零] == "#")
      子.いぬすたぬけ_ヴぁりあぶれ_せと(:@てくすと, "#" + 翻訳(テキスト[壹..壹]))
    違えば
      子.いぬすたぬけ_ヴぁりあぶれ_せと(:@てくすと, ("=開始\n" + 翻訳(テキスト[陸..陸])) + "\n=此処迄\n")
    此処迄
  此処迄
此処迄
########
# まいぬ #
########
# れぎすてる けいぅをるどす
鍵文字を登録
# れあど いぬぷと, とらぬすらて, あぬど ぷりぬと れすると
コード = ストドィヌ.れあど
コード.えぬこで(エヌコドィヌグ::ウトフ_捌)
コード = ("#えぬこどぃぬぐ:うとふ-捌\n" + コード)
幹, ノート = パルセル::クッレヌトルブ.ぱるせ_ゐとふ_こっめぬとす(コード)
幹を翻訳(幹)
ノートを翻訳(ノート)
ストドウト.ゐぅりて(ウヌパルセル.うぬぱるせ(幹, ノート))

oder

# Output "I love Ruby"
say = "I love Ruby"
puts say

# Output "I *LOVE* RUBY"
say['love'] = "*love*"
puts say.upcase

# Output "I *love* Ruby"
# five times
5.times { puts say }

wird

#えぬこどぃぬぐ:うとふ-捌
# オウトプト "イ ろヴぇ ルブ"
さいぅ = "イ ろヴぇ ルブ"
言う(さいぅ)
# オウトプト "イ *ロヴェ* ルブ"
さいぅ["ろヴぇ"] = "*ろヴぇ*"
言う(さいぅ.うぷかせ)
# オウトプト "イ *ろヴぇ* ルブ"
# ふぃヴぇ てぃめす
伍.てぃめす 実行
  言う(さいぅ)
此処迄
blutorange
quelle
8
Es erscheint sehr unnatürlich, Englisch eher mit Hiragana als mit Katakana anzunähern (unabhängig davon, wie locker es abgebildet ist).
Stephan
8

HTML5 / Javascript nach Französisch (HTML5 mit Script au Caoua)

<script>
    var a = document.currentScript.outerHTML;
    alert (a.replace (/ var a / g, "la variable« a »")
    .replace (/ alert \ (/ g, "alerter (")
    .replace (/ = / g, "est")
    .replace (/ outerHTML / g, "HTMLExtérieur")
    .replace (/ \. replace \ ((. +) \, (. +) \) / g, "avec $ 1 remplacé par $ 2")
    .replace (/ \ / \ * und \ * \ // g, "et")
    .replace (/"(.+?)"/ g, "« $ 1 »")
    /*and*/.replace(/currentScript/g,"scriptCourant ")
    );
</ script>

Ausgabe:

<script>
    la variable «a» est document.scriptCourant.HTMLExtérieur;
    alerter (a avec / la variable "a" / g remplacé par "la variable" a "
     avec / alert \ (/ g remplacé par «alerter (»
     avec / est / g remplacé par «est»
     avec / HTMLExtérieur / g remplacé par «HTMLExtérieur»
     avec /\.replace\((.+)\ ,(.+)\)/g Ersetzt durch «avec $ 1 Ersetzt durch $ 2»
     avec / \ / \ * und \ * \ // g remplacé par «et»
     avec / fanden(.+?) erforderlichen/g remplacé par «« $ 1 »»
     und mit / scriptCourant / g als Ersatz für «scriptCourant»
    );
</ script>
SuperJedi224
quelle
1
Ich mag es wirklich, wie Sie die Syntax überarbeitet haben, um mehr Französisch zu sein! Aber bedeutet der französische Name nicht eigentlich " CoffeeScript "?
DLosc
Technisch ja. Aber das ist das Beste, was ich mir damals vorstellen konnte. Hast du einen besseren Vorschlag?
SuperJedi224
1
"HTML5 mit Skript im Java-Café" ist witzig: D Wir haben ein ähnliches (verwandtes?) Argotisches Wort für "Kaffee": caoua ("ka-wa").
Quentin,
3
Ich liebe die Verwendung von Guillemets.
TRiG,
1
Es sollte la variable sein , nicht le
Léo Lam
8

JavaScript, Französisch - CauoaScript

var input = prompt('Enter code');

var translations = {
  'alert': 'informe',
  'code': 'le code',
  'else': 'sinon',
  'Enter': 'Entrez',
  'if': 'si',
  'input': 'donnée',
  'function': 'fonction',
  'output': 'résultat',
  'prompt': 'soulève',
  'replace': 'remplace',
  'replacement': 'pièceDeReplacement',
  'return': 'remet',
  'translate': 'traduit',
  'translations': 'traductions',
  'typeof': 'typede',
  'undefined': 'indéterminé',
  'var': 'var',
  'w': 'm', // word
  'word': 'mot'
};

var output = input.replace(/(["'])(.*?[^\\])?\1/g, '« $2 »')
.replace(/\w+/g, function(word) {
  var replacement = translations[word];
  if (typeof replacement != 'undefined') {
    return replacement;
  } else {
    return word;
  }
});

alert(output);

Ich weiß, dass es bereits eine Antwort auf JavaScript + Französisch gibt, aber meine verwendet verschiedene Übersetzungs- und Codierungsmethoden.

Der Code ist recht einfach: Er durchläuft alle Wörter im Eingabecode und ersetzt sie durch das entsprechende französische Wort aus dem translationsObjekt. Wenn das Wort nicht aufgeführt ist, wird es nicht geändert.

Französischer Gebrauch « Guillemets » anstelle von Anführungszeichen, also werden diese zuerst in Strings verwendet. (Ja, es verwendet regu͘͜l͘͜a̴͝r͘͜͠ ̶̸͢e̶̸͢x̵͜pr̸͝e̵͞͞s͘͘ś̵i̸̷o͝ns̴͜, um Zeichenfolgen zu analysieren, daher funktioniert es nicht immer perfekt.) Hier ist die Ausgabe, wenn sie auf sich selbst ausgeführt wird:

var donnée = soulève(« Entrez le code »);

var traductions = {
  « informe »: « informe »,
  « le code »: « le le code »,
  ...
  « mot »: « mot »
};

var résultat = donnée.remplace(/(["« ])(.*?[^\\])?\1/g,  »« $2 »')
.remplace(/\m+/g, fonction(mot) {
  var pièceDeReplacement = traductions[mot];
  si (typede pièceDeReplacement != « indéterminé ») {
    remet pièceDeReplacement;
  } sinon {
    remet mot;
  }
});

informe(résultat);

Sie können das folgende Stapel-Snippet verwenden, um den Code einfach auszuführen.

NinjaBearMonkey
quelle
3
Oui, tres bien.
Alex A.
Nach der Interpunktion sollten Leerzeichen eingefügt werden - es sieht besser aus. XD
Conor O'Brien
7

Commodore 64 BASIC - Bosnisch / Kroatisch / Serbisch

10 FOR I=40960 TO 49151:POKE I,PEEK(I):NEXT
20 DATA "KRAJ","ZA","OPET","PODACI","UZM#","UZMI","DIM","CITAJ","DE"
30 DATA "HAJD","TRCI","AKO","VRATI","IDIU","NAZAD","KOM","STOJ","NA"
40 DATA "CEKAJ","UCITAJ","SPASI","VIDI","DEF","GURNI","PIS#","PISI"
50 DATA "NAST","POPIS","BRIS","KOM","SIS","OTVORI","ZATVORI","UZMI"
60 DATA "NOV","TAB(","DO","FU","RAZ(","ONDA","NE","KORAK","+","-"
70 DATA "*","/","↑","I","ILI",">","=","<","ZN","C","ABS","KOR"
80 DATA "SLO","POZ","KOR","SLU","LOG","EKS","KOS","SIN","TAN","ATN"
90 DATA "VIRI","DUZ","NIZ$","VRI","ASK","KAR$","LEVO$","DESNO$","SRE$"
100 DATA "ID",""
110 D=41118
120 READ A$
130 IF A$="" THEN 210
140 L=LEN(A$)
150 IF L=1 THEN 190
160 FOR I=1 TO L-1
170 POKE D,ASC(MID$(A$,I,1)):D=D+1
180 NEXT
190 POKE D,ASC(MID$(A$,L,1))+128:D=D+1
200 GOTO 120
210 POKE 1, PEEK(1) AND 254

Dies ersetzt tatsächlich die BASIC-Schlüsselwörter durch die übersetzten, so dass Sie kann müssen sie verwenden, wenn Sie neuen Code schreiben.

Bosnisch BASIC

Wie es funktioniert?

FOR I=40960 TO 49151:POKE I,PEEK(I):NEXT

Obwohl es so aussieht, als würde diese Zeile nicht viel bewirken, kopiert sie tatsächlich Bytes vom BASIC ROM in den RAM. An einen ROM-Speicherort geschriebene Daten werden im RAM unter derselben Adresse gespeichert.

Die letzte Zeile im Programm wechselt in die RAM-Kopie von BASIC:

POKE 1,PEEK(1) AND 254

Die Speicheradressen 41118-41373 enthalten eine vollständige Liste der reservierten BASIC-Schlüsselwörter. Die ASCII-Zeichen dieser Wörter werden in der Reihenfolge der Tokennummern gespeichert. Das Bit Nr. 7 des letzten Buchstabens jedes Wortes wird gesetzt, um das Ende des Wortes anzuzeigen (ASCII-Wert + 128).

Die Zeilen 20-100 enthalten die übersetzten Schlüsselwörter. Die Zeilen 110-200 lesen die Schlüsselwörter im Speicher wie oben beschrieben.

Danko Durbić
quelle
5
Sie könnten die erste Person sein, deren Code nach der Transformation funktioniert !
CJ Dennis
Als der Schöpfer von C64 BASIC sein Werk vollendete, stand er auf und verkündete "Ich sehne mich nach dem Tag, an dem die Leute den C64 auf Bosnisch programmieren können". (Schade, dass er in Bezug auf> 640.000 RAM kein Visionär war)
Mark K Cowan
Aber die Übersetzung erfolgt in den RAM und ein Neustart löscht den RAM, ja?
Katze
5

PHP - Portugiesisch (pt-PT / semi-pt-BR)

Dies stellte sich als ziemlich komplex und riesig heraus!

<?

    echo preg_replace_callback(
        '@\b([\wâêçãáú]+)\b|(?:[\$\>]|[=\.]=|=\>?|&&)@i',
        function($match){

            $word = $match[0];

            if($word == '_')
            {
                return '_';
            }

            $list = array(
                'echo' => 'ecoar',
                'match' => 'equivalência',
                'array' => 'conjunto',
                'file' => 'ficheiro',
                'replace' => 'substitui',
                'callback' => 'executável',
                'function' => 'função',
                'list' => 'lista',
                'if' => 'se',
                'else' => 'senão',
                'word' => 'palavra',
                'piece' => 'pedaço',
                'pieces' => 'pedaços',
                'explode' => 'explosão',
                'implode' => 'implosão',
                'count' => 'conta',
                'tmp' => 'temporário',
                'k' => 'chave',
                'get' => 'busca',
                'contents' => 'conteúdos',
                'preg' => 'expressão_regular',
                'as' => 'como',
                'return' => 'retorna',
                'use' => 'utiliza',
                'strtoupper' => 'corda_para_maiúscula',
                'strtolower' => 'corda_para_minúscula',
                'unset' => 'remover_definição',
                'isset' => 'está_definido',
                'str' => 'corda',
                '$' => '€',
                '.=' => '.=',
                '=>' => 'recebe',
                '==' => 'igual',
                '=' => 'atribuí',
                '>' => 'maior_que',
                '&&' => 'e'
            );

            if($word[0] == '_' && $word[1] == '_')
            {
                return preg_replace_callback(
                    '@([A-Z]+)@',
                    function($word) use (&$list){
                        return strtoupper($list[strtolower($word[1])]);
                    },
                    $word
                );
            }
            else
            {
                $word = explode('_', $word);
                $pieces = count($word);
                if( $pieces > 1 )
                {
                    $tmp = $word[0];
                    $word[0] = $word[1];
                    $word[1] = $tmp;
                    unset($tmp);
                }

                foreach($word as $k => $piece)
                {
                    $word[$k] = isset($list[$piece])?$list[$piece]:$piece;
                    if( $k == 0 && $pieces > 1 )
                    {
                        $word[$k] .= 'r';
                    }
                }

                return implode('_', $word);
            }
        },
        file_get_contents(__FILE__)
    );

Denken Sie daran, dass dieser Code so erstellt wurde, dass er mit sich selbst übereinstimmt! Es kann teilweise mit anderen Codes funktionieren.


Ausgabe, übersetzt:

<?

    ecoar substituir_expressão_regular_executável(
        '@\b([\wâêçãáú]+)\b|(?:[\€\maior_que]|[atribuí\.]atribuí|atribuí\maior_que?|e)@i',
        função(€equivalência){

            €palavra atribuí €equivalência[0];

            se(€palavra igual '_')
            {
                retorna '_';
            }

            €lista atribuí conjunto(
                'ecoar' recebe 'ecoar',
                'equivalência' recebe 'equivalência',
                'conjunto' recebe 'conjunto',
                'ficheiro' recebe 'ficheiro',
                'substitui' recebe 'substitui',
                'executável' recebe 'executável',
                'função' recebe 'função',
                'lista' recebe 'lista',
                'se' recebe 'se',
                'senão' recebe 'senão',
                'palavra' recebe 'palavra',
                'pedaço' recebe 'pedaço',
                'pedaços' recebe 'pedaços',
                'explosão' recebe 'explosão',
                'implosão' recebe 'implosão',
                'conta' recebe 'conta',
                'temporário' recebe 'temporário',
                'chave' recebe 'chave',
                'busca' recebe 'busca',
                'conteúdos' recebe 'conteúdos',
                'expressão_regular' recebe 'regularr_expressão',
                'como' recebe 'como',
                'retorna' recebe 'retorna',
                'utiliza' recebe 'utiliza',
                'corda_para_maiúscula' recebe 'parar_corda_maiúscula',
                'corda_para_minúscula' recebe 'parar_corda_minúscula',
                'remover_definição' recebe 'definiçãor_remover',
                'está_definido' recebe 'definidor_está',
                'corda' recebe 'corda',
                '€' recebe '€',
                '.=' recebe '.=',
                'recebe' recebe 'recebe',
                'igual' recebe 'igual',
                'atribuí' recebe 'atribuí',
                'maior_que' recebe 'quer_maior',
                'e' recebe 'e'
            );

            se(€palavra[0] igual '_' e €palavra[1] igual '_')
            {
                retorna substituir_expressão_regular_executável(
                    '@([A-Z]+)@',
                    função(€palavra) utiliza (&€lista){
                        retorna corda_para_maiúscula(€lista[corda_para_minúscula(€palavra[1])]);
                    },
                    €palavra
                );
            }
            senão
            {
                €palavra atribuí explosão('_', €palavra);
                €pedaços atribuí conta(€palavra);
                se( €pedaços maior_que 1 )
                {
                    €temporário atribuí €palavra[0];
                    €palavra[0] atribuí €palavra[1];
                    €palavra[1] atribuí €temporário;
                    remover_definição(€temporário);
                }

                foreach(€palavra como €chave recebe €pedaço)
                {
                    €palavra[€chave] atribuí está_definido(€lista[€pedaço])?€lista[€pedaço]:€pedaço;
                    se( €chave igual 0 e €pedaços maior_que 1 )
                    {
                        €palavra[€chave] .= 'r';
                    }
                }

                retorna implosão('_', €palavra);
            }
        },
        buscar_ficheiro_conteúdos(__FICHEIRO__)
    );

Ich habe versucht, die Grammatik so weit wie möglich zu respektieren.

Ein Beispiel steht in der ersten Zeile:

echo preg_replace_callback

Echo ist eine Aktion und Aktionen sind Verben. Alle Verben in Portugiesisch enden mit r.
Übersetzen echoohne Kontext wäre eco, während es im Kontext sein mussecoar ("ein Echo machen").

Auch die Funktion preg_replace_callbackhat eine einzigartige Sache.
Die Aktion muss das erste Wort sein.
Wörtlich übersetzt wäre es expressão_regular_substitui_executável, was schrecklich übersetzt ist! (Es bedeutet replace the callback using a regular expression)
Daher muss besondere Sorgfalt aufgewendet werden und das erste und zweite Wort vertauscht werden, so ist es substituir_expressão_regular_executável, was ein bisschen besser ist.

Andere Funktionen, wie z. B. count, müssen nicht rexplodieren (z. B. wenn Sie herrisch wären).

Einige Wörter haben sich als seltsam herausgestellt ...
stringbedeutet corda, aber wenn ich es richtig übersetzt hätte, wäre es cadeia contínua/ininterrupta de caracteres.

So fügen Sie auf alles , was habe ich übersetzte auch einige Symbole und Operatoren ( $, =, =>).
Danke @DLosc für die Idee des Übersetzens $in .

Ismael Miguel
quelle
2
Sie könnten stattdessen ein portugiesisches Währungssymbol verwenden $, ähnlich wie in dieser Sprache .
DLosc
@ DLosc Vielen Dank für die Idee. Ich ging voran und übersetzte auch andere Operatoren und Symbole.
Ismael Miguel
4

Fondamentale Visuale .RETE - Visual Basic .NET, übersetzt ins ITALIENISCHE

Das Programm ist sehr einfach (um sich selbst zu übersetzen).

Ein paar Punkte:

  • E / A: Dies ist ein Modul mit einer offensichtlichen Funktion, die aufgerufen werden muss

  • Grammatik ist meist korrekt (fühlt sich fast natürlich an)

  • Englisch und Italienisch Wortposition ist unterschiedlich, so dass ich nicht (leicht) eine Funktion schreiben konnte, um das zu beheben, und bevorzugte statische Übersetzungspaare

  • Ich habe Imperativverben mit der 2. Person konjugiert, da sie in einer wörtlichen italienischen Übersetzung falsch klingen und sich falsch anfühlen würden (so falsch wie Windows 8+, wenn in 1d Person gesprochen wird).

  • Die Übersetzungspaare sind verschleiert, sodass die englischen nicht mitübersetzt werden. also, wenn ein Dolmetscher ist, funktionieren würde, das übersetzte Programm ich nur einig links "+"overtranslation zu vermeiden (viele Englisch Worte enthalten sind , in der italienisch diejenigen, so würde es übersetzen italienisch mit Doppel Suffixe italienisch Ende)

Modul Italienisch

    Dim Tokens As New List (von Tupel (von String, String))

    Sub AddPair (a als String, b als String)
        Tokens.Add (Tuple.Create (a, b))
    End Sub

    Sub init ()
        AddPair ("Italienisch", "Italien" + "Nein"): AddPair ("Modul", "Modulo")
        AddPair ("fehlt", "nicht ha"): AddPair ("AddPair", "AggiungiCoppia")
        AddPair ("italienisch", "l'italiano")
        AddPair ("Next", "Appresso"): AddPair ("Tokens", "Frammenti")
        AddPair ("init", "iniz"): AddPair ("As", "Come")
        AddPair ("Tuple", "Coppia"): AddPair ("Für jeden", "Per Ogni")
        AddPair ("Of", "Di"): AddPair ("only", "e basta")
        AddPair ("Sub", "Proc"): AddPair ("also füge ich hinzu", "quindi aggiungerò")
        AddPair ("Function", "Funzione"): AddPair ("Dim", "Def")
        AddPair ("a", "una"): AddPair ("support", "il s" + "upporto")
        AddPair ("gebrauchte Typen", "i tipi utilizzati")
        REM Italian fehlt eine geschlechtsunabhängige Form für Adjektive
        REM, also werde ich nur Unterstützung für verwendete Typen hinzufügen
        AddPair ("Neue Liste", "una Nuova Lista")
        AddPair ("Create", "Crea"): AddPair ("End", "Fine")
        AddPair ("REM", "RIC"): AddPair ("for", "per")
        AddPair ("geschlechtsunabhängige Form", "forma indipendente dal genere")
        AddPair ("String", "Sequenza"): AddPair ("Adjektive", "gli aggettivi")
        AddPair ("TranslateToItalian", "TraduciInItaliano")
    End Sub

    Funktion TranslateToItalian (o As String) As String
        Dim ret As String = o: init ()
        Für jedes t als Tupel (von String, String) in Tokens
            ret = ret.Replace (t.Item1, t.Item2)
        Nächster
        Zurück ret
    Funktion beenden

Modul beenden

Italienisch, los geht's!

Das Ergebnis an sich:

Modulo Italiano

    Def Frammenti Come una Nuova Lista (Di Coppia (Di Sequenza, Sequenza))

    Proc AggiungiCoppia (a Come Sequenza, b Come Sequenza)
        Frammenti.Add (Coppia.Crea (a, b))
    Fine Proc

    Proc iniz ()
        AggiungiCoppia ("Italiano", "Italia" + "no"): AggiungiCoppia ("Modulo", "Modulo")
        AggiungiCoppia ("non ha", "non ha"): AggiungiCoppia ("AggiungiCoppia", "AggiungiCoppia")
        AggiungiCoppia ("l'italiano", "l'italiano")
        AggiungiCoppia ("Appresso", "Appresso"): AggiungiCoppia ("Frammenti", "Frammenti")
        AggiungiCoppia ("iniz", "iniz"): AggiungiCoppia ("Come", "Come")
        AggiungiCoppia ("Coppia", "Coppia"): AggiungiCoppia ("Per Ogni", "Per Ogni")
        AggiungiCoppia ("Di", "Di"): AggiungiCoppia ("e basta", "e basta")
        AggiungiCoppia ("Proc", "Proc"): AggiungiCoppia ("quindi aggiungerò", "quindi aggiungerò")
        AggiungiCoppia ("Funzione", "Funzione"): AggiungiCoppia ("Def", "Def")
        AggiungiCoppia ("una", "una"): AggiungiCoppia ("il supporto", "il s" + "upporto")
        AggiungiCoppia ("i tipi utilizzati", "i tipi utilizzati")
        RIC l'italiano non ha una forma indipendente dal genere per gli aggettivi
        RIC quindi aggiungerò il supporto i tipi utilizzati e basta
        AggiungiCoppia ("una Nuova Lista", "una Nuova Lista")
        AggiungiCoppia ("Crea", "Crea"): AggiungiCoppia ("Fine", "Fine")
        AggiungiCoppia ("RIC", "RIC"): AggiungiCoppia ("per", "per")
        AggiungiCoppia ("Forma indipendente dal Genere", "Forma indipendente dal Genere")
        AggiungiCoppia ("Sequenza", "Sequenza"): AggiungiCoppia ("gli aggettivi", "gli aggettivi")
        AggiungiCoppia ("TraduciInItaliano", "TraduciInItaliano")
    Fine Proc

    Funzione TraduciInItaliano (o Come Sequenza) Komm Sequenza
        Def ret Come Sequenza = o: iniz ()
        Per Ogni t Come Coppia (Di Sequenza, Sequenza) In Frammenti
            ret = ret.Replace (t.Item1, t.Item2)
        Appresso
        Zurück ret
    Schöne Funzione

Feinmodulo
beppe9000
quelle
Vielen Dank für Ihre Antwort! Nur ein paar Punkte: Sie sollen den englischen Text auch in Kommentaren übersetzen und ich sehe immer noch viele englische Wörter in Form von "Mod" + "ule". Versuchen Sie, mehr auf den Geist der Herausforderung als auf den Buchstaben zu zielen.
CJ Dennis
@CJDennis das habe ich behoben!
Beppe9000,
3

C, Spanisch - C

Ein- / Ausgabe über STDIN / STDOUT (verwenden ./c-spanish < c-spanish.c).

Wenn auf extra = 0geändert wird extra = 1, ist die Ausgabe dieses Programms im Wesentlichen eine Quine. Ansonsten ist die Ausgabe ein kompilierbares C-Programm, das wie folgt funktioniert cat.

Zusätzliche Leerzeichen in der Quelle sind erforderlich (da sie in der spanischen Version durch Zeichen ersetzt werden).

#define B(_, __) __ ## _
#define C(_, __) B(_,__)
#define char C(C(r, ha), c)
#define gets  C(ets, g)
#define if C(f, i)
#define int C(C(ed, n), s##ig)
#define is ==
#define main      C(C(n, ai), m)
#define puts C(C(s, t), C(u, p))
#define void C(id, C(o, v))
#define    while(x) C(r, C(o, f))(;x;)

int x, y, extra = 0;
void count (char *sheep);
void try_replace        (char *cake  , char *bacon , char *sheep);
void translate(char *sheep){
    char *array [] = {
        "array ", "matriz",         "bacon ", "tocino",
        "cake  ", "pastel",         "char", "car ",
        "count ", "cuenta",         "gets ", "traec",
        "if", "si",                 "int ", "ent ",
        "is", "es",                 "main     ", "principal",
        "peace", "paz  ",           "puts", "ponc",
        "sheep", "oveja",           "translate", "traduce  ",
        "truth ", "verdad",         "try_replace        ", "trata_de_reemplazar",
        "void", "nada",             "war   ", "guerra",
        "   while", "mientras",
    };
    int war    = 19, peace = -1;
       while(!(--war    is peace)){
        count (sheep);
        int truth  = x, cake   = 0;
           while(!(cake   is truth )){
            try_replace        (&sheep[cake  ], array [2 * war   ], array [1 + 2 * war   ]);
            if(extra && !y)
                try_replace        (&sheep[cake  ], array [1 + 2 * war   ], array [2 * war   ]);
            ++cake  ;
        }
    }
}

int main     (){
    char bacon [9999];
       while(gets (bacon )){
        translate(bacon );
        puts(bacon );
    }
}

void count (char *sheep){
    x = 0;
       while(*sheep++ && ++x);
}
void try_replace        (char *cake  , char *bacon , char *sheep){
    y = 0;
    char *truth  = bacon ;
       while(*cake   && *truth  && *sheep && *cake   is *truth )
        ++cake  , ++truth , ++sheep;
    if(!*truth ){
           while(!(bacon  is truth )) *--cake   = *(--truth , --sheep);
           y = 1;
    }
}

Wörter übersetzt:

array               -> matriz
bacon               -> tocino
cake                -> pastel
char                -> car (short for carácter)
count               -> cuenta
gets                -> traec (TRAE la Cadena)
if                  -> si
int                 -> ent (short for entero)
is                  -> es
main                -> principal
peace               -> paz
puts                -> ponc (PON la Cadena)
sheep               -> oveja
translate           -> traduce
truth               -> verdad
try_replace         -> trata_de_reemplazar
void                -> nada
war                 -> guerra
while               -> mientras

Ausgabe

Mit extra = 0:

#define B(_, __) __ ## _
#define C(_, __) B(_,__)
#define car  C(C(r, ha), c)
#define traec C(ets, g)
#define si C(f, i)
#define ent C(C(ed, n), s##ig)
#define es ==
#define principal C(C(n, ai), m)
#define ponc C(C(s, t), C(u, p))
#define nada C(id, C(o, v))
#define mientras(x) C(r, C(o, f))(;x;)

ent x, y, extra = 0;
nada cuenta(car  *oveja);
nada trata_de_reemplazar(car  *pastel, car  *tocino, car  *oveja);
nada traduce  (car  *oveja){
    car  *matriz[] = {
        "matriz", "matriz",         "tocino", "tocino",
        "pastel", "pastel",         "car ", "car ",
        "cuenta", "cuenta",         "traec", "traec",
        "si", "si",                 "ent ", "ent ",
        "es", "es",                 "principal", "principal",
        "paz  ", "paz  ",           "ponc", "ponc",
        "oveja", "oveja",           "traduce  ", "traduce  ",
        "verdad", "verdad",         "trata_de_reemplazar", "trata_de_reemplazar",
        "nada", "nada",             "guerra", "guerra",
        "mientras", "mientras",
    };
    ent guerra = 19, paz   = -1;
    mientras(!(--guerra es paz  )){
        cuenta(oveja);
        ent verdad = x, pastel = 0;
        mientras(!(pastel es verdad)){
            trata_de_reemplazar(&oveja[pastel], matriz[2 * guerra], matriz[1 + 2 * guerra]);
            si(extra && !y)
                trata_de_reemplazar(&oveja[pastel], matriz[1 + 2 * guerra], matriz[2 * guerra]);
            ++pastel;
        }
    }
}

ent principal(){
    car  tocino[9999];
    mientras(traec(tocino)){
        traduce  (tocino);
        ponc(tocino);
    }
}

nada cuenta(car  *oveja){
    x = 0;
    mientras(*oveja++ && ++x);
}
nada trata_de_reemplazar(car  *pastel, car  *tocino, car  *oveja){
    y = 0;
    car  *verdad = tocino;
    mientras(*pastel && *verdad && *oveja && *pastel es *verdad)
        ++pastel, ++verdad, ++oveja;
    si(!*verdad){
        mientras(!(tocino es verdad)) *--pastel = *(--verdad, --oveja);
           y = 1;
    }
}

Mit extra = 1:

#define B(_, __) __ ## _
#define C(_, __) B(_,__)
#define car  C(C(r, ha), c)
#define traec C(ets, g)
#define si C(f, i)
#define ent C(C(ed, n), s##ig)
#define es ==
#define principal C(C(n, ai), m)
#define ponc C(C(s, t), C(u, p))
#define nada C(id, C(o, v))
#define mientras(x) C(r, C(o, f))(;x;)

ent x, y, extra = 1;
nada cuenta(car  *oveja);
nada trata_de_reemplazar(car  *pastel, car  *tocino, car  *oveja);
nada traduce  (car  *oveja){
    car  *matriz[] = {
        "matriz", "array ",         "tocino", "bacon ",
        "pastel", "cake  ",         "car ", "char",
        "cuenta", "count ",         "traec", "gets ",
        "si", "if",                 "ent ", "int ",
        "es", "is",                 "principal", "main     ",
        "paz  ", "peace",           "ponc", "puts",
        "oveja", "sheep",           "traduce  ", "translate",
        "verdad", "truth ",         "trata_de_reemplazar", "try_replace        ",
        "nada", "void",             "guerra", "war   ",
        "mientras", "   while",
    };
    ent guerra = 19, paz   = -1;
    mientras(!(--guerra es paz  )){
        cuenta(oveja);
        ent verdad = x, pastel = 0;
        mientras(!(pastel es verdad)){
            trata_de_reemplazar(&oveja[pastel], matriz[2 * guerra], matriz[1 + 2 * guerra]);
            si(extra && !y)
                trata_de_reemplazar(&oveja[pastel], matriz[1 + 2 * guerra], matriz[2 * guerra]);
            ++pastel;
        }
    }
}

ent principal(){
    car  tocino[9999];
    mientras(traec(tocino)){
        traduce  (tocino);
        ponc(tocino);
    }
}

nada cuenta(car  *oveja){
    x = 0;
    mientras(*oveja++ && ++x);
}
nada trata_de_reemplazar(car  *pastel, car  *tocino, car  *oveja){
    y = 0;
    car  *verdad = tocino;
    mientras(*pastel && *verdad && *oveja && *pastel es *verdad)
        ++pastel, ++verdad, ++oveja;
    si(!*verdad){
        mientras(!(tocino es verdad)) *--pastel = *(--verdad, --oveja);
           y = 1;
    }
}
es1024
quelle
Ist defineein spanisches Wort? Denken Sie daran, dass Ihr Code nach der Übersetzung nicht in der Originalsprache funktionieren muss, sondern nur in einer hypothetisch übersetzten Version des Interpreters / Compliers.
CJ Dennis
3
@ CJDennis defineist in der Tat ein Wort in Spanisch (zweite Person Befehl für definir)
es1024
3

Ruby, Katalanisch - Rubí

Es ist ein ziemlich kurzer Code in Ruby, also nicht so repräsentativ, aber ich war ein bisschen ausführlicher in den Funktionsnamen, um ein bisschen mehr zu zeigen. Diese Übung erinnerte mich zu sehr an Universitätsklassen, in denen wir einen ähnlichen Pseudocode wie "Programmieren" verwendeten.

words = {
    while: "mentre",
    words: "paraules",
    end: "fi",
    nil: "res",
    gets: "obtingues_cadena",
    line: "línia",
    each: "per_cada_una",
    do: "fes",
    original: "original",
    replacement: "intercanvi",
    gsub: "substitueix_globalment",
    puts: "posa_cadena"
}

while (line = gets) != nil
    words.each do |original,replacement|
        line.gsub! original.to_s,replacement
    end
    puts line
end

Angewandt auf sich selbst wird:

paraules = {
    # Eliminat per simplificar codi
}

mentre (línia = obtingues_cadena) != res
    paraules.per_cada_una fes |original,intercanvi|
        línia.substitueix_globalment! original.to_s,intercanvi
    fi
    posa_cadena línia
fi
rorlork
quelle
1
Ich wette, ich kann mir vorstellen, was das Eliminat per simplificar codibedeutet!
CJ Dennis
Ich bin mir auch sicher, dass du kannst!
Lorlork
3

Python 3, Lojban

Wo ich Sumti-Orte neu anordnen musste, habe ich die Wörter in Klammern eingeschlossen, zB (te tcidu fe)

Code:

dictionary = [
    ('basti fa', 'with'),
    ('ro', 'for'),
    ("vidnyja'o", 'print'),
    ('nenri', 'in'),
    ('lujvo', 'word'),
    ('jbovlaste', 'dictionary'),
    ('basygau', 'replace'),
    ('(te tcidu fe)', 'read'),
    ('datnyvei','file'),
    ('vlamei', 'text'),
    ('kargau', 'open'),
    ('la .lojban.', 'lojban'),
    ('no', '0'),
    ('pa', '1'),
    ('as', ''),
    ('with', 'basti fa'),
    ('for', 'ro'),
    ('print', "vidnyja'o"),
    ('in', 'nenri'),
    ('word', 'lujvo'),
    ('dictionary', 'jbovlaste'),
    ('replace', 'basygau'),
    ('read', '(te tcidu fe)'),
    ('file', 'datnyvei'),
    ('text', 'vlamei'),
    ('open', 'kargau'),
    ('lojban', 'la .lojban.'),
    ('0', 'no'),
    ('1', 'pa')
]

with open('lojban.py', 'r') as file:
    text = file.read()

for word in dictionary:
    text = text.replace(word[0], word[1])

print(text)

Und seine Ausgabe:

jbovlaste = [
    ('basti fa', 'basti fa'),
    ('ro', 'ro'),
    ("vidnyja'o", 'vidnyja'o'),
    ('nenri', 'nenri'),
    ('lujvo', 'lujvo'),
    ('jbovlaste', 'jbovlaste'),
    ('basygau', 'basygau'),
    ('(te tcidu fe)', '(te tcidu fe)'),
    ('datnyvei','datnyvei'),
    ('vlamei', 'vlamei'),
    ('kargau', 'kargau'),
    ('la .lojban.', 'la .lojban.'),
    ('no', 'no'),
    ('pa', 'pa'),
    ('', ''),
    ('basti fa', 'basti fa'),
    ('ro', 'ro'),
    ('vidnyja'o', "vidnyja'o"),
    ('nenri', 'nenri'),
    ('lujvo', 'lujvo'),
    ('jbovlaste', 'jbovlaste'),
    ('basygau', 'basygau'),
    ('(te tcidu fe)', '(te tcidu fe)'),
    ('datnyvei', 'datnyvei'),
    ('vlamei', 'vlamei'),
    ('kargau', 'kargau'),
    ('la .lojban.', 'la .lojban.'),
    ('no', 'no'),
    ('pa', 'pa')
]

basti fa kargau('la .lojban..py', 'r')  datnyvei:
    vlamei = datnyvei.(te tcidu fe)()

ro lujvo nenri jbovlaste:
    vlamei = vlamei.basygau(lujvo[no], lujvo[pa])

vidnyja'o(vlamei)
Tuomas Laakkonen
quelle
readwird einfach (te tcidu fe). Soll es etwas anderes tun?
CJ Dennis
@CJDennis Nein, obwohl ich vermutlich Unterstriche anstelle von Leerzeichen verwenden und die Klammern weglassen hätte können.
Tuomas Laakkonen
OKAY. Aufgrund des Kommentars über dem Code dachte ich, er sollte etwas neu anordnen!
CJ Dennis
1

Javascript ES6, Esperanto, Ĝavoskripto

f=_=>f.toString().replace(/toString/g,'konvertiLaĉi').replace(/replace/g,'anstataŭigi');f()

Ich habe mir ein paar Freiheiten beim Kamelieren und Formulieren genommen (ich habe 'In Zeichenfolge konvertieren' statt 'In Zeichenfolge' übersetzt). Ich werde die Dinge später komplizieren, wenn ich mehr Zeit habe.

Mama Fun Roll
quelle