Schreiben Sie ein Programm, das ausgibt

Do not repeat yourself!

Ihr Programmcode muss die folgenden Einschränkungen erfüllen:

• seine Länge muss eine gerade Zahl sein
• Jedes Zeichen an der Position 2n(wobei neine Ganzzahl> 0 ist) muss mit dem Zeichen an der Position übereinstimmen 2n-1. Das zweite Zeichen des Programms entspricht dem ersten, das vierte dem dritten usw.

Zeilenumbrüche gelten als Zeichen!

Das ist Code-Golf, also gewinnt der kürzeste Code!

Beispiele

HHeellllooWWoorrlldd ist ein gültiges Programm

123oder AAABBBoder HHeellosind falsch

Nachprüfung

Mit diesem CJam-Skript können Sie überprüfen, ob Ihr Quellcode gültig ist. Fügen Sie einfach Ihren Code in das Feld "Eingabe" ein und führen Sie das Skript aus.

Hexagony , 166 126 124 Bytes

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

Das Einfügen der impliziten No-Ops und Whitespace entspricht dem folgenden Quellcode:

       \ \ ; ; ; ; 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 . . .

Ich bin mir sicher, dass es möglich ist, dies noch weiter zu verkürzen und vielleicht sogar in Seitenlänge 6 zu lösen, aber es wird schwierig ...

Wie es funktioniert

^{Diagramm erstellt mit Timwi's Hexagony Colorer .}

Der Code ist vollständig linear. Das \Recht am Anfang leitet die IP in eine Diagonale um, so dass wir uns überhaupt nicht um die doppelten Zeichen kümmern müssen. Die farbigen Pfade werden in der Reihenfolge Orange / Rot, Blau / Grau, Grün, Lila ausgeführt (wenn zwei Pfade derselben Farbe vorhanden sind, wird der linke Pfad zuerst ausgeführt, bevor der rechte Pfad umbrochen wird).

Wenn wir No-Ops, Mirrors und Befehle ignorieren, die von anderen überschrieben werden, läuft der lineare Code folgendermaßen ab:

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

Buchstaben in Hexagony setzen nur den aktuellen Wert der Speicherkante auf den Zeichencode des Buchstabens. ;druckt die aktuelle Speicherflanke als Zeichen. Mit setzen wir &den Speicherrand auf zurück 0und drucken ein Leerzeichen mit 32;. }bewegt sich zu einer anderen Kante, damit wir uns die 32für weitere Räume merken können . Der Rest des Codes druckt nur Buchstaben an der neuen Kante und bewegt sich gelegentlich mit vor und zurück ';}, um ein Leerzeichen zu drucken. Am Ende bewegen wir uns wieder mit 'an die Leerstelle, erhöhen den Wert mit auf 33 )und drucken das Ausrufezeichen. @Beendet das Programm.

GolfScript, 130 84 76 Bytes

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

Versuchen Sie es online in Web GolfScript .

Wie es funktioniert

Der GolfScript-Interpreter beginnt mit dem Platzieren einer leeren Zeichenfolge auf dem Stapel.

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

Das Verketten eines Arrays mit einer Zeichenfolge wird flacher, sodass das Ergebnis die gewünschte Ausgabe ist.

Unär , ~ 1,86 × 10 ²²²

Einfaches Brainfuck -> unäre Antwort. Sehr suboptimal;).

Das Programm besteht aus einer geraden Anzahl von Nullen; speziell:

18591845443321578900589300142868714304076630713114971071040949673052770413161833680684536892489021934372189963883751786804825252611634934782876706698317436209125772548546

von ihnen.

Ursprünglicher Brainfuck-Code:

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

Ruby - 2100 1428 1032 820 670 Bytes

Dies setzt voraus, dass die Ausgabe ein Rückgabewert einer Funktion sein kann (es wurde nicht angegeben, dass die Ausgabe STDOUT sein muss).

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))

Der Trick besteht darin, die Zeichenfolge aus einer leeren Zeichenfolge unter ""Verwendung der Anhängeoperation <<und der ASCII-Codes der Zeichen zu erstellen .

Um die Zahlen für die ASCII-Codes zu erhalten, versuche ich, die Zahl in Werte zu zerlegen, die ich leicht erzeugen kann. Zum Beispiel ist ASCII 90einfach 88+1+1:

• 88 ist okay für sich
• 11**00ist 11^0, was einfach ist1

Zum Glück beide ++und --würde bedeuten , addin Rubin, so kann ich schreiben 90als88++11**00++11**00

