编写输出程序

Do not repeat yourself!

您的程序代码必须遵守以下约束：

• 它的长度必须是偶数
• 位置中的每个字符2n（其中n> 0的整数）必须等于位置中的字符2n-1。程序的第二个字符等于第一个字符，第四个等于第三个字符，依此类推。

换行符视为字符！

这是代码高尔夫球，所以最短的代码获胜！

例子

HHeellllooWWoorrlldd 是有效的程序

123或者AAABBB或者HHeello是不正确的

验证

您可以使用此CJam脚本来验证您的源代码有效。只需将代码粘贴到“输入”框中，然后运行脚本。

Hexagony，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的Hexagony Colorer生成的图表。}

该代码是完全线性的。\一开始的右边将IP重定向到对角线，这样我们根本不必担心字符加倍。彩色路径以橙色/红色，蓝色/灰色，绿色，紫色的顺序执行（当有两个相同颜色的路径时，首先执行左手路径，然后再绕到右手路径）。

如果我们忽略被其他人覆盖的无操作，镜像和命令，则线性代码可以归结为：

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

六边形中的字母只是将当前存储器边缘的值设置为字母的字符代码。;将当前内存边缘打印为字符。我们用于&将内存边缘重置为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× ¹⁰²²²

简单的头脑操->一元答案。非常次优;）。

该程序包括偶数0。特别：

1859184544332157890058930014286871430407663071311497107104094967305277041316183368068453689248902193437218996388375178680482526116349347828767066983734362041491257725282304432256118059236484741485455046352611468332836658716

其中。

原始的Brainfuck代码：

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

Ruby- 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是just 88+1+1，即：

• 88 可以单独使用
• 11**00是11^0，这很简单1

好在双方++并--就意味着add在Ruby中，所以我可以写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个字节，但我喜欢这种方式。）}

Sclipting，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形式的值，该值分解为三个byte 0x44 0xn4 0x4n。

对于o，这是0x6F，我们得到的字节0x6F 0xn6 0xFn。

因为我懒，我开始编码"DDDooo nnnooottt (etc.)"，然后更换所有其他角色与以前相比，这就是为什么我得到0x444444= "DDD"的D和0x6F66F6= "of�"的o。�之所以存在，是因为0xF6它本身是无效的UTF-8编码。

现在，回到程序。该程序的其余部分如下进行：

껢껢—推弦 ".\"�"

镓镓-删除最后一个字符两次，使我们 "."

❶❶-两份重复。现在堆叠：[".", ".", "."]

合合—串联两次。现在堆叠：["..."]

现在，我想接下来做的是使用"..."一个正则表达式，这样我可以同时匹配来自原始字符串三个字符，使用替...终循环结构。但是，由于每条指令都是重复的，因此我需要相互嵌套两个这样的正则表达式循环，并且如果堆栈不足，则会出现运行时错误。因此，

虚虚—将空字符串推两次

并随后启动循环。这样，外部循环仅迭代一次，因为它将正则表达式""与字符串""匹配，从而产生单个匹配项。对于"..."大字符串的每次匹配，内部循环都会运行一次。循环的主体为：

标标—将两个标记推入堆栈。现在堆叠：[mark mark]

现现—推送当前正则表达式匹配项的两个副本。现在堆叠：[mark mark "DDD" "DDD"]

