Merhaba dünya dizesi ("Merhaba dünya", "Merhaba, Dünya" vb.) Ve kaynak kodu çıktısı veren bir program oluşturun. Çıktı stdout veya eşdeğerine yazılır. Merhaba dünya dizesi kaynak koduna gömülüdür.

Örneğin,

(some source code here)hello world(some source code here)

Çıktı yeniden derlendiğinde veya yorumlandığında, benzer bir çıktı oluşturmalıdır, ancak merhaba dünya dizgisinin farklı bir noktalama işareti veya büyük harf kullanımı olmalıdır. Örneğin, önceki örnek aşağıdaki çıktıyı oluşturabilir

(some source code here)hello, wORld(some source code here)

Bu örneklerde yer alan her "(burada bazı kaynak kodları)" her yürütmeden sonra değişebilir veya aynı olabilir.

Çıktınız tam bir kez geçerli bir merhaba dünya dizesi içermelidir. Herhangi bir miktarda geçersiz merhaba dünya dizesi içerebilir. Kaynak kodu herhangi bir miktarda yorum içerebilir ve merhaba dünya dizesi yorumlara gömülebilir. İlk program sıfır veya bir geçerli merhaba dünya dizesine sahip olabilir, ancak daha fazla olamaz.

Aşağıdaki noktalama işaretleri geçerlidir:

hello, world
hello world
helloworld

Herhangi bir büyük harf kullanımı kabul edilebilir. Örneğin, bunlar geçerli merhaba dünya dizeleridir:

Hello, world
hellO WORld
HELLoworlD

Bu dizeler geçerli değil:

Hello     world
Hello(newline)world
Hello,world
Hello, Steve

Aşağıdaki koşullardan biri gerçekleştiğinde programınız başarısız olur:

• Daha önceki bazı yürütme sırasında çıktı alınan bir merhaba dünya dizesi çıktılar,
• çıktı artık aynı dilde geçerli kaynak kodu değil veya
• çıktı tam olarak geçerli bir merhaba dünya dizesi içermiyor.

En az iki ilk uygulama başarılı olmadıkça, programınız bu yarışma için geçerli değil. Bu, üçüncü çıktının geçersiz olmasına izin verildiği anlamına gelir. Programınızın çıktısı rastgele olmayabilir. İlk yürütme her zaman aynı ikinci çıktıyı oluşturmalı, ikinci yürütme her zaman aynı üçüncü çıktıyı oluşturmalıdır vb.

Skor, ilk programın kaynak kodundaki bayt miktarı olarak hesaplanır. En düşük puan kazanır.

