Напишите программу, которая не требует ввода и печатает Hello, World!на стандартный вывод или ближайшую альтернативу вашего языка. Подвох в том, что каждая строка в вашей программе должна содержать только печатные символы ASCII и должна быть в лексикографическом порядке, или отсортирована.

Вот все 95 печатных символов ASCII по порядку:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Так, например, строка !!A0~будет недействительной, потому что Aи 0не в порядке. Линия !!0A~будет действительной.

Каждая строка в вашей программе может быть любой длины и может содержать любое количество строк. Пустые строки считаются отсортированными. Каждый из новых строк в вашей программе должен быть одинаковым (без микширования \nи \r\n). Вкладки и другие непечатаемые символы ASCII запрещены.

Из-за популярного спроса условие выигрыша было изменено: выигрывает
подача с наименьшим количеством строк . Tiebreaker переходит к самой короткой программе (переводы строк считаются как одиночные символы).

Только Hello, World! и дополнительный конечный перевод строки должен быть выведен. Обратите внимание, что HQ9 + недопустим, поскольку он выводит hello, world. Я могу запретить языки, похожие на HQ9 +, которые имеют один символ "Hello, World!" Команды из-за их тривиальности.

Подсказка:

Это, безусловно , возможно , в унарный и Lenguage , хотя и не очень сжато.

