Напишите программу, которая выводит

Do not repeat yourself!

Код вашей программы должен соответствовать следующим ограничениям:

• его длина должна быть четным числом
• каждый символ в позиции 2n(где nцелое число> 0) должен быть равен символу в позиции 2n-1. Второй символ программы равен первому, четвертый - третьему и т. Д.

Новые строки считаются символами!

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

Примеры

HHeellllooWWoorrlldd является действительной программой

123или AAABBBили HHeelloневерны

верификация

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

Гексагония , 166 126 124 байта

\\;;;;33rr''22DD..));;;;;;oo;;}}eeoo\\@@nn;;;;ee;;;;aass&&;;uuoo;;;;..\\\\;;ttee..pp;;tt;;;;..rr;;''ll..'';;;;..;;}}ff..}}yy

Вставка неявных no-ops и пробелов, это соответствует следующему исходному коду:

       \ \ ; ; ; ; 3
      3 r r ' ' 2 2 D
     D . . ) ) ; ; ; ;
    ; ; o o ; ; } } e e
   o o \ \ @ @ n n ; ; ;
  ; e e ; ; ; ; a a s s &
 & ; ; u u o o ; ; ; ; . .
  \ \ \ \ ; ; t t e e . .
   p p ; ; t t ; ; ; ; .
    . r r ; ; ' ' l l .
     . ' ' ; ; ; ; . .
      ; ; } } f f . .
       } } y y . . .

Я уверен, что возможно сократить это еще больше, и, возможно, даже решить это в длине стороны 6, но это становится хитрым ...

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

^{Диаграмма, созданная с помощью Timwi's Hexagony Colorer .}

Код полностью линейный. \В самом начале перенаправляет IP в диагонали, так что нам не нужно беспокоиться о сдвоенных символов на всех. Цветные пути выполняются в следующем порядке: оранжевый / красный, синий / серый, зеленый, фиолетовый (когда есть два пути одного и того же цвета, сначала выполняется левый путь, прежде чем переходить к правому).

Если мы игнорируем no-ops, зеркала и команды, которые переопределяются другими, линейный код сводится к следующему:

D;o;&32;}n;o;t;';}r;e;p;e;a;t;';}y;o;u;r;s;e;l;f;');@

Буквы в Hexagony просто устанавливают значение текущего края памяти в код символа буквы. ;печатает текущий край памяти как символ Мы используем &для сброса края памяти 0и печати пробела с 32;. }перемещается к другому краю, так что мы можем помнить 32для дальнейших пробелов. Остальная часть кода просто печатает буквы на новом ребре и иногда перемещается вперед и назад, ';}чтобы напечатать пробел. В конце мы снова перемещаемся к краю пробела ', увеличиваем значение до 33 )и печатаем восклицательный знак. @завершает программу

GolfScript, 130 84 76 байт

22..!!..00)){{DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff}}``%%>><<[[33]]++

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

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

Интерпретатор GolfScript начинает с помещения пустой строки в стек.

22 # Push 22.
.. # Push two copies.
!! # Negate the last copy twice. Pushes 1.
.. # Push two copies.
00 # Push 0.
)) # Increment twice. Pushes 2.

   # STACK: "" 22 22 1 1 1 2

{{DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff}}

`` # Push a string representation of the string representation of the block.

   # This pushes "{{DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff}}" (with quotes).

%% # Take every second element of that string, then every element of the result.
>> # Discard the first element of the result. Repeat.
<< # Truncate the result to length 22. Repeat.
[[ # Begin a two-dimensional array.
33 # Push 33, the character code of '!'.
]] # End the two-dimensional array.
++ # Concatenate the empty string, the 22-character string and the array [[33]].

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

Одинарный , ~ 1,86 × 10 ²²²

Простой бред -> унарный ответ. Очень неоптимальный;).

Программа состоит из четного числа 0; в частности:

1859184544332157890058930014286871430407663071311497107104094967305277041316183368068453689248902193437218996388375178680482526116349347828767066983174362041491257725282304432256118059236484741485455046352611468332836658716

из них.

Оригинальный код брейкфук:

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

Рубин - 2100 1428 1032 820 670 байт

Это предполагает, что выходные данные могут быть возвращаемым значением из функции (не было указано, что выходные данные должны быть в STDOUT)

Код:

