英語のソースコードを外国語に翻訳する[終了]


66

私は、英語に基づいたコンピューター言語の数が不釣り合いに多いことに気付きました。既存のコンピューター言語を外国語に翻訳することでこれを修正することを提案します!

  • 英語のキーワード/機能を使用するコンピューター言語を選択してください
  • 英語以外の自然な*言語を選択してください
  • 独自のソースコード、または同じキーワード/関数のサブセットを使用して記述された他のプログラムを他の言語に翻訳するプログラムを作成する
  • ソースコードと出力(翻訳されたコード)を投稿する

次のようなもので投稿を開始します。

ベーシック、フランス語

または

ベーシック、フランス語-フォンダメンタル

あなたがしたくない場合は、言語名を翻訳する必要はありません、それはただの楽しみのためです!

選択した言語ですべてのキーワード/機能を翻訳する必要はありません。ソースコードで実際に使用しているものだけです。たとえば、PHPには数千個あるので、すべてを翻訳する必要はありません!また、コメントを使用する場合は、コメントも翻訳してください。プログラムが終了した後、外国語に適切でない限り、認識可能な英語の単語はないはずです。文字列内の単語も翻訳する必要があります(翻訳されたプログラムは、実行できたとしても、英語のソースコードでは動作しなくなります!)。他の言語を話すプログラマにとって、あなたのプログラムが何らかの意味をなすことを願っています!

たとえば、フランス語にif () {} elseif () {} else {}なるかもしれませんsi () {} sinonsi () {} sinon {}!Perl elsifをフランス語に翻訳している場合はn、2番目eを英語でドロップするのと同じ方法で2 番目をドロップする可能性がありますsinosi。フランス語では、他の可能性が高いだろうAUTREが、代替sinonまたは他のそうでない場合は)私にはよりよい感じ!

クリエイティブに!コンピューターと自然言語の両方の感触をキャプチャしてみてください!英語のトークンを持たないBrainfuck、CJamなどの言語は使用できません。BASICやCOBOLなどの言語がはるかに適しています。言語が英語の単語である変数名をサポートしていない場合を除き、意味のある変数名を使用して翻訳します。

コンピューター/自然言語の組み合わせごとに1つずつ、複数の回答を投稿できます。ライブラリまたは外部ツールを使用して翻訳を行うことはできません!コードは、翻訳を行う他の何かを呼び出すのではなく、翻訳自体を行う必要があります!これはコードゴルフではありません!プログラムが入力を受け取る場合、それは独自のソースコードのみである必要があり、ディスクから読み取る場合はソースファイルのみである場合があります。

*この課題の目的のために、私はエスペラント語、ロジバン、ヴォラピュク、インターリングアなどを自然言語と見なします。この挑戦のためにあなた自身の言語を発明することはできません!

明示的なクインを防止するルールを追加しました。翻訳するために、キーワード/機能のすべてのサブセットを選択することができます。あなたのプログラムは最低限それ自身を翻訳できる必要があります。つまり、元のソースに単語が含まれている場合、プログラム自体ではなく入力コードに任意の場所をprint追加してprint(42)も正しい結果が得られます。

例えば:

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

になるかもしれない

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

入力が次のように変更された場合

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

出力はその後になるはずです

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

4
「print」は「empriinte」(「footprint」など)ではなく「imprimer」(「printer」など)になります:)
クエンティン

4
@クエンティン私はそれが良いフランス語だと主張したことはありません!
CJデニス

13
Excelがネイティブ言語をサポートしていることは十分に悪いと思います.. :(。数式のデバッグが非常に困難になります
Mave June

1
@Quentinフランス語の動詞が不定詞の代わりに命令形を使用すべきかどうか疑問に思っています。唯一の問題は、私のフランス語だけでは十分ではないということです!
CJデニス

3
@CJDennisフランス語の擬似コードでは、私は常に不定詞を見てきましたが、必要に応じて手を与えることができます:p-
クエンティン

回答:


67

Python、Koineギリシャ語 -Πύθων

私の好きな外国語での私のお気に入りのプログラミング言語-完璧!そして、名前がすでにギリシャ語であることを傷つけません

Python 3のトランスレータープログラム(ネイティブのUnicodeサポートに感謝):

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)

コードをそれ自体で実行した結果(大きな翻訳リストが編集された状態):

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

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

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

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

