Переведите ваш английский исходный код на иностранный язык [закрыто]

66

Я заметил, что существует огромное количество компьютерных языков, основанных на английском. Я предлагаю исправить это путем перевода существующих компьютерных языков на иностранные языки!

  • Выберите компьютерный язык, который использует английские ключевые слова / функции
  • Выберите любой естественный * язык, кроме английского
  • Напишите программу, которая переводит свой собственный исходный код или любую другую программу, написанную с использованием того же набора ключевых слов / функций, на другой язык.
  • Опубликовать исходный код и вывод (переведенный код)

Начните свой пост с чего-то вроде:

Бейсик, французский

или же

ОСНОВНОЙ, французский - FONDAMENTAL

Вам не нужно переводить название языка, если вы не хотите, это просто для удовольствия!

Вам не нужно переводить все ключевые слова / функции на выбранном вами языке, только те, которые вы фактически используете в своем исходном коде. Например, в PHP тысячи, поэтому вам не нужно переводить их все! Кроме того, если вы используете какие-либо комментарии, пожалуйста, сделайте все возможное, чтобы перевести их тоже! После завершения вашей программы не должно быть узнаваемых английских слов, если они не подходят для иностранного языка. Слова в строках также должны быть переведены (то есть ваша переведенная программа больше не будет работать с исходным кодом на английском языке, даже если она может быть запущена!). Надеюсь, ваша программа будет иметь какой-то смысл для программиста, который говорит на другом языке!

Например, if () {} elseif () {} else {}может стать si () {} sinonsi () {} sinon {}по-французски! Если вы переводили в Perl elsifна французский язык, может быть , вы бы бросить второй nспособ , второй eбудет упал на английском языке: sinosi. Во французском языке еще бы более вероятно , будет Autre но альтернатива Sinon ( или же , в противном случае ) чувствует себя лучше для меня!

Будь креативным! Попробуйте запечатлеть ощущение как компьютера, так и естественных языков! Такие языки, как Brainfuck, CJam и т. Д., В которых нет английских токенов, не могут быть использованы. Такие языки, как BASIC или COBOL, гораздо более подходящие. Используйте значимые имена переменных и переводите их тоже, если ваш язык не поддерживает имена переменных, которые могут быть английскими словами.

Вы можете опубликовать несколько ответов, по одному на каждую комбинацию компьютера / естественного языка. Вы не можете использовать библиотеку или внешний инструмент для перевода! Ваш код должен делать перевод сам, а не вызывать что-то еще, что делает перевод! Это не Код Гольф! Если ваша программа принимает какие-либо данные, это должен быть только собственный исходный код, если она читает с диска, это может быть только исходный файл и т. Д.

* Для целей этой задачи я буду считать эсперанто, ложбан, волапюк, интерлингва и т. Д. Естественными языками. Вы не можете изобретать свой собственный язык для этого испытания!

