Çıktı yapan bir program yaz

Do not repeat yourself!

Program kodunuz aşağıdaki sınırlamalara uymalıdır:

• uzunluğu bir çift sayı olmalıdır
• pozisyondaki her karakter 2n( n> 0 olan bir tamsayı) pozisyondaki karaktere eşit olmalıdır 2n-1. Programın ikinci karakteri birincisine, dördüncüsü de üçüncü, vb.

Newlines, karakter olarak sayılır!

Bu kod golf, yani en kısa kod kazanır!

Örnekler

HHeellllooWWoorrlldd geçerli bir program

123veya AAABBBveya HHeelloyanlış

Doğrulama

Kaynak kodunuzun geçerli olduğunu doğrulamak için bu CJam komut dosyasını kullanabilirsiniz . Kodunuzu "Giriş" kutusuna yapıştırın ve komut dosyasını çalıştırın.

Altıgen , 166 126 124 bayt

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

Örtük işlem dışıları ve boşlukları eklemek, aşağıdaki kaynak koduna karşılık gelir:

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

Eminim bunu daha da kısaltmak mümkün olabilir ve belki de 6 boyunda çözebilirsin ama zorlaşıyor ...

Nasıl çalışır

^{Timwi'nin Hexagony Colorer'ı ile oluşturulan diyagram .}

Kod tamamen doğrusaldır. Başlangıçtaki \hak, IP'yi köşegene yönlendirir, böylece iki katına çıkan karakterler hakkında endişelenmemize gerek kalmaz. Renkli yollar turuncu / kırmızı, mavi / gri, yeşil, mor sırayla yürütülür (aynı rengin iki yolu olduğunda, soldaki yol önce sağa sarılmadan önce yürütülür).

No-op'ları, başkaları tarafından geçersiz kılan aynaları ve komutları görmezden gelirsek, doğrusal kod şuna iner:

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

Altıgenli Harfler, geçerli bellek kenarının değerini yalnızca harfin karakter koduna ayarlar. ;mevcut bellek kenarını karakter olarak yazdırır. Biz kullanmak &için bellek kenarını sıfırlamak 0ve bir boşluk baskı 32;. }Farklı bir kenara doğru ilerler, böylece 32daha sonraki alanlar için hatırlayabiliriz . Kodun geri kalanı sadece yeni kenardaki harfleri yazdırır ve ara sıra ';}boşluk bırakmak için ileri geri hareket eder . Sonunda tekrar boşluk kenarına hareket ediyoruz, 'değeri 33 ile )arttırıp ünlem işaretini yazdırıyoruz. @programı sonlandırır.

GolfScript, 130 84 76 bayt

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

Çevrimiçi olarak Web GolfScript'te deneyin .

Nasıl çalışır

GolfScript yorumlayıcısı yığına boş bir dize koyarak başlar.

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

Bir dizeyi bir dizeyle yassılaştırmak, böylece istenen çıktı elde edilir.

Unary , ~ 1.86 × 10 ²²²

Basit beyin fırtınası -> unary cevap. Çok alt-optimal;).

Program 0'lı çiftlerden oluşuyor; özellikle:

1859184544332157890058930014286871430407663071311497107104094967305277041316183368068453689248902193437218996388375178680482526116349347828767066983174362041491257725282304432256118059236484741485455046352611468332836658716

Bunların

Orijinal brainfuck kodu:

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

Ruby - 2100 1428 1032 820 670 bayt

Bu, çıkışın bir işlevden dönüş değeri olabileceğini varsayar (çıkışın STDOUT olması gerektiği belirtilmedi)

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

İşin püf noktası dize "", append işlemini <<ve karakterlerin ASCII kodlarını kullanarak boş bir dize oluşturmaktır .

ASCII kodlarının sayılarını almak için sayıyı kolayca oluşturabileceğim değerlere ayırmaya çalışıyorum. Örneğin, ASCII 90sadece 88+1+1şöyledir:

• 88 tamam kendi başına
• 11**00olduğu 11^0basitçe olan1

Neyse hem ++ve --anlamına geleceğini addYakut, bu yüzden yazabilir 90olarak88++11**00++11**00