Koine Greekは2000年前なので、プログラミング用語の翻訳は楽しかったです。私のお気に入りのいくつかを次に示します。

  • βιβλίον = "スクロール"(file
  • γραψάτω = "書き込み"(print
  • λαβέτω = "take"(input
  • εἰσενεγκάτω = "持ち込み"(import
  • τύπος = "パターン、タイプ"(encoding
  • λόγοι / νεόλογοι = "words" / "new words"(code/ replacements
  • ἕκαστον...ἐκ = "each ... from"(for ... in
  • εἰ...εἰδὲ...εἰδὲμή = "if ... but if ... but if if not"(if ... elif ... else
  • ἐντῷは文字通り「in the」を意味しますが、特定のコンテキストでは「when、while」のイディオムになります
  • 「正規表現」はῥήμαλογικόν、「合理的/合理的な格言」になりました。したがって、略語reῥλ

ウィクショナリーで検索することでも、ほとんどの単語を見つけることができます。

他の顕著な特徴:

  • 英語のプログラミングは(不可欠動詞の束を使用してprintreadreplace)。私は古代ギリシア人がこのようにコンピューターと話すのは少し愚かだと思うので、私は彼らにすべての第三者の命令を作成しました。
  • ギリシャ語の句読点は英語とは少し異なります。角括弧と下線を何に置き換えるかわからないので、これで行き過ぎませんでしたが、アノテレアまたは「ハイピリオド」(·)のコロンを交換しました。
  • リストにない単語については、小文字もすべて音訳するようにしました。常にまっすぐな1対1の対応があるわけではありません。そう例えば、utf変身ουτφあなたがそれを発音しようとすると、「ootf」のように聞こえる程度--which。

これはまだ文法的に望ましい多くのものを残しています。ギリシャ語は英語よりもはるかに屈折した言語であり、私のコードはすべてのケースと数字を正しくするほどには洗練されていません。例えば、ἕκαστονπαλαιόν、νέονἐκνεόλογοιは読み取るべきἐκνεολόγ ωνの属格場合に前置詞の目的で、。しかし、私は置くことを約ないよというこのに多くの時間を!見た目は(少なくとも訓練を受けていない目には)十分にギリシャ語であり、高い期間は素晴らしいタッチを追加します。全体として、私は結果にかなり満足しています。


4
私にはギリシャ語のように見えます!私はギリシャ語を理解していませんが、文法を正しくするためにあなたがいくつかの問題を抱えているようです。翻訳リストの数行を含めていただけますか?
CJデニス

私はまだ見るだけνεόλογοι = [...]です。そこに数行だけ入れることができますか?リスト全体は必要ありません!
CJデニス

確かに、それはそれほど面白くはありませんが、出力全体を示しています。
CJデニス

翻訳では、文字列定数はそのままにして、キーワード(および場合によっては変数名)のみを翻訳することになっていますか?
カスペルド

@kasperd 金contraireWords in strings should be translated too
DLosc

65

チキン、中国語-鸡

鶏肉は思ったよりずっと使いにくいです。

末尾の改行はありません。しかし、最後chickenはこのプログラムの終わりを示すためだけのもので、空行で置き換えることができます。

私はこのインタープリターを使用していますいます。これは余分な改行を出力し、抑制できません。したがって、出力には元の行よりも1行多くなり、Chickenプログラムが破損する可能性があります。これによって無効にならないことを願っています。

入力のインデックス-1から空の文字列を取得し、空の文字列と比較してEOFを検出するなどのトリックを使用しました。また、このcompareコマンドを使用して、タイプを気にせずにスタック内の未使用のアイテムを破棄しました。他の通訳では機能しない場合があります。また、文字列をUTF-8バイトとして印刷します。他のインタープリターはUnicode文字の直接印刷をサポートする場合があります。

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

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

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

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

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

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

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


chicken

このコマンドを使用して、このコードを実行します。

bin/chicken "`<file`" <file

奇妙なことに、最初fileは入力用で、2番目はコード用です。

出力(中国語は単語間にスペースを使用しません):

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

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

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

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

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

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

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


鸡

このプログラムは置き換えられh、改行は影響を受けず、他のすべてを無視します。

ご覧のとおり、有効なすべてのチキンプログラムを翻訳できます。


3
あなたは、これは私がof--と思わせるものを知っているyoutu.be/vExjnn_3ep4
DLosc

5
うーん!中華チキン!出力は元のプログラムよりも理解しやすいと思います!他の誰かが今、持ち帰りのように感じていますか?
CJデニス

2
良い仕事です、ジミー
アレックスA.

18
@AlexA。その後、ユーザー名を変更しました。
jimmy23013


36

C ++、ラテン-C Plus 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;
}

ノート:

  • コマンドラインで入出力ファイルを取得します
  • すべてのキーワードを翻訳します
  • 完全なローマ数字のパーサーを作成しませんでしたが、少なくともソース(nihili、およびii)に存在する数字を翻訳するのがいいと思いました
  • C ++で使用されているシンボルを翻訳する道をたどりませんでした。
  • キーワードはconstenumint、およびoperator変更されません。それらは今、constanteenumeratumintegrum、およびoperatorを表しています。
  • 私はローマ人が_単語の区切りになるとは思わなかったので、句読点を使用しました。
  • 翻訳は非常に愚かで非効率的で、単語の境界などを無視します。

出力:

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

「文字列」は、現代のロマンス語のように「カテナ」として翻訳されるべきではありませんか?
200_success

あなたが感じている文字通りに依存します。
ルーク

6
むしろ、あなたが感じているロマンチックさ。
アレックスA.

1
「空」を見逃したと思います。
パック

1
ありがとう。@ Vioz-の本から葉を取り出して、無効に「inane」を使用したため、空に「vacuum」を使用できました。
ルーク

25

JavaScript(NodeJS)-ヘブライ語

エンコードの私の方法は、DLoscのPythonプログラムに非常に似ています。ソースコードを読み取り、トークンのリストを持ち、検索と置換を実行します。

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);
});

これにより、次の出力が得られます。

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

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

残念ながら、SEはRTLテキストを好まないようです。上記のコードブロックを手動でラップしようとしましたが<pre dir="rtl">、削除されました。:(実際のコードは次のようになります:(geditのスクリーンショット)

RTLフォーマットで適切に表示されるコード

ヘブライ語のテキストについて注意すべきこと:

  • 略語のヘブライ語の方法(このコードでは複数回使用されます)は、単一の単語を短縮するために末尾に単一引用符を使用し、複数の単語の場合は最後の文字の前に二重引用符を使用します。単一の単語についてはvarמש'「i」(変数)の略語として翻訳されています。fs、「ファイルシステム」の頭字語は、מ"ק、「מערכתקבצים」の最初の文字。
  • ヘブライ語には大文字/小文字がありません。いくつかの文字には通常/最終形式(それぞれכמנפצおよび))がありますが、それだけです。そのため、「readFile」や「filename」などのマッシュアップ単語では、2番目の単語が単語の途中にあるにもかかわらず、ヘブライ語の「קראקובץ」と「שםקובץ」も一緒にマッシュアップしました。
  • 上記はには適用されませんtoString。ヘブライ語では、前置詞は単語の先頭に追加される単一の文字です。したがって、「string」が「מחרוזת」の場合、「to string」は「למחרוזת」です。また、for..inブロックでは、inトークンにスペースが含まれるので、次の単語(にword in wordsなりますמילה במילים)。
  • 私は自分のコンピュータからこれを再現することができませんが、私はに行ったときtranslate.google.com私のiPadからと入れregex、それは、文字通り意味している「という表現を命じた」סדירביטוי私に返しました。うわー!JSのように、私はそれをטסיטס"דと略しましたRegExp
  • g私はと訳さ正規表現フラグע」、グローバルעולמי、の略です。
  • 置換するための複雑な正規表現形式に注意してくださいnew。ヘブライ語では、形容詞(「新しい」など)が名詞(正規表現など)の後に来るためです。したがって、ではなく、new RegExp()「RegExp [つまり] new()」になります。
  • 引用符は、古典的なヘブライ語には存在しないため、削除しました。それは確かに文法をずっと難しくします!良い決断であったかどうかはまだわかりません。
  • 私はすべての終了セミコロンをコロンに置き換えているようです。それは実際にはU + 05C3 SOF PASUQであり、聖書の詩を終わらせる句読点です。

このコードは確かにすべての有効なJSプログラムを翻訳するわけではありません。実際、おそらくこれを翻訳するだけです。しかし、これはこの課題には十分です。;)

ところで、ヘブライ語に興味があるなら、Hebrew.SEの提案に従ってください(そして10点未満の質問に投票してください)!(ソース:stackexchange.com
Stack Exchange Q&Aサイトの提案:ヘブライ語


9
PHPを使用する必要がありました。すでにT_PAAMAYIM_NEKUDOTAYIMカバーされています。
wchargin

2
RTLソースの最後の行は、ひげを生やした悲しい顔をした男のように見えます。:)
マットライオンズ

(いずれにせよ、何らかの理由でLTRソースに気づかなかった)
マットライオンズ

@MattLyonsあまり英語に見えないので、おそらく英語では気付かなかったでしょう。
-Scimonster

1
proקורה@proudhaskeller
sagiksp

22

Perl、PigLatin-erlPay

まず、実際のプログラムは非常に短いので、テキストの長いセクションでの動作を示すために、入出力の別の例としてPerl詩をいくつか含めました。詩は後に含まれているので ENDの行の実際には実行されません。

実際のアルゴリズムは非常に単純です。

  • 単語の境界で入力をトークンに分割する
  • 少なくとも2つのアルファ文字を含む単語は、ブタラテン語に翻訳されます
    • 単語の主要な子音を見つける
    • それらを最後に移動し、「ay」接尾辞を付けます
  • すべてを印刷します。非アルファ入力(および単一文字)は翻訳されません

#!/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)

自身でプログラムを実行した結果:

#!/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)

2
豚のラテン語は、自然言語ではなく言語ゲームと見なされます。参照してください豚ラテン語Wikipediaのページを
アレックスA.

5
私はあなたがそれを呼ぶことができると思いますが、この挑戦​​が形式に関する限りでは連邦RFPのレベルにかなり上昇するかどうかはわかりません。
ラルフマーシャル

3
翻訳された言語名はerlPayであるべきです、そして、それも出力するならば、私はそれが好き__DENAY__です。ならないopenayacceptayなるenopayceptacay
CJデニス

1
チャレンジは「外国語」を指定します。豚のラテン語は数えません。
mbomb007

6
PigLatinの外国語としての受容性について皆さんに明るくすることをお勧めします。私のソリューションが気に入らない場合は、投票しないでください。CJはこれに十分満足していると思います。これは楽しい小さなエクササイズであるため、入力に固執しています。
ラルフマーシャル

17

Visual Basic .Net、ペルシャ語

それが難しくなるように、私は冗長言語を選択しました。結局、文法を変更する必要はありませんでした。コードのペルシャ形式は同じくらい冗長です。

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

結果には、右から左へのテキストエディターが必要です。ここで適切に表示することができませんでした。しかし、表示する必要がある場合は、ここにあります。これが写真です:

コード

注:Persian.txtという名前のファイルから読み取り、code.txtに出力します。疑問符に変わることなく、コンソールウィンドウでペルシャ語を読み書きすることができませんでした。(たとえば、4文字の単語は????に変わります)

注:ペルシア語で単語を相互に接続すると、文字は相互に接続されて異なる形式になるため、ほとんど読めません。そのため、スペースで区切る必要があり、その結果、単語にスペースが含まれることになりました。Importsのような単語は、2つの単語であるواردکردنに変わりました。


私にはヘブライ語のポスト、私はRTLをサポートしてエディタで正しく表示され、それのスクリーンショットが含まれています。
Scimonster

@Scimonsterいいね。すぐにやるよ。ありがとう。
JNV

2
ユニコードのゼロ幅の非結合文字(U + 200C)を使用して、「درستکردن」をスペースなしで「درستکردن」に変換せずに使用できます:「درست‌کردن」-文字を強制的に並べますギャップなしで、それらを結合することなく-結果が見栄えが良いかどうかはフォントによって異なります
-psmears

@psmearsそのとおりです。私はそれを忘れていました。ありがとう!
JNV

14

Java、ドイツ語-Java

このプログラムは本当に簡単です。
最初の引数として指定されたファイルを読み取り、英語の単語をすべてドイツ語の翻訳に置き換えます。

2つのグループ(([^a-zA-Z\\d:])*)で正規表現を使用して、英数字以外の文字が前に付いた/後に続く個々のアイテムを一致させています。これにより、翻訳の重複に関する問題が解決されました(英語List->ドイツ語ですListeが、その後ListeになりますListee)。$1/ $2を使用すると、これらの文字が追加され、翻訳されたソースコードが残ります。

更新1:

ドイツ語のJavaの命名規則に従うにはeanbeaなどの略語を使用します。

アップデート2:

配列内の3番目のコンポーネントを使用して、最初の置換後にブレークします。これは私のチートな赤緯/活用アプローチに必要です。class/ Klasseはドイツ語で女性で、void/ nichtsは中立なので、後者の置き換えをスキップして、後で置き換えました。別の編集は、私が使用するのは女性であるため、newの翻訳になってneueStringます。

アップデート3:

大文字と小文字を区別する正規表現を追加して、大文字化を適切に処理します。

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);
        }
    }