并并—连接到第一个标记。现在堆叠：["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将我的程序大小除以2 :-)

说明

• 代码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值，我将创建该值的两倍，然后除以2。稍微短一点的是修改整个源以生成奇数值。

果冻，66 字节（无竞争）

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

在线尝试！

类固醇

如果您删除每隔一个字符，该程序仍然有效。

在线尝试！

这个怎么运作

““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.

Gammaplex，66个字节

\\

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

Gammaplex是一种2D语言，使用第一个换行符的位置作为行长，而忽略所有其他换行符。

MSM，270160字节

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

我的第一个MSM程序！

MSM中的字符串输出是通过以下方式完成的：将各个字符压入堆栈，然后通过将它们连接成单个字符串.，例如

!olleH.....

的数量.比字符数少一。因为Do not repeat yourself!我们需要22 .秒。幸运的是，这是一个偶数，所以我们有11个双打

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

将字母放在前面需要更多的努力。模式

cc'',,

为每个角色做the俩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种这样的模式，以22 !!'',,结尾DD'',,的join命令开头和结尾.。

Befunge 98、70 66字节

在线尝试！

在我给出无效答案之后，这是一个更好地适合挑战的答案！

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

（感谢Martin Ender建议使用��字符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

>>  ^^

反手，54字节

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

在线尝试！

由于Backhand的指针已经移动了三个格，因此我们要做的就是使用 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;

这是一个简单的输出程序。

其他

这正在争夺WallyWest的JavaScript奖励：

我可以证明，虽然可以在此限制下构造数字，但是字符串却不能。由于不能使用任何文字，因此任何文字建立字符的放置都会创建一个空字符串：

""
''
``

然后，只能使用某些运算符。唯一使用的“成对”运算符是：

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

这些都不可以将数字/其他字符转换为字符串。因此无法输出任何字符串。

爱丽丝，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@处于Ordinal模式。

这Y是“ unzip”命令，该命令将字符串分成交替位置的字符。由于每个字符都是重复的，所以实际上只为我们提供了所要查找的字符串的两个副本，尽管第一个副本具有两个尾随空格，第二个副本具有一个尾随空格。t分割该尾随空间并将其;丢弃。最后，o打印字符串并@终止程序。

05AB1E，100 58 52字节

-6个字节，感谢Kevin Cruijssen

„„€€··™™……€€––  ……¹¹‚‚  ……––‚‚))εε##θθáá}}»»……!!θθ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上运行和调试它！

幸运的是，Stax具有内置::的n分之一。我需要做的就是将字符串加倍，推动2并运行::。容易吧？

错误。

推送该字符串很棘手。第一个引号可以加倍..""，这是一个长度为2的文字，."后跟一个有意义的引号。问题是，我认为没有启动新字符串就无法终止字符串（这是必需的，否则将打印出双倍的版本）。

程序的末尾终止字符串文字。如果我可以在其中放置这个加倍的文字，那么也许会有一个不错的解决方法。但是，要从程序末尾跳转到某个地方需要G}，因此至少，我正在研究以下内容：

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

这没什么... G不会开始一个程序块，因此它们都不会跳到第二个}。同样，我需要忽略一个字符：..}}。执行从第一个跳到G第二个}，继续到末尾，G从第二个跳到第二个，然后从第二个跳到第二个}，然后再继续到最后，然后在该[deduplicate]部分的开头以堆栈顶部加倍的字符串继续。

重复数据删除很简单。11hh将11减半，两次减半，两次舍入并产生两次，然后::将获得所需的输出。

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

哦哦 这不会打印任何内容。这里有两个问题：首先，这..}意味着字符串.}将在程序结尾处位于堆栈的顶部，其次，Stax的普通隐式输出现在被禁用！

更糟糕的问题是输出。当Stax程序正常终止而不打印任何内容时，堆栈的顶部将被隐式打印。但是我们还没有打印任何东西...？啊，但是我们有。未终止的字符串文字将被打印而不是推送，即使是空的那两个空字符串（从"末尾的不匹配字符串开始）也足以触发此检查。任何打印都必须手工完成。

我们需要ppor PP，或者在这种情况下，忽略first through ..pp是不可接受的，因为它将打印出string .p。这意味着我们需要单独在堆栈上或在前两个中的期望输出以及一个空字符串。后者可以通过在打印之前推入两个空字符串（zz）并旋转两次顶部（aa）两次来实现。

完成后，我们将获得一堆四串高的琴叠。.}然后，在程序正常退出之前，先按五号；在这一点上，缺少隐式输出既是福也是祸，因为现在什么都不会印刷了！