Bazı numaralara sadece 1 eklemekten daha kolay ulaşmak için bazı hileler var, işte yukarıdakileri oluşturmak için kullanıyorum (kullandığım tüm eşlemeleri içeren):

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

Hala bir numaraya ulaşmak için gereken karakterleri azaltmak için diğer numaralar hakkında düşünüyorum.

-rppBayrağı kullanırsanız ppve kodun başına şunu eklerseniz şunu unutmayın :

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

daha sonra fazladan 2 + 4 bayt için bu tam olarak tamamlanmış bir program olarak işlev görebilir, ancak "gerekli dizgiden önce ve sonra fazladan yazdırır :

Örnek:

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

> <> , 174 bayt

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

**

..

Neyse ki, bir anlamda kısıtlama dikey olarak uygulanmıyor. Ancak en büyük sorun, her yeni hattı iki katına çıkarmamız gerektiğidir.

Kabaca çalışan kod şöyle gider:

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

Programın çift boşluk bırakmadığını unutmayın - string modunda,> <> boş hücreler için boşluk iter. Bununla birlikte, bunun tersi, bunun anlamı g(tek bir hücreyi kaynak kodundan oku) kullanan bir çözümün daha zor olacağı, çünkü programda hangi boşlukların okunduğunda NUL olduğu.

^{(Not: Bir hatayla sonlanırsa bu 50 bayt daha kısa olabilir , ancak bu şekilde hoşuma gidiyor.)}

Scipting , 186 146 bayt

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

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

Açık olmak gerekirse, ortası boş olan üç satır kod vardır, çünkü yeni satırın kopyalanması gerekir. Bayt sayısı, UTF-16 kodlamasına dayanır.

açıklama

Başlangıçtaki Korece karakter bloğu dizeyi iter "DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012". Her üçüncü karakterin istediğimiz bir karakter olduğunu fark edeceksiniz ; Gerisi saçma. İşte nedeni:

Sclipting uygulamasında iki Korece karakter, üç baytı kodlar. Böylece, her Koreli karakter etkili bir şekilde 12 bit kodlar. İle başlayan bir dize elde etmek için Dilk 8 bit 0x44; Gerisi önemli değil, ama her karakteri tekrarlamamız gerektiğinden, 12. ila 20. bitler de olacak 0x44. Böylece, 0x44n44nbazı n'ler için formun bir değerine sahip olacağız , bu da üç byte'a ayrışır 0x44 0xn4 0x4n.

İçin oolan 0x6F, biz bayt olsun 0x6F 0xn6 0xFn.

Tembel olduğum için, kodlayarak başladım "DDDooo nnnooottt (etc.)"ve sonra diğer karakterleri öncekiyle değiştirdim, bu yüzden 0x444444= "DDD"için Dve 0x6F66F6= "of�"için o. �Çünkü orada 0xF6kendisi tarafından geçersiz UTF-8 kodlama.

Şimdi programa geri dönelim. Programın geri kalanı şu şekilde devam eder:

껢껢 - dizeyi iter ".\"�"

Character 鎵 - son karakteri iki kere kaldırarak bizi "."

❶❶ - iki kopya. Şimdi yığınla:[".", ".", "."]

合 合 - iki kere birleştirin. Şimdi yığınla:["..."]

Şimdi, daha sonra yapmak istediğim"..." normal ifade olarak kullanmak , böylece a ... a döngü yapısını kullanarak bir seferde orijinal dizgeden üç karakter eşleştirebilirim. Bununla birlikte, her komut çoğaltıldığı için, birbirlerinin içine yerleştirilmiş iki adet normal ifade döngüsüne ihtiyacım var ve eğer yığın altüst olursa, çalışma zamanı hatası alıyorum. Bu nedenle,

String - boş ipi iki defa itin

ve sonra döngüleri başlatın. Bu şekilde, dış döngü yalnızca bir kez yinelenir, çünkü normal ifadeyi tek bir eşleşme sağlayan ""dizeyle ""eşleştirir. İç halka "..."büyük dizeye karşı her maç için bir kez çalışır . Döngünün gövdesi:

Marks 標 - yığına iki işaret itin. Şimdi yığınla:[mark mark]

