Napisz program, który wyjdzie

Do not repeat yourself!

Twój kod programu musi przestrzegać następujących ograniczeń:

• jego długość musi być liczbą parzystą
• każdy znak na pozycji 2n(gdzie nliczba całkowita> 0) musi być równy znakowi na pozycji 2n-1. Drugi znak programu jest równy pierwszemu, czwarty jest równy trzeciemu itd.

Nowe linie liczą się jako znaki!

To jest golf golfowy, więc wygrywa najkrótszy kod!

Przykłady

HHeellllooWWoorrlldd jest prawidłowym programem

123lub AAABBBlub HHeellosą niepoprawne

Weryfikacja

Za pomocą tego skryptu CJam można sprawdzić, czy kod źródłowy jest prawidłowy. Wystarczy wkleić kod w polu „Input” i uruchomić skrypt.

Sześciokąty , 166 126 124 bajtów

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

Wstawienie niejawnych zakazów i białych znaków odpowiada następującemu kodowi źródłowemu:

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

Jestem pewien, że można to jeszcze bardziej skrócić, a może nawet rozwiązać to z boku o długości 6, ale robi się to trudne ...

Jak to działa

^{Schemat wygenerowany przy użyciu Sześciokąta Colorer Timwi .}

Kod jest całkowicie liniowy. Na \samym początku przekierowuje adres IP na przekątną, tak że nie musimy się w ogóle martwić o podwojone znaki. Kolorowe ścieżki są wykonywane w kolejności pomarańczowy / czerwony, niebieski / szary, zielony, fioletowy (gdy są dwie ścieżki tego samego koloru, najpierw wykonuje się ścieżkę po lewej stronie, a następnie owija się ją po prawej).

Jeśli zignorujemy brak operacji, mirrory i polecenia, które są nadpisywane przez innych, kod liniowy sprowadza się do tego:

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

Litery w Hexagony po prostu ustawiają bieżącą wartość krawędzi pamięci na kod literowy litery. ;drukuje bieżącą krawędź pamięci jako znak. Używamy &do resetowania krawędzi pamięci 0i drukowania miejsca za pomocą 32;. }przesuwa się na inną krawędź, abyśmy mogli zapamiętać 32kolejne miejsca. Reszta kodu po prostu drukuje litery na nowej krawędzi i od czasu do czasu przesuwa się tam iz powrotem, ';}aby wydrukować spację. Na koniec ponownie przechodzimy do krawędzi spacji za pomocą ', zwiększamy wartość do 33 za pomocą )i drukujemy wykrzyknik. @kończy program.

GolfScript, 130 84 76 bajtów

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

Wypróbuj online w Web GolfScript .

Jak to działa

Interpreter GolfScript rozpoczyna się od umieszczenia pustego łańcucha na stosie.

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

Łączenie tablicy z ciągiem spłaszcza się, więc wynikiem jest pożądany wynik.

Unary , ~ 1,86 × 10 ²²²

Proste pieprzenie mózgu -> jednoznaczna odpowiedź. Bardzo nieoptymalne;).

Program składa się z parzystej liczby zer; konkretnie:

1859184544332157890058930014286871430407663071311497107104094967305277041316183368068453689248902193437218996388375178680482526116349347828767066983174362041491257725282304432256118059236484741485455046352611468332836658716

z nich.

Oryginalny kod pieprzenia mózgu:

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

Rubinowy - 2100 1428 1032 820 670 bajtów

Zakłada się, że wyjście może być wartością zwracaną z funkcji (nie określono, że wyjście musi być do STDOUT)

Kod:

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

Sztuką jest zbudowanie ciągu z pustego ciągu ""przy użyciu operacji dołączania <<i kodów ASCII znaków.

Aby uzyskać liczby dla kodów ASCII, próbuję rozłożyć liczbę na wartości, które mogę łatwo wygenerować. Na przykład ASCII 90jest po prostu 88+1+1:

• 88 sam jest w porządku
• 11**00jest 11^0, co jest po prostu1

Na szczęście jedno ++i drugie --oznaczałoby addrubin, więc mogę pisać 90jako88++11**00++11**00