これにより、次が出力されます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);
        }
    }

コードまたは翻訳に改善点がある場合はお知らせください。実装できるかどうかを確認します。


/󠀠 そして-おそらく識別子が良くありません。
Vi。

6
私は2つの言語の対応が大好きです。どちらも、すべてに巨大な複合語を使用しています。;)しかし、私はドイツ人がまだEingabe/AusgabeどういうわけEinausか短縮するのではないかと疑っています。
DLosc

1
@DLosc I / O(入力/出力)は通常、E / A(Eingabe / Ausgabe)と省略されます。Einaus可能性もあると思いますが、それは正しいとは思いません。Rein/Raus同様に可能に思えますが、やはり良い翻訳のようには感じません。
ジャイアントツリー

@Vi。あなたは(左側)を置き換える文字列の文字とは?Javaではこのような文字を名前/識別子の一部として使用できないため、これらは必要ありません。私は文字列全体を何度も繰り返しチェックしているため、E/Aまたは同様のものが問題を引き起こす可能性があると思うかもしれませんが、正規表現として解釈されず、一致するだけであり、したがって正規表現は影響を受けないままにするためです。(間違っているかもしれませんが、これは正規表現で経験したことです)
ジャイアントツリー

@GiantTree、私は仮想ドイツ語Javaコンパイラのコードを解析するのが難しいことを意味します。
Vi。

