Напишите фрагмент кода, который может быть выполнен как минимум на трех разных языках. Код должен выводить целое число 1на языке номер один, 2на языке номер два, 3на языке номер три и т. Д.

Правила:

• Вывод должен быть только целым числом, но завершающие символы новой строки в порядке.
• Код не может принимать какие-либо данные
• Различные основные версии одного и того же языка считаются уникальными. Таким образом, ваш код может быть исполняемым в Python 2 и Python 3, однако Python 2.5 и Python 2.7 не считаются уникальными.
• Вы можете использовать новый язык тогда и только тогда, когда у него есть статья на esolang / wiki, доступен переводчик и документация, и он использовался как минимум двумя пользователями на PPCG до его использования в этом испытании. Он также должен придерживаться этих 4 правил .

Оценка вашего представления - это количество байтов в вашем коде, деленное на количество языков, на которых он может работать в кубе. Таким образом, 54-байтовое решение, которое выполняется на 3 языках, будет иметь оценку 2:

54 / 3^3 = 2  

Чем ниже балл, тем лучше.

Leaderboard

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 65641; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 31516; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d?\.?\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

30 языков, 248 байтов, 248/30 ^ 3 = 0,009185

#|#?15g,@           kkmNmSaIeoe99+{\#/-;n@0ea
#[9!@>.>.eeaww#-1@*"12" L
#{  
###
#`{
25
print(4^2 +7)/2


"""
Jo is here.
$'main'MoO OOM
 7
>Jo, 30
>X Jo
f::=~27
::=]##}#(prin 29)
print (7/6*24)###;alert 2#-[>+<-----]>-.|#(write(if(= 1/5 .2)26 3))"""

Редактировать: Beatnik удален, так как тестирование простоты в Beatnik может быть невозможно.

В коде есть вкладки (которые обрабатываются Stack Exchange) и завершающий перевод строки, поэтому вот xxd:

00000000: 237c 233f 3135 672c 4020 2020 0920 2020  #|#?15g,@   .   
00000010: 206b 6b6d 4e6d 5361 4965 6f65 3939 2b7b   kkmNmSaIeoe99+{
00000020: 5c23 2f2d 3b6e 4030 6561 0a23 5b39 2140  \#/-;n@0ea.#[9!@
00000030: 3e2e 3e2e 6565 6177 7723 2d31 402a 2231  >.>.eeaww#-1@*"1
00000040: 3222 094c 0a23 7b20 090a 2323 230a 2360  2".L.#{ ..###.#`
00000050: 7b0a 3235 0a70 7269 6e74 2834 5e32 202b  {.25.print(4^2 +
00000060: 3729 2f32 0a0a 0a22 2222 0a4a 6f20 6973  7)/2...""".Jo is
00000070: 2068 6572 652e 0a24 276d 6169 6e27 4d6f   here..$'main'Mo
00000080: 4f20 4f4f 4d0a 2037 0a3e 4a6f 2c20 3330  O OOM. 7.>Jo, 30
00000090: 0a3e 5820 4a6f 0a66 3a3a 3d7e 3237 0a3a  .>X Jo.f::=~27.:
000000a0: 3a3d 5d23 237d 2328 7072 696e 2032 3929  :=]##}#(prin 29)
000000b0: 0a70 7269 6e74 2028 372f 362a 3234 2923  .print (7/6*24)#
000000c0: 2323 3b61 6c65 7274 2032 232d 5b3e 2b3c  ##;alert 2#-[>+<
000000d0: 2d2d 2d2d 2d5d 3e2d 2e7c 2328 7772 6974  -----]>-.|#(writ
000000e0: 6528 6966 283d 2031 2f35 202e 3229 3236  e(if(= 1/5 .2)26
000000f0: 2033 2929 2222 220a                       3))""".

Кроме того, вы можете скопировать и вставить код из этого "Попробуйте онлайн!" ссылка .

Это очень плохо, но я хотел отыграть идею, что, когда у вас будет достаточно языков, количество байтов уже не будет иметь большого значения. Сказав, что есть некоторые языки, которые я мог бы легко добавить (например, Objeck), но в настоящее время они слишком длинные, чтобы быть полезными. Хотя у меня заканчиваются хорошие языки, поэтому я могу на этом остановиться.

Запустите все программы с помощью </dev/null 2>/dev/null(т. Е. Пустой ввод, перегруженный STDERR).

Объяснение довольно длинное, поэтому вот резюме:

No.  Lang.              Non-esolang?     2D esolang?      BF/BF-deriv?
--------------------------------------------------------------------------
1    COW                                                       ✓
2    CoffeeScript            ✓
3    Common Lisp             ✓
4    Retina
5    Befunge-93                               ✓
6    Python 2                ✓
7    Rail                                     ✓
8    ETA
9    Prelude
10   Gol><>                                   ✓
11   evil
12   Foo                                                       ✓
13   Ruby                    ✓
14   ><>                                      ✓
15   Brian & Chuck                                             ✓
16   Whitespace
17   3var
18   Axo                                      ✓
19   Labyrinth                                ✓
20   Starry
21   Fission                                  ✓
22   Brainfuck                                                 ✓
23   Julia                   ✓
24   Lily                    ✓
25   GolfScript
26   Chicken Scheme          ✓
27   Thue
28   Perl 6                  ✓
29   Picolisp                ✓
30   TRANSCRIPT

1. корова

COW - это производная от Brainfuck с дополнительными командами, одной из которых является числовой вывод. Все недействительные игнорируются, поэтому исполняемая программа просто

MoO OOM

который увеличивает ячейку до 1, затем печатает ее как число.

2. CoffeeScript (включает переводчика)

CoffeeScript видит:

# comments
###
multiline comment
###;alert 2# comment

который просто предупреждает 2.

^{(Да, возможно, было бы лучше, если бы этот слот занял другой язык, но я слишком ленив, чтобы перетасовать его: P)}

3. Общий Лисп | ideone

Common Lisp (clisp) видит:

#|
multiline comment
|#(write(if(= 1/5 .2)26 3))"""

1/5является рациональным и не равен 0.2, поэтому 3 печатается. Продолжение """является синтаксической ошибкой.

Обратите внимание, что printв Common Lisp , похоже, выводится предыдущий символ новой строки и завершающий пробел. Однако, к счастью, writeработает как в Common Lisp, так и в Chicken Scheme.

4. Сетчатка | Попробуйте онлайн!

^{Введенные ограничения : каждая вторая строка, начиная с первой, должна быть действительным регулярным выражением.}

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

«»»

которая заменяет исходную пустую строку на """. Последняя пустая строка, не являющаяся частью какой-либо пары, рассматривается как стадия совпадения, считая количество совпадений регулярного выражения. Есть четыре экземпляра пустой строки """, а именно 1"2"3"4.

5. Befunge-93 | переводчик

Befunge - это двумерный язык, и соответствующие инструкции

# # 15g,@

в первой строке и 5в 25строке. #пропускает следующую инструкцию, 15gполучает символ в позиции (1, 5)кода ( строка 5в 25строке), ,выводит символ и @останавливается.

6. Python 2 | ideone

Python видит:

# comments
25
print(4^2 +7)/2


"""
multiline string
"""

(4^2+7)/2 = (xor(4,2)+7)/2 = (6+7)/2 = 13/2 = 6, который получает printред.

7. Рельс | Попробуйте онлайн!

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

$'main'
 7
  o
   J

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

8. ЭТА | Попробуйте онлайн!

^{Введены ограничения: не следует вводить символы до программы ETA etaoinsh.}

ETA распознает только буквы etaoinshи их заглавные версии, то есть код начинается с

NSaIeoe

n...eтолкает основную цифру 7 в зависимости от того, что находится внутри разделителей, для которых SaIесть 624, или 312 в десятичном виде. oзатем выводит как char, по-видимому, по модулю 256, давая char 8(кодовая точка 56). eзатем пытается разделить с пустым стеком, который терпит неудачу.

9. Прелюдия | Попробуйте онлайн!

^{Введены ограничения: не более одного ()в любом столбце, ()совпадающих с чтением столбца за раз, без бесконечных циклов, вызванных ().}

Это требует, чтобы интерпретатор Python был NUMERIC_OUTPUT = Trueустановлен.

Прелюдия - это язык, где каждая строка выполняется отдельно. Многие символы выполняются, но важной частью является

9!

во второй строке, которая выводит 9. ()в Prelude обозначает цикл, но благодаря выдающемуся значению #s (который вырывается из стека), вершины стеков всегда равны 0 к моменту попадания в цикл, поэтому ни один из них запускаются. Ограничения исходного кода Prelude относительно ()введенных некоторых посторонних мест все же.

10. Гол> <> | переводчик

Эта часть (и> <>) работает как ответ Мартина . Соответствующий код

#                                      ;n@0ea

Gol> <> - это двумерный язык, который #отражает IP-адрес, что позволяет ему перемещаться влево. Он оборачивается, вставьте 10, 14 и 0 в стек. @затем вращает стек, выводя 10 наверх, nвыводит его и ;останавливает программу.

11. зло | Попробуйте онлайн!

Эта часть также похожа на ответ Мартина.

зло игнорирует все, кроме строчных букв. Игнорируя еще несколько символов, соответствующая часть

aeeeaeeaww

где aувеличивает значение переменной A, eэто функция зла, которая тасует биты Aи wвыводит A. Следовательно мы выводим 1дважды, давая 11.

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

12. Фу | Попробуйте онлайн!

Foo выводит что-либо между двойными кавычками, поэтому соответствующая часть

"12"

на второй линии. Однако, поскольку нам понадобятся двойные кавычки позже, мы используем метод, аналогичный ответу Мартина, чтобы исключить ошибку Foo, а именно предыдущий #-1@. Непонятно, почему это работает на языке, который использует пустой стек и деление на ноль ошибок, но я рад, что это так.

13. Рубин | ideone

Как и Python, Ruby видит:

# comments
25
print(4^2 +7)/2


"""
multiline string
"""

Тем не менее, стоит отметить , что многострочная строка фактически три отдельных строк ( "", "...", "") объединяется вместе. (4^2+7) = xor(4,2)+7 = 6+7 = 13Вывод строки печати , прежде чем вывести ошибку, пытаясь разделить nilна 2.

14. > <> | Попробуйте онлайн!

Эта часть такая же, как и часть Gol> <>, за исключением @того, что вместо этого 14 выводится наверх, которая выводится.

15. Брайан и Чак | Попробуйте онлайн!

Brian & Chuck является производной BF с двумя лентами, где указатель инструкции одной ленты является указателем памяти другой ленты. В отсутствие ```первых двух строк исходного кода используются для инициализации лент.

Соответствующие символы в первых двух строках:

   ?15
#     >.>.

?В ленте Брайана проходит контроль над Чаку в сота указал ( #) отличен от нуля. Затем Чак выполняет >.>., выводя два знака после знака вопроса.

16. Пробелы | переводчик

Используя STLдля пробела, табуляции и перевода строки соответственно, запуск программы:

SSSTSSSSL
TL
STL
L
L

Первая строка нажимает 16 ( +10000основание 2), предыдущая TLSTпечатает его как число. Следующие три перевода строки останавливают программу.

Обратите внимание, однако, что эта программа специфична для интерпретатора. Остальные синтаксические ошибки кода в большинстве интерпретаторов, поэтому требуется более мягкий интерпретатор, такой как приведенный выше.

17. 3вар | Попробуйте онлайн!

Из первой строки выполняется множество инструкций, но соответствующие

kkmmao#/

Из-за ограничения ETA, мы используем kдля уменьшения переменной B, а не aдля ее увеличения. kkуменьшает B до -2 и mmвозводит в квадрат B дважды до 16, что увеличивается до 17 с a. Это затем выводится с o.

#затем используется для сброса B на 0 и /вызывает ошибку программы через деление на 0.

18. Аксо | Попробуйте онлайн!

^{Введены ограничения: нет никаких инструкций перед программой Axo, которые меняют направление IP}

Еще раз, множество инструкций выполняется в первой строке, но соответствующие

# # 15 ,@            9 9  + {   \

Axo - это двумерный язык, такой как Befunge, и #аналогично мост, пропускающий следующую инструкцию, но только если вершина стека равна нулю. 15,нажмите на стек, но стек очищается @. 99+затем нажимает 18, {выводит и \останавливает.

19. Лабиринт | Попробуйте онлайн!

Лабиринт - еще один двумерный язык, и выполненные инструкции

#|#
 [9!@

#толкает длину стека, которая в первый раз равна 0 |является побитовым ИЛИ, ничего не изменяя, так как в этой точке стека просто есть 0, а вторая #теперь выдвигает 1 из-за одиночного нуля. Мы поворачиваем направо из-за 1, 9преобразовываем это 1 в 1*10+9 = 19, !печатаем его и @останавливаем.

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

20. Звездный | Попробуйте онлайн!

^{Введенные ограничения: Все +s должны иметь по крайней мере один предшествующий пробел}

Если мы уберем нераспознанные символы, соответствующая часть кода

,       +.. +

,является входом, но так как мы по конвейеру /dev/nullоттуда нет ни одного, подталкивая 0 в стек. A +с n >= 5предыдущими пробелами нажимает n-5, поэтому следующая инструкция нажимает 2. ..затем выводит эти две цифры в обратном порядке.

Далее у нас есть +с одним предшествующим пробелом, который дублирует. Тем не менее, стек пуст, поэтому мы делаем ошибку.

21. Деление | Попробуйте онлайн!

Единственная важная часть для деления

*"12"L

Lпорождает атом, движущийся влево, "21"печатает 21 и *останавливается.

22. Брейнфук | Попробуйте онлайн!

^{Введенные ограничения: нет .до первого[}

Это требует интерпретатора, который дает 0 на EOF и имеет 8-битные ячейки. Соответствующий код

,+-[>.>.-+.>,>]-[>+<-----]>-..

Начальный -должны компенсировать +, и первый [...]не выполняются , так как клетка равно 0. Следующие -[>+<-----]>-наборы ячейки полукокса кода 2, и ..выводит его в два раза.

23. Юлия | Попробуйте онлайн!

Юля видит:

# comments
25
print(4^2 +7)/2

То, что напечатано 4^2+7 = pow(4,2)+7 = 16+7 = 23, и программа выдает ошибку, пытаясь разделить nothingна 2. Обратите внимание, что Джулия, похоже, не возражает против того факта, что остальная часть кода в любом случае вызовет синтаксическую ошибку.

24. Лили | переводчик

Лили видит:

# comment
#[
multiline comment
]## comment
print (7/6*24)# comment

7/6*24 = 1*24 = 24 печатается.

25. GolfScript | Попробуйте онлайн!

GolfScript видит:

# comments
25
print(

GolfScript основан на стеке, поэтому 25 помещается в стек, затем извлекается и печатается с помощью print. (затем пытается уменьшить неявную пустую строку в стеке, что приводит к сбою и ошибкам программы.

26. Цыпленок Схема | ideone

Куриная схема имеет тот же #| ... |#синтаксис многострочных комментариев, что и Common Lisp. Однако в

(write(if(= 1/5 .2)26 3))

1/5с плавающей точкой , который является равным 0.2, так что 26 выводится вместо этого.

27. чт | Попробуйте онлайн!

Thue - это язык, основанный на перезаписи строк. Первая соответствующая часть

f::=~27
::=

который определяет замену, f -> 27затем обозначает конец замен с ::=. Lone fin ifзатем заменяется на 27, который выводится.

28. Perl 6 | ideone

В Perl 6 появился новый синтаксис комментариев, а именно #`(some bracket)многострочный комментарий вплоть до соответствующей скобки. Таким образом, Perl 6 видит:

# comments
#`{
multiline comment
}# comment
print (7/6*24)# comment

который печатает 7/6*24 = 28.

29. Пиколисп | ideone

Picolisp видит:

# comment
#{
multiline comment
}#(prin 29)

которая печатает 29. Затем строка затем вызывает синтаксическую ошибку.

30. ТРАНСКРИПТ | Попробуйте онлайн!

TRANSCRIPT - это тематический esolang, смоделированный после текстовых приключений. Нераспознанные строки игнорируются (что позволяет добавить дополнительный текст истории / аромата среди фактических инструкций кода), поэтому соответствующие строки:

Jo is here.
>Jo, 30
>X Jo

В первой строке объявляется строковая переменная Joс использованием двухбуквенного имени, поскольку однобуквенные имена кажутся ошибочными. Вторая строка устанавливает эту строку в значение "30", которое выводится с помощью X«исследовать» в третьей строке.

15 языков, 68 66 65 байт / 15 ^ 3 = 0,019 ...

Сетчатка , Звездная , Прелюдия , ЭТА , Аксо , Лабиринт , Гексагония , Фу , Брайан и Чак , Гол> <> , зло , Пробел , Деление , > <> и GolfScript .

После масштабной переписки мне удалось уместить еще четыре языка. Код содержит несколько вкладок для пробелов. Так как Stack Exchange преобразует их в пробелы, я представил их \tниже:

#I5aeeNTH{\?      \t\t + +3;n@"8"ea9
15}7'`--~!@<"31"LSOe.\t
 \teaww`

Я думаю, что я закончил добавление языков (хотя добавление только одного может сэкономить несколько байтов в том, что у меня уже есть). Интересно, можно ли играть в гольф ... 65 байтов для 15 языков - это большой скачок с 32 байтов для 11 языков, и теперь у меня есть хотя бы один бесполезный символ, чтобы заставить Фу работать ...

Сетчатки принты 1

Попробуйте онлайн.

К счастью, первая строка - это правильное регулярное выражение. Однако это регулярное выражение, очевидно, не соответствует пустому вводу, поэтому первый этап (состоящий из первых двух строк) ничего не делает.

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

Звездные принты 2

Попробуйте онлайн.

Звездное игнорирует все, кроме пробелов и +*,'`.. Каждая команда является одним из этих символов в сочетании с пробелами, начиная с последнего из этих символов. Итак, давайте удалим весь посторонний код:

       + +'`. `

Семь пробелов с последующими +нажатиями a 2. Один пробел с последующим +дублированием. 'это условный прыжок. Он попадает в верхнюю часть стека, что является правдивым (положительным), поэтому он переходит к соответствующей метке (где метки обозначены, `а «соответствующий» означает «с таким же количеством начальных пробелов»), что является первым `. .без пробелов перед ним печатается вершина стека как число.

Прелюдия принты 3

Попробуйте онлайн.

Предполагается, что интерпретатор Python использует числовой вывод. Давайте удалим все no-ops:

# 5        ?         + +3    8   9
15 7  -- !   31

Первый голос делает кучу вещей, но ничего из этого не имеет значения, потому что нет результатов !для печати. Второй голос толкает a 1, затем a 5, затем a 7. Мы берем разность последних двух, чтобы получить -2, а затем вычитаем это из, 1чтобы получить 3. !печатает это. Третий голос имеет только не-опс.

ЭТА печатает 4

Попробуйте онлайн.

ETA игнорирует все, кроме символов ETAOINSH(в любом случае). Итак, код, который видит ETA:

IaeeNTHneaSOeea

Iпытается прочитать ввод, но не может, поэтому он толкает -1. aтолкает текущий номер строки плюс 1, который 2. eявляется divmod , который заменяет те с 0и 1(или -1, я не знаю, но это не имеет значения). Следующая eзаменяет их обоих 0.

Теперь интересная часть. NTHneявляется литералом числа 7. Nи eявляются только разделителями, и три цифры THN. То есть 54(где Tцифра 1, Hесть 0и nесть 5). aтолкает 2еще раз. Sвычитает его, в результате чего 52и Oвыводит его как символ ( 4). Теперь eснова пытается выполнить divmod, но стек содержит два нуля, поэтому программа завершается с ошибкой (но при этом не загрязняет STDOUT).

Аксо принты 5

Попробуйте онлайн.

Этот язык был в значительной степени единолично ответственен за переписывание. У меня не могло быть }первой строки, потому что она заблокировала бы ввод в Axo (см. Историю изменений, о чем я говорю). Для Axo важна только эта часть кода:

#I5aeeNTH{\

К счастью, Axo также имеет неявные 0s в нижней части своего стека, поскольку #выскакивает вершина стека (чтобы проверить, следует ли пропустить следующую инструкцию или нет). Письма все бездействуют. Затем 5нажимает 5, {печатает, \завершает программу. Все очень просто.

Лабиринтные принты 6

Попробуйте онлайн.

Я немного усекаю код, потому что правая половина никогда не достигается, и я также использую tвместо него \t, чтобы столбцы выстроились правильно:

#I5aeeNTH{\
15}7'`--~!@
 teaww`

Теперь, когда буквы, пробелы и символы табуляции являются стенами в Лабиринте, поэтому доступный код на самом деле выглядит следующим образом:

# 5      {\
15}7'`--~!@
      `

Указатель инструкций будет автоматически следовать по этому пути. #толкает глубину основного стека ( 0) и 15превращает его в 15. }перемещает его во вспомогательный стек, и мы больше не будем его использовать. Это удобно делает вершину стека нулевой, так что IP не поворачивается влево на 5. 7превращает ноль в 7, 'это неоперация. Это `унарное отрицание, поэтому мы получаем -7. Теперь -вычитает -7из неявного 0нижележащего 7. На этот раз IP поворачивается вправо к тому `, что является унарным отрицанием, так что мы получаем 7снова. IP попадает в тупик и разворачивается. The -делает то же самое, что и раньше, поэтому мы получаем7еще раз. Так как вершина стека теперь положительная, IP поворачивается направо. Есть еще один, -который дает -7снова. Тогда ~побитовое НЕ, что дает 6и !печатает его. Это как раз подходящий момент для этого, потому что теперь стек снова пуст, так что IP не поворачивается влево, {а вместо этого продолжается прямо в том, @что завершает программу.

Гексагональные принты 7

Попробуйте онлайн.

Развернутый код выглядит так:

     # I 5 a e
    e N T H { \
   ? + + 3 ; n @
  " 8 " e a 9 1 5
 } 7 ' - - ~ ! @ <
  " 3 1 " L S O e
   . e a w w . .
    . . . . . .
     . . . . .

Обычно это ужасная программа Hexagony, но фактически используемых символов не так уж много. На самом деле они почти так же , как те , которые используются лабиринтом , и я думаю, как я дифференцироваться между 5и 6весьма приятно. :)

Верхний ряд в принципе можно игнорировать. #обычно переключается на другой IP, но текущий край памяти равен 0, так что это не так. Буквы просто устанавливают фиксированное значение памяти, но мы не собираемся его использовать. После окончания первого ряда поток управления продолжается в среднем ряду (начиная с }, направо). В }переходит к другому краю памяти. 7устанавливает этот край на 7. 'возвращается туда, откуда мы пришли. -вычитает край памяти, который мы только что установили, 7из неиспользованного края памяти ( 0), так что мы получаем -7. Следующий -снова делает то же самое, так что это не оперирование. Пока что довольно похоже на Labyrinth (кроме макета памяти). Но сейчас~это не побитовое НЕ, а унарное отрицание в гексагонии. Так что это дает 7вместо 6. !@, как в Лабиринте печатает значение и завершает программу.

Фу принты 8

Попробуйте онлайн.

Как мы все знаем со времен Викторины «Язык программирования», печать в Foo довольно тривиальна, даже если большая часть кода представляет собой случайный набор символов. Ни один из символов не влияет на вывод, кроме того, "8"который печатает 8. Ну, есть "31"позже, но Foo завершается с ошибкой в ​​конце первой строки. Я не совсем уверен, почему это происходит, но для этого требуется 3(или любая другая цифра) в верхней строке, которая больше нигде не используется.

Отпечатки Брайана и Чака 9

Попробуйте онлайн.

Давайте сделаем это снова, когда мы удалим третью строку (она никогда не анализируется) и заменим все нерелевантные символы (например, no-ops или ячейки, которые не читаются) пробелами:

         { ?         + +         9
  }   --   <        .

Как напоминание, каждая строка похожа на Brainfuck, и ее лента является исходным кодом другой программы. Поток управления начинается с первой строки (называется Брайан).

Эти {движения ленты головы весь путь влево (где она уже есть), а ?руки контроль над потоком Чаку (вторая линия). Там }перемещает головку ленты вправо, пока не найдет нулевую ячейку. Это не происходит до конца программы, поэтому головка ленты заканчивается на одну ячейку после 9. -уменьшает эту ячейку, но это не имеет значения. <перемещает головку ленты на 9и .печатает ее. Чак выбегает из программы и завершает работу.

Гол> <> принты 10

Проверено здесь.

#является зеркалом, поэтому IP-адрес сразу пропускается до конца первой строки (и идет влево). 9Можно пренебречь. aтолкает 10, eтолкает 14, "8"толкает код символа 8, @вращает три верхних элемента стека (подтягивает вверх 10), так что nпечатает 10и ;завершает программу.

Спасибо Sp3000 за предложение использовать @вместо !(который сохранил байт).

злые отпечатки 11

Спасибо Sp3000 за то, что он прислал мне несколько командных списков для создания однозначных чисел.

Попробуйте онлайн.

зло игнорирует все, кроме строчных букв, поэтому код выглядит так:

aeeneaeeaww

Кроме того, nвлияет на состояние, в котором мы не заботимся, поэтому давайте проигнорируем это. Теперь aувеличивает регистр (который начинается с 0), и eэто волшебная операция «соткать» зла, которая переставляет биты определенным образом. aeeeaeeaслучается, чтобы привести к значению, 49которое является кодом символа 1. wwпечатает это дважды.

Отпечатки пробелов 12

Попробуйте онлайн.

Хорошо, мы знаем, что Whitespace только читает пробелы, табуляции и переводы строк, поэтому давайте напишем код, который видит Whitespace, с помощью STL:

SSSSSSTTSSLTLST

Это две команды:

SSSSSSTTSSL
TLST

Первый толкает номер 12. Конкретно, SSначинается числовой литерал. Следующим Sявляется знаковый бит (положительный). Тогда все, вплоть до Lдвоичного представления числа. Есть тонна ведущих нулей, которые нам нужны для Звездного, но они не влияют на число. Тогда TTSSs 12в двоичном. Интересный факт: если бы я добавил 16-й язык, я мог бы сохранить здесь байт, потому что Starry мог бы использовать четыре Sв двоичном представлении 16. Я сомневаюсь, что буду, хотя ...

TLSTПросто печатает вершину стека как число. ( TLпомечает команду как команду ввода / вывода и STпечатает числа.)

Отпечатки деления 13

Попробуйте онлайн.

Fission видит только эту часть кода:

           <"31"L

Lначинает управление потоком с левым атомом. "переключает режим печати, так что 31просто печатает 13. Затем атом захватывается в клин <, который завершает программу.

> <> печать 14

Проверено здесь.

Различить> <> и Gol> <> не так просто, как я думал, потому что Gol> <> почти всегда делает то же самое, что и> <> для команд, которые существуют в обоих, и команд, которые существуют только в Gol> < > вызвать> <> сбой. Тем не менее, @вращается в обратном направлении в> <>, так что он толкает вниз 7вместо подтягивания вверх 10, а затем 14печатается вместо вместо 10.

GolfScript печатает 15

Попробуйте онлайн.

Этот #самый простой: комментирует первую строку. Затем 15выдвигает себя и }представляет собой «супер комментарий», который игнорирует всю остальную часть программы. Таким образом, 15это напечатано в конце программы.

Python 1.x, 2.x и 3.x, 32 байта / 3 ^ 3 = 1.1851 ...

import sys
print(sys.version[0])

Печатает первый номер версии, которая находится 1в Python 1.x, 2в Python 2.x и 3в Python 3.x.

К тому времени, как мы получим Python 9.x, мой счет будет великолепным 0.04389!

: ~)!

3 языка, 2 байта / 27 = 0,074

1P

Ну, это бьет половину представлений по крайней мере: P

1. GolfScript

GolfScript игнорирует P, выводя только 1. Попробуйте онлайн .

2. Пар

P2 к власти, так 1P = 2^1 = 2. Попробуйте онлайн .

3. Серьезно

Pдает n-е простое число, индексированное нулями. Мы получаем 3, так как это второе простое число. Попробуйте онлайн .

Примечания

Моей первоначальной целью было найти правильный ответ в 1 байт. Моей первой попыткой было то, \x12что работает в Bubblegum и gs2 , но для этого требуется минимум три языка. \x13будет работать, если есть язык, на котором это выводит 1.

Отказавшись от однобайтового ответа, я перешел на два байта. 3uэто близкий вызов, выводящий 1 в Japt , 3 в GolfScript и 4 в Seriously, но было трудно найти язык, который вывел бы 2, чтобы заполнить пробел.

Все это заняло у меня слишком много времени: /

6 языков - 44 байта / 6 ^ 3 = 0,204 ...

Спасибо SnoringFrog за сохранение 10 байтов!

Работает в:

• Befunge
• Pyth
• Brainfuck
• Hexagony
• Пробелы
• AniRad v0.2

2# "1",@"-[----->+<]>.*@@@!4<SSTST
T
ST
 >6=

Примечание: перед тем, как попробовать онлайн, обязательно замените S пробелами и T на табуляцию или преобразуйте следующий hexdump в ASCII

32 23 20 22 31 22 2c 40 22 2d 5b 2d 2d 2d 2d 2d 3e 2b 3c 5d 3e 2e 2a 40 40 40 21 34 3c 20 20 09 20 09 0d 0a 09 0d 0a 20 09 0d 0a 20 3e 36 3d

Я собираюсь попытаться использовать больше языков программирования :)

Befunge (печать 1):

Попробуйте онлайн

2# "1",@"-[----->+<]>.*@@@!4<
2                             # This puts 2 onto the stack
 #                            # Skips the next op (the space)
   "1"                        # Sets the ASCII value of 1 onto the stack
      ,                       # Pop the last item (1)
       @                      # Terminate program

Пиф (печатает 2):

Попробуйте онлайн

2# "1",@"-[----->+<]>.*@@@!4<
2                             # Prints 2
 #                            # Infinite while loop until an error occurs
   "1"                        # String
      ,@                      # This gives the error and terminates the program

Brainfuck (отпечатки 3):

Попробуйте онлайн

2# "1",@"-[----->+<]>.*@@@!4<
2# "1",@"                     # Since these are not brainfuck ops, these will be ignored
         -[----->+<]>         # Puts "3" on the stack
                     .        # Prints the last item (3)     

Гексагония (отпечатки 4):

Попробуйте онлайн

2# "1",@"-[----->+<]>.*@@@!4<   

Более читаемая версия:

   2 # " 1       # The steps:
  " , @ " -      # 1 (2) - Hexagony starts at the top-left of the hexagon
 [ - - - - -     #       - This immediately puts 2 onto the stack
> + < ] > . *    # 2 (#) - Since the stack is 2, this makes the 2nd pointer the 
 @ @ @ ! 4 <     #       - new current pointer
  > 6 = . .      # 3 (*) - The position of the 2nd pointer is in the left-most
   . . . .       #       - position. This sets the stack to the product
                         - of the two neighbours which is zero
                 # 4 (<) - Changes the pointer direction to west
                 # 5 (4) - Sets the stack to 4
                 # 6 (!) - Outputs the decimal 4
                 # 7 (@) - Terminates the program

Пробелы (отпечатки 5):

Попробуйте онлайн

Так как другие символы игнорируются, кроме пробелов и табуляции, нам остается следующее:

SSTST                 # This pushes 5 onto the stack
T                     # 
ST                    # This prints the decimal

AniRad версия 0.2 (печать 6):

Каким-то образом это работает для версии 0.2, но выдает ошибку для версии 0.4. Понятия не имею почему. Вы можете найти версию 0.2 здесь . Для этого вы можете скопировать и вставить код интерпретатора в repl.it и запустить его. После этого вам нужно только вставить программу в STDIN и запустить ее.

2# "1",@"-[----->+<]>.*@@@!4<      # (#)  Starts at the hashtag (starting point)
                                   #      Direction is down
                                   # (>)  When the pointer gets to the '>', it changes
 >6=                               #      its direction
                                   # (6) Puts 6 onto the stack 
                                   # (=) Pushes the result and terminates

6 7 языков, 32 37 байт, оценка 0,148 ... 37/7 ³ ≈ 0,107872 ...

#7+!"@\"6.@;n5
print(4--int(-3/2)#"
)

Brainfuck-нг

+увеличивает текущую ячейку, !печатает как целое число, @выходит. #и "являются NOP.

Python 2

Первая строка - комментарий. Используя целочисленное деление, вычисляет 4 - -int(-3 / 2) = 4 - -int(-2) = 4 - -(-2) = 4 - 2 = 2и печатает результат.

Python 3

То же, что и предыдущий, но с делением поплавка. 4 - -int(-3 / 2) = 4 - -int(-1.5) = 4 - -(-1) = 4 - 1 = 3,

Lua

--начинается комментарий, а #в первой строке находится комментарий, так что в основном print(4).

> <>

#отражает IP, 5нажимает 5, nпечатает число и ;выходит.

Befunge

#пропускает +, !логически отрицает вершину стека, "@\"толкает строку @\, 6толкает 6, .печатает число и @выходит.

Pyth

#запускает бесконечный цикл, исключая любые ошибки. 7печатает 7, затем следует, +!"string")что в основном вызывает ошибку из-за отсутствия двух операндов для +завершения программы.

JavaC ++ C, 363/27 = 13,4 ....

Java печатает 1, C ++ печатает 2, C печатает 3. Не нарушая здесь никаких записей (потому что Java), но мне действительно нравится умный, оскорбительный способ создания полиглота на этих языках, который я обнаружил.

//\u000a/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*\u002a/
import static java.lang.System.out;
public class P{//*/
/*\u002a/public static void//*/
main(/*\u002a/String[] args//*/
){//\u000a/*
out.print=p;
//\u002a/
out.print(1);}
/*\u002a/}//*/

Это беспорядок. Вот разбивка того, как это работает. Литералы Unicode ( \u000aиначе называемые переводом строки и \u002aиначе *) расширяются компилятором Java в их действительные символы. Итак, вот что видит компилятор Java:

//
/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/**/
import static java.lang.System.out;
public class P{//*/
/**/public static void//*/
main(/**/String[] args//*/
){//
/*
out.print=p;
//*/
out.print(1);}
/**/}//*/

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

Это эквивалентный код Java с удаленными комментариями:

import static java.lang.System.out;
public class P{
public static void
main(String[] args
){
out.print(1);}
}

Вот что видит компилятор C / C ++ (я удалил литералы Unicode, так как они не раскрываются компилятором и поэтому ничего не делают):

///*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*/
import static java.lang.System.out;
public class P{//*/
/*/public static void//*/
main(/*/String[] args//*/
){//\/*
out.print=p;
///
out.print(1);}
/*/}//*/

Здесь однострочные комментарии переопределяют многострочные разделители комментариев в начале, поэтому все #defines и #includeget предварительно обрабатываются. Далее, многострочные комментарии используются для комментирования кода boiletplate для Java. Это эквивалентный код с удаленными комментариями:

#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
main(
){
out.print=p;
out.print(1);}

Стандартный трюк с полиглотом C / C ++ (the #ifdef __cplusplus) используется для определения токена oкак или, "2"или "3", в зависимости от того, компилятор кода - компилятор C ++ или C. Далее мы определяем функцию, pкоторая принимает один (игнорируемый) intаргумент и вызывает printf, используя наш недавно определенный oтокен. Как обычно, возвращаемое значение не учитывается, поскольку мы не в строгом режиме. Далее мы определяем structс одним членом указатель на функцию, чья подпись соответствует ps, и создаем единственный экземпляр с именем out. В основном методе (мы оставляем intкак обычно), адрес pприсваивается out.print(так называемые out.printвызовы p), и он вызывается.

Если бы C ++ не был включен в языки, мы могли бы отбросить весь код препроцессора и определить pкак int p(int a){puts("2");}. К сожалению, C ++ требует #includeввода / вывода. Если C не был включен, мы могли бы отбросить определение pи #ifdefмакрос препроцессора и напрямую определить функцию-член structвместо того, чтобы нуждаться в указателе функции. К сожалению, C не поддерживает функции-члены.

4 языка, 28 байтов / 64 = 0,4375

print((0 and 3^1or 1/2>0)+1)

1. Python 2

0является ложным и /целочисленным делением, так

(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0 > 0) + 1 = False + 1 = 1

2. Perl (также Python 3)

0является ложным и /является делением поплавка, так

(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0.5 > 0) + 1 = 1 + 1 = 2

3. Рубин

0правдиво и ^поразрядно xor, так

(0 and 3^1 or 1/2 > 0) + 1 = xor(3,1) + 1 = 2 + 1 = 3

4. Луа

0является правдой и ^возведением в степень, так

(0 and 3^1 or 1/2 > 0) + 1 = pow(3,1) + 1 = 3 + 1 = 4

Обратите внимание, что Lua и Ruby не могут добавлять логические значения, как если бы они были целыми числами, поэтому их можно объединять в группы. К сожалению 0and, в Lua не работает, поэтому мы не можем сохранить там байт.

Предыдущая 17-байтовая версия, которая печатает 1 (Lua), 2 (Ruby), 3 (Python / Perl):

print(2^(0 or 1))

-3 байта спасибо @xnor за эту версию, что делает ее намного аккуратнее :)

BFSRS> <> funge93thon123, 73/343 ≈ 0.212827 ...

Brainfuck, Серьезно ,> <>, Befunge-93, Python 1, Python 2, Python 3

# 4['.]@kX21z-[>+<-----]>--.<;n3
import sys;print(3+int(sys.version[0]))

Содержит непечатные, hexdump (обратимый с xxd -ps -r):

2320345b272e5d406b5832317a7f2d5b3e2b3c2d2d2d2d2d5d3e2d2d2e3c
3b6e330a696d706f7274207379733b7072696e7428332b696e7428737973
2e76657273696f6e5b305d2929

Я буду добавлять больше языков (и, вероятно, байтов) с течением времени. Языки в заголовке перечислены в порядке их печати. Предполагается 8-битные ячейки обертки и лента, которая не будет жаловаться на то, что она ушла влево от начальной позиции (обтекания или бесконечной) для Brainfuck

Brainfuck:

[.]   initial value of first cell is 0, so loop is skipped
-[>+<-----]>--  push 49 (ASCII ordinal of 1)
.     print "1"
<     move to blank cell
[0]   skip loop because cell is 0
      everything else is ignored

Серьезно :

# 4['.]@  does some stuff we don't care about
kX        pop entire stack, push as list, discard (essentially the same as é, but is ASCII so we can use Python)
2         push 2
1z        pop 1 item from stack and print (used instead of . so Brainfuck doesn't print here; same as ü in this scenario, but is ASCII so we can use Python)
0x7f      terminate program
          everything else is ignored

><>:

#    mirror, reverse direction
3n;  push 3, print "3", end (reversed because IP is scanning RTL at this point)
     everything else is ignored

Befunge-93:

#     jump over the space
4['.] push 4, print 4 (brackets and ' do nothing)
@     end program
      everything else is ignored

Питон 1 (спасибо, мутная рыба):

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+1=5

Python 2 :

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+2=6

Python 3 :

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+3=7

14 языков, 73 байта, оценка = (73/14 ^ 3) = 0,02660349854

#Y2(3`5n~thneo e        ;n@0d c
#   -[>+<"9"L-----]>+.
14  
print(int(15/2))+3

Я могу добавить еще несколько языков, но я думаю, что я добавлю то, что у меня есть здесь.

1. Brainbool ; Попробуйте онлайн!

Соответствующий код:

    [>+<         ]>+.

               + 

Это действительно просто +.+, который выводит 1.

2. Джольф ; Попробуй это здесь!

Символ (перестает интерпретировать исходный код, поэтому соответствующий код:

#Y2

Это эквивалентно (в JavaScript)

var Y = []; toHex(Y); alert(2);

Какие выходы 2.

3. Элемент; Попробуйте онлайн!

Соответствующий код:

    3`

Это захватывает 3и печатает это.

4. Brainfuck ; Попробуйте онлайн!

Соответствующий код:

-[>+<    -----]>+.

  -    -      + 

Что является стандартным способом генерации 4-х символьного кода и его вывода, а также некоторых других вещей после него.

5. Ренг; Попробуй это здесь!

~ завершает программу, поэтому соответствующий код здесь:

#Y2(3`5n~

#Yв этом случае переопределяется как TOS 0. 2толкает 2; (вращает стек N раз, выталкивая N из стека; 3`толкает -3; и наконец, 5nпечатает 5.

6. ЭТА; Попробуйте онлайн!

ETA читает только буквы E, T, A, O, I, N, S, H, поэтому выполняется только следующий код:

       n thneo e         n     


  int int          

Супер-релевантный код:

       n thneo

Или, что то же самое: nthne o. n...eявляется литералом base-7 и thnявляется числом base-7 для 54. oвыводит этот символ. Ошибка представления, но я не знаю почему.

7. Питон 3

Что он видит:

# comment
# comment
14
print(int(15/2))+3

15/2дает 7,5, как /и деление поплавка. int(...)делает число int, которое затем печатается. Ошибка программы при +3обнаружении.

8. Юлия

Юля видит:

# comment
# comment
14
print(int(15/2))+3

Вместо усечения 15/2 Джулия округляет ее, получая 8. Она печатает это, затем выдает ошибки при встрече с +3.

9. Деление; Попробуйте онлайн!

Соответствующий код:

        <"9"L         

Я получил эту идею из части Мартина Fission (больше как украл ее). Lначинается с левой стороны, захватывает 9и заканчивается <.

10. Пробелы; Попробуй это здесь!

Соответствующий код, перевод пробелов в Sи табуляции в T:

SSSTSTS
T
ST

Он помещает 10 в стек и выводит его как число ( T\nST).

11. Питон 2

Python 2 видит это:

# comment
# comment
14
print(int(15/2))+3

(int(15/2))+3 оценивается как 11, и это напечатано.

12. Гол> <>; Попробуй это здесь!

Соответствующий код:

#                      ;n@0d c

Это использует трюк, использованный в ответе Мартина, который @вращает разные направления в> <> и Gol> <>. #зеркала, cтолкает 12, dтолкает 13, 0толкает 0, и @приводит cк вершине стопки, затем выходит наружу и печатается с ;n.

13.> <>; Попробуйте онлайн!

Соответствующий код:

#                      ;n@0d c

Опять же использование этого @вращает разные направления в> <> и Gol> <>. #зеркала, cтолкает 12, dтолкает 13, 0толкает 0, и @приводит dк вершине стопки, затем выходит наружу и печатается с ;n.

14. Гольфскрипт; Попробуйте онлайн!

Что он видит:

# comment
# comment
    14
print(-int(-15/2))+3

Это толкает 14, printS, и ошибки. Украденный вдохновлен ответом Sp3000 .

Subskin , Brainfuck и Fob 27 байтов / 3 ^ 3 = 1

0#>&$3#<>$-[----->+<]>-.
31

Subskin

0
31

Мы устанавливаем указатель инструкции (здесь не имеет значения) 0и регистр вывода в 31. Если содержимое выходного регистра равно >= 0, мы выводим содержащее значение как char. Весь другой код игнорируется.

Brainfuck

-[----->+<]>-.

Добавляет 3в регистр, уменьшает значение один раз с -и, наконец, выводит с ..

надувать

#>&$3#<>$

Это немного сложнее, так как Brainfuck также читает <и >инструкции Fob. Мы входим в режим выполнения с #и увеличиваем указатель Brainfuck на единицу, что облегчает нам позже. Нам пока нечего выполнять, поэтому ничего не выполняется.

Мы входим в режим аккумулятора с помощью $, добавляем a 3, снова входим в режим выполнения, помещаем содержимое аккумулятора в стек с помощью <и, наконец, выводим содержимое с помощью >.

Чтобы Brainfuck не прикоснулся к программе, мы снова входим в режим накопления нажатием $.

7 языков, 55/7 ^ 3 ≈ 0.16035

Работает в PowerShell v1, v2, v3, v4 и v5, Foo и Pyth

#7.q"6""
$p=$PSVersionTable;($p.PSVersion.Major,1)[!$p]

Цифры 1-5 используют аналогичную логику для ответа Свирпотато . $PSVersionTableСпециальная переменная была введена в PowerShell v2, и содержит полный список сборки, ревизии и т.д. Вот пример вывода переменной:

PS C:\Tools\Scripts> $PSVersionTable

Name                           Value                                                                                                                           
----                           -----                               
PSVersion                      4.0
WSManStackVersion              3.0
SerializationVersion           1.1.0.1
CLRVersion                     4.0.30319.34209
BuildVersion                   6.3.9600.17400
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0}
PSRemotingProtocolVersion      2.2

В этом коде мы сначала сохраняем его $pтак, чтобы длина кода была меньше. Затем мы проверяем его существование, используя переменную как индекс в массиве из двух элементов:

• Если переменная не существует, PowerShell динамически создаст ее и назначит ее $NULL, значение !которой равно $TRUEили 1, что соответствует второму элементу в массиве, который выводится 1.
• Если переменная существует (как в случае v2 +), то !переменная приводит к $FALSEили 0, который указывает на первый элемент, который выводит номер версии.

Используя Foo для 6, мы используем этот #комментарий в PowerShell, поэтому он игнорируется при его выполнении в среде PS. Тем не менее, Foo с удовольствием выплюнет номер 6и затем продолжит выполнение остальной части программы, которая ничего не делает.

Используя Pyth для 7, мы возвращаемся 7, а затем немедленно завершаем работу .q, поэтому бесконечный цикл while-true, который начался с, #не имеет значения. Так как у нас есть что-то, что неявно печатается. Спасибо @ FryAmTheEggman за это дополнение.

_{Редактировать - Гольф несколько байтов благодаря Mauris Редактировать - разъяснение Pyth объяснение благодаря Sp3000}

7 языков, 287/7 ^ 3 = 0,836

Вероятно, самый низкий балл, который я получаю, так или иначе, мне нравятся эти 3 версии полиглота C.

Добавлено скучное решение Python, чтобы хотя бы претендовать на награду «3 уникальных» языка.

Добавил Java, использовав триграфы C для разных интерпретаций комментариев.

Работает в:

• Python 1

• Python 2

• Python 3

• C89

• C99

• C ++

• Ява

версия для гольфа:

/*
*??/
/
#include <stdio.h>
#ifndef __cplusplus
#define true 8/*
import sys
print(sys.version[0])
'''
#*??/
/
#endif
int main(){int a=(true>1)?-6:3;printf("%d",(true//*
+a
//**??/
/+2));}
#define a \
'''
/**\u002f
public class p{public static void main(){System.out.println("7");}}
/**/

Ungolfed:

/*
*??/
/

#include <stdio.h>

#ifndef __cplusplus
#define true 8/*

import sys
print(sys.version[0])
'''
#*??/
/
#endif 

int main()
{
    int a = (true > 1) ? -6 : 3;
    printf ("%d", (true//*
    +a
    //**??/
/
    +2));
}
#define a \
'''

/**\u002f
public class p
{
    public static void main()
    {
        System.out.println("7");
    }
}
/**/

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

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

Итак, давайте возьмем первый блок:

/*
*??/
/

Для Java это только начало многострочного комментария. Но ... в C99 / 89 / ++ это оценивается как

/*
*/

Так ??/как это триграф, в \то время как в C \символ является своего рода непротиворечивым и даже использует разрывы строк в своей командной функциональности. Это приводит к тому, что результат « \nпросто отображается» вместо разрыва строки. это означает, что данный байтовый массив, представляющий первый блок: [ /] [ *] [ \n] [ *] [ ?] [ ?] [ /] [ \n] [ /] будет после оценки триграфа: [ /] [ *] [ \n] [ *] [ \] [ \n] [ /] Там, где согласованная функциональность \триггеров и «потребляет», \nоставшиеся и финальные в C langs оцененные байты: [ /] [ *] [ \n] [ *] [ /]

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

(продолжение следует!)

4 языка (Befunge-93, Microscript II, Microscript и Foo), оценка 7/64 = 0,109

"4"1.@2

Предостережение: нажмите 4, нажмите 1, напечатайте 1 и завершите.

Microscript II: создайте строку «4», отбросьте ее, возьмите квадратный корень из одного, отбросьте ее и, наконец, установите x в 2. Затем она будет напечатана неявно.

Microscript: толкнуть 52 в стек (который фактически никогда не будет использоваться для оставшейся части программы), увеличить регистр (изначально ноль) на единицу, затем увеличить регистр на два. Это тогда напечатано неявно.

Foo: выведите строку «4», затем нажмите 2

Python 1 | 2 | 3, 27 байт / 27 = 1

print(len("\xabc")+(1/2>0))

Использование @ sweerpotato номеров версий заставило меня задуматься о том, можно ли отличить Питонов от меньшего. Вот лучшее, что я нашел.

объяснение

Чтобы отличить Python 3 от более ранних версий, мы используем стандартное целочисленное деление против трюка с плавающей запятой. (1/2>0) == (0>0)возвращает 0 до Python 2.3 или Falseначиная с Python 2.3 и далее и (1/2>0) == (0.5>0)возвращает Trueдля Python 3.

Чтобы отличить Python 1 от остальных, мы берем длину строки "\xabc"- длину один в Python 1 и длину два от Python 2 и далее. Почему? Потому что

Экранирование \ x в строковых литералах теперь занимает ровно 2 шестнадцатеричных цифры. Ранее он потреблял все шестнадцатеричные цифры, следующие за «х», и брал 8 младших битов результата, поэтому \ x123456 было эквивалентно \ x56.

(Из того, что нового в Python 2.0 )

Python 3, Ruby, Perl, C, C ++, Objective-C 202 байта / 6 ^ 3 = 0,935 ...

На самом деле это было довольно весело, и много играть с булевыми значениями.

Вы можете просмотреть все версии кода на следующем сайте , скопировав и вставив код в интерпретатор.

#include <stdio.h> /*
print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1
"""""
*/
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}/*
"""
#*/

Python 3, печать 1

Хитрость заключается в следующем:

print ((("0"+"0"==0)and 3) or (0and 2or 1));

Это напечатает 1

Рубин, принты 2

Интерпретированный код для Ruby:

print ((("0"+"0"==0)and 3) or (0and 2or 1));

Так что это печатает 2

Perl, печать 3

Интерпретированный код для Perl:

print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1

Прежде всего, __DATA__токен сообщает компилятору Perl, что компиляция завершена. Все после игнорируется.

print ((("0"+"0"==0)and 3) or (0and 2or 1));

И печатает 3

С, печать 4

Интерпретированный код сильно отличается от других:

#include <stdio.h>
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}

