Viết chương trình xuất ra

Do not repeat yourself!

Mã chương trình của bạn phải tôn trọng các ràng buộc sau:

• độ dài của nó phải là một số chẵn
• mỗi ký tự ở vị trí 2n(trong đó nmột số nguyên> 0) phải bằng với ký tự ở vị trí 2n-1. Nhân vật thứ hai của chương trình bằng với người thứ nhất, người thứ tư bằng người thứ ba, v.v.

Dòng mới được tính là ký tự!

Đây là môn đánh gôn, vì vậy đoạn mã ngắn nhất sẽ thắng!

Ví dụ

HHeellllooWWoorrlldd là một chương trình hợp lệ

123hay AAABBBhoặc HHeellolà không chính xác

xác minh

Bạn có thể sử dụng tập lệnh CJam này để xác minh rằng mã nguồn của bạn là hợp lệ. Chỉ cần dán mã của bạn vào hộp "Đầu vào" và chạy tập lệnh.

Lục giác , 166 126 124 byte

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

Chèn các khoảng trống và khoảng trắng ẩn, điều này tương ứng với mã nguồn sau:

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

Tôi chắc chắn rằng nó có thể rút ngắn điều này hơn nữa, và thậm chí có thể giải quyết nó trong chiều dài 6, nhưng nó trở nên khó khăn ...

Làm thế nào nó hoạt động

^{Sơ đồ được tạo bằng Hexagony Colorer của Timwi's .}

Mã này là hoàn toàn tuyến tính. Các \đúng vào lúc bắt đầu chuyển hướng IP thành một đường chéo, như vậy mà chúng ta không cần phải lo lắng về các nhân vật tăng gấp đôi ở tất cả. Các đường dẫn màu được thực hiện theo thứ tự cam / đỏ, xanh dương / xám, xanh lục, tím (khi có hai đường dẫn cùng màu, đường dẫn bên trái được thực hiện trước, trước khi quấn quanh bên phải).

Nếu chúng ta bỏ qua no-op, gương và các lệnh bị ghi đè bởi người khác, mã tuyến tính sẽ dẫn đến điều này:

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

Các chữ cái trong Hexagony chỉ đặt giá trị của cạnh bộ nhớ hiện tại thành mã ký tự của chữ cái. ;in cạnh bộ nhớ hiện tại dưới dạng ký tự. Chúng tôi sử dụng &để thiết lập lại cạnh bộ nhớ 0và in một khoảng trắng với 32;. }di chuyển đến một cạnh khác, để chúng ta có thể nhớ các 32không gian xa hơn. Phần còn lại của mã chỉ in các chữ cái trên cạnh mới và đôi khi di chuyển qua lại ';}để in một khoảng trắng. Cuối cùng, chúng ta di chuyển đến cạnh không gian một lần nữa ', tăng giá trị lên 33 với )và in dấu chấm than. @chấm dứt chương trình.

GolfScript, 130 84 76 byte

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

Dùng thử trực tuyến trong Web GolfScript .

Làm thế nào nó hoạt động

Trình thông dịch GolfScript bắt đầu bằng cách đặt một chuỗi rỗng trên ngăn xếp.

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

Nối một mảng với một chuỗi làm phẳng, do đó, kết quả là đầu ra mong muốn.

Đơn phương , ~ 1,86 × 10 ²²²

Brainfuck đơn giản -> câu trả lời đơn nhất. Rất tối ưu phụ;).

Chương trình bao gồm số chẵn là 0; đặc biệt:

Số điện thoại trong phòng

của họ.

Mã Brainfuck gốc:

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

Ruby - 2100 1428 1032 820 670 byte

Điều này giả sử đầu ra có thể là giá trị trả về từ một hàm (nó không được chỉ định rằng đầu ra cần phải là STDOUT)

Mã số:

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

Mẹo nhỏ là xây dựng chuỗi từ một chuỗi trống ""bằng cách sử dụng thao tác chắp thêm <<và mã ASCII của các ký tự.