Я добавил правило, чтобы предотвратить явные ошибки. Вы можете выбрать любое подмножество ключевых слов / функций - даже все из них - для перевода. Ваша программа должна быть в состоянии перевести себя как минимум, т. Е. Если ваш исходный источник содержит слово, 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);
CJ Деннис
источник
4
«print» станет «imprimer» (как в «printer»), а не «empreinte» (как в «footprint») :)
Квентин,
4
@Quentin Я никогда не утверждал, что это был хороший французский!
CJ Деннис
13
Я думаю, это достаточно плохо, что в Excel есть поддержка родного языка .. :(. Делает отладку формул намного сложнее
Mave
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 лет, так что переводить термины программирования было весело. Вот несколько моих любимых:

  • βιβλίον = "scroll" ( file)
  • γραψάτω = "write" ( print)
  • λαβέτω = "take" ( input)
  • εἰσενεγκάτω = "принести" ( import)
  • τύπος = "pattern, type" ( encoding)
  • λόγοι / νεόλογοι = "слова" / "новые слова" ( code/ replacements)
  • ἕκαστον ... ἐκ = "каждый ... от" ( for ... in)
  • εἰ ... εἰ δὲ ... εἰ δὲ μή = "если ... но если ... но если нет" ( if ... elif ... else)
  • ἐν τῷ буквально означает «в», но в определенных контекстах это может быть идиома «когда, в то время как»
  • «Регулярное выражение» стало ῥήμα λογικόν , «рациональное / разумное высказывание»; Таким образом, аббревиатура reявляется ῥλ

Большинство слов также можно найти с помощью поиска в Викисловарь .

Некоторые другие существенные особенности:

  • Английское программирование использует кучу императивных глаголов ( print, read, replace). Я подозреваю, что древние греки чувствовали бы себя немного глупо, разговаривая с таким компьютером, поэтому я сделал для них все императивы от третьего лица : «он должен печатать», «он должен читать», «он должен заменять».
  • Греческая пунктуация немного отличается от английской. Я не стал зацикливаться на этом, потому что я не уверен, что заменить квадратные скобки и подчеркивания, но я поменял двоеточия на ano teleia или «высокий период» ( ·).
  • Для слов, которых нет в списке, я также убедился в том, чтобы транслитерировать все строчные буквы. Здесь не всегда прямая переписка; так, например, utfпревращается в - ουτφкоторый звучит как «ootf», если вы пытаетесь произнести это.

Это все еще оставляет желать лучшего по грамматике. Греческий язык гораздо более выражен, чем английский, и мой код недостаточно сложен, чтобы правильно понять все случаи и цифры. Например, ἕκαστον παλαιόν, νέον ἐκ νεόλογοι следует читать ἐκ νεολόγ ων с объектом предлога в родительном падеже. Однако я не собираюсь тратить на это столько времени! Взгляд достаточно греческий (по крайней мере, для неопытного глаза), и высокие периоды добавляют приятное прикосновение. В целом, я очень доволен результатами.

DLosc
источник
4
Это похоже на греческий для меня! Я не понимаю по-гречески, но, похоже, у вас возникли проблемы с правильной грамматикой, так что, молодец! Не могли бы вы добавить несколько строк из вашего списка переводов?
CJ Деннис
Я до сих пор только вижу νεόλογοι = [...]. Можете ли вы добавить пару строк? Нет необходимости для всего списка!
CJ Деннис
Правда, это не очень интересно, но дает представление о всей продукции!
CJ Деннис
Разве перевод не должен оставлять строковые константы в покое и переводить только ключевые слова (и, возможно, имена переменных)?
Касперд
@kasperd Au contraire : Words in strings should be translated too.
DLosc
66

Цыпленок , китайский - 鸡

Цыпленок использовать намного сложнее, чем я думал.

Там нет завершающей новой строки. Но финал chickenтолько для обозначения конца этой программы, который может быть заменен пустой строкой.

Я использую этот интерпретатор , который печатает дополнительный символ новой строки и не может быть подавлен. Таким образом, выходные данные содержат на одну строку больше, чем исходные, и это может привести к поломке программы Chicken. Я надеюсь, что это не сделает его недействительным.

Он использовал некоторые приемы, такие как получение пустых строк из индекса -1 ввода и обнаружение EOF путем сравнения с пустыми строками. Я также использовал compareкоманду для удаления неиспользуемых элементов в стеке, не заботясь о типе. Они могут не работать с другими переводчиками. И он печатает строку в байтах UTF-8, где другие интерпретаторы могут напрямую поддерживать печать символов Юникода.

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

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

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

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

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

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

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken 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для ввода, а второй для кода.

Вывод (китайцы не используют пробелы между словами):

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

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

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

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

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

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

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


鸡

Эта программа заменяется hна , оставляет новые строки без изменений и игнорирует все остальное.

И, как вы видите, он может перевести любую действительную программу Chicken.

jimmy23013
источник
3
Вы знаете , что это заставляет меня думать of-- youtu.be/vExjnn_3ep4
DLosc
5
Ммм! Китайская курица! Я думаю, что вывод легче понять, чем оригинальная программа! Кто-нибудь еще чувствует себя как на вынос сейчас?
CJ Деннис
2
Хорошая работа, Джимми .
Алекс А.
18
@AlexA. Изменил мое имя пользователя тогда.
jimmy23013
6
季 姬 击 鸡 记
алефальфа
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;
}