Это просто напечатает символ 4.

C ++, печать 5

Такой же, как код С

Это напечатает символ 5.

Objective-C, печать 6

Такой же, как код С

Это напечатает символ 6.

5 языков, 18 байт / 5 ^ 3 = 0,144

Работает в Brainbool , Mathematica , Foo , > <> и Befunge-93 .

4!<n;+Print@2"3".5

Brainbool

Brainbool похож на Brainfuck, но он работает только с битами, а его вход и выход состоит исключительно из 0и 1.

4!<n;+Print@2"3".5
  <                   move the pointer to the left
     +                logic not
                .     print the current cell

Mathematica

В Mathematica все является выражением и имеет значение. Print@2печатает 2и возвращает символNull . После этого код выполняет некоторые символические вычисления, но ничего не печатает.

Foo

"3" 3. Я не знаю, что делают другие части.

> <>

4!<n;+Print@2"3".5
4                     push 4
 !                    skip the next command
   n                  pop and print it as a number
    ;                 end the program

Befunge

4!<n;+Print@2"3".5
4                     push 4
 !                    logical not
  <                   makes the program counter travel to the right
 !                    logical not
4                     push 4
                 5    push 5
                .     pop and print it as a number
             "3"      push the string "3"
            2         push 2
           @          end the program