Để lấy số cho mã ASCII, tôi đang cố gắng phân tách số thành các giá trị tôi có thể dễ dàng tạo. Ví dụ ASCII 90là 88+1+1, đó là:

• 88 tự nó ổn
• 11**00là 11^0, đơn giản1

May mắn là cả hai ++và --có nghĩa là addtrong ruby, vì vậy tôi có thể viết 90như88++11**00++11**00

Có một số thủ thuật để có được một số số dễ dàng hơn là chỉ thêm 1 số, đây là mã tôi đang sử dụng để tạo ở trên (bao gồm tất cả các ánh xạ tôi đang sử dụng):

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

Tôi vẫn đang suy nghĩ về các thủ thuật khác để giảm các ký tự cần thiết để lấy số.

Lưu ý rằng nếu bạn sử dụng -rppcờ và thêm ppvào đầu mã như vậy:

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

sau đó để có thêm 2 + 4 byte, điều này có thể hoạt động như một chương trình hoàn chỉnh, nhưng nó sẽ in thêm "trước và sau chuỗi yêu cầu:

Thí dụ:

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

> <> , 174 byte

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

**

..

Rất may, theo một nghĩa nào đó, hạn chế không áp dụng theo chiều dọc. Tuy nhiên, vấn đề lớn nhất là chúng ta cần tăng gấp đôi mỗi dòng mới.

Mã chạy đại khái như thế này:

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

Lưu ý rằng chương trình không có khoảng trắng kép - khi ở chế độ chuỗi,> <> đẩy khoảng trắng cho các ô trống. Tuy nhiên, ngược lại, điều này có nghĩa là một giải pháp sử dụng g(đọc một ô từ mã nguồn) sẽ khó khăn hơn, vì khoảng trắng nào trong chương trình sẽ trở thành NUL khi đọc.

^{(Lưu ý: Điều này có thể ngắn hơn 50 byte nếu nó kết thúc với một lỗi , nhưng tôi thích nó theo cách này.)}

Quét , 186 146 byte

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

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

Để rõ ràng, có ba dòng mã, ở giữa là trống, bởi vì dòng mới cần phải được sao chép. Số lượng byte được dựa trên mã hóa UTF-16.

Giải trình

Khối ký tự tiếng Hàn khi bắt đầu đẩy chuỗi "DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012". Bạn sẽ nhận thấy rằng mỗi nhân vật thứ ba là một nhân vật chúng ta muốn; phần còn lại là vô nghĩa. Đây là lý do tại sao:

Trong Sclipting, hai ký tự tiếng Hàn mã hóa ba byte. Do đó, mỗi ký tự tiếng Hàn có hiệu quả mã hóa 12 bit. Để có được một chuỗi bắt đầu bằng D, 8 bit đầu tiên phải là 0x44; phần còn lại không quan trọng, nhưng vì chúng ta phải lặp lại mọi ký tự, các bit thứ 12 đến 20 cũng sẽ xuất hiện 0x44. Do đó, chúng ta sẽ có một giá trị của biểu mẫu 0x44n44ncho một số n , phân tách thành ba byte 0x44 0xn4 0x4n.

Đối với o, đó là 0x6F, chúng tôi nhận được các byte 0x6F 0xn6 0xFn.

Vì tôi lười biếng, tôi bắt đầu bằng cách mã hóa "DDDooo nnnooottt (etc.)"và sau đó thay thế mọi ký tự khác bằng ký tự trước đó, đó là lý do tại sao tôi nhận 0x444444= "DDD"cho Dvà 0x6F66F6= "of�"cho o. Có �bởi vì 0xF6bản thân nó là mã hóa UTF-8 không hợp lệ.

Bây giờ, trở lại chương trình. Phần còn lại của chương trình tiến hành như sau:

- đẩy chuỗi ".\"�"