Примечания:

  • Принимает входной и выходной файл в командной строке
  • Переводит все ключевые слова
  • Я не писал полный анализатор римских цифр, но подумал, что было бы неплохо хотя бы перевести числа, присутствующие в источнике ( nihil , i и ii )
  • Я не пошел по пути перевода символов, используемых в C ++, который выглядел как огромная банка червей
  • Ключевые слова const, enum, int, и 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;
}
Люк
источник
Разве «string» не следует переводить как «catena», как в современных романских языках?
200_success
Зависит от того, насколько буквально вы себя чувствуете.
Люк
6
Точнее, как романтично ты себя чувствуешь.
Алекс А.
1
Я думаю, что вы пропустили "пусто".
PA71
1
Благодарю. Я взял листок из книги @ Vioz и использовал «inane» для пустоты, чтобы я мог использовать «вакуум» для пустых.
Люк
25

JavaScript (NodeJS) - иврит

Мой метод кодирования очень похож на программу Python от DLosc : он читает исходный код, имеет список токенов и выполняет поиск и замену.

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, которое я перевел как מש'«משתנה» (переменная). fs, аббревиатура от «файловой системы», переводится как מ"קпервые буквы «מערכת קבצים», показанные выше.
  • На иврите нет заглавных / строчных букв. Несколько букв имеют нормальные / окончательные формы (כמנפצ и ךםןףץ соответственно), но это все. Таким образом, в словах mashup, таких как «readFile» и «filename», я также смешал иврит «קרא קובץ» и «שם קובץ», несмотря на то, что второе заканчивалось последней буквой в середине слова.
  • Вышеуказанное не распространяется на toString. На иврите предлоги - это отдельные буквы, которые ставятся перед словом. Таким образом, если «строка» - это «מחרוזת», то «строка» - это «למחרוזת». Вот почему в 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: иврит

Scimonster
источник
9
Должны были пойти с PHP - они уже T_PAAMAYIM_NEKUDOTAYIMпокрыты !
wchargin
2
Последняя строка источника RTL выглядит как человек с грустным лицом и бородой. :)
Мэтт Лайонс
(в этом отношении любой из них, по какой-то причине я не заметил этого на источнике LTR)
Мэтт Лайонс
@MattLyons Вы, вероятно, не заметили по-английски, потому что на самом деле это не так уж и похоже.
Scimonster
1
מה קורה @proudhaskeller
sagiksp
22

Perl, PigLatin - erlPay

Во-первых, реальная программа очень короткая, поэтому, чтобы продемонстрировать, как она работает с более длинными разделами текста, я включил некоторые стихи Perl в качестве дополнительного примера ввода / вывода. Поскольку поэзия включена после строки END, она фактически не исполняется.

Фактический алгоритм довольно прост:

  • Разделить ввод на токены по границам слов
  • Для любого слова, по крайней мере, с двумя буквенными символами перевести на Pig Latin
    • Найдите ведущие согласные в слове
    • переместите их в конец и добавьте к ним суффикс '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
Латинская свинья считается языковой игрой, а не естественным языком. Смотрите страницу Свинья Латинская Википедия .
Алекс А.
5
Я полагаю, вы могли бы назвать это так, хотя я не уверен, что этот вызов вполне поднимается до уровня федерального запроса предложений в отношении формальности.
Ральф Маршалл
3
Имя переведенного языка должно быть erlPay, и я хотел бы, чтобы оно выводилось__DENAY__ . Не должно openayи acceptayбыть , enopayи ceptacay?
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. Я не мог заставить окно консоли писать или читать по-персидски без превращения его в вопросительные знаки. (например, слово из четырех букв превратится в ????)

Примечание: если вы соедините слова друг с другом на персидском языке, это будет почти нечитаемо, потому что буквы соединяются друг с другом и получают другую форму. Поэтому я должен был разделить их пробелами, что привело к тому, что слова имели пробелы. Слово типа «Импорт» превратилось в وارد کردن, которое является двумя словами.

JNV
источник
В моем посте на иврите я включаю скриншот, который отображается правильно в редакторе, поддерживающем RTL.
Scimonster
@ Scimonster Хорошая идея. Я сделаю это прямо сейчас. Благодарю.
JNV
2
Вы можете получить «درست کردن» без пробелов, не превращая его в «درستکردن», используя Unicode-символ без объединения ширины (U + 200C): «درست‌کردن» - это заставляет буквы быть рядом друг с другом без разрыва, без объединения их - хотя, будут ли результаты хорошо выглядеть, будет зависеть от шрифта!
psmears
@psmears Ты прав; Я забыл об этом. Спасибо!
JNV
14