Используя трюк со сладким картофелем , дешево, но мощно.

Работает в Brainbool , Mathematica 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 и 10.0 , Foo и > <> .

cn;+"11".Print@Floor@$VersionNumber

6 языков, 38/6 ^ 3 = 0,17592̅5̅9̅

Пробелы , Брейнфук, Рубин, Лабиринт , Фу, Серьезно

Условные обозначения:

£: вкладка

•: пространство

§: 0x7f

puts•2;#4!@•-[>+<-----]>6.§"5"•£    
£
•£

Это содержит непечатаемые символы, поэтому вот hexdump:

7075747320323b23342140202d5b3e2b3c2d2d2d2d2d5d3e362e7f22352220090a090a20090a

Объяснение:

Пробелы

Попробуйте онлайн. (Примечание: моя программа пропускает закрывающие три перевода строки, чтобы завершить программу, я написал / протестировал это на Whitelips, и это дает правильный вывод там, но не на Try It Online, поэтому в связанной программе эти два символа добавлены. как я могу сказать, некоторые интерпретаторы позволяют вам это делать, другие застревают в бесконечном цикле без явного завершения)

(без учета игнорируемых символов)

spacespacespacetabenter: вставьте 1 в стек

tabenterspacetab: вывести вершину стека

Рубин