((((((((((((((((((((((((((((((((((((((((((((((""<<66++11**00++11**00))<<99++11++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11))<<99++11++11**00))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11++((11**00<<11**00<<11**00))))<<99++11**00++11**00))<<99++11++11**00++11**00))<<99++11**00++11**00))<<88++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++22))<<99++11++11**00))<<99++((33>>11**00))++11**00++11**00))<<99++11++((11**00<<11**00<<11**00))))<<99++((33>>11**00))))<<99++11**00++11**00))<<99++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++11**00++11**00++11**00))<<33))

Хитрость заключается в том, чтобы создать строку из пустой строки, ""используя операцию добавления <<и коды символов ASCII.

Чтобы получить числа для кодов ASCII, я пытаюсь разложить число на значения, которые я могу легко сгенерировать. Например, ASCII 90просто 88+1+1, что:

• 88 это нормально само по себе
• 11**00есть 11^0, что просто1

К счастью, оба ++и --означают addв рубине, поэтому я могу написать 90как88++11**00++11**00

Есть несколько хитростей, чтобы получить некоторые цифры проще, чем просто добавить 1, вот код, который я использую для генерации вышеупомянутого (который включает все отображения, которые я использую):

d = "Do not repeat yourself!"

d.each_char do |c|
  print "(("
end

print '""'

VALUES = [
  [0,'00'],
  [1,'11**00'],
  [4,'((11**00<<11**00<<11**00))'],
  [5,'((11>>11**00))'],
  [11,'11'],
  [16,'((33>>11**00))'],
  [22,'22'],
  [27,'((55>>11**00))'],
  [33,'33'],
  [38,'((77>>11**00))'],
  [44,'44'],
  [49,'((99>>11**00))'],
  [55,'55'],
  [66,'66'],
  [77,'77'],
  [88,'88'],
  [99,'99']
].reverse

d.each_char do |c|
  print "<<"
  num = c.ord
  while num != 0
    convert = VALUES.find{|val|val.first<=num}
    print convert.last
    num -= convert.first
    print "++" unless num == 0
  end
  print "))"
end

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

Обратите внимание, что если вы используете -rppфлаг и добавляете ppв начало кода вот так:

pp((((((((((((((((((((((((((((((((((((((((((((((""<<66++11**00++11**00))<<99++11++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11))<<99++11++11**00))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11++((11**00<<11**00<<11**00))))<<99++11**00++11**00))<<99++11++11**00++11**00))<<99++11**00++11**00))<<88++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++22))<<99++11++11**00))<<99++((33>>11**00))++11**00++11**00))<<99++11++((11**00<<11**00<<11**00))))<<99++((33>>11**00))))<<99++11**00++11**00))<<99++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++11**00++11**00++11**00))<<33))

тогда для дополнительных 2 + 4 байтов это может функционировать как полностью завершенная программа, но она напечатает дополнительные "до и после требуемой строки:

Пример:

$ ruby -rpp golf.rb
"Do not repeat yourself!"

> <> , 174 байта

vv

77

99

**

00

77

bb

**

pp

""

!!

ff

ll

ee

ss

rr

uu

oo

yy



tt

aa

ee

pp

ee

rr



tt

oo

nn



oo

DD

""

~~

oo

ll

11

==

;;

00

66

bb

**

..

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

Код, который работает примерно так:

v            Redirect instruction pointer to move downwards
79*07b*p     Place a ? on row 77 before the first ;
"..."        Push "Do not repeat yourself!" backwards, riffled between spaces

[main loop]
~o           Pop a space and output a char
l1=?;        If there is only the final space left, halt
06b*.        Jump back to the start of the loop

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

^{(Примечание: это может быть на 50 байт короче, если оно заканчивается с ошибкой , но мне это нравится.)}

Скользящий , 186 146 байт

끄끄 닶닶 긂긂 닦닦 닶닶 덇덇 긂긂 댧댧 뉖뉖 댇댇 뉖뉖 눖눖 덇덇 긂긂 뎗뎗 닶닶 덗덗 댧댧 댷댷 뉖뉖 닆닆 뉦뉦 긒긒

껢껢 鎵 鎵 ❶❶ 合 合 虛虛 替 替 標 標 現 現 併 併 一一 終 終

Чтобы было ясно, есть три строки кода, середина которых пуста, потому что перевод строки должен быть продублирован. Количество байтов основано на кодировке UTF-16.

объяснение

Блок корейских символов в начале толкает строку "DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012". Вы заметите, что каждый третий символ - это тот символ, который нам нужен; остальное - бред. Вот почему:

В Sclipting два корейских символа кодируют три байта. Таким образом, каждый корейский символ эффективно кодирует 12 бит. Чтобы получить строку, начинающуюся с D, первые 8 бит должны быть 0x44; остальное не имеет значения, но так как мы должны повторять каждый символ, 12–20-й биты тоже будут 0x44. Таким образом, у нас будет значение вида 0x44n44nдля некоторого n , которое раскладывается на три байта 0x44 0xn4 0x4n.

За oчто 0x6Fмы получаем байты 0x6F 0xn6 0xFn.

Поскольку я ленивый, я начал с кодирования, "DDDooo nnnooottt (etc.)"а затем заменил все остальные символы на предыдущий, поэтому я получаю 0x444444= "DDD"для Dи 0x6F66F6= "of�"для o. Это �происходит потому, что 0xF6сама по себе является недопустимой кодировкой UTF-8.

Теперь вернемся к программе. Остальная часть программы происходит следующим образом:

껢껢 - толкает строку ".\"�"

鎵 鎵 - удаляет последний символ дважды, оставляя нас с "."

❶❶ - две копии. Стек сейчас:[".", ".", "."]

Conc 合 - объединить дважды. Стек сейчас:["..."]

Теперь, что я хочу сделать дальше, это использовать "..."в качестве регулярного выражения, чтобы я мог сопоставлять три символа из исходной строки за раз, используя конструкцию цикла 替 ... 終. Однако, поскольку каждая инструкция дублируется, мне нужно иметь два таких цикла регулярных выражений, вложенных друг в друга, и, если стек переполняется, я получаю ошибку времени выполнения. Следовательно,

Push - дважды нажать пустую строку

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

Push 標 - вставьте две метки в стек. Стек сейчас:[mark mark]

Push 現 - нажмите две копии текущего соответствия регулярному выражению. Стек сейчас:[mark mark "DDD" "DDD"]

Conc 併 - объединить до первой отметки. Стек сейчас:["DDDDDD"]

一一 - взять первый символ этой строки, а затем (избыточно) первый символ этой строки. У стека теперь есть тот символ, который нам нужен.

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

Затем внешний цикл завершается, и в этот момент желаемая строка удаляется из стека, и единственное совпадение ""в строке ""заменяется им, оставляя желаемую строку еще раз в стеке.

Лабиринт , 528 байт

66))__vv          ..33::00&&__vv          ..44__99||__vv          ..33::00&&__vv            ..99))__vv            ..99))__vv      ..44__88$$__vv          ..22__99++__vv          ..22__99$$__vv            ..22__99))$$__vv      ..33__77$$__vv            ..33__vv

      ..44__99||__^^          ..11__99++__^^          ..44__88$$__^^          ..44((__88$$__^^      ..11))__99++__^^      ..99((__^^          ..33::00&&__^^          ..44__99||__^^          ..44((__88$$__^^            ..99))__^^          ..11__99$$((__^^    ..@@

xx

Двойные переводы строки больно, но по крайней мере это доказывает, что это выполнимо!

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

D 68  66))
o 111 44__99||
  32  33::00&&
n 110 11__99++
t 116 44__88$$
r 114 44((__88$$
e 101 99))
p 112 11))__99++
a 97  99((
y 121 22__99++
u 117 22__99$$
s 115 22__99))$$
l 108 33__77$$
f 102 11__99$$((
! 33  33

где

)(        Increment/decrement by 1 respectively
&|$       Bitwise AND/OR/XOR respectively
+         Add
:         Duplicate
_         Push zero
0-9       Pop n and push n*10+<digit>

Необычное поведение цифр Лабиринта эксплуатируется 33::00&&, что на самом деле

[33] -> [33 33] -> [33 33 33] -> [33 33 330] -> [33 33 3300] -> [33 32] -> [32]
     :          :             0              0               &          &

Каждый символ печатается с механизмом

__vv

  ..

xx

xxСуществует только для прокладки сетки , так что это 5 высоких. Сначала __толкаем два ноля, затем мы попадаем в оператор поворота сетки v. Мы вставляем ноль и вращаемся:

__ v
  v
   .
  .
xx

и снова:

__ v

  v.

xx.

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

CJam - 176 136 байт

66))HH77++GG00++BB88++HH77++EE88++GG00++DD88++99))CC88++99))AA77++EE88++GG00++BB99++HH77++KK77++DD88++JJ77++99))AA88++II66++33]]{{cc}}//

Спасибо Sp3000 за разделение размера моей программы на два :-)

объяснение

• Коды HH77++, GG00++... вычисляют целочисленный ascii-код символов, добавляя числа (например: `HH77 ++ 'помещает 17, 17 и 77 в стек, а затем добавляет эти 3 числа)
• часть кода в конце ]]{{cc}}//перебирает коды ascii и преобразует их в символы.

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

Самомодифицирующийся Brainf *** , 72 байта

Обратите внимание, что \x00представляет собой буквенный NULшестнадцатеричный байт (пустая ячейка). Исходный код размещается на ленте слева от начальной ячейки.

!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD\0\0<<<<<<++[[<<]]<<[[..<<]]

объяснение

!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD  The string on the tape for easy printing
\x00\x00                                        A separator to make printing shorter
<<<<<<++                                        Change first '.' to '0' (comment)
[[<<]]<<                                        Move to separator, then left to string
[[0.<<]]                                        Print string

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

Желе , 66 байт (не конкурирует)

““DDoo  nn““oott  rreepp““eeaatt  yyoouurrss““eellff!!””ṛṛḷḷWWQQ€€

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

Factoid

Программа по-прежнему работает, если вы удаляете каждый второй символ.

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

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

““DDoo  nn““oott  rreepp““eeaatt  yyoouurrss““eellff!!”

возвращает массив строк. Литерал начинается с a “, заканчивается a ”, а строки ограничиваются внутри “. Результат

["", "DDoo  nn", "", "oott  rreepp", "", "eeaatt  yyoouurrss", "", "eellff!!"]

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

<literal>”ṛṛḷḷWWQQ€€  Argument/return value: A (string array)

         ”ṛ           Yield the character 'ṛ'.
           ṛ          Select the right argument of 'ṛ' and A: A.
            ḷ         Select the left argument of A and A: A.
              W       Wrap; yield [A].
             ḷ        Select the left argument of A and [A]: A.
               W      Wrap; yield [A].
                Q     Unique; deduplicate [A]. Yields [A].
                 Q€€  Unique each each; for each string s in A, deduplicate s.

Гаммаплекс , 66 байт

\\

XX""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD""XXXXrrRREE

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

МСМ , 270 160 байт

!!'',,ff'',,ll'',,ee'',,ss'',,rr'',,uu'',,oo'',,yy'',,  '',,tt'',,aa'',,ee'',,pp'',,ee'',,rr'',,  '',,tt'',,oo'',,nn'',,  '',,oo'',,DD'',,......................

Моя первая программа для МСМ!

Вывод строки в MSM осуществляется путем помещения отдельных символов в стек и объединения их в одну строку с помощью ., например,

!olleH.....

Количество на .один меньше количества символов. Для Do not repeat yourself!нас необходимо 22 .с. К счастью, это четное число, поэтому у нас 11 двойных

......................

Размещение букв перед ним требует дополнительных усилий. Шаблон

cc'',,

делает трюк для каждого персонажа c. Он оценивает следующим образом

cc'',,            push c (remember: commands are taken from the left and operate on the right)
c'',,c            push c
'',,cc            quote ' and push
,,cc'             pop
,cc               pop
c                 voilà!

Нам нужно 23 таких шаблона, начиная с !!'',,и заканчивая DD'',,22 командами соединения ..

Befunge 98, 70 66 байт

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

После моего неверного ответа, вот лучший, который действительно соответствует задаче!

2200**xx""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD��""kk,,@@

(Спасибо Мартину Эндеру за предложение использовать ��символ 0x17 вместо 88ff++)

Объяснение:

2200          Push 2, 2, 0, and 0 onto the stack
*             Multiply 0 and 0, yielding 0
*             Multiply 2 and 0, yielding 0
              The stack is now [2, 0]
x             Pop a vector off the stack and set the instruction pointer delta to that
              The instruction pointer is now skipping over every other character, since the delta is (2, 0)
"!f ... oD�" Push the string onto the stack, with the number 23 (number of characters in the string) at the top
k,            Pop characters off the stack and print them, 23 times
@             End the program

DC , 348 346 342 306 290 278 байт

Файл dnr6.short.dc(без завершающей строки):

AAzz--22222222vvPPAAAAAAAAvvPP88vvFFFFFFFFvv00++AAzz--PP11vvFFFFFFFFvv00++AAAAAAvvPP11vvEEEEEEEEvv00++OOOO//44999999vv++PP77II++OOOO//44999999vv++PPAAAAAAvv88vvFFFFFFFFvv00++PPAAzz--BBPP11vvFFFFFFFFvv00++77OOOO++++PPOOOO//44999999vv++66vvFFFFFFFFvv00++PP99zz++OO88++PPAAAAvv33PP

Бегать:

$ dc < dnr6.short.dc 
Do not repeat yourself!

BotEngine , 6x49 = 294

vv  PP

  !!ee

  ffee

  llee

  eeee

  ssee

  rree

  uuee

  ooee

  yyee

    ee

  ttee

  aaee

  eeee

  ppee

  eeee

  rree

    ee

  ttee

  ooee

  nnee

    ee

  ooee

  DDee

>>  ^^

Backhand , 54 байта

vv""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD""HH

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

Поскольку указатель Backhand уже перемещается на три ячейки, все, что нам нужно сделать, это уменьшить его до 2, используя v

сетчатый, неконкурентный, 62 байта

2200**UU""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""oo;;

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

Пояснения по частям:

2200**
2200    the stack looks like [2 2 0 0]
    *   [2 2 0*0]
     *  [2 2*0*0]
        [2 0]

Uустанавливает указатель направления (2, 0), то есть перемещая 2x-единицы и 0y-единицы, поэтому он пропускает все остальные символы, начиная со следующего Uпропускаемого. Затем записывается каждый другой символ, и это эквивалентно:

"Do not repeat yourself!"o;

которая является простой программой вывода.

Другие

Это конкурирует за вознаграждение JavaScript WallyWest:

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

""
''
``

Тогда можно использовать только некоторый оператор; используются только «парные» операторы:

++ -- << >> ** ~~ || && !! ==

И ни один из них не может привести числа / другие к строкам. Поэтому никакие строки не могут быть выведены.

Алиса , 74 байта

aa00tt,,JJ""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!//@@""ooYY;;tt

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

объяснение

Первый улов заключается в том, что нам нужно иметь возможность вводить строку, поэтому мы хотим пропустить только первое ". Мы делаем это, перепрыгивая на первую, "потому что тогда IP переместится на одну ячейку, прежде чем снова смотреть на текущую ячейку, так что это вторая, "которая входит в строковый режим. Но чтобы иметь возможность прыгать туда, нам нужно 10, 0на вершине стека, в таком порядке (второй, верхний). Это сделано с aa00tt,,:

                          Stack:
aa   Push two 10s.        [... 10 10]
00   Push two 0s.         [... 10 10 0 0]
tt   Decrement twice.     [... 10 10 0 -2]
,    Rotate(-2).          [... 0 10 10]
,    Rotate(10).          [... 0 10 0]

Эта функция вращения выдает аргумент. Если этот аргумент отрицателен, он сдвигает значение на вершину стека на столько позиций. Если аргумент положительный, он ищет элемент, который находится на много позиций ниже вершины, и тянет его вверх. Обратите внимание, что в случае Rotate(10), если в стеке недостаточно элементов, но в конце есть неявное бесконечное количество нулей, поэтому ноль заканчивается сверху.

Теперь мы можем Jперейти к первому, "используя эти два аргумента. Второй "вводит строковый режим и записывает все это DDoo nnoott.... Когда он попадает в /, IP-адрес перенаправляется на юго-восток, и мы входим в обычный режим. На данный момент IP-адрес прыгает вверх и вниз по трем строкам (две из которых пусты), поэтому сначала записывает еще три пробела в строках две и три, а затем мы покидаем строковый режим, когда он попадает в ". Поскольку в настоящее время мы находимся в обычном режиме, все записанные символы помещаются в стек как одна строка (даже если мы записали большинство из них в режиме кардинала), поэтому мы получаем эту строку (обратите внимание на конечные пробелы) :

DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!   

Теперь IP продолжает подпрыгивать вверх и вниз, что означает, что он выполняет одну команду из каждой другой пары, то есть Yи t. Затем IP достигнет конца сетки во второй строке и начнет прыгать назад через сетку. Это также переключает, в какой паре символов IP попадает в первую строку, поэтому при возврате он теперь выполняется ;, oи @. Таким образом, игнорируя все пробелы и неявные перенаправления IP, исполняемый код находится Yt;o@в обычном режиме.

Это Yкоманда «unzip», которая разделяет строку на символы в чередующихся позициях. Поскольку каждый символ повторяется, это действительно дает нам две копии строки, к которой мы стремимся, хотя первая копия имеет два конечных пробела, а вторая - один конечный пробел. tотделяет этот завершающий пробел и ;отбрасывает его. Наконец, oпечатает строку и @завершает программу.

05AB1E , 100 58 52 байта

-6 байт благодаря Кевину Круйссену

„„€€··™™……€€––  ……¹¹‚‚  ……––‚‚))εε##θθáá}}»»……!!θθJJ

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

„„€€·              # dictionary string "g do"
     ·             # double (no effect on strings)
      ™            # title case: "G Do"
       ™           # title case again (no effect)
……€€––             # dictionary string "tools not–"
                   # spaces necessary so "–…" isn't parsed as a dictionary word
……¹¹‚‚             # dictionary string "team repeat‚"
                   # spaces necessary again
……––‚‚             # dictionary string "j yourself‚"
)                  # wrap the entire stack in an array
 )                 # and again: [["G Do", "tools not–", "team repeat‚", "j yourself‚"]]
  ε        }       # for each:
   ε      }        #  for each:
    #              #   split on spaces: ["tools", "not–"]
     #             #   and again: [["tools", "not–"]]
      θ            #   get the last element: ["tools", "not–"]
       θ           #   and again: "not–"
        á          #   keep only letters: "not"
         á         #   and again (no effect)
            »      # join the list by newlines, joining sublists by spaces:
                   # "Do not repeat yourself"
             »     # join the stack by newlines, joining lists by spaces (no effect)
……!!               # literal string "…!!"
    θ              # get the last character: "!"
     θ             # and again (no effect)
      J            # join the stack without separators: "Do not repeat yourself!"
       J           # and again (no effect)
                   # implicit output

Правила идемпотентности.

Stax , 70 байт

GG11hh::zzaapp..}}..""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""

Запустите и отладьте его на staxlang.xyz!

Стакс, к счастью, имеет встроенный ::для каждого. Все, что мне нужно, это нажать на удвоенную строку, нажать 2 и бежать ::. Легко, правда?

Неправильно.

Нажав на эту строку сложно. Первая кавычка может быть удвоена .."", что является литералом длины 2, за ."которым следует значащая кавычка. Проблема в том, что я не вижу способа завершить строку (что необходимо, иначе дублированная версия будет напечатана) без запуска новой.

Конец программы завершает строковые литералы. Если я смогу поместить этот удвоенный литерал туда, возможно, будет хороший обходной путь. Однако, чтобы перейти куда-нибудь с конца программы, требуется G}, поэтому, как минимум, я смотрю на это:

GG [deduplicate] }}""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""

Это не делает ... ничего. Gне начинается блок, поэтому ни один не перейдет ко второму }. Опять же , мне нужно игнорировать один символ: ..}}. Выполнение переходит от первого Gко второму }, продолжается до конца, переходит обратно ко второму Gи оттуда ко второму }, и продолжается еще раз до конца, прежде чем возобновится в начале [deduplicate]раздела с удвоенной строкой поверх стека.

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

GG11hh::..}}..""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""

Ой-ой. Это ничего не печатает. Здесь есть две проблемы: во-первых, это ..}означает, что строка .}будет на вершине стека в конце программы, а во-вторых, обычный неявный вывод Stax теперь отключен!

Худшая проблема - выход. Когда программа Stax корректно завершает работу, ничего не печатая, верхняя часть стека будет неявно печататься. Но мы ничего не напечатали ...? Ах, но у нас есть. Неопределенные строковые литералы печатаются, а не выдвигаются, и даже этих двух пустых строк (из несопоставленных "в конце), несмотря на то, что они пустые, достаточно, чтобы отключить эту проверку. Любая печать должна быть сделана вручную.

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

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