- xóa nhân vật cuối cùng hai lần, để lại cho chúng tôi "."

❶❶ - hai bản sao. Chồng ngay bây giờ:[".", ".", "."]

合 - nối hai lần. Chồng ngay bây giờ:["..."]

Bây giờ, điều tôi muốn làm tiếp theo là sử dụng "..."như một biểu thức chính quy để tôi có thể khớp ba ký tự từ chuỗi gốc tại một thời điểm, sử dụng cấu trúc vòng lặp 替 .... Tuy nhiên, vì mỗi lệnh được sao chép, tôi cần phải có hai vòng lặp biểu thức chính quy như vậy được lồng vào nhau và nếu ngăn xếp vượt quá tôi sẽ gặp lỗi thời gian chạy. Vì thế,

- đẩy chuỗi trống hai lần

và sau đó bắt đầu các vòng lặp. Theo cách này, vòng lặp bên ngoài chỉ lặp lại một lần vì nó khớp với biểu thức chính quy ""so với chuỗi "", tạo ra một kết quả khớp duy nhất. Vòng lặp bên trong chạy một lần cho mỗi trận đấu "..."với chuỗi lớn. Phần thân của vòng lặp là:

標 標 - đẩy hai dấu lên ngăn xếp. Chồng ngay bây giờ:[mark mark]

現 現 - đẩy hai bản sao của trận đấu regex hiện tại. Chồng ngay bây giờ:[mark mark "DDD" "DDD"]

併 - nối đến điểm đầu tiên. Chồng ngay bây giờ:["DDDDDD"]

- lấy ký tự đầu tiên của chuỗi đó, và sau đó (thừa) ký tự đầu tiên của chuỗi đó. Stack bây giờ có nhân vật chúng ta muốn.

Vòng lặp bên trong kết thúc tại đây, vì vậy mọi trận đấu của biểu thức chính quy được thay thế bằng ký tự đầu tiên của trận đấu đó. Điều này để lại chuỗi mong muốn trên ngăn xếp.

Sau đó, vòng lặp bên ngoài kết thúc, tại đó, chuỗi mong muốn được đưa ra khỏi ngăn xếp và kết quả khớp duy nhất ""trong chuỗi ""được thay thế bằng chuỗi đó, để lại chuỗi mong muốn một lần nữa trên ngăn xếp.

Mê cung , 528 byte

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

Các dòng mới gấp đôi bị tổn thương, nhưng ít nhất điều này chứng tỏ rằng nó có thể thực hiện được!

Mỗi ký tự được in từng cái một, đầu tiên bằng cách tạo điểm mã sau đó in một ký tự đơn. Các điểm mã được hình thành bởi:

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

Ở đâu

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

Hành vi bất thường của các chữ số của Labyrinth được khai thác 33::00&&, thực sự là

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

Mỗi char được in với cơ chế

__vv

  ..

xx

Chỉ xxtồn tại để đệm lưới sao cho nó cao 5. Đầu tiên, __đẩy hai số 0, sau đó chúng ta nhấn một toán tử xoay lưới v. Chúng tôi bật một số không và xoay:

__ v
  v
   .
  .
xx

Và một lần nữa:

__ v

  v.

xx.

Sau đó chúng tôi di chuyển sang phải .trên hàng thứ ba, do đó chỉ thực hiện lệnh in một lần.

CJam - 176 136 byte

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

Cảm ơn Sp3000 vì đã chia kích thước chương trình của tôi cho hai :-)

Giải trình