Не нужно объяснять. Prints 2, обрабатывает оставшуюся часть этой строки (ergo, программа brainfuck) как комментарий, рассматривает остальную часть файла как пустую.

Brainfuck

Попробуйте онлайн.

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

Лабиринт

Попробуйте онлайн.

(пропуская последние две строки для удобочитаемости, потому что они никогда не достигаются)

puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•                            skipped
     2                           push 2 onto stack
      ;                          pop 2 from stack
       #                         push current stack depth (0) to stack
        4                        push 4 to stack
         !                       print top of stack as integer
          @                      program terminates

Foo

Попробуйте онлайн.

Единственное, что влияет на вывод, это «5», который печатает 5.

Шутки в сторону

Попробуйте онлайн.

puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•2;#4!@ -[>+<-----]>           assorted stack manipulation that doesn't affect this program
                        6          push 6 to the stack
                         .         output top of the stack
                          §        (0x7f) terminate program

5 языков, Chaîne , Minkolang , Foo , Brainf ** к-нг и Vitsy , 21/5 ^ 3 = 0,168

2|<«+!@"3".N+m

5N»

Brainf ** к-нг

2|<«+!@"3".N+m

5N»
  <            go left (should still be ok)
    +!         output 1
      @        halt execution

Chaîne

2|<«+!@"3".N+m