Jest kilka sztuczek, aby łatwiej dostać się do niektórych liczb niż dodawanie 1, oto kod, którego używam do wygenerowania powyższego (który obejmuje wszystkie mapowania, których używam):

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

Nadal myślę o innych sztuczkach, aby zmniejszyć liczbę znaków wymaganych do uzyskania liczby.

Pamiętaj, że jeśli użyjesz -rppflagi i dodasz ppna początku kodu w następujący sposób:

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

następnie dla dodatkowych 2 + 4 bajtów może to działać jako w pełni kompletny program, ale wypisze dodatkowy "przed i po wymaganym ciągu:

Przykład:

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

> <> , 174 bajty

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

**

..

Na szczęście w pewnym sensie ograniczenie nie ma zastosowania w pionie. Jednak największym problemem jest to, że musimy podwoić każdą nową linię.

Kod, który działa z grubsza, wygląda następująco:

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

Zauważ, że program nie ma podwójnych spacji - w trybie łańcuchowym> <> wypycha spacje dla pustych komórek. Odwrotnie jednak oznacza to, że rozwiązanie wykorzystujące g(odczyt pojedynczej komórki z kodu źródłowego) byłoby trudniejsze, ponieważ przestrzenie w programie stają się NUL podczas odczytu.

^{(Uwaga: Może być o 50 bajtów krótszy, jeśli zakończy się błędem , ale podoba mi się to w ten sposób.)}

Sclipting , 186 146 bajtów

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

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

Żeby było jasne, istnieją trzy linie kodu, z których środek jest pusty, ponieważ nowa linia musi zostać zduplikowana. Liczba bajtów oparta jest na kodowaniu UTF-16.

Wyjaśnienie

Blok koreańskich znaków na początku popycha ciąg "DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012". Zauważysz, że co trzecia postać jest postacią, której chcemy; reszta to bełkot. Dlatego:

W Sclipting dwa koreańskie znaki kodują trzy bajty. Zatem każdy znak koreański skutecznie koduje 12 bitów. Aby otrzymać ciąg zaczynający się od D, pierwsze 8 bitów musi być 0x44; reszta nie ma znaczenia, ale ponieważ musimy powtarzać każdą postać, od 12 do 20 bitów też będą 0x44. Tak więc 0x44n44ndla pewnej liczby n będziemy mieli wartość postaci , która rozkłada się na trzy bajty 0x44 0xn4 0x4n.

Dla o, czyli 0x6Fdostajemy bajty 0x6F 0xn6 0xFn.

Ponieważ jestem leniwy, zacząłem od kodowania, "DDDooo nnnooottt (etc.)"a następnie zamieniłem każdy inny znak na poprzedni, dlatego otrzymuję 0x444444= "DDD"dla Di 0x6F66F6= "of�"dla o. �Ma ponieważ 0xF6sama jest nieprawidłowy kodowania UTF-8.

Wróćmy do programu. Reszta programu przebiega w następujący sposób:

껢껢 - popycha sznur ".\"�"

鎵 鎵 - usuwa ostatni znak dwa razy, pozostawiając nas z "."

❶❶ - dwa duplikaty. Teraz stos:[".", ".", "."]

合 合 - konkatenuj dwa razy. Teraz stos:["..."]

Teraz chcę użyć "..."wyrażenia regularnego, dzięki czemu mogę dopasować trzy znaki z oryginalnego ciągu jednocześnie, używając konstrukcji pętli 替 ... 終. Ponieważ jednak każda instrukcja jest zduplikowana, muszę mieć dwie takie pętle wyrażeń regularnych zagnieżdżone w sobie, a jeśli zapełni się stos, otrzymuję błąd czasu wykonywania. W związku z tym,

虛虛 - naciśnij pusty ciąg dwa razy

a następnie uruchom pętle. W ten sposób zewnętrzna pętla iteruje tylko raz, ponieważ dopasowuje wyrażenie regularne ""do łańcucha "", co daje pojedyncze dopasowanie. Wewnętrzna pętla działa raz na każde dopasowanie "..."do dużego łańcucha. Ciało pętli to:

標 標 - wciśnij dwa znaczniki na stos. Teraz stos:[mark mark]

現 現 - wciśnij dwie kopie bieżącego dopasowania wyrażenia regularnego. Teraz stos:[mark mark "DDD" "DDD"]