• Các mã HH77++, GG00++... tính toán mã ascii số nguyên của các ký tự bằng cách thêm số (ví dụ: `HH77 ++ 'đẩy 17, 17 và 77 trên ngăn xếp, sau đó thêm 3 số này)
• phần mã ở cuối ]]{{cc}}//vòng lặp thông qua mã ascii và chuyển đổi chúng thành ký tự.

Hãy thử nó ở đây

Brainf tự sửa đổi *** , 72 byte

Lưu ý rằng \x00đại diện cho một NULbyte hex bằng chữ (ô trống). Mã nguồn được đặt trên băng, bên trái của ô bắt đầu.

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

Giải trình

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

Ngoài ra, trước khi thực hiện chương trình này, tôi đã tạo một cái chỉ sử dụng các ký tự BF trong nguồn. Điều đó là có thể! Nó cũng dài hơn nhiều, vì đối với một giá trị ASCII lẻ, tôi sẽ tạo gấp đôi giá trị, sau đó chia cho hai. Một chút ngắn hơn sẽ được sửa đổi toàn bộ nguồn để tạo ra các giá trị lẻ để bắt đầu.

Jelly , 66 byte (không cạnh tranh)

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

Hãy thử trực tuyến!

Factoid

Chương trình vẫn hoạt động nếu bạn loại bỏ mọi ký tự thứ hai.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

trả về một mảng của chuỗi. Nghĩa đen bắt đầu bằng a “, kết thúc bằng a ”và các chuỗi được phân định bên trong bởi “. Kết quả là

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

Đối số của liên kết và giá trị trả về được đặt thành mảng chuỗi này, sau đó phần còn lại của mã nguồn được thực thi.

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

\\

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

Gammaplex là ngôn ngữ 2D sử dụng vị trí của dòng mới đầu tiên làm độ dài dòng và bỏ qua tất cả các dòng mới khác.

MSM , 270 160 byte

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

Chương trình MSM đầu tiên của tôi!

Đầu ra chuỗi trong MSM được thực hiện bằng cách đẩy các ký tự riêng lẻ lên ngăn xếp và nối chúng thành một chuỗi thông qua ., ví dụ:

!olleH.....

Số lượng .ít hơn một ký tự. Vì Do not repeat yourself!chúng ta cần 22 .s. May mắn thay, đây là một số chẵn, vì vậy chúng tôi có 11 nhân đôi

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

Đặt các chữ cái ở phía trước của nó đòi hỏi một số nỗ lực hơn. Mẫu

cc'',,

không lừa cho mỗi nhân vật c. Nó đánh giá như sau

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

Chúng ta cần 23 mẫu như vậy bắt đầu bằng !!'',,và kết thúc bằng DD'',,tiếp theo là 22 lệnh nối ..

Befunge 98, 70 66 byte

Hãy thử trực tuyến!

Sau câu trả lời không hợp lệ của tôi, đây là một câu trả lời tốt hơn thực sự phù hợp với thử thách!

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

(Cảm ơn Martin Ender đã đề xuất sử dụng ��, ký tự 0x17, thay vì 88ff++)

Giải trình:

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 byte

Tệp dnr6.short.dc(không có dòng mới):

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

Chạy:

$ 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

>>  ^^

Trái tay , 54 byte

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

Hãy thử trực tuyến!

Vì con trỏ của Backhand đã di chuyển ở ba ô một tích tắc, tất cả những gì chúng ta cần làm là giảm nó xuống 2 bằng cách sử dụng v

dạng lưới, không biên dịch, 62 byte

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

Hãy thử trực tuyến!

Giải thích trong các phần:

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

Uđặt hướng con trỏ thành (2, 0), nghĩa là di chuyển 2các đơn vị x và đơn vị 0y, để nó bỏ qua mọi ký tự khác, bắt đầu với việc tiếp theo Uđược bỏ qua. Sau đó, mọi ký tự khác được ghi lại và tương đương với:

"Do not repeat yourself!"o;

đó là một chương trình đầu ra đơn giản.

Khác

Điều này đang cạnh tranh cho tiền thưởng JavaScript của WallyWest:

Tôi có thể chứng minh rằng, trong khi các số có thể được xây dựng theo hạn chế này, các chuỗi không thể. Vì không có nghĩa đen nào có thể được sử dụng, vì vị trí của bất kỳ ký tự xây dựng theo nghĩa đen nào sẽ tạo ra một chuỗi trống:

""
''
``

Sau đó, chỉ một số toán tử có thể được sử dụng; toán tử "ghép nối" duy nhất được sử dụng là:

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

Và không ai trong số này có thể chuyển số / số khác thành chuỗi. Vì vậy, không có chuỗi có thể được xuất ra.

Alice , 74 byte

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

Hãy thử trực tuyến!

Giải trình

Điều hấp dẫn đầu tiên là chúng ta cần có thể nhập chuỗi, vì vậy chúng ta chỉ muốn bỏ qua chuỗi đầu tiên ". Chúng tôi thực hiện điều này bằng cách nhảy lên ô đầu tiên "vì sau đó IP sẽ di chuyển một ô trước khi nhìn lại ô hiện tại, để nó trở thành ô thứ hai chuyển sang "chế độ chuỗi. Nhưng để có thể nhảy đến đó, chúng ta cần 10, 0lên trên cùng của ngăn xếp, theo thứ tự đó (thứ hai, trên cùng). Điều này được thực hiện với 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]

Hàm xoay này xuất hiện một đối số. Nếu đối số đó là âm, nó sẽ đẩy giá trị lên trên cùng của ngăn xếp xuống bởi nhiều vị trí đó. Nếu đối số là tích cực, nó sẽ tìm kiếm phần tử có nhiều vị trí bên dưới đỉnh và kéo nó lên trên cùng. Lưu ý rằng trong trường hợp Rotate(10), không có đủ các phần tử trên ngăn xếp, nhưng có một số lượng không giới hạn ẩn ở phía dưới, đó là lý do tại sao số 0 kết thúc ở trên cùng.

Bây giờ chúng ta có thể kết hợp Jvới cái đầu tiên "bằng cách sử dụng hai đối số này. Thứ hai "vào chế độ chuỗi và ghi lại tất cả điều đó DDoo nnoott.... Khi chạm vào /, IP được chuyển hướng về phía đông nam và chúng ta vào chế độ Thông thường. Hiện tại, IP nảy lên và xuống trên ba dòng (hai trong số đó là trống), do đó, đầu tiên nó ghi thêm ba khoảng trắng trên dòng hai và ba và sau đó chúng ta rời khỏi chế độ chuỗi khi chạm vào ". Vì chúng tôi đang ở chế độ Thông thường vào thời điểm này, tất cả các ký tự được ghi lại được đẩy thành một chuỗi vào ngăn xếp (mặc dù chúng tôi đã ghi lại hầu hết chúng ở chế độ Cardinal), vì vậy chúng tôi kết thúc chuỗi này (lưu ý các khoảng trắng ở cuối) :

DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!   

Bây giờ IP liên tục nảy lên xuống có nghĩa là nó thực thi một lệnh của mọi cặp khác, tức là Yvà t. Sau đó, IP sẽ chạm vào cuối lưới trên dòng thứ hai và bắt đầu nảy ngược qua lưới. Đây cũng chuyển trong đó cặp nhân vật IP hits dòng đầu tiên, vì vậy khi đi lại nó bây giờ thực hiện ;, ovà @. Vì vậy, bỏ qua tất cả các khoảng trắng và ẩn chuyển hướng IP, mã được thực thi Yt;o@ở chế độ Thông thường.

Lệnh Y"giải nén" phân tách một chuỗi thành các ký tự ở các vị trí xen kẽ. Vì mỗi ký tự được lặp lại, điều đó thực sự mang lại cho chúng ta hai bản sao của chuỗi chúng ta sẽ tìm, mặc dù bản sao đầu tiên có hai khoảng trắng ở cuối và bản thứ hai có một khoảng trắng ở cuối. ttách ra khỏi không gian đó và ;loại bỏ nó. Cuối cùng, oin chuỗi và @kết thúc chương trình.

05AB1E , 100 58 52 byte

-6 byte nhờ Kevin Cruijssen

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

Hãy thử trực tuyến!

„„€€·              # 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

Quy tắc tự do.

Stax , 70 byte

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

Chạy và gỡ lỗi nó tại staxlang.xyz!

Stax rất may mắn có tích hợp sẵn ::cho mọi thứ. Tất cả những gì tôi cần là đẩy chuỗi nhân đôi, đẩy 2 và chạy ::. Dễ thôi phải không?

Sai lầm.

Đẩy chuỗi đó là khó khăn. Dấu ngoặc kép đầu tiên có thể được nhân đôi .."", đó là một chữ dài 2 chữ để ."theo sau là dấu ngoặc kép có ý nghĩa. Vấn đề là, tôi thấy không có cách nào để chấm dứt chuỗi (điều này là cần thiết, nếu không thì phiên bản nhân đôi sẽ được in) mà không bắt đầu một chuỗi mới.

Sự kết thúc của chương trình chấm dứt chuỗi ký tự. Nếu tôi có thể đặt chữ nhân đôi này ở đó, có lẽ sẽ có một cách giải quyết tốt. Tuy nhiên, để nhảy đến một nơi nào đó từ cuối chương trình G}, do đó, tối thiểu, tôi đang xem xét điều này:

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

Điều này không ... không có gì. Gkhông bắt đầu một khối, vì vậy sẽ không nhảy sang thứ hai }. Một lần nữa, tôi cần bỏ qua một nhân vật : ..}}. Thực thi nhảy từ thứ nhất Gđến thứ hai }, tiếp tục đến cuối, nhảy trở lại thứ hai Gvà từ đó đến thứ hai }, và tiếp tục một lần nữa đến cuối trước khi tiếp tục ở phần đầu [deduplicate]với chuỗi gấp đôi trên đỉnh ngăn xếp.

Khử trùng là đơn giản. 11hhđẩy mười một và giảm một nửa hai lần, làm tròn cả hai lần và thu được hai, và ::sau đó sẽ cho chúng ta sản lượng chúng ta cần.

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

Uh-oh. Cái này in không có gì. Có hai vấn đề ở đây: thứ nhất, điều đó ..}có nghĩa là chuỗi .}sẽ nằm trên ngăn xếp ở cuối chương trình và thứ hai, đầu ra ẩn thông thường của Stax hiện bị vô hiệu hóa!

Vấn đề tồi tệ hơn là đầu ra. Khi một chương trình Stax chấm dứt một cách duyên dáng mà không in bất cứ thứ gì, phần trên cùng của ngăn xếp sẽ được in ngầm. Nhưng chúng tôi chưa in gì cả ...? À, nhưng chúng tôi có. Các chuỗi ký tự không hoàn chỉnh được in thay vì được đẩy và thậm chí cả hai chuỗi trống đó (từ phần chưa từng có "ở cuối), mặc dù trống, cũng đủ để vượt qua kiểm tra này. Bất kỳ in ấn phải được thực hiện bằng tay.

Chúng ta sẽ cần pphoặc PP, và trong trường hợp này, bỏ qua lần đầu tiên ..pplà không thể chấp nhận được, vì nó sẽ in chuỗi .p. Điều đó có nghĩa là chúng ta cần đầu ra mong muốn của mình một mình trên ngăn xếp hoặc trong hai đầu cùng với một chuỗi trống. Điều này sau được thực hiện bằng cách đẩy hai chuỗi trống ( zz) và xoay ba mục trên cùng hai lần ( aa) trước khi in.

Khi đã xong, chúng ta có một chồng cao bốn chuỗi. Một phần năm, .}sau đó được đẩy trước khi chương trình thoát ra một cách duyên dáng; tại thời điểm này, việc thiếu đầu ra ngầm trở thành một phước lành cũng như một lời nguyền, vì bây giờ không có gì thêm sẽ được in!