Es gibt einige Tricks, um zu einigen Zahlen zu gelangen, die einfacher sind als nur das Hinzufügen von Einsen. Hier ist der Code, mit dem ich das oben Genannte generiere (einschließlich aller von mir verwendeten Zuordnungen):

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

Ich denke immer noch über andere Tricks nach, um die Zeichen zu verringern, die erforderlich sind, um zu einer Zahl zu gelangen.

Beachten Sie Folgendes, wenn Sie das -rppFlag verwenden und wie folgt ppam Anfang des Codes einfügen:

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))

dann kann dies für zusätzliche 2 + 4 Bytes als ein vollständiges Programm funktionieren, aber es wird ein Extra "vor und nach der erforderlichen Zeichenfolge gedruckt :

Beispiel:

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

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

**

..

Zum Glück gilt die Einschränkung in gewisser Weise nicht vertikal. Das größte Problem ist jedoch, dass wir jede neue Zeile verdoppeln müssen.

Der Code, der ungefähr so ​​läuft, sieht folgendermaßen aus:

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

Beachten Sie, dass das Programm keine doppelten Leerzeichen enthält. Im Zeichenfolgenmodus werden durch Drücken von> <> Leerzeichen für leere Zellen eingefügt. Umgekehrt bedeutet dies jedoch, dass eine Lösung mit g(Lesen einer einzelnen Zelle aus dem Quellcode) schwieriger ist, da die im Programm enthaltenen Leerzeichen beim Lesen zu NULs werden.

^{(Hinweis: Dies kann 50 Byte kürzer sein, wenn es mit einem Fehler endet , aber ich mag es so.)}

Sclipting , 186 146 Bytes

긒긒 끄끄 닶닶 긂긂 닦닦 긒긒 긒긒 긒긒 긒긒 긒긒 긒긒 긒긒 긒긒 긒긒 긒긒

終 껢껢 鎵 鎵 ❶❶ 合 終 終 替 標 標 終 終 終

Um klar zu sein, gibt es drei Codezeilen, deren Mitte leer ist, da die neue Zeile dupliziert werden muss. Die Byteanzahl basiert auf der UTF-16-Codierung.

Erläuterung

Der Block koreanischer Zeichen am Anfang drückt die Zeichenfolge "DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012". Sie werden feststellen, dass jedes dritte Zeichen ein von uns gewünschtes Zeichen ist. der Rest ist Kauderwelsch. Hier ist der Grund:

In Sclipting codieren zwei koreanische Zeichen drei Bytes. Somit codiert jedes koreanische Zeichen effektiv 12 Bits. Damit eine Zeichenfolge beginnt D, müssen die ersten 8 Bits sein 0x44. Der Rest spielt keine Rolle, aber da wir jedes Zeichen wiederholen müssen, werden auch die Bits 12 bis 20 angezeigt 0x44. Wir werden also 0x44n44nfür einige n einen Wert der Form haben , der in die drei Bytes zerfällt 0x44 0xn4 0x4n.

Für das o, was ist 0x6F, erhalten wir die Bytes 0x6F 0xn6 0xFn.

Da ich faul bin, habe ich mit dem Codieren begonnen "DDDooo nnnooottt (etc.)"und dann jedes andere Zeichen durch das vorherige ersetzt, weshalb ich 0x444444= "DDD"für das Dund 0x6F66F6= "of�"für das bekomme o. Die �ist da, weil 0xF6an sich die UTF-8-Codierung ungültig ist.

Nun zurück zum Programm. Der Rest des Programms läuft wie folgt ab:

껢껢 - drückt die Saite ".\"�"

鎵 鎵 - Entfernt das letzte Zeichen zweimal und lässt uns dabei "."

❶❶ - zwei Duplikate. Jetzt stapeln:[".", ".", "."]

合 合 - zweimal verketten. Jetzt stapeln:["..."]

Als Nächstes möchte ich "..."als regulären Ausdruck verwenden, damit ich mit dem Schleifenkonstrukt 替 ... 終 drei Zeichen gleichzeitig aus der ursprünglichen Zeichenfolge abgleichen kann. Da jedoch jede Anweisung dupliziert wird, müssen zwei solcher regulären Ausdrucksschleifen ineinander verschachtelt sein. Wenn der Stapel unterläuft, wird ein Laufzeitfehler angezeigt. Deshalb,

虛虛 - zweimal die leere Zeichenfolge drücken

und starten Sie dann die Schleifen. Auf diese Weise wird die äußere Schleife nur einmal wiederholt, da sie mit dem regulären Ausdruck und ""der Zeichenfolge ""übereinstimmt, was zu einer einzelnen Übereinstimmung führt. Die innere Schleife läuft einmal für jedes Match "..."gegen die große Saite. Der Körper der Schleife ist:

標 標 - Schieben Sie zwei Markierungen auf den Stapel. Jetzt stapeln:[mark mark]

現 現 - Zwei Kopien des aktuellen Regex-Matches pushen. Jetzt stapeln:[mark mark "DDD" "DDD"]

併 併 - bis zur ersten Markierung verketten. Jetzt stapeln:["DDDDDD"]

一一 - nimm das erste Zeichen dieser Zeichenkette und dann (redundant) das erste Zeichen davon. Stack hat jetzt den Charakter, den wir wollen.

Die innere Schleife endet hier, sodass jede Übereinstimmung des regulären Ausdrucks durch das erste Zeichen dieser Übereinstimmung ersetzt wird. Dadurch bleibt die gewünschte Zeichenfolge auf dem Stapel.

Dann endet die äußere Schleife, und an diesem Punkt wird die gewünschte Zeichenfolge vom Stapel genommen und die einzige Übereinstimmung ""der Zeichenfolge ""mit dieser ersetzt, wobei die gewünschte Zeichenfolge erneut auf dem Stapel verbleibt.

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

Die doppelten Zeilenumbrüche tun weh, aber das beweist zumindest, dass es machbar ist!

Jedes Zeichen wird einzeln gedruckt, indem zuerst der Codepunkt gebildet und dann ein einzelnes Zeichen gedruckt wird. Die Codepunkte setzen sich zusammen aus:

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

wo

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

Das ungewöhnliche Verhalten der Labyrinth-Ziffern 33::00&&wird dabei tatsächlich ausgenutzt

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

Jedes einzelne Zeichen wird mit dem Mechanismus gedruckt

__vv

  ..

xx

Die xxexistieren nur, um das Gitter so aufzufüllen, dass es 5 hoch ist. Zuerst __drücken wir zwei Nullen, dann treffen wir einen Raster-Rotationsoperator v. Wir werfen eine Null und drehen:

__ v
  v
   .
  .
xx

und wieder:

__ v

  v.

xx.

Wir gehen dann nach rechts in die .dritte Zeile und führen den Druckbefehl nur einmal aus.

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}}//

Danke an Sp3000 für das Teilen meiner Programmgröße durch zwei :-)

Erläuterung