現 現 - Geçerli regex eşleşmesinin iki kopyasını it. Şimdi yığınla:[mark mark "DDD" "DDD"]

併 併 - ilk işarete kadar bitiştir. Şimdi yığınla:["DDDDDD"]

String - bu dizginin ilk karakterini alır, sonra da (fazladan) bunun ilk karakterini alır. Yığın şimdi istediğimiz karaktere sahip.

İç döngü burada sona ermektedir, bu nedenle normal ifadenin her eşleşmesi, eşleşmenin ilk karakteri ile değiştirilir. Bu istenen dizeyi yığında bırakır.

Daha sonra, dış döngü ve bu noktada istenen dize yığını ve sadece maçı çıkarmış olup, uçları ""dizede ""yığın bir kez daha arzu edilen dizi bırakılarak değiştirilir.

Labirent , 528 bayt

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

Çifte yeni çizgiler incindi, ama en azından bu bunun mümkün olduğunu kanıtladı!

Her karakter önce kod noktası oluşturularak, sonra tek bir karakter basılarak tek tek yazdırılır. Kod noktaları aşağıdakilerden oluşur:

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

nerede

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

Labyrinth'in rakamlarının olağandışı davranışlarından yararlanılıyor 33::00&&, ki bu aslında

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

Her bir karakter char mekanizmasıyla basılır

__vv

  ..

xx

xxO 5 yüksek olacak şekilde ped sadece ızgara mevcuttur. İlk önce __iki sıfırı itin, sonra bir ızgara döndürme operatörüne çarptık v. Sıfır atar ve döndürürüz:

__ v
  v
   .
  .
xx

ve yeniden:

__ v

  v.

xx.

Daha sonra .üçüncü satıra doğru sağa hareket ediyoruz , böylece sadece bir kez print komutunu çalıştırıyoruz.

CJam - 176 136 bayt

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

Program boyutumu ikiye böldüğüm için Sp3000'e teşekkürler :-)

açıklama