併 併 - konkatenuje do pierwszego znaku. Teraz stos:["DDDDDD"]

一一 - weź pierwszy znak tego ciągu, a następnie (nadmiarowo) pierwszy znak tego ciągu. Stack ma teraz postać, którą chcemy.

Pętla wewnętrzna kończy się tutaj, więc każde dopasowanie wyrażenia regularnego jest zastępowane pierwszym znakiem tego dopasowania. Pozostawia to żądany ciąg na stosie.

Następnie kończy się zewnętrzna pętla, w którym to momencie pożądany ciąg jest usuwany ze stosu, a jedyne dopasowanie ""ciągu w łańcuchu ""jest zastępowane nim, pozostawiając pożądany ciąg ponownie na stosie.

Labirynt , 528 bajtów

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

Podwójne znaki nowej linii bolą, ale przynajmniej to dowodzi, że jest to wykonalne!

Każdy znak jest drukowany jeden po drugim, najpierw przez utworzenie punktu kodowego, a następnie wydrukowanie pojedynczego znaku. Punkty kodowe są tworzone przez:

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

gdzie

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

Niezwykłe zachowanie cyfr Labiryntu jest wykorzystywane, w 33::00&&rzeczywistości

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

Każdy pojedynczy znak jest drukowany z mechanizmem

__vv

  ..

xx

xxIstnieć tylko pad siatkę tak, że jest to 5 wysokie. Najpierw __wciśnij dwa zera, a następnie uderzymy w operatora obrotu siatki v. Wystawiamy zero i obracamy:

__ v
  v
   .
  .
xx

i znowu:

__ v

  v.

xx.

Następnie przechodzimy w prawo do .trzeciego wiersza, wykonując polecenie drukowania tylko raz.

CJam - 176 136 bajtów

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

Dzięki Sp3000 za podzielenie mojego programu przez dwa :-)

Wyjaśnienie