14

ジュリア、タタール -ジュリア

これは2001年に設立されたİdel-UralTatarのラテン語ベースの非公式のZamanälifアルファベットを使用しています。しかし、2002年にロシア連邦は、Tatarstanのタタール語の公式アルファベットを作成するというタタールスタンの動きを打ち切り、キリル文字以外のアルファベット。

過去1世紀、タタール語には5つのアルファベットがありました。

  • İskeimlâ、アラビア語のアルファベットの変形、1870年代〜1920年代
  • Yañaimlâ、別のアラビア語のバリアント、1920年代および30代
  • Jaᶇalif、ラテン系アルファベットの変形、1930年代
  • キリル文字、1940年代から現在まで、ジョセフスターリンによって義務付けられた変換
  • ザマネリフ、非公式、2001年〜現在

キリル文字を使用した場合、私の祖父は失望すると思うので、私はザマナリフを選択しました。彼の第一言語はタタール語であり、1920年代に生まれ、彼はiskeimlâアルファベットの読み書きを学びました。

英語:

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"))

タタール語:

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"))

翻訳を少し簡潔にするために、いくつかの自由を取りました。たとえば、forとなったsaen、これはより文字通り「各」に翻訳します。私も省略しませんでしたSüzlek。これは「辞書」を意味します。ukırgaböten、私の翻訳readallukırga(read)+ böten(all / every)です。başägär、の私の翻訳はelseifbaşbaşkaça「その他」を意味するの略語)+ ägär(if)です。

