Tulis program yang menampilkan

Do not repeat yourself!

Kode program Anda harus menghormati batasan-batasan berikut:

• panjangnya harus bilangan genap
• setiap karakter yang ada di posisi 2n(di mana nbilangan bulat> 0) harus sama dengan karakter di posisi 2n-1. Karakter kedua dari program ini sama dengan yang pertama, yang keempat sama dengan yang ketiga, dll.

Baris baru dihitung sebagai karakter!

Ini adalah kode-golf, jadi kode terpendek menang!

Contohnya

HHeellllooWWoorrlldd adalah program yang valid

123atau AAABBBatau HHeellosalah

Verifikasi

Anda dapat menggunakan skrip CJam ini untuk memverifikasi bahwa kode sumber Anda valid. Cukup tempel kode Anda ke dalam kotak "Input" dan jalankan skrip.

Hexagony , 166 126 124 byte

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

Menyisipkan no-ops dan spasi kosong implisit, ini terkait dengan kode sumber berikut:

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

Saya yakin mungkin untuk mempersingkat ini lebih lama lagi, dan mungkin bahkan menyelesaikannya dengan panjang sisi 6, tapi semakin rumit ...

Bagaimana itu bekerja

^{Diagram dihasilkan dengan Hexagony Colorer Timwi .}

Kode ini sepenuhnya linier. The \tepat di awal pengalihan IP ke dalam diagonal, sehingga kita tidak perlu khawatir tentang karakter dua kali lipat sama sekali. Jalur berwarna dieksekusi dalam urutan oranye / merah, biru / abu-abu, hijau, ungu (ketika ada dua jalur dengan warna yang sama, jalur kiri dieksekusi terlebih dahulu, sebelum membungkus sekitar ke kanan).

Jika kita mengabaikan no-ops, mirror, dan perintah yang ditimpa oleh orang lain, kode linearnya adalah sebagai berikut:

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

Letters in Hexagony hanya mengatur nilai tepi memori saat ini ke kode karakter huruf. ;mencetak tepi memori saat ini sebagai karakter. Kami menggunakan &untuk mengatur ulang tepi memori ke 0dan mencetak spasi dengan 32;. }bergerak ke tepi yang berbeda, sehingga kita dapat mengingat 32untuk ruang selanjutnya. Sisa kode hanya mencetak huruf di tepi yang baru, dan sesekali bergerak bolak-balik ';}untuk mencetak spasi. Pada akhirnya kami pindah ke tepi ruang lagi dengan ', menambah nilai menjadi 33 dengan )dan mencetak tanda seru. @mengakhiri program.

GolfScript, 130 84 76 byte

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

Cobalah online di Web GolfScript .

Bagaimana itu bekerja

Penerjemah GolfScript dimulai dengan menempatkan string kosong pada tumpukan.

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

Menggabungkan array dengan string mendatar, sehingga hasilnya adalah output yang diinginkan.

Unary , ~ 1,86 × 10 ²²²

Brainfuck sederhana -> jawaban unary. Sangat sub-optimal;).

Program ini terdiri dari angka genap 0's; secara khusus:

1859184544332157890058930014286871430407663071311497107104094967305277031618336806845368688688688688688fbadadalahpenuhandesudahkemudianmemiliki

dari mereka.

Kode brainfuck asli:

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

Ruby - 2100 1428 1032 820 670 byte

Ini mengasumsikan output dapat berupa nilai balik dari suatu fungsi (tidak ditentukan bahwa output harus ke STDOUT)

Kode:

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

Caranya adalah dengan membangun string dari string kosong ""menggunakan operasi append <<dan kode ASCII dari karakter.

Untuk mendapatkan angka untuk kode ASCII saya mencoba menguraikan angka menjadi nilai yang saya dapat dengan mudah menghasilkan. Misalnya ASCII 90saja 88+1+1, yaitu:

• 88 tidak apa-apa pada itu sendiri
• 11**00adalah 11^0, yang sederhana1

Untungnya keduanya ++dan --berarti addruby, jadi saya bisa menulis 90sebagai88++11**00++11**00