• Kody HH77++, GG00++... obliczają całkowity kod ascii znaków, dodając liczby (na przykład: `HH77 ++ 'wypycha 17, 17 i 77 na stos, a następnie dodaje te 3 liczby)
• część kodu na końcu ]]{{cc}}//zapętla się przez kody ascii i konwertuje je na znaki.

Wypróbuj tutaj

Samo-modyfikujący Brainf *** , 72 bajty

Zauważ, że \x00reprezentuje dosłowny NULbajt szesnastkowy (pusta komórka). Kod źródłowy jest umieszczony na taśmie po lewej stronie komórki początkowej.

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

Wyjaśnienie

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

Ponadto, przed stworzeniem tego programu, robiłem taki, używając tylko znaków BF w źródle. To jest możliwe! Jest także znacznie dłuższy, ponieważ dla nieparzystej wartości ASCII zamierzałem utworzyć podwójną wartość, a następnie podzielić przez dwa. Nieco krócej byłoby zmodyfikować całe źródło, aby generować nieparzyste wartości na początek.

Galaretka , 66 bajtów (niekonkurencyjna)

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

Wypróbuj online!

Faktoid

Program nadal działa, jeśli usuniesz co drugi znak.

Wypróbuj online!

Jak to działa

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

zwraca tablicę ciągów. Dosłowność zaczyna się na a “, kończy na a ”, a łańcuchy są wewnętrznie ograniczone przez “. Wynik to

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

Argument dowiązania i wartość zwracana są ustawiane na tę tablicę ciągów, a następnie wykonywana jest pozostała część kodu źródłowego.

<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 bajtów

\\

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

Gammaplex to język 2D, który wykorzystuje pozycję pierwszej nowej linii jako długość linii i ignoruje wszystkie inne nowe linie.

MSM , 270 160 bajtów

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

Mój pierwszy program MSM!

Wyprowadzanie ciągu znaków w MSM odbywa się poprzez wypychanie poszczególnych znaków na stos i łączenie ich w pojedynczy ciąg znaków ., np

!olleH.....

Liczba .jest o jeden mniejsza niż liczba znaków. Dla Do not repeat yourself!potrzebujemy 22 .s. Na szczęście jest to liczba parzysta, więc mamy 11 podwójnych

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

Umieszczenie przed nim liter wymaga większego wysiłku. Wzór

cc'',,

robi lewę dla każdej postaci c. Ocenia w następujący sposób

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

Potrzebujemy 23 takich wzorów, zaczynających się !!'',,i kończących DD'',,na 22 komendach łączenia ..

Befunge 98, 70 66 bajtów

Wypróbuj online!

Po mojej niepoprawnej odpowiedzi, oto lepsza, która faktycznie pasuje do wyzwania!

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

(Podziękowania dla Martina Endera za sugestię użycia ��znaku 0x17 zamiast 88ff++)

Wyjaśnienie:

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 bajtów

Plik dnr6.short.dc(bez końcowego znaku nowej linii):

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

Biegać:

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

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

Wypróbuj online!

Ponieważ wskaźnik Backhand już porusza się w trzech komórkach tyknięcia, wszystko, co musimy zrobić, to zmniejszyć go do 2 za pomocą v

siatkowy, niekonkurencyjny, 62 bajty

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

Wypróbuj online!

Objaśnienie w częściach:

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

Uustawia kierunek wskaźnika na (2, 0), tj. przesuwanie 2jednostek xi jednostek 0y, więc przeskakuje co drugą postać, zaczynając od następnej Upomijanej. Następnie każda inna postać jest rejestrowana i jest to równoważne z:

"Do not repeat yourself!"o;

który jest prostym programem wyjściowym.

Inny

To konkuruje o nagrodę JavaScript WallyWest:

Mogę udowodnić, że chociaż liczby mogą być konstruowane zgodnie z tym ograniczeniem, ciągi nie mogą. Ponieważ nie można użyć literałów, ponieważ umieszczenie dowolnego znaku budującego literały utworzy pusty ciąg:

""
''
``

Wtedy można użyć tylko niektórych operatorów; jedynymi używanymi operatorami „sparowanymi” są:

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

I żaden z nich nie może rzucać liczb / innych na ciągi. Dlatego nie można wyprowadzać żadnych ciągów.

Alice , 74 bajty

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

Wypróbuj online!

Wyjaśnienie

Pierwszy haczyk polega na tym, że musimy być w stanie wprowadzić ciąg, więc chcemy pominąć tylko pierwszy ". Robimy to, przeskakując na pierwszą, "ponieważ wtedy IP poruszy jedną komórkę przed ponownym spojrzeniem na bieżącą komórkę, tak że druga "wejdzie w tryb ciągów. Ale aby móc tam wskoczyć, potrzebujemy 10, 0na szczycie stosu, w tej kolejności (drugi, górny). Odbywa się to za pomocą 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]

Ta funkcja rotacji wyskakuje z argumentem. Jeśli argument ten jest negatywny, przesuwa wartość na szczycie stosu o tyle pozycji. Jeśli argument jest pozytywny, szuka elementu, który umieszcza wiele poniżej szczytu i wyciąga go na górę. Zauważ, że w przypadku Rotate(10)nie ma wystarczającej liczby elementów na stosie, ale na dole jest ukryta nieskończona liczba zer, dlatego zero kończy się na górze.

Teraz możemy Jprzejść do pierwszego "za pomocą tych dwóch argumentów. Drugi "wchodzi w tryb strunowy i rejestruje to wszystko DDoo nnoott.... Po trafieniu /adres IP zostaje przekierowany na południowy wschód i wchodzimy w tryb porządkowy. Na razie adres IP odbija się w górę iw dół przez trzy linie (z których dwie są puste), więc najpierw rejestruje trzy kolejne spacje w liniach drugiej i trzeciej, a następnie opuszczamy tryb łańcuchowy, gdy uderza ". Ponieważ obecnie jesteśmy w trybie porządkowym, wszystkie zarejestrowane znaki są wypychane jako jeden ciąg znaków na stos (mimo że większość z nich nagrywaliśmy w trybie kardynalnym), więc kończymy na tym ciągu (zwróć uwagę na spacje końcowe) :

DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!   

Teraz IP utrzymuje podskakują w górę iw dół, co oznacza, że wykonuje jedno polecenie każdej innej pary, czyli Ya t. Wtedy IP uderzy w koniec siatki w drugiej linii i zacznie się odbijać do tyłu przez siatkę. To także włącza w którym para znaków IP uderza pierwszą linię, więc kiedy wraca teraz wykonuje ;, oi @. Ignorując wszystkie spacje i niejawne przekierowania IP, wykonany kod działa Yt;o@w trybie porządkowym.

Jest Yto polecenie „rozpakuj”, które dzieli ciąg znaków na znaki na przemiennych pozycjach. Ponieważ każdy znak jest powtarzany, to tak naprawdę daje nam tylko dwie kopie ciągu, dla którego idziemy, chociaż pierwsza kopia ma dwie końcowe spacje, a druga jedną spację końcową. tdzieli to końcowe miejsce i ;odrzuca je. Na koniec odrukuje ciąg i @kończy działanie programu.

05AB1E , 100 58 52 bajtów

-6 bajtów dzięki Kevin Cruijssen

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

Wypróbuj 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

Zasady idempotencji.

Stax , 70 bajtów

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

Uruchom i debuguj na staxlang.xyz!

Na szczęście Stax ma wbudowane ::co n-ty. Wszystko, czego potrzebuję, to podwoić ciąg, pchnąć 2 i uruchomić ::. Łatwe, prawda?

Źle.

Naciskanie tego sznurka jest trudne. Pierwszy znak cudzysłowu może być podwojony o .."", który jest literałem o długości 2, ."po którym następuje znaczący znak cudzysłowu. Problem polega na tym, że nie widzę sposobu na zakończenie łańcucha (co jest konieczne, w przeciwnym razie zostanie wydrukowana wersja podwójna) bez uruchamiania nowego.

Koniec programu kończy literały łańcuchowe. Jeśli uda mi się umieścić tam podwojony literał, być może będzie fajne obejście. Jednak przeskok gdzieś od końca programu wymaga G}, więc przynajmniej patrzę na to:

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

To nie robi ... nic. Gnie rozpoczyna bloku, więc żaden nie przejdzie do drugiego }. Znowu muszę ignorować jeden znak: ..}}. Wykonanie przeskakuje od pierwszego Gdo drugiego }, kontynuuje do końca, przeskakuje z powrotem do drugiego, Ga stamtąd do drugiego }, i kontynuuje jeszcze raz do końca, zanim zostanie wznowiony na początku [deduplicate]sekcji z podwójnym łańcuchem na stosie.

Deduplikacja jest prosta. 11hhprzesunęliśmy jedenaście razy i zmniejszamy ją o połowę, zaokrąglając dwa razy w dół i uzyskując dwa, a ::następnie zapewni nam potrzebną wydajność.

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

O o. To nic nie drukuje. Są tutaj dwa problemy: po pierwsze, ..}oznacza to, że łańcuch .}będzie na szczycie stosu na końcu programu, a po drugie, zwykłe niejawne wyjście Stax jest teraz wyłączone!

Najgorszym problemem jest wydajność. Gdy program Stax zakończy się płynnie bez drukowania, górna część stosu zostanie wydrukowana domyślnie. Ale nic nie wydrukowaliśmy ...? Ach, ale my mamy. Nieokreślone literały łańcuchowe są drukowane, a nie wypychane, a nawet te dwa puste łańcuchy (od niedopasowanego "na końcu), pomimo tego, że są puste, wystarczą do wyzwolenia tej kontroli. Wszelkie drukowanie musi być wykonane ręcznie.

Musimy albo ppalbo PP, w tym przypadku, ignorując pierwsze przez ..ppto nie do przyjęcia, ponieważ będzie ona drukować ciąg .p. Oznacza to, że potrzebujemy pożądanego wyjścia pojedynczo na stosie lub w dwóch pierwszych, wraz z pustym ciągiem. To ostatnie osiąga się przez naciśnięcie dwóch pustych łańcuchów ( zz) i obrócenie dwóch górnych elementów dwa razy ( aa) przed wydrukowaniem.

Po wykonaniu tej czynności mamy stos o wysokości czterech sznurków. Piąta część .}jest następnie wypychana, zanim program zakończy się z wdziękiem; w tym momencie brak dorozumianych rezultatów staje się zarówno błogosławieństwem, jak i przekleństwem, ponieważ nic więcej nie będzie teraz drukowane!