Ява, Немецкий - Ява

Эта программа действительно проста.
Он просто читает файл, указанный в качестве первого аргумента, и заменяет все вхождения английского слова соответствующим немецким переводом.

Я использую регулярное выражение с двумя groups ( ([^a-zA-Z\\d:])*) для сопоставления отдельных элементов с добавленным / префиксом после буквенно-цифрового символа. Это решило проблему с перекрывающимися переводами (англ. List-> нем., ListeНо тогда Listeбы стало Listee). Использование $1/ $2добавляет эти символы обратно и оставляет нам переведенный исходный код.

Обновление 1:

Используйте аббревиатуры, такие как eaи nbeaт. Д., Чтобы следовать соглашениям об именах Java на немецком языке.

Обновление 2:

Теперь использует третий компонент в массиве, чтобы сломаться после их первой замены. Это необходимо для моего хитрого подхода склонения / спряжения. class/ Klasseявляется женщиной на немецком языке и void/ nichtsявляется нейтральной, поэтому я просто пропустил замену последней и заменил позже. Другое редактирование - newэто перевод на русский, neueпотому что я использую его только для Stringженщин.

Обновление 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);
        }
    }

Если у вас есть какие-либо улучшения в коде или переводе, дайте мне знать, и я посмотрю, смогу ли я их реализовать.

GiantTree
источник
/, 󠀠 И -, вероятно , не очень хорошо в идентификаторах.
Ви.
6
Мне нравится переписка между двумя языками - оба используют сложные слова для всего. ;) Но я подозреваю, что немцы все равно будут сокращаться Eingabe/Ausgabe- может быть Einaus?
DLosc
1
@DLosc I / O (вход / выход) обычно сокращается до E / A (Eingabe / Ausgabe). Einausбыло бы возможно, я тоже думаю, но это не правильно. Rein/RausКазалось бы, возможно, но опять же просто не хочется хорошего перевода.
GiantTree
@Vi. Вы имеете в виду как символы в строке для замены (левая сторона)? Они не нужны, поскольку Java запрещает таким символам быть частью имени / идентификатора. Я думаю, вы имеете в виду, потому что я проверяю всю строку снова и снова, и вы можете подумать, что E/Aили подобное может вызвать проблемы, но они не интерпретируются как регулярное выражение, они только сопоставляются и, таким образом, оставляют регулярное выражение неизменным. (Я могу ошибаться, но это то, что я испытал с регулярными выражениями)
GiantTree
@GiantTree, я имею в виду, что код будет трудно разобрать для гипотетического немецкого компилятора Java.
Ви.
14

Юлия, татарин - Юлия

При этом используется неофициальный латинский алфавит заманалиф для идель-уральского татарского языка, созданный в 2001 году. Однако в 2002 году Российская Федерация отклонила предложение Татарстана сделать заманалиф официальным алфавитом для татарского языка, криминализируя официальное использование любого алфавита. алфавит кроме кириллицы.

В прошлом веке было 5 алфавитов для татарского языка:

  • Изке имля, вариант арабского алфавита, 1870–1920-е гг.
  • Yaña imlâ, другой арабский вариант, 1920-е и 30-е годы
  • Jaᶇalif, вариант латинского алфавита, 1930-е годы
  • Кириллица, обращение по поручению Иосифа Сталина, 1940-е годы
  • Заманалиф, неофициальный, 2001-настоящее время

Я выбрал Zamanälif, потому что я думаю, что мой дедушка был бы разочарован, если бы я использовал кириллицу. Его первым языком является татарский, и, родившись в 1920-х годах, он научился читать и писать на алфавите иске-имля.

Английский:

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мой перевод для readall, ukırga(читать) + böten(все / каждый). başägär, мой перевод для elseif, является baş(сокращение başkaça, означающее «иначе / иначе») + ägär(если).

Если кто-то из PPCG знает татарский язык, вы, вероятно, знаете больше, чем я. Любые предложения будут приветствоваться.