PPCGの誰かがTatarを知っているなら、あなたはおそらく私よりも多くを知っているでしょう。どんな提案も歓迎します。


13

ベラルーシ語(Ржа)

プログラム:

#![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!("{}", зьмест);
}

出力:

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

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

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

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

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


фн галоўная() {
    хай зьмян зьмест : Радок = "".у_радок();
    супастаўленьне звыч_уваход().чытаць_у_радок(&зьмян зьмест) {
        Ок(_) => (),
        Збой(памылка) => паніка!(памылка),
    }
    кожная замена ў ЗАМЕНЫ.пераліч() {
        зьмест = зьмест.замяніць(замена.0, замена.1);
    }
    друкрад!("{}", зьмест);
}

No.󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠󠀠
Viに。

ロシア語とC ++?
GamrCorps

@IonLee、いいえ。ヒント:最初の推測は近かった。
Vi。

@IonLee:自然言語はベラルーシ語です。
アレックスA.

1
さびとベラルーシ?
ProgramFOX

12

DogeScript、スペイン語-ElCódigodel Perro

DogeScriptはJavaScriptに解釈されるため、有効なJSはすべて有効なDogeScriptです。ここで説明した翻訳は、実際にはキーワードの仕様全体を網羅しています(さらに、プログラムで使用される単語をカバーするためにさらにいくつか)。

"英語":

 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

スペイン語:

 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

あなたは私が翻訳でいくつかの自由をとったことに気付くかもしれません。これは、私のスペイン語がかなり貧弱で、スペイン語のミームに関する知識が不足しているためです。

ここに画像の説明を入力してください


11

C#、ラテン-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);
        }
    }
}

コマンドライン引数からファイルを読み取り、output.txtに書き込みます。

例:

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);
        }
    }
}

くそー、C ++ラテン語版を見たばかりです。


s/ToLatin/AdLatinam/...また、(複数形)であってはargsなりませんargumentaか?
DLosc

@DLoscどうすればいいのかわかりません、ラテン語は知りませんが、あなたの言葉を受け取ります。
ケイド

良いことですが、一般的な用語について翻訳を比較しています。「または」は「秋」でなければなりません。
ルーク

System Ratioラテン語はなぜですか?では、ラテン語の比率は何ですか?
phuclv

@LưuVĩnhPhúc- ratio>ratione/proportio
Kade

8

ルビー、日本語-AkaDama

