[Question]
  [
Write a program that outputs 
```
Do not repeat yourself!
```
Your program code must respect the following constraints :
* its length must be an even number
* each character that is in position `2n` (where `n` is an integer > 0) must be equal to the character in position `2n-1`. The second character of the program is equal to the first, the fourth is equal to the third, etc.
Newlines count as characters!
This is code-golf, so the shortest code wins!
## Examples
`HHeellllooWWoorrlldd` is a valid program
`123` or `AAABBB` or `HHeello` are incorrect
## Verification
You can use [this CJam script](http://cjam.aditsu.net/#code=q2%2F%7B)-%7D%2F%5Ds%22not%20%22*%22valid%22) to verify that your source code is valid. Simply paste your code into the "Input" box and run the script.
  
[Answer]
# [Hexagony](https://github.com/mbuettner/hexagony), ~~166~~ ~~126~~ 124 bytes
```
\\;;;;33rr''22DD..));;;;;;oo;;}}eeoo\\@@nn;;;;ee;;;;aass&&;;uuoo;;;;..\\\\;;ttee..pp;;tt;;;;..rr;;''ll..'';;;;..;;}}ff..}}yy
```
Inserting the implicit no-ops and whitespace, this corresponds to the following source code:
```
       \ \ ; ; ; ; 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 . . .
```
I'm sure it's possible to shorten this even more, and maybe even solve it in side-length 6, but it's getting tricky...
## How it works
[![enter image description here](https://i.stack.imgur.com/ZwOwF.png)](https://i.stack.imgur.com/ZwOwF.png)
Diagram generated with [Timwi's Hexagony Colorer](https://github.com/Timwi/HexagonyColorer).
The code is completely linear. The `\` right at the start redirects the IP into a diagonal, such that we don't need to worry about the doubled characters at all. The coloured paths are executed in the order orange/red, blue/grey, green, purple (when there are two paths of the same colour, the left-hand path is executed first, before wrapping around to the right-hand one).
If we ignore no-ops, mirrors and commands which are overridden by others, the linear code comes down to this:
```
D;o;&32;}n;o;t;';}r;e;p;e;a;t;';}y;o;u;r;s;e;l;f;');@
```
Letters in Hexagony just set the current memory edge's value to the letter's character code. `;` prints the current memory edge as a character. We use `&` to reset the memory edge to `0` and print a space with `32;`. `}` moves to a different edge, so that we can remember the `32` for further spaces. The rest of the code just prints letters on the new edge, and occasionally moves back and forth with `';}` to print a space. At the end we move to the space edge again with `'`, increment the value to 33 with `)` and print the exclamation mark. `@` terminates the program.
[Answer]
# GolfScript, ~~130~~ ~~84~~ 76 bytes
```
22..!!..00)){{DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff}}``%%>><<[[33]]++
```
Try it online in [Web GolfScript](http://golfscript.apphb.com/?c=MjIuLiEhLi4wMCkpe3tERG9vICBubm9vdHQgIHJyZWVwcGVlYWF0dCAgeXlvb3V1cnJzc2VlbGxmZn19YGAlJT4%2BPDxbWzMzXV0rKw%3D%3D).
### How it works
The GolfScript interpreter starts by placing an empty string on the stack.
```
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]].
```
Concatenating an array with a string flattens, so the result is the desired output.
[Answer]
# [Unary](https://esolangs.org/wiki/Unary), ~1.86 × 10222
Simple brainfuck -> unary answer. Very sub-optimal ;).
The program consists of an even number of 0’s; specifically:
> 
> 1859184544332157890058930014286871430407663071311497107104094967305277041316183368068453689248902193437218996388375178680482526116349347828767066983174362041491257725282304432256118059236484741485455046352611468332836658716
> 
> 
> 
of them.
Original brainfuck code:
```
++++[++++>---<]>+.[--->+<]>+++.[--->+<]>-----.+[----->+<]>+.+.+++++.[---->+<]>+++.---[----->++<]>.-------------.+++++++++++.-----------.----.--[--->+<]>-.[---->+<]>+++.--[->++++<]>+.----------.++++++.---.+.++++[->+++<]>.+++++++.------.[--->+<]>-.
```
[Answer]
# Ruby - 2100 1428 1032 820 670 bytes
This assumes the output can be a return value from a function (it wasn't specified that the output needs to be to STDOUT)
Code:
```
((((((((((((((((((((((((((((((((((((((((((((((""<<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))
```
The trick is to build the string from an empty string `""` using the append operation `<<` and the ASCII codes of the characters. 
To get the numbers for the ASCII codes I'm trying to decompose the number into values I can easily generate. For example ASCII `90` is just `88+1+1`, which is:
* `88` is okay on it's own
* `11**00` is `11^0`, which is simply `1`
Fortunately both `++` and `--` would mean `add` in ruby, so I can write `90` as `88++11**00++11**00`
There are some tricks to get to some numbers easier than just adding 1s, here is the code I'm using to generate the above (which includes all mappings I'm using):
```
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
```
I'm still thinking about other tricks to decrease the characters required to get to a number.
Note that if you use the `-rpp` flag, and add `pp` to the start of the code like so:
```
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))
```
then for extra 2+4 bytes this can function as a fully complete program, but it will print an extra `"` before and after the required string:
Example:
```
$ ruby -rpp golf.rb
"Do not repeat yourself!"
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 174 bytes
```
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
**
..
```
Thankfully, in a sense the restriction doesn't apply vertically. However, the biggest problem is that we need to double every newline.
The code that runs roughly goes like this:
```
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
```
Note that the program has no double spaces — when in string mode, ><> pushes spaces for empty cells. Conversely, however, this means that a solution using `g` (read single cell from source code) would be trickier, since what spaces are in the program become NULs when read.
(Note: This can be 50 bytes shorter if it [terminates with an error](http://pastebin.com/UzLESVzm), but I like it this way.)
[Answer]
# [Sclipting](http://esolangs.org/wiki/Sclipting), ~~186~~ 146 bytes
> 
> 끄끄닶닶긂긂닦닦닶닶덇덇긂긂댧댧뉖뉖댇댇뉖뉖눖눖덇덇긂긂뎗뎗닶닶덗덗댧댧댷댷뉖뉖닆닆뉦뉦긒긒
> 
> 
> 껢껢鎵鎵❶❶合合虛虛替替標標現現併併一一終終
> 
> 
> 
To be clear, there are three lines of code, the middle of which is empty, because the newline needs to be duplicated. The byte count is based on UTF-16 encoding.
# Explanation
The block of Korean characters at the start pushes the string `"DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012"`. You will notice that every *third* character is a character we want; the rest is gibberish. Here’s why:
In Sclipting, two Korean characters encode three bytes. Thus, each Korean character effectively encodes 12 bits. To get a string starting with `D`, the first 8 bits have to be `0x44`; the rest don’t matter, but since we have to repeat every character, the 12th to 20th bits are also going to be `0x44`. Thus, we will have a value of the form `0x44n44n` for some *n*, which decomposes into the three bytes `0x44 0xn4 0x4n`.
For the `o`, which is `0x6F`, we get the bytes `0x6F 0xn6 0xFn`.
Since I’m lazy, I started by encoding `"DDDooo nnnooottt (etc.)"` and then replaced every other character with the previous, which is why I get `0x444444` = `"DDD"` for the `D` and `0x6F66F6` = `"of�"` for the `o`. The `�` is there because `0xF6` by itself is invalid UTF-8 encoding.
Now, back to the program. The rest of the program proceeds as follows:
> 
> 껢껢 — pushes the string `".\"�"`
> 
> 
> 鎵鎵 — removes the last character twice, leaving us with `"."`
> 
> 
> ❶❶ — two duplicates. Stack now: `[".", ".", "."]`
> 
> 
> 合合 — concatenate twice. Stack now: `["..."]`
> 
> 
> 
Now, what I *want* to do next is use `"..."` as a regular expression so that I can match three characters from the original string at a time, using the 替...終 loop construct. However, since every instruction is duplicated, I need to have *two* such regular-expression loops nested inside each other, and if the stack underruns I get a runtime error. Therefore,
> 
> 虛虛 — push the empty string twice
> 
> 
> 
and *then* start the loops. This way, the outer loop iterates only once because it matches the regular expression `""` against the string `""`, which yields a single match. The inner loop runs once for every match of `"..."` against the big string. The body of the loop is:
> 
> 標標 — push two marks onto the stack. Stack now: `[mark mark]`
> 
> 
> 現現 — push two copies of the current regex match. Stack now: `[mark mark "DDD" "DDD"]`
> 
> 
> 併併 — concatenate up to the first mark. Stack now: `["DDDDDD"]`
> 
> 
> 一一 — take first character of that string, and then (redundantly) the first character of that. Stack now has the character we want.
> 
> 
> 
The inner loop ends here, so every match of the regular expression is replaced with the first character of that match. This leaves the desired string on the stack.
Then the outer loop ends, at which point the desired string is taken off the stack and the only match of `""` in the string `""` is replaced with it, leaving the desired string once again on the stack.
[Answer]
# [Labyrinth](http://esolangs.org/wiki/Labyrinth), 528 bytes
```
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
```
The double newlines hurt, but at least this proves that it's doable!
Each character is printed one-by-one, first by forming the code point then printing a single char. The code points are formed by:
```
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
```
where
```
)(        Increment/decrement by 1 respectively
&|$       Bitwise AND/OR/XOR respectively
+         Add
:         Duplicate
_         Push zero
0-9       Pop n and push n*10+<digit>
```
The unusual behaviour of Labyrinth's digits is exploited in `33::00&&`, which is actually
```
[33] -> [33 33] -> [33 33 33] -> [33 33 330] -> [33 33 3300] -> [33 32] -> [32]
     :          :             0              0               &          &
```
Each single char is printed with the mechanism
```
__vv
  ..
xx
```
The `xx` exist only to pad the grid so that it's 5 high. First the `__` push two zeroes, then we hit a grid rotation operator `v`. We pop a zero and rotate:
```
__ v
  v
   .
  .
xx
```
and again:
```
__ v
  v.
xx.
```
We then move rightwards to the `.` on the third row, thus executing the print command only once.
[Answer]
# CJam - 176 136 bytes
```
66))HH77++GG00++BB88++HH77++EE88++GG00++DD88++99))CC88++99))AA77++EE88++GG00++BB99++HH77++KK77++DD88++JJ77++99))AA88++II66++33]]{{cc}}//
```
*Thanks to Sp3000 for dividing my program size by two :-)*
**Explanation**
* The codes `HH77++`, `GG00++`, ... compute the integer ascii code of the characters by adding numbers (for example: `HH77++' pushes 17, 17 and 77 on the stack, then add these 3 numbers)
* the portion of code at the end `]]{{cc}}//` loops through the ascii codes and convert them to characters.
Try it [here](http://cjam.aditsu.net/#code=66))HH77%2B%2BGG00%2B%2BBB88%2B%2BHH77%2B%2BEE88%2B%2BGG00%2B%2BDD88%2B%2B99))CC88%2B%2B99))AA77%2B%2BEE88%2B%2BGG00%2B%2BBB99%2B%2BHH77%2B%2BKK77%2B%2BDD88%2B%2BJJ77%2B%2B99))AA88%2B%2BII66%2B%2B33%5D%5D%7B%7Bcc%7D%7D%2F%2F)
[Answer]
# [Self-modifying Brainf\*\*\*](http://esolangs.org/wiki/Self-modifying_Brainfuck), 72 bytes
Note that `\x00` represents a literal `NUL` hex byte (empty cell). The source code is placed on the tape, left of the starting cell.
```
!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD\0\0<<<<<<++[[<<]]<<[[..<<]]
```
### Explanation
```
!!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
```
Also, before making this program, I was making one using only BF characters in the source. It's possible! It's also much longer, since for an odd ASCII value, I was going to create double the value, then divide by two. Somewhat shorter would be modifying the entire source to generate odd values to start with.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 66 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
““DDoo  nn““oott  rreepp““eeaatt  yyoouurrss““eellff!!””ṛṛḷḷWWQQ€€
```
[Try it online!](http://jelly.tryitonline.net/#code=4oCc4oCcRERvbyAgbm7igJzigJxvb3R0ICBycmVlcHDigJzigJxlZWFhdHQgIHl5b291dXJyc3PigJzigJxlZWxsZmYhIeKAneKAneG5m-G5m-G4t-G4t1dXUVHigqzigqw&input=)
### Factoid
The program still works if you remove every second character.
[Try it online!](http://jelly.tryitonline.net/#code=4oCcRG8gbuKAnG90IHJlcOKAnGVhdCB5b3Vyc-KAnGVsZiHigJ3huZvhuLdXUeKCrA&input=)
### How it works
```
““DDoo  nn““oott  rreepp““eeaatt  yyoouurrss““eellff!!”
```
returns an array of string. The literal begins with a `“`, ends with a `”`, and the strings are delimited internally by `“`. The result is
```
["", "DDoo  nn", "", "oott  rreepp", "", "eeaatt  yyoouurrss", "", "eellff!!"]
```
The link's argument and the return value are set to this array of strings, then the remainder of the source code is executed.
```
<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.
          
```
[Answer]
# [Gammaplex](http://esolangs.org/wiki/Gammaplex), 66 bytes
```
\\
XX""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD""XXXXrrRREE
```
Gammaplex is a 2D language that uses the position of the first newline as the line length, and ignore all other newlines.
[Answer]
# [MSM](http://esolangs.org/wiki/MSM), ~~270~~ 160 bytes
```
!!'',,ff'',,ll'',,ee'',,ss'',,rr'',,uu'',,oo'',,yy'',,  '',,tt'',,aa'',,ee'',,pp'',,ee'',,rr'',,  '',,tt'',,oo'',,nn'',,  '',,oo'',,DD'',,......................
```
My first MSM program!
String output in MSM is done by pushing the individual characters onto the stack and joining them into a single string via `.`, e.g.
```
!olleH.....
```
The number of `.` is one less than the number of characters. For `Do not repeat yourself!` we need 22 `.`s. Luckily this is an even number, so we have 11 doubles
```
......................
```
Putting the letters in front of it requires some more effort. The pattern
```
cc'',,
```
does the trick for each character `c`. It evaluates as follows
```
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à!
```
We need 23 such patterns starting with `!!'',,` and ending with `DD'',,` followed by the 22 join commands `.`.
[Answer]
# Befunge 98, 70 66 bytes
[Try it online!](https://tio.run/nexus/befunge-98#@29kZGCgpVVRoaSkqJiWlpOTmlpcXFRUWpqfX1mpoFBSkpiYmlpQkJpaVATi5efn5Sko5Oe7uIiLKyllZ@voODj8/w8A)
After my invalid answer, here's a better one that actually fits the challenge!
```
2200**xx""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD��""kk,,@@
```
(Thanks to Martin Ender for suggesting the use of `��`, character 0x17, instead of `88ff++`)
Explanation:
```
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
```
[Answer]
# [Backhand](https://github.com/GuyJoKing/Backhand), 54 bytes
```
vv""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD""HH
```
[Try it online!](https://tio.run/##FcdLCsAgDAXAq8ScxYXXSG2kUPFJ/ICnT@ns5pL8PtJu972ZQyilVtUxzNYCziGaU0S1d1Wzf0BrRECMzCm5fw "Backhand – Try It Online")
Since Backhand's pointer already moving at three cells a tick, all we need to do is decrease that to 2 using `v`
[Answer]
# [DC](https://rosettacode.org/wiki/Dc), ~~348~~ ~~346~~ ~~342~~ ~~306~~ ~~290~~ 278 bytes
File `dnr6.short.dc` (without trailing newline):
```
AAzz--22222222vvPPAAAAAAAAvvPP88vvFFFFFFFFvv00++AAzz--PP11vvFFFFFFFFvv00++AAAAAAvvPP11vvEEEEEEEEvv00++OOOO//44999999vv++PP77II++OOOO//44999999vv++PPAAAAAAvv88vvFFFFFFFFvv00++PPAAzz--BBPP11vvFFFFFFFFvv00++77OOOO++++PPOOOO//44999999vv++66vvFFFFFFFFvv00++PP99zz++OO88++PPAAAAvv33PP
```
Run:
```
$ dc < dnr6.short.dc 
Do not repeat yourself!
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~100~~ ~~58~~ 52 bytes
*-6 bytes thanks to Kevin Cruijssen*
```
„„€€··™™……€€––  ……¹¹‚‚  ……––‚‚))εε##θθáá}}»»……!!θθJJ
```
[Try it online!](https://tio.run/##yy9OTMpM/f//UcM8EGpaA0SHth/a/qhlEQg1LAMhsOijhslApKAAETu089DORw2zgAgmApGHiGlqntt6bquy8rkd53YcXnh4YW3tod2HdkPUKSqCRL28/v8HAA "05AB1E – Try It Online")
```
„„€€·              # 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
```
Idempotency rules.
[Answer]
# [BotEngine](https://github.com/SuperJedi224/Bot-Engine), 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
>>  ^^
```
[Answer]
# reticular, noncompeting, 62 bytes
```
2200**UU""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""oo;;
```
[Try it online!](http://reticular.tryitonline.net/#code=MjIwMCoqVVUiIkREb28gIG5ub290dCAgcnJlZXBwZWVhYXR0ICB5eW9vdXVycnNzZWVsbGZmISEiIm9vOzs&input=&args=)
Explanation in parts:
```
2200**
2200    the stack looks like [2 2 0 0]
    *   [2 2 0*0]
     *  [2 2*0*0]
        [2 0]
```
`U` sets the pointer direction to `(2, 0)`, that is, moving `2` x-units and `0` y-units, so it skips every other character, starting with the next `U` being skipped. Then, every other character is recorded, and it is equivalent to:
```
"Do not repeat yourself!"o;
```
which is a simple output program.
## Other
This is competing for WallyWest's JavaScript bounty:
I can prove that, while numbers can be constructed under this restriction, strings cannot. Since no literals can be used, as the placement of any literal-building character would create an empty string:
```
""
''
``
```
Then, only some operator can be used; the only "paired" operators used are:
```
++ -- << >> ** ~~ || && !! ==
```
And none of these can cast numbers/others to strings. So no strings can be outputted.
[Answer]
## [Alice](https://github.com/m-ender/alice), 74 bytes
```
aa00tt,,JJ""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!//@@""ooYY;;tt
```
[Try it online!](https://tio.run/nexus/alice#FccxDkARDADQ3Smqs4TdYjC5gdFQk6hUDU7v57/tvdZCUHWuFMScmQHmZFYFECFai6i1f/cynyOyN9EYvVvrfUqIzLXGqGrMex8 "Alice – TIO Nexus")
### Explanation
The first catch is that we need to be able to enter the string, so we want to skip only the first `"`. We do this by jumping onto the first `"` because then the IP will move one cell before looking at the current cell again, so that it's the second `"` which enters string mode. But to be able to jump there, we need `10, 0` on top of the stack, in that order (second, top). This is done with `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]
```
This rotation function pops an argument. If that argument is negative, it pushes the value on top of the stack down by that many positions. If the argument is positive, it goes looking for the element that many positions below the top and pulls it up to the top. Note that in the case of `Rotate(10)`, there aren't enough elements on the stack, but there is an implicit infinite amount of zeros at the bottom, which is why a zero ends up on top.
Now we can `J`ump onto the first `"` using these two arguments. The second `"` enters string mode and records all of that `DDoo nnoott...`. When it hits the `/`, the IP is redirected southeast and we enter Ordinal mode. For now on the IP bounces up and down across the three lines (two of which are empty), so it first records three more spaces on lines two and three and then we leave string mode when it hits the `"`. Since we're in Ordinal mode at this time, all the recorded characters are pushed as a single string to the stack (even though we recorded most of them in Cardinal mode), so we end up with this string (note the trailing spaces):
```
DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!   
```
Now the IP keeps bouncing up and down which means that it executes one command of every other pair, i.e. `Y` and `t`. Then the IP will hit the end of the grid on the second line and start bouncing backwards through the grid. This also switches in which pair of characters the IP hits the first line, so when going back it now executes `;`, `o` and `@`. So ignoring all the spaces and implicit IP redirections, the executed code is `Yt;o@` in Ordinal mode.
The `Y` is the "unzip" command which separates a string into the characters in alternating positions. Since each character is repeated, that really just gives us two copies of the string we're going for, although the first copy has two trailing spaces and the second has one trailing space. `t` splits off that trailing space and `;` discards it. Finally, `o` prints the string and `@` terminates the program.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 70 bytes
```
GG11hh::zzaapp..}}..""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""
```
[Run and debug it at staxlang.xyz!](https://staxlang.xyz/#c=GG11hh%3A%3Azzaapp..%7D%7D..%22%22DDoo++nnoott++rreeppeeaatt++yyoouurrsseellff%21%21%22%22&i=&a=1)
Stax very fortunately has the builtin `::` for every-nth. All I need to is push the string doubled, push 2, and run `::`. Easy, right?
Wrong.
Pushing that string is tricky. The first quotation mark can be doubled by `..""`, which is a length-2 literal for `."` followed by a meaningful quotation mark. Problem is, I see no way to terminate the string (which is necessary, or else the doubled version will be printed) without starting a new one.
The end of the program terminates string literals. If I can put this doubled literal there, perhaps there'll be a nice workaround. To jump somewhere from the end of a program, however, requires `G}`, so at minimum, I'm looking at this:
```
GG [deduplicate] }}""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""
```
This does... nothing. `G` does not begin a block, so neither will jump to the second `}`. Again, I need to ignore one character: `..}}`. Execution jumps from the first `G` to the second `}`, continues to the end, jumps back to the second `G` and from there to the second `}`, and continues once more to the end before resuming at the start of the `[deduplicate]` section with the doubled string atop the stack.
Deduplication is simple. `11hh` pushed eleven and halves it twice, rounding down both times and yielding two, and `::` will then get us the output we need.
```
GG11hh::..}}..""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""
```
Uh-oh. This prints nothing. There are two problems here: first, that `..}` means the string `.}` will be atop the stack at the end of the program, and second, Stax's ordinary implicit output is now disabled!
The worse issue is the output. When a Stax program terminates gracefully without printing anything, the top of the stack will be implicitly printed. But we haven't printed anything...? Ah, but we have. Unterminated string literals are printed rather than pushed, and even those two empty strings (from the unmatched `"` at the end), despite being empty, are enough to trip this check. Any printing must be done by hand.
We'll need either `pp` or `PP`, and in this instance, ignoring the first through `..pp` is unacceptable, as it will print the string `.p`. That means we need our desired output either alone on the stack or in the top two along with an empty string. This latter is accomplished by pushing two empty strings (`zz`) and rotating the top three items twice (`aa`) before printing.
Once that's done, we have a stack four strings tall. A fifth, `.}`, is then pushed before the program exits gracefully; at this point, the lack of implicit output becomes a blessing as well as a curse, as nothing extra will now be printed!
]