Как некоторые из вас могут знать, чтобы получить язык от замечательного Денниса, попробуйте онлайн! Привет, Мир! Программа обязательна. Недавно Деннис предложил способ загрузки этих программ с веб-сайта. Вот JSON пастбина символов, используемых в этих программах, по частоте, по состоянию на 27 июля 2017 года.

Некоторым из этих персонажей нужна любовь, поэтому ваша задача - вывести Hello, World! (желательно на языке, участвующем в этом процессе), используя только символы, указанные ниже. Эти персонажи - все персонажи, используемые между 10и 99(включительно) временем, вместе с двумя наиболее распространенными персонажами, 0и , потому что я чувствую себя хорошо.

0 $&*?ABCDEFGIJKLNPQRSTUXYZ\`gjkqwxyz{}÷≤≥=║_

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

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

Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.

JSFiddle для проверки правильности вашего ответа

SOGL V0.12 , 89 75 68 байтов

z{}xxxx≥x≥x≥xXUqXxq≤qq≤q *R_IIRq  q *R_I0II*IRqxXq≤qxqxq CR_0II÷Rq0*

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

Пояснение (устарело, изменилось то, что буква «H» печатается с использованием букв алфавита):

 $             push "$"
  R_           convert to an array of ordinals, then push all the contents to the stack
    0II        push 0+1+1 = 2
       *       multiply by that
        R      convert to character
         q     output
          z    push the lowercase alphabet
           {}  iterate over it, pushing each char, and do nothing. Stack: ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
stack manipulation:
 xxxx ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r"]
 ≥    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q"]
 x    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o"]
 ≥    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n"]
 x    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l"]
 ≥    ["l","o","r","H","a","b","c","d","e","f","g","h","i","j","k"]
 xxx  ["l","o","r","H","a","b","c","d","e"]
 q    output the "e"
 ≤    ["o","r","H","a","b","c","d","e","l"]
 qq   output the "l" twice
 ≤    ["r","H","a","b","c","d","e","l","o"]
 q    output the "o"

*                       push "*",
 R_                     convert to an array of ordinals, then push all to stack
   II                   increase by 2
     R                  convert back to character
      q                 output
         q              push a space, then output
           *            push "*"
            R_          convert to an array of ordinals, then push all to stack
              I         increase that
               0II      push 0+1+1 = 2
                  *     multiply
                   I    increase
                    Rq  output as character
stack manipulation: (starting stack: ["r","H","a","b","c","d","e","l","o",","," ","W"])
 x  ["r","H","a","b","c","d","e","l","o",","]
 X  ["r","H","a","b","c","d","e","l","o"]
 q  output the "o"
 ≤  ["H","a","b","c","d","e","l","o","r"]
 q  output the "r"
 x  ["H","a","b","c","d","e","l"]
 q  output the "l"
 x  ["H","a","b","c","d"]
 q  output the "d"

C            push "C"
 R_          convert to ordinal as before
   0II÷      floor divide by 2
       Rq    output as character
         0*  multiply by 0 so nothing extra would be outputted

Интересный факт: все символы из разрешенных символов находятся в кодовой странице SOGL: D

Perl 5 , 76 байт

}{${$_=$`x?B?}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}=$_=\*G

При этом используется функция, которая устарела, но работает локально в моем терминале (как указано, в версии 5.18.2). В более старых версиях Perl ?\w?- это синоним, /\w/который дает мне доступ к соответствию регулярному выражению, и у меня достаточно символов для $&(последнее совпадение) и $`(текст, предшествующий последнему совпадению). Мне нужно это, чтобы иметь возможность получить O. Я генерирую это, создавая globссылку ( $_=\*Gкоторая, приведенная к скаляру, является чем-то вродеGLOB(0x7ffb728028d0) ). После того $_, как это ?B?будет , будет соответствовать Bи $`будет содержать GLO, я могу затем сопоставить с \w$которым будет хранить Oв$&который вставляется в строки, которые я запускаю по строкам - И чтобы создать остальную часть текста, тело строки используется в нижнем регистре \L.

Попробуйте онлайн! - использует /\w/вместо того, ?\w?чтобы версия Perl на TIO была слишком новой.

Perl 5 , 65 байт