日本語でRubyがあるrubii(ルビー)、退屈ですので、私は文字通りそれを名付けた赤い宝石を

ルビーでは、変数とメソッドはASCIIに限定されないため、

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

有効なルビーです。すべてのベースの難読化に可能な限りこれを使用しています。

rubyの解析にgemを使用しても問題ないことを願っていますが、それでもstillいモンキーパッチが必要です。

を展開して、TRANS_TABLEさらにメソッドの翻訳を追加できます。表にないものはすべて、その発音に基づいて大まかに日本語に「翻訳」されます(またはスペルに似ています)。したがって、eatはえあと(「a-ah-toe」)になります。

整数を「非常に」実用的な表記に変換します。

# 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(幹,ノート)

いくつかの変換テーブルなどを省略して、自分自身で実行します。

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

または

# 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 }

になる

#えぬこどぃぬぐ:うとふ-捌
# オウトプト "イ ろヴぇ ルブ"
さいぅ = "イ ろヴぇ ルブ"
言う(さいぅ)
# オウトプト "イ *ロヴェ* ルブ"
さいぅ["ろヴぇ"] = "*ろヴぇ*"
言う(さいぅ.うぷかせ)
# オウトプト "イ *ろヴぇ* ルブ"
# ふぃヴぇ てぃめす
伍.てぃめす 実行
  言う(さいぅ)
此処迄

8
カタカナではなく、ひらがなを使用して英語を近似することは、非常に不自然に思えます(マッピングの程度に関係なく)。
ステファン

8

HTML5 / Javascriptからフランス語(HTML5 avec le Script au Caoua)

<スクリプト>
    var a = document.currentScript.outerHTML;
    alert(a.replace(/ var a / g、 "la変数«a»")
    .replace(/ alert \(/ g、 "alerter(")
    .replace(/ = / g、 "est")
    .replace(/ outerHTML / g、 "HTMLExtérieur")
    .replace(/ \。replace \((。+)\、(。+)\)/ g、 "avec $ 1remplacépar $ 2")
    .replace(/ \ / \ * and \ * \ // g、 "et")
    .replace(/"(.+?)"/ g、 "«$ 1»")
    /*and*/.replace(/currentScript/g,"scriptCourant ")
    );
</ script>

出力:

<スクリプト>
    la変数«a»estdocument.scriptCourant.HTMLExtérieur;
    alerter(a avec / la変数«a»/ gremplacépar«la変数«a»»
     avec / alert \(/ gremplacépar«alerter(»
     avec / est / gremplacépar«est»
     avec /HTMLExtérieur/ gremplacépar«HTMLExtérieur»
     avec /\.replace\((.+)\,(.+)\)/gremplacépar«avec $ 1remplacépar $ 2»
     avec / \ / \ * and \ * \ // gremplacépar«et»
     avec/«(.+?)»/gremplacépar««$ 1»»
     et avec / scriptCourant / gremplacépar«scriptCourant»
    );
</ script>

1
私はあなたがどのようにシンタックスをよりフランス語に修正したかが本当に好きです!しかし、フランス語の名前は実際には「CoffeeScript」を意味していませんか?
DLosc

技術的には、はい。しかし、それは当時私が考えることができた最高のものです。より良い提案がありますか?
SuperJedi224

1
「HTML5 avec le Script auCaféde Java」は陽気です:D「コーヒー」に似た(関連する?)argotic語があります:caoua(「ka-wa」)
クエンティン

3
ギメットの使用が大好きです。
-TRiG

1
それはする必要がありますラ変数ではなく、
レオ・ラム

8

JavaScript、フランス語– 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);

JavaScript +フランス語の回答が既にあることは知っていますが、私の場合は異なる翻訳とコーディング方法を使用しています。

コードは非常に簡単です。入力コード内のすべての単語を反復処理し、それらをtranslationsオブジェクトの対応するフランス語の単語に置き換えます。単語がリストされていない場合、変更されません。

フランス語では引用符の代わりに« Guillemets »を使用するため、最初に文字列で引用符を使用します。(はい、文字列を解析するためにregu͘͜l̴͝a͘͜͠r͏͏̶̸͢e̵͜x̸͝pr̵͞͞e͘͘s̵ś̸̷i͝o̴ns̴͜を使用しているため、常に完全に動作するとは限りません。)

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);

以下のStack Snippetを使用して、コードを簡単に実行できます。


3
ウイ、トレスビエン。
アレックスA.

句読点の後にスペースを追加する必要があります-XDの見栄えが良い
コナーオブライエン

7

Commodore 64 BASIC-ボスニア語/クロアチア語/セルビア語

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

これは実際にBASICキーワードを翻訳されたものに置き換えるため、 できる 新しいコードを書くときにそれらを使用する必要があります。

ボスニア語BASIC

使い方?

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

この行はあまり効果がないように見えますが、実際にはBASIC ROMからRAMにバイトをコピーします。ROMロケーションに書き込まれたデータは、RAMの同じアドレスに保存されます。

プログラムの最後の行は、BASICのRAMコピーに切り替わります。

POKE 1,PEEK(1) AND 254

メモリアドレス41118-41373には、予約済みのBASICキーワードの完全なリストが含まれています。これらの単語のASCII文字は、トークン番号順に保存されます。各単語の最後の文字のビット#7は、単語の終わりを示すように設定されます(ASCII値+ 128)。

行20〜100には翻訳されたキーワードが含まれています。行110〜200は、上記のようにメモリ内のキーワードを読み取ります。


5
変換後にコードが機能する最初の人かもしれません!
CJデニス

C64 BASICの作成者が仕事を終えたとき、彼は立ち上がって「ボスニア語でC64をプログラムできる日が欲しい」と宣言しました。(恥ずかしい彼はRAMの> 640kについてそのような先見の明はなかった)
マークKコーワン

しかし、変換はRAMに行われ、再起動するとRAMがクリアされます。

5

PHP-ポルトガル語(pt-PT / semi pt-BR)

これは非常に複雑で巨大なものになりました!

<?

    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__)
    );