5N»
2              «add 2 to the current string»
 |<            «take off and put on the string (no op)»
   «           «comment»

  »
               «implicit output»

Foo

2|<«+!@"3".N+m

5N»
       "3"     print three

Minkolang

2|<«+!@"3".N+m

5N»
2              C push 2 to the stack [2] C
 |             C mirror C
2              C push 2 to the stack [2,2] C
             m C ignored C
            +  C add top two [4] C
           N   C output C
          .    C terminate program C

Vitsy

2|<«+!@"3".N+m

5N»
2              push 2
 |             mirror
2              push 2
             m pop 2, goto line 2
5              push 5
 N             output 5
  »            ignored

Я, вероятно, могу добавить> <> или что-то.

Craneflak , Brain-Flak Classic , Rain-Flak , BrainHack , Brain-Flueue , Miniflak , miniHack : .1020

(([]()()()<()()()>)()()){}#{}({}())

Попробуйте онлайн!

объяснение

Первое, что здесь происходит, заключается в том, что существует разница в способе чтения комментариев между интерпретаторами BrainHack, CraneFlak и Rain-Flak. Craneflak не имеет комментариев, в Rain-Flak #комментирует остальную часть строки, а в BrainHack #{...}- внутренности.

Итак, вот что читает каждый язык:

Rain-Flak: (([]()()()<()()()>)()()){}         -> 3
BrainHack: (([]()()()<()()()>)()()){}({}())   -> 4
Craneflak: (([]()()()<()()()>)()()){}{}({}()) -> 1

Следующее - это разница между мозговыми мозгами и минифлаками. И Rain-Flak, и BrainHack поддерживают минифлаки, где все лишние операции просто удаляются. Это означает, что они теряют []и<...>

Rain-Flak: (()()()()()())         -> 6
BrainHack: (()()()()()())({}())   -> 7

Далее у нас есть разница между Brain-Flak и Brain-Flak Classic. В Классике []есть-1 вместо высоты дымовой трубы, а это значит , что наш результат 1 меньше , чем в обычном Дожде-Flak, что делает его 2.

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

Млечный Путь 1.0.2 , CJam и STXTRM , 20 байтов / 3 ^ 3 = 0,741

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

'2"3""1"1<<1>;;"2"3;

объяснение

Млечный Путь ,1

В Млечном Пути строки обозначаются только парами двойных кавычек. Одиночная кавычка читает ввод из командной строки; если его нет, он выдвигает пустую строку. Знаки больше чем и меньше повернут весь стек вправо и влево соответственно. Наконец, точка с запятой заменяет два верхних элемента стека.

Вот визуализация стека (показанный стек является результатом перечисленной операции после того, как она произошла):

["", 0]                                             #  default stack

["", 0, ""]                                 #   '   #  read input from command line
["", 0, "", 2]                              #   2   #  push 2 to the stack
["", 0, "", 2, "3"]                         #  "3"  #  push "3" to the stack
["", 0, "", 2, "3", "1"]                    #  "1"  #  push "1" to the stack
["", 0, "", 2, "3", "1", 1]                 #   1   #  push 1 to the stack
[0, "", 2, "3", "1", 1, ""]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0, 1]              #   1   #  push 1 to the stack
[1, "", 2, "3", "1", 1, "", 0]              #   >   #  rotate the stack rightward
[1, "", 2, "3", "1", 1, 0, ""]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0, "", 2]       #  "2"  #  push 2 to the stack
[1, "", 2, "3", "1", 1, "", 0, "", 2, "3"]  #   3   #  push "3" to the stack
[1, "", 2, "3", "1", 1, "", 0, "", "3", 2]  #   ;   #  swap the top two stack elements

CJam ,2

В CJam строки также обозначаются двойными кавычками. Одиночная кавычка выдвигает код символа следующего символа. Когда код символа выводится, он выводится как соответствующий ему символ. Знаки «больше» и «меньше» действуют как ожидалось, оценивая порядок двух верхних элементов стека. Наконец, точка с запятой отбрасывает верхний элемент стека. По завершении программы содержимое стека выводится.

Вот визуализация стека (показанный стек является результатом перечисленной операции после того, как она произошла):

[]                         #  default stack