• Kodları HH77++,, GG00++... karakterlerin tam sayı ascii kodunu sayı ekleyerek hesaplar (örneğin: `HH77 ++ 'yığına 17, 17 ve 77 iter, sonra bu 3 sayıyı ekler)
• kodun sonunda bulunan kod ]]{{cc}}//, ascii kodları arasında dolaşır ve karakterlere dönüştürür.

Burada dene

Kendini değiştiren Brainf *** , 72 bayt

\x00Değişmez bir NULonaltılık baytı (boş hücre) temsil ettiğini unutmayın . Kaynak kod, başlangıç ​​hücresinin solundaki kasete yerleştirilir.

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

açıklama

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

Ayrıca, bu programı yapmadan önce, kaynağında sadece BF karakterlerini kullanarak bir tane yapıyordum. Mümkün! Aynı zamanda çok daha uzun, çünkü tek bir ASCII değeri için, değeri iki katına çıkarıp sonra ikiye böldüm. Biraz daha kısa bir süre içinde başlamak için tek değerler üretmek üzere tüm kaynağı değiştiriyor olabilir.

Jöle , 66 bayt (yarışmaz)

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

Çevrimiçi deneyin!

Uydurma

Her ikinci karakteri kaldırırsanız, program hala çalışır.

Çevrimiçi deneyin!

Nasıl çalışır

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

bir dizge dizisi döndürür. Değişmez a ile başlar, a “ile biter ”ve dizeler dahili olarak sınırlandırılır “. Sonuç

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

Bağlantının argümanı ve dönüş değeri bu dizi dizisine ayarlanır, sonra kaynak kodun geri kalanı yürütülür.

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

\\

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

Gammaplex, ilk yeni satırın konumunu satır uzunluğu olarak kullanan ve diğer tüm satırları yok sayan bir 2B dilidir.

MSM , 270 160 bayt

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

İlk MSM programım!

MSM'deki dize çıkışı, tek tek karakterleri yığına iterek ve bunları tek bir dizgeye birleştirerek yapılır .;

!olleH.....

Sayısı ., karakter sayısından daha az. İçin Do not repeat yourself!biz 22 ihtiyacımız .s. Neyse ki bu bir çift sayı, 11 çiftimiz var.

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

Harfleri önüne koymak daha fazla çaba gerektirir. Desen

cc'',,

Her karakter için hile yapar c. Aşağıdaki gibi değerlendirir

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

22 birleştirme komutu !!'',,ile başlayan ve biten 23 bu formata ihtiyacımız var .DD'',,.

Befunge 98, 70 66 bayt

Çevrimiçi deneyin!

Benim geçersiz cevabımdan sonra, işte bu gerçekten de mücadeleye uyan daha iyi bir cevap!

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

( ��Bunun yerine, karakterin 0x17 kullanılmasını önerdiği için Martin Ender'e teşekkürler 88ff++)

Açıklama:

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 bayt

Dosya dnr6.short.dc(takip eden yeni satır olmadan):

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

Çalıştırmak:

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

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

Çevrimiçi deneyin!

Backhand'in işaretçisi zaten üç hücreye bir kene hareket ettiğinden, tek yapmamız gereken bunu 2'ye düşürmek. v

retiküler, rekabetçi olmayan, 62 bayt

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

Çevrimiçi deneyin!

Parça açıklaması:

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

Uişaretçi yönünü (2, 0), yani 2x birimleri ve 0y birimleri olarak ayarlar , böylece bir sonraki Uatlanmadan başlayarak diğer tüm karakterleri atlar . Sonra diğer her karakter kaydedilir ve şuna eşittir:

"Do not repeat yourself!"o;

Bu basit bir çıktı programıdır.

Diğer

Bu WallyWest'in JavaScript ödülü için yarışıyor:

Rakamlar bu sınırlama altında oluşturulabilirken, dizelerin yapamayacağını ispatlayabilirim. Herhangi bir değişmez yapı kullanılamadığından, herhangi bir değişmez yapı karakterinin yerleştirilmesi boş bir dize oluşturur:

""
''
``

Ardından, sadece bazı operatörler kullanılabilir; kullanılan tek "eşleştirilmiş" işleçler:

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

Ve bunların hiçbiri rakamları / diğerlerini dizelere dökemez. Böylece hiçbir karakter dizisi verilemez.

Alice , 74 bayt

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

Çevrimiçi deneyin!

açıklama

İlk yakalama dizeye girebilmemiz gerektiği, bu yüzden sadece ilkini atlamak istiyoruz ". Bunu birinciye atlayarak yapıyoruz "çünkü IP mevcut hücreye tekrar bakmadan önce bir hücreyi hareket ettirecek, böylece "dize moduna giren ikincisi olacak . Fakat oraya atlayabilmek 10, 0için yığının üstüne, o sırayla (ikinci, üst) ihtiyacımız var. Bu ile yapılır 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]

Bu döndürme işlevi bir argüman açar. Bu argüman negatifse, yığının en üstündeki değeri bu kadar konum tarafından aşağı iter. Eğer argüman pozitifse, üste birçok pozisyon yerleştiren ve onu yukarı çeken eleman aranır. Durumda Rotate(10), yığında yeterli eleman bulunmadığını, ancak dipte sonsuz miktarda sıfır bulunduğunu ve bu nedenle sıfırın üst üste geldiğini unutmayın.

Şimdi bu iki argümanı kullanarak Jilkine değinebiliriz ". İkinci "dize moduna girer ve hepsini kaydeder DDoo nnoott.... O çarptığında /, IP güneydoğu yönlendirilir ve biz Sıra moduna girmek. Şimdilik IP, üç satır boyunca (ikisi boş olan) yukarı ve aşağı sıçramaktadır, bu nedenle ilk önce iki ve üç satırlara üç boşluk daha kaydeder ve sonra isabet ettiği zaman dize modundan çıkarız ". Şu anda Ordinal modda olduğumuz için, kaydedilen tüm karakterler yığına tek bir dize olarak itiliyor (çoğunu Kardinal modunda kaydetmiş olsak bile), bu nedenle bu dizeyle bitiyoruz (boşluklara dikkat edin) :

DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!   

Şimdi IP yukarı sıçrayan tutar ve hangi aşağı o her çifti, yani bir komutu yürütür anlamına gelir Yve t. Ardından IP, ikinci satırdaki kılavuzun sonuna vuracak ve kılavuzdan geriye doğru sıçrayacaktır. Bu aynı zamanda IP ilk satırı vurur karakterlerin hangi çifti de geçer, yani geri giderken şimdi yürütür ;, ove @. Bu yüzden tüm boşlukları ve örtük IP yönlendirmelerini yok sayarak, yürütülen kod Yt;o@Ordinal modda.

YAlternatif pozisyonlarda karakterleri içine bir dize ayıran "unzip" komuttur. Her karakter tekrarlandığından, ilk kopya iki iz boşluğuna ve ikincinin bir iz boşluğuna sahip olmasına rağmen, bu gerçekten bize sadece bizim kullandığımız dizenin iki kopyasını verir. tbu takip eden alanı ayırır ve ;atar. Son olarak odizeyi yazdırır ve @programı sonlandırır.

05AB1E , 100 58 52 bayt

Kevin Cruijssen sayesinde -6 bayt

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

Çevrimiçi deneyin!

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

Bekaretsizlik kuralları.

Stax , 70 bayt

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

Koşun ve staxlang.xyz de hata ayıklayın!

Çok Neyse ki Stax ::her yıl için yerleşiktir . Tek ihtiyacım olan ipi iki katına itmek, 2'ye basmak ve koşmak ::. Kolay değil mi?

Yanlış.

Bu dizgeye basmak zor. İlk tırnak işareti iki katına çıkarılabilir .."", ki bu ."anlamlı bir tırnak işareti tarafından takip edilen uzunluk uzunluğu 2'dir . Sorun şu ki, yeni bir tane başlatmadan dizgeyi sonlandırmanın bir yolu görmüyorum (gerekli, ya da iki katına basılmış sürüm basılacak).

Programın sonu string değişmezlerini sonlandırıyor. Eğer bu iki misli değişmezi oraya koyabilirsem, belki de güzel bir geçici çözüm olacaktır. Bir programın sonundan bir yere atlamak için, ancak, gerektirir G}, bu yüzden en azından, şuna bakıyorum:

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

Bu ... hiçbir şey yapmaz. Gbir bloğa başlamaz, bu yüzden ikisi de ikinciye atlamaz }. Yine, bir karakter görmezden gerekir: ..}}. Uygulama birinci G-ikinci }atlar, sonuna kadar devam eder, ikinciye Gve oradan ikinciye geri atlar }ve [deduplicate]bölümün başlangıcında yığının üstündeki iki kat iple devam etmeden önce bir kez daha sonuna kadar devam eder.

Tekilleştirme basittir. 11hhon bir itti ve iki kere ikiye katladı, iki kere yuvarladı ve iki verdi, ve ::sonra bize ihtiyacımız olan çıktıyı alacak.

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

Hata. Bu hiçbir şey basmaz. Burada iki sorun var: birincisi, ..}dize .}programın sonunda yığının tepesinde olacak ve ikincisi Stax'ın sıradan örtülü çıktısı şimdi devre dışı!

En kötü sorun çıktı. Bir Stax programı hiçbir şey yazdırmadan incelikle sona erdiğinde, yığının üstü örtük olarak yazdırılır. Ama hiçbir şey basmadık ...? Ah, ama biz var. Sonlandırılmamış dize değişmezleri itilmek yerine yazdırılır ve bu boş iki dize bile ( "sonunda eşleşmeyen ) boş olsa da bu çeke geçmesi için yeterlidir. Herhangi bir baskı elle yapılmalıdır.

Her ikisine de ihtiyacımız var ppveya PPbu örnekte, ilkini yok saymak ..pp, dizeyi basacağı için kabul edilemez .p. Bu, boş bir dize ile birlikte yığın üzerinde tek başına veya ilk ikide istenen çıktımıza ihtiyacımız olduğu anlamına gelir. Bu sonuncusu, iki boş dizeye ( zz) aabasılarak ve ilk üç maddeyi yazdırmadan önce iki kez ( ) döndürerek gerçekleştirilir .

Bunu yaptıktan sonra, dört tane uzun boylu bir yığımız var. Beşinci, .}daha sonra program incelikle çıkmadan önce itilir; Bu noktada, örtük çıktı eksikliği bir lanet kadar lütuf olur, çünkü artık hiçbir şey basılmayacaktır!