このコードは、それ自体と一致するように作成されたことを忘れないでください!他のコードで部分的に機能する場合があります。


出力、翻訳済み:

<?

    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__)
    );

私は文法を可能な限り尊重しようとしました。

例は最初の行にあります:

echo preg_replace_callback

エコーはアクションであり、アクションは動詞です。ポルトガル語の動詞はすべてで終わりrます。コンテキストなしの
翻訳echoはになりますがeco、コンテキスト内では翻訳する必要がありますecoar(「エコーを作成する」)。

また、関数preg_replace_callbackにはユニークなものがあります。
アクションは最初の単語でなければなりません。
文字通り翻訳、それは次のようになりますexpressão_regular_substitui_executável(これは意味!ひどく翻訳され、replace the callback using a regular expression
そのため、特別な注意を払う必要があり第一及び第二の単語を入れ替えるので、それはsubstituir_expressão_regular_executável少し優れています、。

その他の機能は、のようなcount、なしで残っていますr、注文を爆発させるれます(あなたがボスである場合のように)。

いくつかの言葉は奇妙になりました...
stringという意味cordaですが、私がそれを正しく翻訳したら、cadeia contínua/ininterrupta de caracteres

すべてのことに追加するには、私は(一部の記号と演算子をも翻訳してきました$==>)。@DLoscに翻訳するアイデアを
ありがとう。$


2
この言語の$ように、の代わりにポルトガルの通貨記号を使用できます。
DLosc

@DLoscアイデアをありがとう。私は先に進み、他の演算子と記号も翻訳しました。
イスマエルミゲル

4

Fondamentale Visuale .RETE- Visual Basic .NET、イタリア語に翻訳

プログラムは非常にシンプルです(それ自体を翻訳することを目的としています)。

いくつかのポイント:

  • I / O:これは明らかな関数が呼び出されるモジュールです

  • 文法はほとんど正しい(ほとんど自然に感じる)

  • 英語とイタリア語の位置が異なるため、それを修正するための関数を(簡単に)書くことができませんでした。

  • 私は文字通りのイタリア語の翻訳のように、彼らが聞こえて間違っていると感じるように、命令型動詞を2人称に活用しています(窓8+が1人で話しているように間違っています)

  • 翻訳ペアは難読化されているため、英語のペアも翻訳されません。通訳があった場合はこのように、翻訳されたプログラムが動作します 私は一部だけを残し"+"overtranslationを避けるために(それはサフィックスの重複をイタリア語にイタリア語翻訳終わるだろうので、多くの英単語は、イタリアのものに含まれています)

モジュールイタリア語

    Dim Token As As New List(Of Tuple(Of String、String))

    Sub AddPair(a As String、b As String)
        Tokens.Add(Tuple.Create(a、b))
    サブ終了

    Sub init()
        AddPair( "Italian"、 "Italia" + "no"):AddPair( "Module"、 "Modulo")
        AddPair( "lacks"、 "non ha"):AddPair( "AddPair"、 "AggiungiCoppia")
        AddPair( "italian"、 "l'italiano")
        AddPair( "Next"、 "Appresso"):AddPair( "Tokens"、 "Frammenti")
        AddPair( "init"、 "iniz"):AddPair( "As"、 "Come")
        AddPair( "Tuple"、 "Coppia"):AddPair( "For Each"、 "Per Ogni")
        AddPair( "Of"、 "Di"):AddPair( "only"、 "e basta")
        AddPair( "Sub"、 "Proc"):AddPair( "so i add add"、 "quindiaggiungerò")
        AddPair( "Function"、 "Funzione"):AddPair( "Dim"、 "Def")
        AddPair( "a"、 "una"):AddPair( "support"、 "il s" + "upporto")
        AddPair( "used types"、 "i tipi utilizzati")
        REMイタリア語には形容詞の性別依存形式がない
        REMなので、使用済みの型のみのサポートを追加します
        AddPair( "New List"、 "una Nuova Lista")
        AddPair( "Create"、 "Crea"):AddPair( "End"、 "Fine")
        AddPair( "REM"、 "RIC"):AddPair( "for"、 "per")
        AddPair( "性別独立形式"、 "独立した形式の形式")
        AddPair( "String"、 "Sequenza"):AddPair( "形容詞"、 "gli aggettivi")
        AddPair( "TranslateToItalian"、 "TraduciInItaliano")
    サブ終了

    関数TranslateToItalian(o As String)文字列として
        Dim ret As String = o:init()
        トークン内のTuple(Of String、String)としての各t
            ret = ret.Replace(t.Item1、t.Item2)
        次
        retを返す
    終了機能

終了モジュール

イタリア語、ここに行きます!

それ自体の結果:

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))
    ファインプロセス

    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( "quindiaggiungerò"、 "quindiaggiungerò")
        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 quindiaggiungeròil supporto per 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( "形式独立したダル属"、 "形式独立したダル属")
        AggiungiCoppia( "Sequenza"、 "Sequenza"):AggiungiCoppia( "gli aggettivi"、 "gli aggettivi")
        AggiungiCoppia( "TraduciInItaliano"、 "TraduciInItaliano")
    ファインプロセス

    Funzione TraduciInItaliano(o Come Sequenza)カム・セクエンツァ
        Def ret Come Sequenza = o:iniz()
        Per Ogni t Come Coppia(Di Sequenza、Sequenza)Frammentiで
            ret = ret.Replace(t.Item1、t.Item2)
        アプレッソ
        retを返す
    ファインファンジオーネ