Алекс А.
источник
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);
    }
    друкрад!("{}", зьмест);
}
Vi.
источник
Нет.
Ви.
Русский а с ++?
GamrCorps
@IonLee, Нет. Подсказка: первое предположение было ближе.
Ви.
@IonLee: естественным языком является белорусский.
Алекс А.
1
Ржавчина а белорусская?
ProgramFOX
12

DogeScript , испанский - El Código del 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 Я не знаю, стоит ли это делать, я не знаю латыни, но я верю вашему слову.
Каде
Хороший материал, я сравниваю наши переводы для общих терминов. "или" должно быть "aut".
Люк
Почему System Ratioна латыни? Тогда какое соотношение по латыни?
phuclv
@ LưuVĩnhPhúc ratio->ratione/proportio
Kade
8

Рубин, Японский - AkaDama

Ruby по-японски - это rubii (ル ビ ー), что скучно, поэтому я назвал его буквально красным драгоценным камнем .

В ruby ​​переменные и методы не ограничиваются ASCII, поэтому что-то вроде

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

действительно рубин. Я использую это в максимально возможной степени для запутывания для всех ваших баз.

Надеюсь, что для разбора рубина можно использовать драгоценные камни, но все же потребовалось несколько уродливых исправлений обезьян.

Вы можете расширить, TRANS_TABLEчтобы добавить перевод для большего количества методов. Все, чего нет в таблице, «переводится» на японский язык в зависимости от его произношения (или, скорее, от орфографии), поэтому еда становится becomes あ と («а-а-нолик»).

Преобразует целые числа в «очень» практическую запись .

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

становится

#えぬこどぃぬぐ:うとふ-捌
# オウトプト "イ ろヴぇ ルブ"
さいぅ = "イ ろヴぇ ルブ"
言う(さいぅ)
# オウトプト "イ *ロヴェ* ルブ"
さいぅ["ろヴぇ"] = "*ろヴぇ*"
言う(さいぅ.うぷかせ)
# オウトプト "イ *ろヴぇ* ルブ"
# ふぃヴぇ てぃめす
伍.てぃめす 実行
  言う(さいぅ)
此処迄
blutorange
источник
8
Кажется очень неестественным приближать английский с использованием хираганы, а не катаканы (независимо от того, насколько свободно он нанесен на карту).
Стефан
8

HTML5 / Javascript для французского (HTML5 avec le Script au Caoua)