Это немного более обманчиво, поскольку оно опирается на имя файла на TIO (то есть .code.tio), так что я не думаю, что это конкурирует, но я был доволен результатом!

}{${$_=$0}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}

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

Одинарный , 7 * 10 ¹⁸² байта

Унарный - это Brainfuck, преобразованный в двоичный, преобразованный в унарный с использованием 0в качестве счетчика. По сути, он конденсирует программу Brainfuck в число, и на выходе получается это число 0s. Обычно это очень большие программы.

Я не буду вставлять программу здесь, потому что я не знаю, сколько текста позволяет SE, но держу пари, что это меньше, чем это. Вместо этого я вставлю точное число нулей в этот ответ:

708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556

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

05AB1E , 137 106 95 байтов

X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B

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

-31 спасибо @Adnan за указание на то, что я могу использовать базу 108.

- ?? спасибо @Riley за то, что он указал на некоторые вещи неправильно.

Старая версия (другой метод):

05AB1E , 211 186 166 байт

0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B

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

Ха-ха! И ЗДЕСЬ Я ДУМАЛ, ЧТО ЭСОЛАНГ НЕ ОСТАЕТСЯ НЕДОРОГОНЫМ ШАНСОМ!

Сначала мы получаем 255 в X:

00g               # Push 2 (length of 00).
   00000g         # Push 5 (length of 00000).
         00000g   # Push 5.
               JU # Join to 255 and store in X.

Затем, используя тот же трюк длины, мы нажимаем: 1296995323340359595058728869715

0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ

Где мы просто используем 0<space>вместо трюка длины для нулей.

Затем, наконец, мы передаем 255, которые мы сохранили, и конвертируем из 255 в базу 10 :

X  # Push stored 255.
 B # Convert to base 255.

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

Битник , 148 байт

K QQQQQQQG ZD XA K QQJA KD ZD XA K KG KD ZD ZD ZD XA XA K B KD ZD XA K QQQQF ZD ZD XA K QQQD XA K A Z KD XA ZD XA K B KD XA ZD XA K J Z XA K QQQB XA

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

объяснение

Битник основывает инструкцию, выполненную на основе оценки слова «скраббл». Вот сокращенное объяснение:

Code         Scrabble Score   Explanation

K            5                push the scrabble score of the next word
QQQQQQQG     72               72 ['H']
ZD           12               pop a value; push it back twice
XA           9                pop a value; print its ASCII character
KD           7                pop two values; push their sum
Z            10               pop two values; push their difference

Moorhens (v2.0), 3423 983 923 866 749 716 bytes

Я думаю, что это может быть немного в гольфе, Moorhens не простой язык для работы.

xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU KA AA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU KA KA xU xU xU AA AA AA AA AA KA xU AA KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU KA XI XI XI XI XI XI KA XI XI XI XI XI XI XI XI AA AA AA AA AA AA AA AA AA AA AA AA

объяснение

Moorhens - это язык, основанный на словарных словах. Каждое слово соответствует операции, основанной на его хеше. Пять операций , используемые здесь xU, ER, XI, KA, иAA

• xU увеличивает TOS
• ER помещает новый ноль в стек.
• XI уменьшает TOS
• KA дублирует TOS
• AA скатывает TOS на дно

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

Glypho , 480 байт

AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB

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

Headsecks , 78 байтов