ファインモジュロ

ご回答ありがとうございます!ほんの2、3のポイント:あなたもコメントの英語のテキストを翻訳することになっていますが、私はまだ多くの英語の単語をの形で見ることができ"Mod" + "ule"ます。手紙よりも挑戦の精神をもっと目指してみてください。
CJデニス

@CJDennis私はそれを修正しました!
beppe9000

3

C、スペイン語-C

STDIN / STDOUTを介した入出力(使用./c-spanish < c-spanish.c)。

extra = 0がに変更された場合extra = 1、このプログラムの出力は本質的に相互の馬です。それ以外の場合、出力はのように機能するコンパイル可能なCプログラムですcat

ソースに余分なスペースが必要です(スペイン語版では文字に置き換えられるため)。

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

翻訳された言葉:

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

出力

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;
    }
}

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;
    }
}

あるdefineスペイン語?コードは翻訳後、元の言語で動作する必要はなく、仮想の翻訳バージョンのインタープリター/コンパイラーでのみ動作する必要があります。
CJデニス

3
@CJDennis defineは確かにスペイン語の単語です(二人称コマンドdefinir
es1024

3

ルビー、カタロニア語-ルビー

それはルビーではかなり短いコードなので、その代表ではありませんが、関数名をもう少し詳しく表示するためにもう少し冗長にしています。この演習では、「プログラム」と同様の疑似コードを使用した大学の授業をあまりにも多く思い出しました。

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

それ自体に適用されます:

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

1
どういうEliminat per simplificar codi意味か推測できると思います!
CJデニス

私もできると確信しています!
-rorlork

3

Python 3、ロジバン

スムティの場所を並べ替える必要がある場合は、単語を角かっこで囲みました。たとえば(te tcidu fe)

コード:

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)

そしてその出力:

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)

readだけになり(te tcidu fe)ます。それは何か他のものをすることになっていますか?
CJデニス

@CJDennisいいえ、スペースの代わりにアンダースコアを使用してブラケットを捨てることができたと思いますが。
のTuomas Laakkonen

OK。コードの上のコメントから、何かを再配置することになっていると思いました!
CJデニス

1

Javascript ES6、エスペラント、チャヴォスクリプト

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

キャメルケースと言葉遣いでいくつかの自由を取りました(「文字列に」ではなく「文字列に変換」に翻訳しました)。後で時間があれば、物事を複雑にします。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.