['2]               #  '2   #  push the character code of "2" to the stack
['2, "3"]          #  "3"  #  push "3" to the stack
['2, "3", "1"]     #  "1"  #  push "1" to the stack
['2, "3", "1", 1]  #   1   #  push 1 to the stack
['2, "3", "1"]     #   <   #  leave the greater of the top two stack elements on the stack
['2, 0]            #   <   #  leave the greater of the top two stack elements on the stack
['2, 0, 1]         #   1   #  push 1 to the stack
['2, 1]            #   >   #  leave the lesser of the top two stack elements on the stack
['2]               #   ;   #  pop the top stack value
[]                 #   ;   #  pop the top stack value
['2]               #  "2"  #  push the character code of "2" to the stack
['2, "3"]          #   3   #  push "3" to the stack
['2]               #   ;   #  pop the top stack item

STXTRM ,3

В MSM все, что не является оператором, помещается в стек как символ. Точка с запятой дублирует верхний элемент стека. Программа продолжается до тех пор, пока не останется больше операторов или пока в стеке не будет одного элемента.

Последний символ в стеке 3, который дублируется последним оператором. 3это самый верхний элемент в конце программы, поэтому он выводится.

5 языков, 18 байтов / 5 ^ 3 = 0,144

Уроборос , Пип , QBasic, Foo и Pyth

5'"4"()"
1?3'@n()2

1. Уроборос

Каждая строчка программы представляет собой змею, которая ест свой хвост.

Змея 1

Push 5, 'это неоперация, push 52(код ASCII "4"). (заставляет змею сунуть число и съесть столько символов своего хвоста. Так как это приводит к проглатыванию указателя инструкции (и всей змеи), выполнение останавливается.

Змея 2

Нажмите 1, нажмите случайное число ( ?), нажмите 3, 'это не работает. @поворачивает 1верхнюю часть стека и nвыводит его как число, оставляя 3верхнюю часть стека. Затем (съедает столько символов с конца змеи, проглатывая указатель инструкций и останавливаясь.

Вы можете запустить эту программу онлайн в интерпретаторе Stack Snippet здесь .

2. Пип

Большая часть программы состоит из выражений, которые оцениваются и отбрасываются:

• 5
• '" (буквальный символ)
• 4
• "()"
• 1?3'@ (троичное выражение)
• n (переменная, = новая строка)
• () (Ноль)

Наконец, последнее выражение, 2печатается.

3. QBasic

Все после 'является комментарием. Первая строка, таким образом, сводится к 5номеру строки. Во второй строке 1номер строки и ?3ярлык для PRINT 3.

^{(Очевидно, что номера строк не по порядку не проблема, хотя было бы легко исправить, если бы это было.)}

4. Фу

Почти все бездействует. "4"отпечатки 4. Круглые скобки (x2) представляют собой цикл, который выполняется до тех пор, пока текущая ячейка массива не станет равной нулю, что является истинным значением немедленно и цикл завершается. @, если за ним не следует число, принимает значение текущей ячейки массива (инициализируется до 0) и помещает его в стек.

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

5. Пиф

5это выход. Затем программа встречается '"4", которая пытается прочитать из файла с именем 4. Пока такого файла не существует, я думаю, что это должно завершить программу с ошибкой. (В онлайн-версии написано: « name 'open' is not definedЯ предполагаю, что открытие файлов в Интернете запрещено».)

Стрела "в конце строки 1 гарантирует, что строка 2 не вызовет синтаксическую ошибку перед выполнением.

4 языка, 24 байта, 24/4 ^ 3 = 0,375

print(1//0.5--1+1/2*2
);

1. PHP

PHP выполняет, print(1);который равен 1

2. Луа

Lua выполняет, print(1//0.5);который равен 2

3. Python 2

Python 2 выполняется, print(1//0.5--1+1/2*2);что равно 3 (целочисленное деление)

4. Питон 3

Python 3 выполняет print(1//0.5--1+1/2*2);что равняется 4 (деление поплавка)

Brainfuck-ng, Foo,> <>, 9 байт / 3 ^ 3 = 0,333 ...

#+!"2";n3

Brainfuck-нг

Единственные персонажи он признает это +и !:

+ Increment cell by one
! Print as integer

Печать 1

Foo

Печатает все в кавычках.

"2"

Печать 2

> <>

#Зеркально отображает точку слева, 3помещает 3 в стек, nвыводит его как целое число, ;останавливает программу.

#      ;n3

3 языка, 82 83/3 ^ 3 = 3,074 ...

Работает в ??? , Пробел и битник . Вернее, он должен работать на этих языках, но я не смогу протестировать их в течение нескольких дней. Во всяком случае, вот код:

K... Jax... Jy... Jy...   ...
My...    My...
... ...     ......................XO!

1. ???

.................................................!

??? в основном брейкфак, но он использует обычные знаки препинания в качестве команд вместо традиционных символов. .увеличивает текущую ячейку памяти, что делается 49 раз. !принимает текущую ячейку памяти и выводит его как символ, здесь 1.

2. Пробелы

[Space][Space][Space][Tab][Line Feed]
[Tab][Line Feed]
[Space][Tab]

Пробел - это язык, который игнорирует все непробельные символы. Здесь я преобразовал это в легко читаемую форму. Первая строка помещается 2в стек, а вторые две строки здесь печатают верхнюю часть стопки как число 2.
Обратите внимание, что в объединенном коде я заменил вкладки четырьмя пробелами из-за технических ограничений.

3. Битник

K Jax
Jy Jy
My My
XO

Beatnik - это язык, в котором каждое слово конвертируется в его оценку по скрэбблу, тогда эти оценки интерпретируются как команды. Первая строка помещается 17в стек. Вторая строка дублирует вершину стека дважды, а третья строка добавляет вершину к элементам стека дважды, эффективно увеличивая 17в три раза 51. Последняя строка печатает символ на вершине стека, здесь 3.
Обратите внимание, что я использую Beatnik по номинальной стоимости, предполагая, что в исходной спецификации Beatnik нет ошибок. Также обратите внимание, что я использую североамериканскую систему оценки английского скрэббла.

Если сейчас это неясно, каждый из этих языков принимает только определенный тип символов (знаки препинания, пробелы и буквы соответственно), поэтому написание этого полиглота было так же просто, как написание отдельных программ. Единственный реальный трюк - использование пробельного кода для отделения слов от битника. Кроме того, отдельные программы не перекрываются вообще.

5 языков, 175/5 ^ 3 = 1,4

Я решил опубликовать другой ответ, так как щедрость изменяет требования таким образом, что я чувствую себя неуверенно с моим первым ответом (но который все еще удовлетворяет меня на пути общего вызова!)

Итак, вот мое решение, которое подходит для конкурса щедрости:

Компилируется в

• C99
• objC90
• C ++ 0x
• Рубин
• Perl

#if __cplusplus
#define x\
=begin\
=pod
#endif
int a=
#ifndef x
1//**/
+1
#else
3
#endif
;int main(){printf("%d",a);}
#ifdef f
=end
puts 5;
=begin
=cut
print"4";
=end
#endif

3 языка, 15 байтов, оценка 0,555 ...

Позже добавлю больше языков.

2//1+1#😅😨

1. Эмотиномикон

Emotinomicon в значительной степени игнорирует любой текст, который не является строкой. 😅толкает 1 к стеку и 😨выводит TOS как число.

2. Javascript

Комментарии в Javascript начинаются с //, поэтому выполняется только 2часть.

3. Python 2/3 REPL

Комментарии в Python начинаются с #, поэтому выполняется только 2//1+1часть. //является целочисленным делением в Python 3, и оно такое же, как /в Python 2. 2, деленное на 1, равно 2, плюс 1 - это 3.

4 языка, 97 байт, 0.37890625

s="1";s=~-3;2//2;'''/.to_s.ord;"=;print 4;
__DATA__
=1;
";#'''#";print=s=>console.log(3)
print(s)

Рубин

Это устанавливает sдля "1", сопоставляется с использованием =~против -3в пустом контексте, пытается разделить 2на /2;'''/.to_s.ordто начинает новую строку , содержащую =;print 4; __DATA__ =1;, ударяется комментарий, то prints , sкоторый до сих пор 1.

питон

Наборы sдо , "1"как указано выше, а затем устанавливает его снова ~-3который 2. Мы выполняем целочисленное деление 2//2, затем есть строка документации /.to_s.ord;"=;print 4; __DATA__ =1; ";#, за которой следует комментарий, наконец, printing s, который все еще 2.

JavaScript

Наборы sдля "1"затем устанавливает его снова , ~-3как указано выше, то есть 2на линии с последующим комментарием. Затем мы устанавливаем переменную __DATA__в 1. Есть короткая строка, содержащая ;#'''#определение функции, printкоторая жестко закодирует вывод в 3, который вызывается на следующей строке.

Perl

Запускает замену, эквивалентную s/"1";s/~-3;2\/\/2;'''\/.to_s.ord;"/, prints, 4а остальная часть строки маскируется за __DATA__идентификатором.

QBasic, QBIC и> <>, 18 байт / 3 ^ 3 языка = 0,66666 балла

1:?v+1'-5`
''`>3n;

Сломать:

1. QBasic ( получить IDE )

1:          Line number 1
  ?         Print
   v+1      undefined var v = 0 + 1 = 1
'-5`        The rest of theis code is a QBasic comment
''`>3n;     As is this

2. QBIC ( получить переводчика )

1     inserts a 1 in the code - mostly harmless
:     Reads from the cmd line. Nothing there, creates an empty variable a
?     Print
v+1   v is initialised to 6, +1 = 7
'     Code Literal: everything till the ` is passed to QBasic without processing
 -5`  7-5 = 2

''`>3n; Code literal with the first literal being a ': comment in QBasic

3.> <> ( попробуйте онлайн )

1:  Push a 1 on the stack, duplicate stack
?   Pop top off the stack and skip next instruction if that's a 0
v   Move downwards - rest of the line is ignored

>   move to the right
3   Push 3 onto the stack
n   Print the top of the stack as a number
;   End the program

JavaScript, HTML и PHP, 72 байта / 3 ^ 3 = 2,67

1<!top?2:2//><!--<?='--'.'><script>document.body.innerHTML=3</script>'?>

В HTML это выведет первую 1, игнорируя <!window?2:2//> тег, а остальное - HTML-комментарий.

В JavaScript он оценивает 1<!window?2:2и выводит 2 (это нужно запустить в консоли), а остальное - комментарий.

В PHP следующее выводится с сервера: 1<!top?2:2//><!----><script>document.body.innerHTML=3</script>заменяющий языка HTML 1с 3.