Ada beberapa trik untuk mencapai beberapa angka lebih mudah daripada hanya menambahkan 1, berikut adalah kode yang saya gunakan untuk menghasilkan di atas (yang mencakup semua pemetaan yang saya gunakan):

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

Saya masih memikirkan trik lain untuk mengurangi karakter yang diperlukan untuk mendapatkan nomor.

Perhatikan bahwa jika Anda menggunakan -rppflag, dan tambahkan ppke awal kode seperti:

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

kemudian untuk tambahan 2 + 4 byte ini dapat berfungsi sebagai program yang sepenuhnya lengkap, tetapi itu akan mencetak tambahan "sebelum dan sesudah string yang diperlukan:

Contoh:

$ 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

**

..

Untungnya, batasannya tidak berlaku secara vertikal. Namun, masalah terbesar adalah kita perlu menggandakan setiap baris baru.

Kode yang berjalan kira-kira seperti ini:

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

Perhatikan bahwa program tidak memiliki spasi ganda - saat dalam mode string,> <> mendorong spasi untuk sel kosong. Sebaliknya, ini berarti bahwa solusi menggunakan g(membaca sel tunggal dari kode sumber) akan lebih rumit, karena ruang apa yang ada dalam program menjadi NUL saat dibaca.

^{(Catatan: Ini bisa lebih pendek 50 byte jika diakhiri dengan kesalahan , tapi saya suka cara ini.)}

Sclipting , 186 146 byte

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

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

Supaya jelas, ada tiga baris kode, yang tengahnya kosong, karena baris baru perlu diduplikasi. Hitungan byte didasarkan pada pengkodean UTF-16.

Penjelasan

Blok karakter Korea pada awalnya mendorong string "DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012". Anda akan melihat bahwa setiap karakter ketiga adalah karakter yang kita inginkan; sisanya omong kosong. Inilah alasannya:

Dalam Sclipting, dua karakter Korea mengkodekan tiga byte. Dengan demikian, setiap karakter Korea secara efektif mengkodekan 12 bit. Untuk mendapatkan string yang dimulai dengan D, 8 bit pertama harus 0x44; sisanya tidak masalah, tetapi karena kita harus mengulang setiap karakter, bit ke 12 sampai 20 juga akan menjadi 0x44. Jadi, kita akan memiliki nilai form 0x44n44nuntuk beberapa n , yang terurai menjadi tiga byte 0x44 0xn4 0x4n.

Untuk o, yang 0x6F, kita dapatkan byte 0x6F 0xn6 0xFn.

Karena saya malas, saya mulai dengan penyandian "DDDooo nnnooottt (etc.)"dan kemudian mengganti setiap karakter lain dengan yang sebelumnya, itulah sebabnya saya mendapatkan 0x444444= "DDD"untuk Ddan 0x6F66F6= "of�"untuk o. Itu �ada karena 0xF6dengan sendirinya tidak valid pengkodean UTF-8.

Sekarang, kembali ke program. Sisa dari program dilanjutkan sebagai berikut:

껢껢 - mendorong string ".\"�"

鎵 鎵 - menghapus karakter terakhir dua kali, meninggalkan kita "."

❶❶ - dua duplikat. Tumpukan sekarang:[".", ".", "."]

合 合 - menyatukan dua kali. Tumpukan sekarang:["..."]

Sekarang, apa yang ingin saya lakukan selanjutnya adalah menggunakan "..."sebagai ekspresi reguler sehingga saya dapat mencocokkan tiga karakter dari string asli sekaligus, menggunakan konstruksi loop 終 ... 終. Namun, karena setiap instruksi diduplikasi, saya perlu memiliki dua loop ekspresi reguler seperti itu bersarang di dalam satu sama lain, dan jika stack underruns saya mendapatkan kesalahan runtime. Karena itu,

虛虛 - dorong senar kosong dua kali

dan kemudian mulai loop. Dengan cara ini, loop luar iterasi hanya sekali karena itu cocok dengan ekspresi reguler ""terhadap string "", yang menghasilkan kecocokan tunggal. Loop dalam berjalan sekali untuk setiap pertandingan "..."melawan string besar. Tubuh loop adalah:

標 標 - dorong dua tanda ke tumpukan. Tumpukan sekarang:[mark mark]

現 現 - mendorong dua salinan dari pertandingan regex saat ini. Tumpukan sekarang:[mark mark "DDD" "DDD"]

併 併 - digabungkan hingga tanda pertama. Tumpukan sekarang:["DDDDDD"]

一一 - ambil karakter pertama dari string itu, dan kemudian (berlebihan) karakter pertama dari string itu. Stack sekarang memiliki karakter yang kita inginkan.

Lingkaran dalam berakhir di sini, sehingga setiap kecocokan dari ekspresi reguler diganti dengan karakter pertama dari kecocokan itu. Ini meninggalkan string yang diinginkan pada stack.

Kemudian loop luar berakhir, pada titik mana string yang diinginkan diambil dari tumpukan dan satu-satunya kecocokan ""dalam string ""diganti dengan itu, meninggalkan string yang diinginkan sekali lagi pada tumpukan.

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

Baris ganda ganda sakit, tapi setidaknya ini membuktikan bahwa itu bisa dilakukan!

Setiap karakter dicetak satu per satu, pertama dengan membentuk titik kode kemudian mencetak karakter tunggal. Poin kode dibentuk oleh:

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

dimana

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

Perilaku yang tidak biasa dari angka-angka Labyrinth dieksploitasi 33::00&&, yang sebenarnya

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

Setiap karakter dicetak dengan mekanisme

__vv

  ..

xx

Yang xxada hanya untuk pad grid sehingga 5 tinggi. Pertama __tekan dua nol, lalu kita tekan operator rotasi grid v. Kami menghasilkan nol dan memutar:

__ v
  v
   .
  .
xx

dan lagi:

__ v

  v.

xx.

Kami kemudian bergerak ke kanan ke .pada baris ketiga, sehingga menjalankan perintah cetak hanya sekali.

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

Terima kasih kepada Sp3000 untuk membagi ukuran program saya menjadi dua :-)

Penjelasan