<Скрипт>
    var a = document.currentScript.outerHTML;
    alert (a.replace (/ var a / g, «переменная la»)
    .Надеть (/ предупреждения \ (/ г, "сигнализатор (")
    .replace (/ = / g, "есть")
    .Надеть (/ outerHTML / г, "HTMLExtérieur")
    .replace (/ \. replace \ ((. +) \, (. +) \) / g, "avec $ 1 remplacé par $ 2")
    .replace (/ \ / \ * и \ * \ // g, "et")
    .Надеть (/"(.+?)"/ г, "«$ 1»")
    /*and*/.replace(/currentScript/g,"scriptCourant ")
    );
</ Скрипт>

Выход:

<Скрипт>
    переменная «a» est document.scriptCourant.HTMLExtérieur;
    оповещатель (avec / la переменная «a» / g перестановка «la переменная« a »»)
     avec / alert \ (/ g remplacé par «alertter (»
     avec / est / g remplacé par «est»
     avec / HTMLExtérieur / g remplacé par «HTMLExtérieur»
     avec /\.replace\((.+)\,(.+)\)/g remplacé par «avec $ 1 remplacé par $ 2»
     avec / \ / \ * и \ * \ // g remplacé par «et»
     avec / ((.+?) перейдите/g remplacé par «« $ 1 »»
     et avec / scriptCourant / g remplacé par «scriptCourant»
    );
</ Скрипт>
SuperJedi224
источник
1
Мне очень нравится, как вы переработали синтаксис, чтобы быть более французским! Но разве французское название на самом деле не означает « CoffeeScript »?
DLosc
Технически да. Но это лучшее, что я мог придумать в то время. У вас есть лучшее предложение?
SuperJedi224
1
«HTML5 avec le Script au Café de Java» - это весело: D У нас есть похожее (связанное?) Слово «кофе»: caoua («ка-ва»).
Квентин
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);

Вы можете использовать приведенный ниже фрагмент стека, чтобы легко запустить код.

NinjaBearMonkey
источник
3
Oui, Tres Bien.
Алекс А.
Вы должны добавить пробелы после пунктуации - это выглядит лучше 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

Это на самом деле заменяет базовые ключевые слова переведенными, так что вы Можно должны использовать их при написании нового кода.

Боснийский бейсик

Как это устроено?

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

Хотя кажется, что эта строка мало что делает, на самом деле она копирует байты из БАЗОВОГО ПЗУ в ОЗУ. Данные, записанные в ПЗУ, хранятся в ОЗУ по тому же адресу.

Последняя строка в программе переключается на RAM копию BASIC:

POKE 1,PEEK(1) AND 254

Адреса памяти 41118-41373 содержат полный список зарезервированных ключевых слов BASIC. Символы ASCII этих слов хранятся в порядке номеров токенов. Бит № 7 последней буквы каждого слова устанавливается для указания конца слова (значение ASCII + 128).

Строки 20-100 содержат переведенные ключевые слова. Строки 110-200 читают ключевые слова в памяти, как описано выше.

Данко Дурбич
источник
5
Вы можете быть первым человеком, чей код работает после преобразования!
CJ Деннис
Когда создатель C64 BASIC завершил свою работу, он встал и объявил: «Я с нетерпением жду того дня, когда люди смогут программировать C64 на боснийском языке». (позор, он не был таким дальновидным в отношении> 640 КБ ОЗУ)
Марк К Коуэн
Но перевод выполняется в ОЗУ, и перезагрузка приведет к очистке ОЗУ, да?
кот
5

PHP - португальский (pt-PT / полу 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-м человеком, так как в буквальном итальянском переводе они звучат и чувствуют себя не так (как в Windows 8+, говорящей от 1-го человека)

  • пары перевода запутаны, поэтому английские не переводятся. таким образом, если бы был переводчик, переведенная программа работала бы, я оставил только несколько, "+"чтобы избежать чрезмерного перевода (многие английские слова содержатся в итальянских, так что в конечном итоге это переводит итальянский на итальянский с дублированием суффиксов)

Модуль Итальянский

    Dim Tokens как новый список (Of Tuple (Of String, String))

    Sub AddPair (a как строка, b как строка)
        Tokens.Add (Tuple.Create (a, b))
    End Sub

    Sub init ()
        AddPair («Итальянский», «Италия» + «нет»): AddPair («Модуль», «Модуль»)
        AddPair («не хватает», «не ха»): AddPair («AddPair», «AggiungiCoppia»)
        AddPair («итальянский», «итальянский»)
        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 («так я добавлю», «quindi aggiungerò»)
        AddPair («Function», «Funzione»): AddPair («Dim», «Def»)
        AddPair ("a", "una"): AddPair ("поддержка", "il s" + "upporto")
        AddPair («используемые типы», «я типизирую»)
        REM italian не имеет независимой от пола формы для прилагательных
        REM, поэтому я добавлю поддержку только для используемых типов
        AddPair («Новый список», «Una Nuova Lista»)
        AddPair («Создать», «Crea»): AddPair («Конец», «Fine»)
        AddPair («REM», «RIC»): AddPair («для», «для»)
        AddPair («гендерно-независимая форма», «формат indipendente dal genere»)
        AddPair ("String", "Sequenza"): AddPair ("прилагательные", "gli aggettivi")
        AddPair ("TranslateToItalian", "TraduciInItaliano")
    End Sub

    Функция TranslateToItalian (o как строка) как строка
        Dim ret As String = o: init ()
        За каждый т как кортеж (из строки, строки) в токенах
            ret = ret.Replace (t.Item1, t.Item2)
        следующий
        Возвращение в отставку
    Конечная функция

Конечный модуль

Итальянец, поехали!

Результат на себя:

По модулю итальяно

    Def Frammenti Come una Nuova Lista (Ди Коппия (Ди Секвенца, Sequenza))

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

    Proc iniz ()
        AggiungiCoppia ("Italiano", "Italia" + "no"): AggiungiCoppia ("Modulo", "Modulo")
        AggiungiCoppia («non ha», «non ha»): AggiungiCoppia («AggiungiCoppia», «AggiungiCoppia»)
        AggiungiCoppia ("l'italiano", "l'italiano")
        AggiungiCoppia («Аппрессо», «Appresso»): AggiungiCoppia («Фрамменти», «Frammenti»)
        AggiungiCoppia («Иниз», «Иниз»): AggiungiCoppia («Иди», «Приходи»)
        AggiungiCoppia («Coppia», «Coppia»): AggiungiCoppia («Per Ogni», «Per Ogni»)
        AggiungiCoppia («Di», «Di»): AggiungiCoppia («e basta», «e basta»)
        AggiungiCoppia («Proc», «Proc»): AggiungiCoppia («quindi aggiungerò», «quindi aggiungerò»)
        AggiungiCoppia ("Funzione", "Funzione"): AggiungiCoppia ("Def", "Def")
        AggiungiCoppia ("una", "una"): AggiungiCoppia ("il supporto", "il s" + "upporto")
        AggiungiCoppia («я типизирую», «я типизирую»)
        RIC l'italiano non ha una forma indipendente dal genere per gli aggettivi
        RIC Quindi Aggiunger и его поддержка в течение всего срока службы Баста
        AggiungiCoppia («Уна Нуова Листа», «Уна Нуова Листа»)
        AggiungiCoppia («Crea», «Crea»): AggiungiCoppia («Fine», «Fine»)
        AggiungiCoppia («RIC», «RIC»): AggiungiCoppia («за», «за»)
        AggiungiCoppia («жанр Forma Indipendente Dal», «жанр Forma Indipendente DAL»)
        AggiungiCoppia ("Sequenza", "Sequenza"): AggiungiCoppia ("gli aggettivi", "gli aggettivi")
        AggiungiCoppia ("TraduciInItaliano", "TraduciInItaliano")
    Fine Proc

    Funzione TraduciInItaliano (o Приходи Секенца) Приходи Секенца
        Def ret Come Sequenza = o: iniz ()
        Пер Огни т Ком Коппия (Ди Секвенца, Sequenza) В Фрамменти
            ret = ret.Replace (t.Item1, t.Item2)
        Appresso
        Возвращение в отставку
    Fine Funzione

Прекрасно по модулю
beppe9000
источник
Спасибо за ваш ответ! Просто пара моментов: вы должны переводить английский текст в комментариях, и я все еще вижу много английских слов в форме "Mod" + "ule". Попробуйте больше ориентироваться на дух вызова, а не на букву.
CJ Деннис
@CJDennis я исправил это!
beppe9000
3

C, испанский - C

Ввод / вывод через STDIN / STDOUT (использовать ./c-spanish < c-spanish.c).

Если extra = 0изменено наextra = 1 , то вывод этой программы по сути является взаимным квин. В противном случае на выходе получается скомпилированная программа на Си, которая работает следующим образом 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;
    }
}
es1024
источник
Это defineиспанское слово? Помните, что ваш код не должен работать на языке оригинала после перевода, только в гипотетически переведенной версии интерпретатора / компилятора.
CJ Деннис
3
@CJDennis define- действительно слово по-испански (команда от второго лица definir)
es1024
3

Рубин, Каталонский - Руби

Это довольно короткий код в ruby, так что он не такой представительный, но я был более многословен в именах функций, чтобы показать немного больше. Это упражнение запомнило меня слишком много в университетских классах, где мы использовали подобный псевдокод для «программирования».

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
rorlork
источник
1
Могу поспорить, я могу догадаться, что Eliminat per simplificar codiзначит!
CJ Деннис
Я также уверен, что вы можете!
rorlork
3

Python 3, ложбан

Там, где мне нужно было переставить sumti места, я заключил слова в скобки, например (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 Нет, хотя, полагаю, я мог бы использовать подчеркивание вместо пробелов и расставить скобки.
Туомас Лаакконен
ХОРОШО. Из комментария выше кода я думал, что это должно было что-то изменить!
CJ Деннис
1

Javascript ES6, эсперанто, osavoskripto

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

Я взял некоторые свободы с верблюдом и формулировками (я перевел «преобразовать в строку» вместо «в строку»). Я усложню вещи позже, когда у меня будет больше времени.

Mama Fun Roll
источник