Aşağıdaki bonuslar geçerlidir (% -60'a kadar):

• -5% * (N - 2); burada N, programınızın geçersiz çıktı oluşturduğu yürütme dizinidir. Bu bonus% -50'dir. Programınız 12 kat veya daha fazla başarılı olursa, maksimum bonusu alırsınız.
• Çıktılarınız (ilk kaynak kodu dahil) üç geçerli noktalama işaretinin tümünü içeriyorsa% -10.

Gönderiminiz ilk kaynak kodunu içermeli ve başarılı yürütmelerin çıktılarını da içermelidir. Programınız 12 kereden fazla başarılı olursa, 12 yürütme için çıktı ekleyin.

Misal

Sonraki satır ilk kaynak kodudur. Onu yürüttüğümüzde, ilk yürütmedir.

hello world(some source code here)

Sonraki satır, ilk kaynak kod kodundan çıktıdır. İlk çıktıdır.

hello, world(some source code here) 

Sonraki satır, ikinci yürütmeden elde edilen çıktıdır. İkinci çıktıdır.

helloworld(some source code here)

İlk çıktıyı yürüttüğümüzde, bu program% -10 bonus almaya hak kazandı. Bu, hepsinin farklı noktalama işaretlerine sahip iki çıkışı ve bir orijinal kodu olduğu anlamına gelir. Ayrıca, ikinci çıktı geçerli olduğundan, bu program bu yarışma için uygundur.

Sonraki satır üçüncü yürütme çıktısıdır. Üçüncü çıktıdır.

Helloworld(some source code here)

Sonraki satır dördüncü yürütme çıktısıdır. Dördüncü çıktıdır.

hellworld(some source code here)

Bu çıktı geçersizdi. Son geçerli yürütme dizini 4'tür. Bu program noktalama işaretlerinden% -5 * (4 - 2) bonus ve% -10 bonus almaya hak kazanmıştır. Bu toplam -20% yapar. İlk kaynak kodun uzunluğu ("merhaba dünya (burada bazı kaynak kodu)") 34 bayttır, bu nedenle son puan 27.2'dir.

Pyth, 17 bayt

Farklı bir Pyth çözümü:

"r\"helloworld\"1

Çıktı:

r"helloworld"1

İkinci çıktı:

HELLOWORLD

Mathematica, 214 - 50% = 107 bayt

(a = Characters[StringJoin["helloworl", "d"]]; b = Apply[StringJoin, Tuples[Transpose[{a, ToUpperCase[a]}]], {1}]; StringReplacePart[ToString[#0, InputForm], b[[FirstPosition[b, "helloworld"] + 1]], {180, 189}]) & 

Burada dize sayımı için optimize etmeye karar verdim. Bu, büyük ve küçük harflerin her birleşiminden geçmeden, durmadan 1024 program için çalışır. İcra burada görülebilir .

Vitsy, 33-33 * .05 * (11-2) = 18,15 Bayt

Heh! Bunun üstesinden gel! Muhtemelen yapacaksın. c

İlk çıktı:

'0DV \ {25 ^ -V \}} 1 {RD3 * Z; helloworld
'Bir dize olarak yakalamaya başlayın
 0DV Yığına 0 basın ve son değişken olarak ayarlayın.
    \ Bir sonraki öğeyi birçok kez tekrarlayın. (1, 2, 3 ... çıkışlarda.)
     {Yığını sola doğru döndürün.
      25 ^ Yığına 32 itin.
         - Üstteki öğeyi çıkartın - bu, küçük harf yapacaktır.
          V \ Bir sonraki öğenin son değişken zamanlarını yapın.
            } Yığını sağa döndürün.
             } Ve yeniden...
              1+ Bir tane ekleyin. Bu, bu koddaki 0'ı 1, sonra 2 yapar ...
                r Yığını ters çevirin.
                 d3 * Karakteri al '
                    Z Yığındaki tüm öğeleri çıktılar.
                     ; Yürütmeyi sonlandırın.
                      helloworld manipüle etmek için dize.

İkinci çıktı:

'1DV \ {25 ^ -V \}} 1 {RD3 * Z; helloworld

Üçüncü çıktı:

'2DV \ {25 ^ -V \}} 1 {RD3 * Z; helloworld

Dördüncü çıktı:

'3DV \ {25 ^ -V \}} 1 {RD3 * Z; helloworld

Beşinci çıktı:

'4DV \ {25 ^ -V \}} 1 {RD3 * Z; helloworld

Altıncı çıktı:

'5DV \ {25 ^ -V \}} 1 {RD3 * Z; helloworld

Yedinci çıktı:

'6DV \ {25 ^ -V \}} 1 {RD3 * Z; helloworld

Sekizinci çıktı:

'7DV \ {25 ^ -V \}} 1 {RD3 * Z; helloworld

Dokuzuncu çıktı:

'8DV \ {25 ^ -V \}} 1 {RD3 * Z; helloworld

Onuncu çıktı:

'9DV \ {25 ^ -V \}} 1 {RD3 * Z; helloworld

Onbirinci çıktı:

': DV \ {25 ^ -V \}} 1 {RD3 * Z; helloworld

Hataya neden olacağı için bu son çıktıdır.

CJam, N = 3 4, 28 bayt -% 10 -% 10 = 22.4

{`_E=-"_~Hello!, World"2<}_~

bu aşağıdaki zinciri başlatır:

{`_E=-"_~Hello, World"2<}_~
{`_E=-"_~Hello World"2<}_~
{`_E=-"_~HelloWorld"2<}_~
{`_E=-"_~Helloorld"2<}_~

burada sonuncusu artık geçerli bir "Merhaba Dünya" içermiyor.

Burada test edin.

açıklama

{`     e# Quine framework. Leaves a string representation of the block on the stack.
  _E=  e# Make a copy and get the 14th element, which is the character of the first 'o'.
  -    e# Remove that character from the string.
  "_~Hello!, World" e# Push this string, so the "Hello, World!" is part of the code.
  2<   e# Truncate to just "_~" to get the output right.  
}_~

İlk programın geçerli bir "Merhaba, Dünya" içermediğini, ancak bir yineleme daha ileri gitmemize izin verdiğini unutmayın.

CJam 69 60-50 % = 30

Hala acemiyim, lütfen bana CJam'de nasıl golf oynayacağını söyle.

{`_40>\40<_38>~)`2Te[\25<"helloworld"00YbATe[.{{el}{eu}?}`+]W%"_~"}_~

99 yineleme için geçerli olacağı için her yinelemeyi yazdırmak sıkıcıdır.

Merhaba sözcüğün büyük harf kullanımını sıralar. Tedium hem "merhaba dünya" hem de sayaç güncellenmesi gerektiğinden, dizeleri parçalara ayırmaktır.

açıklama

{`_40>\40<_38>~)`2Te[\25<"helloworld"00YbATe[.{{el}{eu}?}`+]W%"_~"}_~
{`                                                                      e# standard quine framework. Thanks for Dennis.
  _40>                                                                  e# get the Yb11..
      \40<                                                              e# get those that not included in top
          _38>~)`2Te[                                                   e# get the accumulator and increment it
                     \25<                                               e# get those before "hello world"
                         "helloworld"                                   e# the Hello World
                                     00                                 e# accumulator
                                        YbATe[                          e# convert to binary and align right.
                                              .{{el}{eu}?}              e# Uppercase if the corresponding bit is 0
                                                          `             e# add quote
                                                           +]W%         e# reorder stack
"_~"}_~

NOT: Mathematica cevabını okumuyorum, üzgünüm, bence orijinal

Yeniden sıralama ve farklı büyük harf kullanımı ile 9 bayt kaybederim.

{`_6<\"helloworld"01YbW%.{{eu}{el}?}`\I>_2<~)`2Te[\2>"_~"}_~
{`                                                   "_~"}_~ e# Standard quine framework
  _6<\                                                       e# Get "{~_6<\"
      "helloworld"                                            e# The helloworld
                  01                                          e# The accumulator
                    Yb                                        e# Convert to base 2
                      W%                                      e# Reverse the binary
                        .{{eu}{el}?}                          e# Convert to uppercase while the corresponding bit is 1.
                                    `                         e# Add quote
                                     _2<                      e# Get accumulator
                                        ~)`2Te[               e# Increment the accumulator
                                               \2>            e# get the rest

CJam 73-60% = 29,2

Bu kez noktalama işaretleri de numaralandırılır.

{`:Z6<"HELLOWORLD"0:AYbW%.{{eu}{el}?}`", ":B-_6<BA3%>@6>A)ZW%52<W%"_~"}_~
{`:Z                                                              "_~"}_~ e# Standard Quine Framework
    6<                                                                    e# take the first 6 character
      "HELLOWORLD"                                                        e# Hello, world
                  0:A                                                     e# Accumulator
                     YbW%.{{eu}{el}?}`                                    e# See above
                                      ", ":B                              e# Punctuation
                                            -                             e# Delete punctuation
                                             _6<                          e# "hello
                                                BA3%>                     e# punctuation
                                                     @6>                  e# world"
                                                        A)                e# incremented accumulator
                                                          ZW%52<W%        e# Remaining part

GolfScript, 35 bayt -% 50 = 17,5

0"HelloWorld"{@@{^.32&\}%`@".~"}.~

Tekrarlamadan önce infazların sayısını aşmaya karar verdim. Çıkışı GolfScript yorumlayıcısına geri beslenen bu program, ilk tekrardan önce 890 ayrı Hello World dizesi üretecektir . Kısa bir örnek olarak, ilk 15 yineleme:

0"HelloWorld"{@@{^.32&\}%`@".~"}.~
0"HeLlOWoRlD"{@@{^.32&\}%`@".~"}.~
0"HelLOWorLD"{@@{^.32&\}%`@".~"}.~
0"HeLLOWoRLD"{@@{^.32&\}%`@".~"}.~
0"HellowORLD"{@@{^.32&\}%`@".~"}.~
32"HeLlOworld"{@@{^.32&\}%`@".~"}.~
0"hELloWoRlD"{@@{^.32&\}%`@".~"}.~
32"helLowORld"{@@{^.32&\}%`@".~"}.~
0"HeLLoWORlD"{@@{^.32&\}%`@".~"}.~
32"HellOWORld"{@@{^.32&\}%`@".~"}.~
0"hElLOWORlD"{@@{^.32&\}%`@".~"}.~
32"heLLOWORld"{@@{^.32&\}%`@".~"}.~
32"HelloworLd"{@@{^.32&\}%`@".~"}.~
32"hElLoWoRLd"{@@{^.32&\}%`@".~"}.~
0"HEllOWorlD"{@@{^.32&\}%`@".~"}.~

Bir önceki harf (büyük olasılıkla büyük / küçük harf çevirdikten sonra) küçük harf ise, dizeyi yineleyerek, her harfin büyük harf kullanımını (ASCII kodunu 32 ile XORing yaparak) dize yoluyla yineleyerek çalışmaktır. Başlangıç ​​programındaki sayı 0 yerine 32 ise ilk harf büyük / küçük harf döndürülür ve dizenin son harfi küçük olduğunda bir sonraki yineleme için sayı çıktısı 32 olur ve böylece sonraki yinelemenin başına geri yayılacak dize.

(Bu özel geri bildirim süreci tamamen ad hoc bir şekilde elde edildi . Başlangıçta bitler olarak büyük ve küçük harf kullanarak basit bir ikili sayaç çalıştırmak istedim, ancak uygulanması çok fazla bayt sürdü, bu yüzden daha kısa bir şey bulmak için ince ayar yapmaya başladım Bu, oldukça yüksek bir döngü uzunluğu sağlayacaktır. Teorik maksimum, yalnızca büyük / küçük harf çevirme kullanarak 2 ¹⁰ = 1024 olduğundan, 890-yineleme döngüsü elde etmek oldukça güzeldir.)

Ne yazık ki, ek iterasyonlar için bonus −% 50 ile sınırlıdır; bu kapak olmadan, bu program okkalı −4440% bonus olurdu. ;-)

Pyth, 18 bayt

"-\"hello world\"d

Hangi döndürür:

-"hello world"d

Hangi sırayla yazdırır:

helloworld

Üç yazımı da yapan bir çözümüm vardı, ama bonusla bile daha uzun.

Tek taraflı , 21 bayt.

Simplex bunun için doğdu . Bununla kesinlikle daha ileri gidebilirim.

(Ctrl + Enter tuşlarına basmaya devam ediyorum, üzgünüm! Tablet klavyesinde suçluyorum)

Deneme 3, v.0.8 +,% 31-5 = 29.45 bayt (UTF-8 methinks)

Ortadaki o ifade kendimi ifade ediyor. Bir çeşit. Bunu neden tekrar yaptım? ._.

"\"f[helloworld]-:D-``\"§R'Hg"g
"                            "  ~~ write that string
 \"f[helloworld]-:D-``\"§R'Hg   ~~ escaped quotes
                              g ~~ output that string

2. Çıkış:

"f[helloworld]-:D-``"§R'Hg
"                   "      ~~ write that string
 f[helloworld]-:D-``       ~~ string to be written
                     §R    ~~ go to second cell
                       'H  ~~ set it to H charcode
                         g ~~ output that string

3. çıktı:

f[Helloworld]-:D-``
f                   ~~ turns off safety mode (heck yeah error suppression!)
 [          ]-      ~~ write inside to outer program
  H                 ~~ sort strip
   e                ~~ write e = 2.718281828459045... to the strip
    ll              ~~ writes 1 twice to the cell
      o             ~~ outputs 1
       wo           ~~ apply o backwards through the strip (outputs 1)
         r          ~~ error! tries to access register for modification. nope!
          l         ~~ write 1 to to the current cell
           d        ~~ reverse the strip (NOP)
              :     ~~ removes last char of outer program
               D    ~~ double the current byte (2)
                -   ~~ writes previous char to outer program
                 `` ~~ suppress outer program evaluation and instead output it

Son çıktı:

HelloworlD

Deneme 2, v.0.8 +, 21 bayt (UTF-8, sanırım)

"\"helloworld\"§'Hg"g
"                  "  ~~ write that string
 \"helloworld\"§'Hg   ~~ escaped quotes
                    g ~~ output that string

Çıktı:

"helloworld"§'Hg
"          "     ~~ write that string
 helloworld      ~~ string to be written
            §    ~~ go to first cell
             'H  ~~ set it to H charcode
               g ~~ output that string

Son çıktı:

helloworld

Deneme 1, s.0.7 + 28 26 bayt

Bunun ilk bonus için uygun olup olmadığından emin değilim…

"BhelloworldB"t[s32S;]'gs;
"            "             ~~ write that string
 BhelloworldB              ~~ the string
              t[     ]     ~~ apply the inner from left to right
                s          ~~ output as character
                 32S       ~~ subtract 32 ("capitalize")
                    ;      ~~ add the current byte's char to the outer program
                      'g;s ~~ add g to the outer program

İlk çıktı:

"HELLOWORLD"g

Dış program yürütme sonunda değerlendirilir (bunu y için yapar; dış program şöyle görünür:

"HELLOWORLD"g
"          "  ~~ write that string
            g ~~ output that string as string characters

Son çıktı:

HELLOWORLD

Yakut,% 81-50 = 40.5

Orijinal kod:

_='_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)';puts _%[_,'HELLOWORL'+?D]

Ardışık çıktılar:

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"HELLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hELLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"heLLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellowORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellowoRLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworlD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworld"]).sub(/[[:upper:]]/,&:swapcase)

Bence bu tam% 50 olarak sayılıyor? Birer birer kapalı olabilir. Ayrıca, Ruby'de muhtemelen daha iyi puan alan bonus olmayan bir çözüm var.

Orijinal kod "helloworld" içermez, ancak kaynak kodundaki ilk büyük harfi küçük harfle değiştiren bir sorgu oluşturur. Böylece, birbirinin ardışık her çalıştırması daha az büyük harf çıkarır.

Buradaki hile, yalnızca dizenin kendisinin, sorgulama için ve Hello World dizesinin enterpolasyonunu yapmak için bir biçim dizesi kullanmaktır, böylece yalnızca bir kez görünür.

PHP, 297 - 40% = 178.2 bayt

Gerçekten rekabetçi değil ama yazmak eğlenceliydi

<?ob_start(function($s){$s=substr(str_replace(0,0+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[0]=$h[0]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(0,0+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[0]=$h[0]^' ';return "<"."?".$s."?".">".$s.$h;});

Bu kinin bir varyasyonu:

<?
ob_start(function($b){ return "<"."?\n$b?".">\n$b"; });?>
ob_start(function($b){ return "<"."?\n$b?".">\n$b"; });

ama aynı zamanda çıkış ve cümledeki için "MerhabaDünya" ekler 0ile 0+1(sonraki tekrarında 1ile 1+1böyle devam eder). Kullanımı substryeni "helloworld" ekledi alır önce mevcut "helloworld" çıkışını kaldırılır.

Farklı çıktılar elde etmek için, bir "helloworld" harfi büyük harfle yazılır (artan sayı ile belirlenir). İlgili kod:

$h=hello.world;$h[0]=$h[0]^' '

Buradaki zorluk, burada ve sayı değiştirme dışında herhangi bir sayı kullanılmamasıydı

str_replace(0,0+(int)true,$s)

Orada zaten olduğunu +1fark etmişsinizdir +(int)true.

İhtiyacım olan alt dize argümanları için 0, 146:

!i, ord(I)+ord(I)

Boş olmayan "i" dizgisi zorlanır trueve reddedilir.falsegeçerli bir tamsayı bağımsız değişkenidir ve 0. ord(I)ASCII değeri "I" dir: 73

Çıktı (1. yineleme):

<?ob_start(function($s){$s=substr(str_replace(1,1+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[1]=$h[1]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(1,1+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[1]=$h[1]^' ';return "<"."?".$s."?".">".$s.$h;});Helloworld

Çıktı (2. yineleme):

<?ob_start(function($s){$s=substr(str_replace(2,2+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[2]=$h[2]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(2,2+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[2]=$h[2]^' ';return "<"."?".$s."?".">".$s.$h;});hElloworld

Çıktı (10. yineleme):

Bu son geçerli çıktıdır, ancak geçerli bir program değil

<?ob_start(function($s){$s=substr(str_replace(10,10+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[10]=$h[10]^' ';return "<"."?".$s."?".">".$s.$h?>ob_start(function($s){$s=substr(str_replace(10,10+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[10]=$h[10]^' ';return "<"."?".$s."?".">".$s.$hhelloworlD

"Merhaba dünya" dizelerini bulmak için sağa kaydırın!

Pip,% 48-50 = 24

V Y"`V Y`.RPyRh:ST`helloworld`UCh@<0.h@>0R0o+0"

ki şu şekilde gelişir:

V Y"`V Y`.RPyRh:ST`helloworld`UCh@<1.h@>1R1o+1"
V Y"`V Y`.RPyRh:ST`Helloworld`UCh@<2.h@>2R2o+2"
V Y"`V Y`.RPyRh:ST`HElloworld`UCh@<3.h@>3R3o+3"
V Y"`V Y`.RPyRh:ST`HELloworld`UCh@<4.h@>4R4o+4"
V Y"`V Y`.RPyRh:ST`HELLoworld`UCh@<5.h@>5R5o+5"
V Y"`V Y`.RPyRh:ST`HELLOworld`UCh@<6.h@>6R6o+6"
V Y"`V Y`.RPyRh:ST`HELLOWorld`UCh@<7.h@>7R7o+7"
V Y"`V Y`.RPyRh:ST`HELLOWOrld`UCh@<8.h@>8R8o+8"
V Y"`V Y`.RPyRh:ST`HELLOWORld`UCh@<9.h@>9R9o+9"
V Y"`V Y`.RPyRh:ST`HELLOWORLd`UCh@<10.h@>10R10o+10"
V Y"`V Y`.RPyRh:ST`HELLOWORLD`UCh@<11.h@>11R11o+11"
V Y"`V Y`.RPyRh:ST`HELLOWORLD`UCh@<12.h@>12R12o+12"

HELLOWORLDdeğişmediği için son çıktı geçersiz . (Bonusu doğru yapmadıysam beni düzeltin.)

Bu soru sayesinde, yeni bir kine tekniği keşfettim! Temel tırnak V Y"`V Y`.RPy":

  Y"         "  Yank that string into the variable y
V               Evaluate it as a Pip expression:
          RPy   y wrapped in double quotes (repr)
    `V Y`.      Prepend that regex pattern
                When this is evaluated, it returns a pattern object, which is
                auto-printed--conveniently, without the `` delimiters

Ek kodumuz, dizeyi yeniden ayarlamadan yönce aşağıdaki gibi değiştirir:

• Şu anki dünyayı, en soldaki 0karakterlerin büyük harflerle yazıldığı bir dünyayla değiştirin ;
• Tüm tekrarlarını değiştirmek 0ile o+0(burada o1'e eşit olduğu bir yerleşik değişkendir).

Koddaki sayının bir dahaki sefere 1yerine, 0vb.

Javascript, 52 bayt

function(){return '("hello world").replace(" ","")'}

Ölçek

=>

<='("hello world").replace(" ","")'

=> eval('("hello world").replace(" ","")')

<= 'helloworld'

///, 23 bayt -% 10 = 20.7?

/,//\/ \/\/hello, world

Çevrimiçi deneyin!

İlk çıktı:

/ //hello world

İkinci çıktı:

helloworld

BBC BASIC, 56 bayt

Oyuna ne kadar geç kaldığımı fark etmeden önce bir çatlak yaşadım. Değer için, İşte benim sürüm ve StackExchange kod golf benim ilk denemem.

Burada V. , ASCII kodları tarafından verilen karakterleri aşağıdaki virgülle ayrılmış listede yankılar ve P yazdırma için kısadır. Mevcut 'helloworld' dizesinin üzerine yazmak için backspace karakterini kullanıyorum.

Giriş kodu:

V.80,46,34:P."helloworld";:V.8,68,34,59:P.":V.8,8,76,68"

İlk Çıktı:

P."helloworlD";:V.8,8,76,68

İkinci Çıktı:

helloworLD

Çevrimiçi olarak test edilebilir Https://bbc.godbolt.org/ adresinden