Наушники , 1 строка, 366 байт

                                                                        $(((((((((((((((((((((((((((((,000000044888<AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIIIIIIIIIIIILPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPTXXXXXXXXXXXXXXXXXXXXXXXX\```diiiiiilqqqqqqqqtyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy|

Headsecks - тривиальная замена Brainfuck, где единственное, что имеет значение, это кодовая точка по модулю 8. Эквивалент Brainfuck - это просто

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.-------------------------------------------------------------------.

К счастью, это наивный подход просто подходит. Есть некоторый потенциал для игры в гольф, но это может быть сложно.

Протестировано с использованием этого интерпретатора Python .

Генерация кода

code = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.-------------------------------------------------------------------."
command_map = "+-<>.,[]"

last_point = 32
out = []

for char in code:
    curr_mod = command_map.index(char)
    last_mod = last_point % 8

    if curr_mod > last_mod:
        last_point += curr_mod - last_mod

    elif curr_mod < last_mod:
        last_point += (8 - last_mod) + curr_mod

    out.append(chr(last_point))

print("".join(out))

/// , 7 строк, 22 байта

/
//Hello
,
 Wor
l
d
!

Редкий шанс для /// быть конкурентоспособным (ну, пока никто не начинает с Унарного и Ленгуагского ...).

Код сначала встречает /и анализирует

/
//

как инструкция замещения, которая удаляет все новые строки из оставшейся части программы. После этого программа просто читает

Hello, World!

который печатается дословно, так как не содержит никаких дополнительных слешей.

JavaScript (67 66 62 строки, 227 269 ​​байт)

(Примечание: тестируется только на Firefox 36 и Safari 8, содержит незначительные функции ES6 ( Setкласс))

Z
=
!""+
(0[[]]
+
(
!!""+Set
));c
=Z[~
-22]
$=Z[
3]
$$=Z[
15]
$$$=Z[
24]
$$$$=Z[
1]
$$$$$=Z[
0]
Set
[c
+
$$$+Z[
5]
+Z[
16]
+
$$$$$+
$$$$+Z[
2]
+c
+
$$$$$+
$$$+
$$$$]
(Z[
14]
+
$$+
$+
$$$$+
$$$$$+
"(\
'H\
"+
$+
$$+
$$+
$$$+
",\
 W\
"+
$$$+
$$$$+
$$+Z[
6]
+
"\
!')\
")
()

Код выше в основном делает:

alert("Hello, World!")

Очевидно alert, не сортируется. Таким образом, вместо этого нам нужно сгенерировать оператор в виде строки и «вычислить» его:

s = "alert('Hello, World!')";   // generate this using sorted code
eval(s)

Как сгенерировать строку? ES5 поддерживает продолжение линии, так что

"AL\
ERT" === "ALERT"

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

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

t e r a o l d

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

t, e, r ← true      = !""
a, l    ← false     = !!""
o       ← function  = Set
d       ← undefined = 0[[]]

Как мы оцениваем строку? Конечно, мы не можем использовать, так eval(s)как он не отсортирован. В качестве альтернативы мы могли бы использовать Function(s)(), но мы не можем использовать, Functionпоскольку он также не отсортирован. Тем не менее, Functionявляется конструктором всех функций, что означает Set.constructor === Function.

Добавление идентификатора constructorделает список строчных букв:

t e r a o l d c u n s

который, к счастью, все еще может быть создан "truefalseundefinedfunction":

t, e, r, u ← true      = !""
a, l, s    ← false     = !!""
o, c, n    ← function  = Set
d          ← undefined = 0[[]]

После предварительного кодирования приведенный выше код должен выглядеть так:

// lines 1~8 defines our string containing all lowercase letters we want
Z = true + (undefined + (false + Set))
// Z = "trueundefinedfalsefunction Set() { [native code] }"

// lines 8~20 defines the variables `c`, `$` (e), `$$` (l), `$$$` (o), 
// `$$$$` (r), `$$$$$` (t)
// for the corresponding lowercase letters extracted from `Z`

// the rest calls:
Set["constructor"]("alert('Hello, World')")()
// lines 22~36 generates the "constructor" string
// lines 37~61 generates the "alert('Hello, World')" string

Обновление: Переименовано E, L, O, R, Tк различным повторению , $чтобы уменьшить 4 линии.

Бессонница , 4 строки, 59 байт

 FFFFGjnnnnooty
FLLddeejkopqyyyyy~~
(<ddjnoppppqrtu
<<Fddfj

Эта программа генерируется путем оптимизации количества строк.

10 строк, 43 байта

(u
pt
(dppty
p~
j
<Fptt{
(otz
?o
FLu
<?FFu~

Данная программа генерируется путем оптимизации количества байтов.

Cygwin bash, 16 строк, 60 байтов

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

A\
=Hello
A\
+=\
",
"Wor
A\
+=l
A\
+=d
A\
+=\
!
E\
CHO\
 $A

Обратите внимание на это ECHOв конце.

> <> , 6 строк, 111 байт

  """""""/;;Hello
        &\o
      &++\oooo~~
"++++++++\bbbdlr
    +++++\ccccccccfooo}
    $++66\cfffffooooopr

У меня проблемы с игрой в гольф на дополнительной линии, но в любом случае я счастлив, что победил метод с 7 линиями.

объяснение

> <> - это основанный на стеке двумерный язык, где инструкции представляют собой одиночные символы, и поток программ может быть вверх, вниз, влево или вправо. "Инструкция переключает строки синтаксический, толкая символов до тех пор , закрывающий "не будет выполнено, но из - за природы> <> нет такого понятия , как «многострочный строки синтаксического анализа» , как со строками CJam в или тройных кавычках Python. Это оказалось большой проблемой, потому что начало и конец строки с а "и другие символы между ними (например,"some chars" ) не допускается!

Обратите внимание, что /и \отражает ход программы, поэтому мы фактически выполняем первую строку, а затем все строки в обратном порядке, и большинство строк фактически выполняются в обратном порядке!

[Line 1]

""""""              Three empty strings, push nothing
"/;;Hello  "        Push "/;;Hello  ". Note the wrapping - ><> is toroidal!
""""""              Three empty strings, push nothing

[Line 6]
66++$               Turn the top " " into "," by adding 12, then swap top two
rp                  Reverse stack and pop top 3
ooooo               Print "Hello", stack is now " ,"
fffffc              Push some 15s and a 12

[Line 5]
+++++               Sum the 15s and 12 to give 87, or "W"
}ooo                Move "W" to the back and output ", W"
fcccccccc           Push a 15 and some 12s

[Line 4]
++++++++            Sum the 15 and 12s to give 111, or "o"
"rldbbb\++++++++"   Push chars to stack
r                   Reverse stack
ld                  Push length of stack and 13, not used
bbb                 Push three 11s

[Line 3]
++&                 Sum the 11s to give 33, or "!" and put in register
~~                  Pop top two
oooo                Print "orld"

[Line 2]
&                   Put "!" from register to stack
o                   Print "!"

[Line 1]
;                   Terminate

Кстати, вот забавная попытка наименьшего байта> <> (23 строки, 47 байтов):

v
"
!
d
l
r
o
W

,
o
l
l
e
H
"
/<
l
?
!
;
o
\^

CJam, 5 4 строки, 162 байта

"Hello
")))))))))))))))))))))))))))))))))))68S\cel
"Wor
")))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))@SX\c|

То же количество строк, что и бессонница! (но намного больше байтов)

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

объяснение

"Hello\n"        Push "Hello" and a newline
)                Uncons the newline
)))...)))        Increment the newline into a ","
68S\             Push 68 and a space then swap, leaving 68 on top
c                Convert 68 into a char "D"
el               Lowercase "D" into "d"
"Wor\n"          Push "Wor" and a newline
)                Uncons the newline
)))...)))        Increment the newline into an "l"
@                Rotate top three elements, moving the "d" to the top
SX\              Push a space and 1 then swap, leaving the space on top
c                Convert the space (which is an array) into a char
|                Bitwise or the space (32) with 1 to give "!" (33)    

CJam автоматически печатает стопку позже.

Спасибо @Optimizer за напоминание о том, что Scработает, потому что в противном случае происходит SX|сбой (это происходит заданным образом или вместо этого, давая массив, состоящий из пробела и 1).

> <> (Рыба) , 5 строк, много байтов

Код очень длинный, когда я говорю [6535529689086686142930090 '+' signs]и [6535529689086686142930090 'd' characters]в первой строке кода, я имею в виду, что есть буквально6535529689086686142930090 плюс знаки подряд!

(И для следующих строк добавьте необходимые пробелы.)

'[6535529689086686142930090 '+' signs]^`[6535529689086686142930090 'd' characters]
                                   **,/288
                                     -/:o
                             %**288:;?\
                                   (1:\

Более короткая тестируемая альтернатива, которая печатает только Hi:

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++^`hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
                                                                                                                               **,/288
                                                                                                                                 -/:o
                                                                                                                         %**288:;?\
                                                                                                                               (1:\

Метод:

• В первой строке мы создаем огромное число, представляющее строку в base128.
• В остальных строках (идущих снизу вверх) мы печатаем следующий символ в каждом цикле, пока значение целого числа не достигнет 0.
• Код зацикливания есть :1(?;:882**%:o-288**,.

(С помощью этого метода мы можем напечатать произвольную строку длиной 2+ символа).

PHP (7/17 строк, 36/59 байт):

Из-за количества неверных ответов я переписал этот ответ.

Версия браузера? Ушел.

Но у меня есть 2 решения, оба основаны на побитовых xor( ^) строк в PHP.

Это чрезвычайно мощное решение! Иногда это позволяет сэкономить много байтов.

Во-первых, самый короткий ответ:

Echo
Hello
,AM^mm
,Wor
,OOO^
"#+n
";

Я знаю, это выглядит ужасно, но это работает!

Следующий зависит от перевода строки.

Да, он использует переводы строки ( \nтребуется стиль / UNIX)!

Echo
Bo
.ff
.e
.
"&*]ex
fn
"^
"\n
\n
\n
\n
\n
\n
\n
",B^c
;

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

Это не идеально, но работает!

Оба ответа были основаны на @ MartinBüttner «s решение :

Echo
Hello
.
chr
(44
).
chr
(29
+3
).Wor
.l
.d
."!
";

Особая благодарность @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ , @CJDennis , @ MartinBüttner и @skagedal за обнаружение всех моих ошибок и за их предложения.

Pyth, 7 строк, 23 байта

-
"Hello
,
 Wor
l
d
!"b

Довольно просто, просто используйте многострочную строку и удалите новые строки.

Попробуй это здесь.

Далее, 41 строка, 143 байта

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

Я очень горжусь этим. Я довольно быстро вытащил его, как только обнаружил, что смогу это сделать, - Google искал языки, не чувствительные к регистру, и уже хорошо знаю Forth. Его можно почти точно сократить, как байты, так и строки. Предложения приветствуются. : D

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

33
99
1
+
DUp
8
+
2DUp
6
+
SWap
11
+
2OVer
SWap
8
9
*
EMit
1
+
EMit
DUp
DUp
EMit
EMit
3
+
EMit
29
3
2DUp
+
EMit
*
EMit
EMit
EMit
EMit
EMit
EMit

Marbelous, 9 строк, 94 байта

3333
    @ADD
    358C
++--29\\
++--3555DE
<<<<<<>>~~
+++++446666D
++++++++../\
      ++------

Проверьте это онлайн здесь. Using spaces for blank cellsдолжен быть проверен.

Визуальное представление источника:

Объяснение: Каждое шестнадцатеричное значение в этой программе перемещается вниз каждый «тик» (если только он не включен \\, в этом случае он перемещается вправо).++будет увеличивать значение, --уменьшать, ~~применять побитовое значение нет и т. д. Значения, которые падают снизу, печатаются как символ ASCII.

Например: 33в верхнем углу становится (((0x33 +1 +1) << 1) +1 +1 = 0x6C (l).

Perl, 17 строк

$_
=
'pr
int
"Hello
,
 Wor
l
d
!"';s
!
!!g
;s
!.
*
!$&
!eex

Rebol - 15 строк (51 байт)

PRin
AJOin
[
'Hello
Sp 
+
12
Sp
'Wor
'l
'd
Sp
+
1
]

Слова в Rebol нечувствительны к регистру (например PRINT,Print и printбудут вызывать одну и ту же функцию).

Приведенный выше код приведен в порядок:

prin ajoin [
    'Hello  sp + 12  sp  'Wor  'l  'd  sp + 1
]

NB. spвозвращает пробел !

Унарный , 1 строка, много байтов

Каждый персонаж в этой программе 0 . Здесь слишком длинный источник, но он состоит из строки из множества нулей:

327380789025192647555922325233404088310881092761595127419003295178342329930050528932118548

Это десятичное представление для этого двоичного числа:

0b1010010010010010010010010110000010010010010110000010010000010010010000010010010000010001001001001011111000010000010000011110001111001011111000000100000011011011100010010010010010010010100100010010010100000000100001011100001100010010010100011011011011011011100011011011011011011011011100000000010100

Который был создан из этой программы BrainF ***:

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

Посмотрите, как я его сгенерировал: http://ideone.com/lMT40p

Пакет - 39 строк (202 байта)

Я хотел сократить размер, включив отложенное расширение, запустив код внутри cmdвызова, используя/v on коммутатора, но не смог пройти все караты.

@S^
ET^
LO^
C^
AL^
 EN^
ABL^
E^
DEL^
AY^
E^
DEX^
P^
ANS^
IO^
N
@S^
ET^
 0=Hello
@S^
ET^
 1=^
,^
 Wor
@S^
ET^
 2=l
@S^
ET^
 3=d
@E^
CHO^
 !^
0^
!!1^
!!2^
!!3^
!^^^
!

Без перевода строки (и каратов, чтобы избежать перевода строки):

@SETLOCAL ENABLEDELAYEDEXPANSION
@SET 0=Hello
@SET 1=, Wor
@SET 2=l
@SET 3=d
@ECHO !0!!1!!2!!3!^^!

Рубин, 19 строк, 95 байтов

$;=
$>
$;<<
:Hello
$;<<
44::chr
$.=
33::
-1
$;<<
$.::chr
$;<<
:Wor
$;<<
:l
$;<<
:d
$;<<
33::chr

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

Редактировать для объяснения: единственный отсортированный метод вывода Ruby - это <<метод в STDOUT. К сожалению, константа для STDOUT есть $>и >выше ASCII, чем большинство символов, поэтому на самом деле невозможно вызвать метод для нее. Нам нужен многострочный оператор присваивания, чтобы получить более подходящее имя переменной,$; (точка с запятой все еще довольно высока, но большинство переменных этой формы либо не присваиваются, либо могут быть только строками).

Символы ( :Worи т. Д.) - это самый простой способ сделать литерал, и я не вижу способа вырезать строки из строки, поэтому мне нужно несколько операторов print. Пробел и пунктуация не могут входить в символьный литерал, но, к счастью, chrметод чисел допустим, поэтому я могу получить символ из его значения ASCII. ::это альтернативный способ вызова методов. Пространство сложно, потому что я не могу писать 32, поэтому я вычитаю 1 из 33 и присваиваю его переменной.

Сетчатка, 12 строк, 29 байт (неконкурентная)

Язык новее, чем вызов.

Hello
$
,
$
 Wor
$
l
$
d
$
!

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