• Die Codes HH77++, GG00++, ... , die ganzzahlige ASCII - Code der Zeichen berechnen durch Zahlen Zugabe (zum Beispiel: `HH77 ++‘ schiebt 17, 17 und 77 auf den Stapel, dann fügen Sie diese Zahlen 3)
• Der Teil des Codes am Ende ]]{{cc}}//durchläuft die ASCII-Codes und konvertiert sie in Zeichen.

Probieren Sie es hier aus

Selbstmodifizierendes Brainf *** , 72 Bytes

Beachten Sie, dass dies \x00ein Literal- NULHex-Byte (leere Zelle) darstellt. Der Quellcode befindet sich auf dem Band links von der Startzelle.

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

Erläuterung

!!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

Bevor ich dieses Programm gemacht habe, habe ich eines gemacht, bei dem nur BF-Zeichen in der Quelle verwendet wurden. Es ist möglich! Es ist auch viel länger, da ich für einen ungeraden ASCII-Wert den doppelten Wert erstellen und dann durch zwei teilen wollte. Etwas kürzer wäre es, die gesamte Quelle zu modifizieren, um zunächst ungerade Werte zu generieren.

Jelly , 66 Bytes (nicht konkurrierend)

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

Probieren Sie es online!

Factoid

Das Programm funktioniert weiterhin, wenn Sie jedes zweite Zeichen entfernen.

Probieren Sie es online!

Wie es funktioniert

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

Gibt ein String-Array zurück. Das Literal beginnt mit a “und endet mit a ”, und die Zeichenfolgen werden intern durch begrenzt “. Das Ergebnis ist

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

Das Argument des Links und der Rückgabewert werden auf dieses String-Array gesetzt, und der Rest des Quellcodes wird ausgeführt.

<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 Bytes

\\

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

Gammaplex ist eine 2D-Sprache, die die Position des ersten Zeilenumbruchs als Zeilenlänge verwendet und alle anderen Zeilenumbrüche ignoriert.

MSM , 270-160 Bytes

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

Mein erstes MSM-Programm!

Die Zeichenkettenausgabe in MSM erfolgt, indem die einzelnen Zeichen auf den Stapel geschoben und zu einer einzigen Zeichenkette zusammengefügt werden ., z

!olleH.....

Die .Anzahl der Zeichen ist eins weniger als die Anzahl der Zeichen. Denn Do not repeat yourself!wir brauchen 22 .s. Zum Glück ist dies eine gerade Zahl, wir haben also 11 Doppel

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

Das Einfügen der Buchstaben erfordert etwas mehr Aufwand. Das Muster

cc'',,

macht den Trick für jeden Charakter c. Es wird wie folgt ausgewertet

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à!

Wir brauchen 23 solcher Muster, beginnend mit !!'',,und endend mit, DD'',,gefolgt von den 22 Verknüpfungsbefehlen ..

Befunge 98, 70 66 Bytes

Probieren Sie es online!

Nach meiner ungültigen Antwort ist hier eine bessere, die tatsächlich zur Herausforderung passt!

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

(Vielen Dank an Martin Ender, der die Verwendung des ��Zeichens 0x17 anstelle von vorgeschlagen hat88ff++ )

Erläuterung:

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 Bytes

Datei dnr6.short.dc(ohne Zeilenumbruch):

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

Lauf:

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

BotEngine , 6 × 49 = 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

>>  ^^

Rückhand 54 Bytes

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

Probieren Sie es online!

Da sich der Backhand-Zeiger bereits bei drei Zellen pro Tick bewegt, müssen wir ihn nur mit auf 2 verringern v

netzförmig, nicht konkurrierend, 62 Bytes

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

Probieren Sie es online!

Erklärung in Teilen:

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

USetzt die Zeigerrichtung auf (2, 0), d. h. bewegt 2x-Einheiten und 0y-Einheiten, sodass jedes andere Zeichen Uübersprungen wird , beginnend mit dem nächsten , das übersprungen wird. Dann wird jedes andere Zeichen aufgezeichnet und entspricht:

"Do not repeat yourself!"o;

Das ist ein einfaches Ausgabeprogramm.

Andere

Dies konkurriert um die JavaScript-Prämie von WallyWest:

Ich kann beweisen, dass Zahlen unter dieser Einschränkung konstruiert werden können, Zeichenfolgen jedoch nicht. Da keine Literale verwendet werden können, würde durch die Platzierung eines Buchstabens eine leere Zeichenfolge erstellt:

""
''
``

Dann kann nur ein Operator verwendet werden. Die einzigen "gepaarten" Operatoren sind:

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

Und keiner von diesen kann Zahlen / andere in Strings umwandeln. Es können also keine Zeichenketten ausgegeben werden.

Alice , 74 Bytes

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

Probieren Sie es online!

Erläuterung

Der erste Haken ist, dass wir in der Lage sein müssen, den String einzugeben, also wollen wir nur den ersten überspringen ". Wir tun dies, indem wir auf die erste "Zelle springen, da die IP dann eine Zelle verschiebt, bevor die aktuelle Zelle erneut angezeigt wird, so dass die zweite Zelle "in den Zeichenfolgenmodus wechselt. Aber um dorthin springen zu können, müssen wir 10, 0in dieser Reihenfolge (zweitens oben) oben auf dem Stapel stehen. Dies geschieht mit 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]

Diese Rotationsfunktion erzeugt ein Argument. Wenn dieses Argument negativ ist, wird der Wert oben auf dem Stapel um so viele Positionen nach unten verschoben. Wenn das Argument positiv ist, sucht es nach dem Element, das sich an vielen Stellen unter dem oberen Rand befindet, und zieht es nach oben. Beachten Sie, dass im Fall vonRotate(10) nicht genügend Elemente auf dem Stapel vorhanden sind, aber im unteren Bereich eine implizite unendliche Anzahl von Nullen vorhanden ist, weshalb eine Null oben endet.

Nun können wir mit diesen beiden Argumenten Jzum ersten übergehen ". Der zweite wechselt "in den String-Modus und zeichnet alles auf DDoo nnoott.... Wenn es das trifft /, wird die IP nach Südosten umgeleitet und wir gehen in den Ordinal-Modus. Im Moment springt die IP über die drei Zeilen (von denen zwei leer sind) auf und ab, so dass sie zuerst drei weitere Leerzeichen in den Zeilen zwei und drei aufzeichnet und dann den String-Modus verlässt, wenn sie auf die trifft ". Da wir uns zu diesem Zeitpunkt im Ordinal-Modus befinden, werden alle aufgezeichneten Zeichen als einzelne Zeichenfolge auf den Stapel verschoben (obwohl wir die meisten im Kardinal-Modus aufgezeichnet haben), sodass wir diese Zeichenfolge erhalten (beachten Sie die nachstehenden Leerzeichen). :

DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!   

Jetzt springt die IP weiter auf und ab, was bedeutet, dass sie einen Befehl von jedem anderen Paar ausführt, dh Yund t. Dann trifft die IP das Ende des Gitters in der zweiten Zeile und springt rückwärts durch das Gitter. Diese schaltet auch in dem Zeichenpaar die IP die erste Zeile trifft, so dass , wenn es geht jetzt zurück führt ;, ound @. Wenn Sie also alle Leerzeichen und impliziten IP-Umleitungen ignorieren, befindet sich der ausgeführte Code Yt;o@im Ordinal-Modus.

Das Yist der „Extrahieren“ -Befehl , der eine Zeichenkette in die Zeichen in alternierenden Positionen trennt. Da jedes Zeichen wiederholt wird, erhalten wir wirklich nur zwei Kopien der Zeichenfolge, die wir suchen, obwohl die erste Kopie zwei nachgestellte Leerzeichen und die zweite ein nachgestelltes Leerzeichen enthält. tspaltet diesen abschließenden Raum ab und ;wirft ihn weg . Zum Schluss wird oder String gedruckt und @das Programm beendet.

05AB1E , 100 58 52 Bytes

-6 Bytes dank Kevin Cruijssen

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

Probieren Sie es 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

Idempotenzregeln.

Stax , 70 Bytes

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

Führen Sie es aus und debuggen Sie es unter staxlang.xyz!

Stax hat zum Glück ::für jedes n-te das eingebaute . Alles, was ich tun muss, ist, die Saite zu verdoppeln, 2 zu drücken und zu rennen ::. Einfach richtig?

Falsch.

Das Drücken dieser Saite ist schwierig. Das erste Anführungszeichen kann verdoppelt werden. Dies ..""ist ein Länge-2-Literal, ."gefolgt von einem sinnvollen Anführungszeichen. Das Problem ist, dass ich keine Möglichkeit sehe, die Zeichenfolge (die notwendig ist, oder die doppelte Version wird gedruckt) zu beenden, ohne eine neue zu starten.

Das Programmende beendet String-Literale. Wenn ich dieses doppelte Wort dort einsetzen kann, gibt es möglicherweise eine nette Problemumgehung. Um irgendwo vom Ende eines Programms zu springen, muss man jedoch G}mindestens Folgendes beachten:

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

Das macht ... nichts. GBeginnt keinen Block und springt auch nicht zum zweiten }. Auch hier muss ich ein Zeichen ignorieren: ..}}. Die Ausführung springt von der ersten Gzur zweiten }, setzt sich bis zum Ende fort, springt zur zweiten Gund von dort zur zweiten zurück }und setzt sich noch einmal bis zum Ende fort, bevor sie am Anfang des [deduplicate]Abschnitts mit der doppelten Zeichenfolge auf dem Stapel fortgesetzt wird .

Die Deduplizierung ist einfach. 11hhschob elf und halbierte es zweimal, rundete beide Male ab und lieferte zwei, und ::dann erhalten wir die Ausgabe, die wir brauchen.

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

Oh, oh. Dies druckt nichts. Hier gibt es zwei Probleme: Erstens ..}bedeutet dies , dass der String .}am Ende des Programms auf dem Stack liegt, und zweitens ist die normale implizite Ausgabe von Stax jetzt deaktiviert!

Das schlimmste Problem ist die Ausgabe. Wenn ein Stax-Programm ordnungsgemäß beendet wird, ohne etwas zu drucken, wird implizit die Oberseite des Stapels gedruckt. Aber wir haben nichts gedruckt ...? Ah, aber wir haben. Nicht abgeschlossene Zeichenfolgenliterale werden gedruckt und nicht verschoben, und selbst diese beiden leeren Zeichenfolgen (von den nicht übereinstimmenden "am Ende) reichen aus, um diese Prüfung auszulösen , obwohl sie leer sind. Der Druck muss von Hand erfolgen.

Wir brauchen entweder ppoder PP, und in diesem Fall ist das Ignorieren des ersten Durchgangs ..ppnicht akzeptabel, da der String gedruckt wird .p. Das heißt, wir brauchen unsere gewünschte Ausgabe entweder alleine auf dem Stack oder in den beiden oberen zusammen mit einer leeren Zeichenkette. Letzteres wird erreicht, indem zwei leere Zeichenfolgen ( zz) gedrückt werden und die oberen drei Elemente aavor dem Drucken zweimal gedreht werden ( ).

Sobald das erledigt ist, haben wir einen Stapel von vier Saiten. Ein Fünftel .}wird dann verschoben, bevor das Programm ordnungsgemäß beendet wird. An diesem Punkt wird der Mangel an impliziter Ausgabe sowohl zum Segen als auch zum Fluch, da jetzt nichts mehr gedruckt wird!