• Kode HH77++,, GG00++... menghitung kode ascii integer dari karakter dengan menambahkan angka (misalnya: `HH77 ++ 'mendorong 17, 17 dan 77 pada stack, lalu tambahkan 3 angka ini)
• bagian kode di akhir ]]{{cc}}//loop melalui kode ascii dan mengkonversinya menjadi karakter.

Coba di sini

Brainf *** yang dimodifikasi sendiri , 72 byte

Catatan yang \x00mewakili NULbyte heks literal (sel kosong). Kode sumber ditempatkan pada kaset, di sebelah kiri sel awal.

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

Penjelasan

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

Juga, sebelum membuat program ini, saya membuat satu hanya menggunakan karakter BF di sumbernya. Itu mungkin! Ini juga jauh lebih lama, karena untuk nilai ASCII yang aneh, saya akan membuat nilai dua kali lipat, kemudian membaginya menjadi dua. Agak lebih pendek akan memodifikasi seluruh sumber untuk menghasilkan nilai aneh untuk memulai.

Jelly , 66 byte (tidak bersaing)

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

Cobalah online!

Faktoid

Program masih berfungsi jika Anda menghapus setiap karakter kedua.

Cobalah online!

Bagaimana itu bekerja

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

mengembalikan array string. Literal dimulai dengan a “, diakhiri dengan a ”, dan string dibatasi secara internal oleh “. Hasilnya adalah

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

Argumen tautan dan nilai pengembalian diatur ke array string ini, kemudian sisa kode sumber dieksekusi.

<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 adalah bahasa 2D yang menggunakan posisi baris baru pertama sebagai panjang baris, dan mengabaikan semua baris baru lainnya.

MSM , 270 160 byte

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

Program MSM pertama saya!

Output string dalam MSM dilakukan dengan mendorong masing-masing karakter ke stack dan bergabung dengan mereka menjadi satu string melalui ., misalnya

!olleH.....

Jumlahnya .kurang dari jumlah karakter. Untuk Do not repeat yourself!kita butuh 22 .detik. Untungnya ini adalah angka genap, jadi kami memiliki 11 ganda

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

Menempatkan huruf di depannya memerlukan upaya lebih banyak. Pola

cc'',,

melakukan trik untuk setiap karakter c. Ini mengevaluasi sebagai berikut

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

Kita membutuhkan 23 pola seperti itu dimulai dengan !!'',,dan diakhiri dengan DD'',,diikuti oleh 22 perintah bergabung ..

Menembus 98, 70 66 byte

Cobalah online!

Setelah jawaban saya yang tidak valid, inilah yang lebih baik yang benar-benar sesuai dengan tantangan!

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

(Terima kasih kepada Martin Ender karena menyarankan penggunaan ��, karakter 0x17, bukan 88ff++)

Penjelasan:

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

File dnr6.short.dc(tanpa mengikuti baris baru):

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

Lari:

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

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

Cobalah online!

Karena penunjuk Backhand sudah bergerak pada tiga sel kutu, yang perlu kita lakukan adalah menguranginya menjadi 2 menggunakan v

reticular, noncompeting, 62 byte

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

Cobalah online!

Penjelasan dalam bagian-bagian:

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

Umengatur arah penunjuk (2, 0), yaitu, memindahkan 2unit x dan unit 0y, sehingga melompati setiap karakter lainnya, dimulai dengan yang berikutnya Udilewati. Kemudian, setiap karakter lain direkam, dan itu setara dengan:

"Do not repeat yourself!"o;

yang merupakan program keluaran sederhana.

Lain

Ini bersaing untuk hadiah JavaScript WallyWest:

Saya bisa membuktikan bahwa, sementara angka dapat dibangun di bawah batasan ini, string tidak bisa. Karena tidak ada literal yang dapat digunakan, penempatan karakter membangun literal apa pun akan membuat string kosong:

""
''
``

Kemudian, hanya beberapa operator yang dapat digunakan; satu-satunya operator "berpasangan" yang digunakan adalah:

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

Dan tidak ada yang bisa memberikan angka / orang lain ke string. Jadi tidak ada string yang bisa dihasilkan.

Alice , 74 byte

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

Cobalah online!

Penjelasan

Tangkapan pertama adalah bahwa kita harus dapat memasukkan string, jadi kami hanya ingin melewati yang pertama ". Kami melakukan ini dengan melompat ke yang pertama "karena kemudian IP akan memindahkan satu sel sebelum melihat sel yang sekarang lagi, sehingga yang kedua "yang memasuki mode string. Tetapi untuk dapat melompat ke sana, kita perlu 10, 0di atas tumpukan, dalam urutan itu (kedua, atas). Ini dilakukan dengan 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]

Fungsi rotasi ini memunculkan argumen. Jika argumen itu negatif, itu mendorong nilai di atas tumpukan ke bawah oleh banyak posisi. Jika argumennya positif, ia akan mencari elemen yang banyak posisi di bawah atas dan menariknya ke atas. Perhatikan bahwa dalam kasus ini Rotate(10), tidak ada cukup elemen pada tumpukan, tetapi ada jumlah nol tak terbatas yang tersirat di bagian bawah, itulah sebabnya nol berakhir di atas.

Sekarang kita dapat Jmenambahkan "argumen pertama menggunakan kedua argumen ini. Yang kedua "memasuki mode string dan mencatat semua itu DDoo nnoott.... Ketika menyentuh /, IP dialihkan ke tenggara dan kita memasuki mode Ordinal. Untuk saat ini, IP memantul ke atas dan ke bawah melintasi tiga baris (dua di antaranya kosong), jadi ia pertama-tama merekam tiga spasi lagi di baris dua dan tiga dan kemudian kami meninggalkan mode string ketika menyentuh ". Karena kita berada dalam mode Ordinal saat ini, semua karakter yang direkam didorong sebagai string tunggal ke stack (meskipun kami mencatat sebagian besar dari mereka dalam mode Kardinal), jadi kami berakhir dengan string ini (perhatikan spasi tambahan) :

DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!   

Sekarang IP terus memantul ke atas dan ke bawah yang berarti bahwa itu mengeksekusi satu perintah dari setiap pasangan lainnya, yaitu Ydan t. Kemudian IP akan mengenai ujung grid pada baris kedua dan mulai memantul ke belakang melalui grid. Ini juga beralih di mana pasangan karakter IP hits baris pertama, jadi ketika kembali sekarang dijalankan ;, odan @. Jadi mengabaikan semua ruang dan pengalihan IP implisit, kode yang dieksekusi Yt;o@dalam mode Ordinal.

Ini Yadalah perintah "unzip" yang memisahkan string ke dalam karakter di posisi bergantian. Karena setiap karakter diulang, itu benar-benar hanya memberi kita dua salinan dari string yang kita buat, meskipun salinan pertama memiliki dua spasi tambahan dan yang kedua memiliki satu spasi tambahan. tmemisahkan ruang trailing itu dan ;membuangnya. Akhirnya, omencetak string dan @mengakhiri program.

05AB1E , 100 58 52 byte

-6 byte terima kasih kepada Kevin Cruijssen

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

Cobalah 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

Aturan idempotensi.

Stax , 70 byte

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

Jalankan dan debug di staxlang.xyz!

Stax sangat beruntung memiliki builtin ::untuk setiap tanggal. Yang saya butuhkan adalah mendorong string menjadi dua kali lipat, mendorong 2, dan lari ::. Mudah kan?

Salah.

Mendorong string itu rumit. Tanda kutip pertama dapat digandakan dengan .."", yang merupakan panjang-2 literal ."diikuti oleh tanda kutip yang bermakna. Masalahnya adalah, saya tidak melihat cara untuk mengakhiri string (yang diperlukan, atau versi dua kali lipat akan dicetak) tanpa memulai yang baru.

Akhir program mengakhiri string literal. Jika saya dapat menempatkan literal berganda ini di sana, mungkin akan ada solusi yang bagus. Untuk melompat ke suatu tempat dari akhir program, bagaimanapun, memerlukan G}, jadi minimal, saya melihat ini:

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

Ini tidak ... tidak ada apa-apa. Gtidak memulai blok, jadi tidak akan melompat ke yang kedua }. Sekali lagi, saya harus mengabaikan satu karakter: ..}}. Eksekusi melompat dari yang pertama Gke yang kedua }, berlanjut ke akhir, melompat kembali ke yang kedua Gdan dari sana ke yang kedua }, dan berlanjut sekali lagi ke akhir sebelum dilanjutkan pada awal [deduplicate]bagian dengan string ganda di atas tumpukan.

Deduplikasi sederhana. 11hhmendorong sebelas dan membagi dua dua kali, membulatkan kedua kali dan menghasilkan dua, dan ::kemudian akan memberi kita output yang kita butuhkan.

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

Uh oh. Ini tidak mencetak apa pun. Ada dua masalah di sini: pertama, itu ..}berarti string .}akan berada di atas tumpukan di akhir program, dan kedua, output implisit biasa Stax sekarang dinonaktifkan!

Masalah yang lebih buruk adalah output. Ketika program Stax berakhir dengan anggun tanpa mencetak apa pun, bagian atas tumpukan akan dicetak secara implisit. Tapi kami belum mencetak apa-apa ...? Ah, tapi sudah. String literal yang dicetak dicetak daripada didorong, dan bahkan dua string kosong (dari yang tidak tertandingi "di akhir), meskipun kosong, sudah cukup untuk membuat trip ini tersandung. Pencetakan apa pun harus dilakukan dengan tangan.

Kita memerlukan salah satu ppatau PP, dan dalam hal ini, mengabaikan through pertama ..pptidak dapat diterima, karena akan mencetak string .p. Itu berarti kita membutuhkan output yang diinginkan baik di stack atau di dua teratas bersama dengan string kosong. Yang terakhir ini dilakukan dengan mendorong dua string kosong ( zz) dan memutar tiga item teratas dua kali ( aa) sebelum mencetak.

Setelah selesai, kami memiliki tumpukan empat senar tinggi. Yang kelima,, .}kemudian didorong sebelum program keluar dengan anggun; pada titik ini, kurangnya output tersirat menjadi berkah sekaligus kutukan, karena tidak ada tambahan yang sekarang akan dicetak!