yyzyzzxNxNzx{yyy{y{y{yzzz_{_zzyy\zxxxxxx\zzy\\zz\zx\{{\{{\zzz\xxx\{{\{{y\zzzx\

Двойной JavaScript, 318 байт

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

`\`\\x${0xA*0xA&0xC}${0xA&0xC}\\x${0xA*0xF&0xF}${0xB*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}F\\x${0xE*0xF&0xF}C\\x${0xE*0xF&0xF}${0}\\x${0xB*0xF&0xF}${0xB*0xB*0xF&0xF}\\x${0xA*0xF&0xF}F\\x${0xB*0xB*0xF&0xF}${0xE*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}${0xA*0xA&0xC}\\x${0xE*0xF&0xF}${0**0}\``

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

Оценивает:

`\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21`

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

Который оценивает Hello, World!

Smallf ** k , 266 байт:

zJ$NJ`ZZx*gQYQQ{zqyKKUkUR?AS`zB`JB&UCKCIxQ_G0*000FzzJ&?YwkC\qqgZ`xYQyC}DgY_&_S}KPZ\&?SGAE&{Gw_w} GAgA{qT{gC&`qI?xwCNQwgR}?{*QEwQUj&BT&jR__IJJIqUqAPF0yICXESL?AYR QIAFU& yYwE&$\Njj B0T*F j$?kCzQk*}U}UgI$}Ew_yDL`qYI*E_G}SCjXDFNJKGNIGyIwA\BzLP`*zCILGCNqyYZyq? GwN{q{gKSj

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

Пайк , 133 144 байта

? BXKKKKRKRKRK\CkJ00q}}}XEjTX}G_E\E\L\LkJjRT}}XRGREkJjR 00q}R? B_RE\ \wkJjRT}}XRGRE\R\L\DkJjRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJjRT}}RG_RE00q}}RAA

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

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

? BXKKKKRKRKRK\CkJ - ".C" - A string that when evaled, gets the character at the point
00q}}}XEj - Construct 64 by doing `((0==0)*2*2*2)**2` and then eval, getting the "@" character and store it in `j`
TX}G_E - Get "h" using `@` by looking it up in the alphabet
\E\L\LkJ - "hELL"
jRT}}XRGREkJ - "hELLo"
jR 00q}R? B_RE  - ","
\ \wkJ - "hELLo, w"
jRT}}XRGRE\R\L\DkJ - "hELLo, woRLD"
jRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJ - "hELLo, woRLD!"
jRT}}RG_RE00q}}RAA - "Hello, World!"

постоянный ток , 164 162 байта

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzS zzS?zzzzzzzzzzzzS$zzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzzzzzzzzzzzzzzzSwzzzzzzzzzzzzzzzPzzzzzzzzSLzPzPzzzzPL$PL PLwPzPzzzzPLLPAI*PL?P

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

Там, вероятно, лучше / более интересный подход. Я попытался использовать трюк ASCII + 256, который dcимеет, но он также выводит дополнительные символы (даже если они не печатаются), и как только я получил «o», чудесно простое число 111, я столкнулся с проблемой, даже получив значение 111+ (кратное 256), которое учитывается чисто. Итак, вот довольно простое (хотя и по возможности, гольф) решение:

In dc, zэто команда, которая помещает глубину стека в стек. Это означает, что мы можем использовать это как приращение. Вот как я создаю большинство своих значений ASCII для этой задачи (напечатанных с помощью P), которые я нажимаю на именованные стеки с помощью Sи возвращаюсь в основной стек с помощью L.

dcпозволяет использовать шестнадцатеричные значения AF, даже если основание ввода десятичное (по умолчанию). К счастью, наша первая буква, 72, кратна 12, поэтому я сохраняю здесь один или два байта, умножая 6 * 12 и печатая немедленно ( zzzzzzzC*P). Моя 164-байтовая версия использовала умножение на ранней стадии, чтобы получить 72 ('H'), который был слегка умным, но пережитком предыдущей попытки и пустой тратой байтов. Теперь я начинаю с увеличения и сохранения пробела, восклицательного знака и запятой, которые вышли из строя и поэтому еще не могут быть напечатаны. Затем я подхожу к букве «H», которую я печатаю немедленно, прежде чем я доберусь до «W», которую я должен сохранить на потом.

Я просто печатаю, когда нажимаю «е», затем увеличиваю до «л». Я печатаю два из них и сохраняю один. Когда я делаю это «о», я сначала подумал , что я должен спасти один из тех , на потом, но все вроде в порядке в этой точке. Я печатаю 'o', получаю запятую, пробел и 'W' из ранее, и теперь я снова возвращаюсь к 'o'. Я печатаю это и увеличиваю несколько до наивысшего необходимого значения, «r» (114), которое я печатаю перед загрузкой и печатью «l», которое я спрятал ранее.

Почти сделано! «d» - это значение ASCII 100, которое легко получается умножением на 10 * 10 (меньше байтов, чем при сохранении его ранее и загрузке сейчас). Шестнадцатеричное значение Aравно 10, как и наш входной радиус, который мы можем получить с помощью команды I. Умножьте их, напечатайте, а затем загрузите и напечатайте наш восклицательный знак из ранее. Привет, мир!