Çünkü yeterince ezoterik dil golfu alamıyoruz, değil mi?

/// - belirgin eğik çizgiler - s///Perl ününün regex değiştirme işlevine dayanan eğlenceli bir dildir . Yalnızca iki özel karakter içerir, eğik çizgi /ve ters eğik çizgi \. Üzerinde wiki esolangs hakkında tam bir makale bulabilirsiniz , ancak bazı örneklerin yanı sıra, aşağıdaki dilin tanımını da çoğaltacağım .

Kısacası, /pattern/repl/restprogramda tanımlayarak ve ikameyi olabildiğince çok kez değiştirerek çalışır . Hiçbir karakter özel değildir /ve \: /Programdaki desenleri ve değiştirmeleri gösterirken, kodunuza \değişmez /veya \karakter eklemenizi sağlar . Özellikle, bunlar normal ifadeler değil, sadece düz dize değişimleridir.

Buradaki zorluk , /// dili için, STDIN okuyan bir program veya bir dize argümanı alan bir işlev olarak, mümkün olduğunca az karakter olarak bir tercüman üretmektir.

/// dışında herhangi bir dili kullanabilirsiniz. /// adlı bir kütüphaneyi kullanamazsınız; Bununla birlikte, regex'leri, regex kütüphanelerini veya string eşleştirme kütüphanelerini kullanabilirsiniz.

infaz

Dört durum vardır; baskı , desen , değiştirme ve değiştirme . İkame hariç her devlette :

• Program boşsa, yürütme durur.
• Aksi takdirde, ilk karakter ise \, bir sonraki karakterle (varsa) bir şeyler yapın ve her ikisini de programdan kaldırın.
• Aksi takdirde, ilk karakter ise /onu kaldırın ve bir sonraki duruma geçin.
• Aksi halde, ilk karakterle bir şeyler yapın ve programdan kaldırın.
• Tekrar et.

Devletler , sırasıyla baskı , desen , değiştirme ve değiştirme işlemlerini gerçekleştirir.

• Gelen baskı modunda, karakter araçları çıktı 'bir şey yapmak'.
• In desen modunda araçlar geçerli Pattern karakter eklemek 'bir şey yapmak'.
• In yedek modunda araçlar geçerli Değiştirilmesi karakter eklemek 'bir şey yapmak'.

In ikame modunda kurallar farklı bir dizi izleyin. Mevcut Modelin ilk oluşumunu, programda mevcut Yedek ile yerine, başka bir değişiklik mümkün olmadıkça tekrarlayın. Bu noktada, Desen ve Değiştirme'yi temizleyin ve baskı moduna dönün .

Programda /foo/foobar/foo foo fooaşağıdakiler gerçekleşir:

/foo/foobar/foo foo foo
foo foo foo
foobar foo foo
foobarbar foo foo
foobarbarbar foo foo
...

Bu sonsuza kadar döngüler ve asla ikame modundan çıkmaz . Benzer şekilde, Desen boşsa, boş dizenin ilk oluşumu - programın başlangıcında - her zaman eşleşir, bu nedenle değiştirme modu sonsuza kadar döngüler, asla durmaz.

Örnekler

no

Çıktı: no.

/ world! world!/Hello,/ world! world! world!

Çıktı: Hello, world!.

/foo/Hello, world!//B\/\\R/foo/B/\R

Çıktı: Hello, world!.

a/ab/bbaa/abb

Çıktı: a. Program durmuyor.

//

Çıktı: yok.

///

Çıktı: yok. Program durmuyor.

/\\/good/\/

Çıktı: good.

Ayrıca deneyebileceğiniz wikide bir de kısma var .

APL (133)

{T←''∘{(0=≢⍵)∨'/'=⊃⍵:(⊂⍺),⊂⍵⋄(⍺,N⌷⍵)∇⍵↓⍨N←1+'\'=⊃⍵}⋄⍞N←T⍵⋄p N←T 1↓N⋄r N←T 1↓N⋄''≡N:→⋄∇{⍵≡p:∇r⋄∨/Z←p⍷⍵:∇(r,⍵↓⍨N+≢p),⍨⍵↑⍨N←1-⍨Z⍳1⋄⍵}1↓N}

Bu, ///kodu doğru argüman olarak alan bir fonksiyondur .

Ungolfed, açıklama ile:

slashes←{
   ⍝ a function to split the input string into 'current' and 'next' parts,
   ⍝ and unescape the 'current' bit
   split←''∘{
       ⍝ if the string is empty, or '/' is reached,
       ⍝ return both strings (⍺=accumulator ⍵=unprocessed)
       (0=≢⍵)∨'/'=⊃⍵:(⊂⍺),⊂⍵
       ⍝ otherwise, add current character to accumulator,
       ⍝ skipping over '\'s. (so if '\/' is reached, it skips '\',
       ⍝ adds '/' and then processes the character *after* that.)
       idx←1+'\'=⊃⍵
       (⍺,idx⌷⍵)∇idx↓⍵
   }

   ⍞   next ← split ⍵      ⍝ output stage
   pat next ← split 1↓next ⍝ pattern stage, and eat the '/'
   rpl next ← split 1↓next ⍝ replacement stage, and eat the '/'

   ⍝ if there are no characters left, halt.
   ''≡next:⍬

   ⍝ otherwise, replace and continue.
   ∇{  ⍝ if the input string equals the pattern, return the replacement and loop
       ⍵≡pat:∇rpl

       ⍝ otherwise, find occurences, if there are, replace the first and loop
       ∨/occ←pat⍷⍵:∇(rpl, (idx+≢pat)↓⍵),⍨ (idx←(occ⍳1)-1)↑⍵

       ⍝ if no occurences, return string
       ⍵

   }1↓next
}

J - 181 190 170 karakter

Bu bir kabustu. İki kere sıfırdan yazdım çünkü beni rahatsız etmeye devam ediyordu. Bu, STDOUT işlevine çıkış yapan tek bir dize argümanı alan bir işlevdir.

(0&$`((2{.{:@>&.>)((j{.]),-i@=`p@.~:~/@[,]}.~#@p+j=.0{p I.@E.])i 5;@}.&,'/';"0;&.>)@.(2<#)@}.[4:1!:2~{:@>@p=.>@{.@[)@((0;(0,:~1 0,.2);'\';&<1 0)<;._1@;:'/'&,)i=. ::](^:_)

Açıklamak için onu alt ifadelere ayıracağım.

i =. ::](^:_))
parse =: ((0;(0,:~1 0,.2);'\';&<1 0)<;._1@;:'/'&,)
print =: 4:1!:2~{:@>@p=.>@{.@[
eval  =: 0&$`((2{.{:@>&.>)sub 5;@}.&,'/';"0;&.>)@.(2<#)@}.
sub   =: ((j{.]),-i@=`p@.~:~/@[,]}.~#@p+j=.0{p I.@E.])i

interp =: (eval [ print) @ parse i

• i( yinelemek için kısa ) bir zarftır. Soldaki fiil argümanını alır ve (f)ibir argümana uygulandığında f, iki şeyden biri gerçekleşene kadar argümana sürekli olarak uygulanan bir fiil döndürür : sabit bir nokta ( y = f y) bulur veya bir hata atar. Sabit nokta davranışı doğaldır ^:_ve ::]hata işlemeyi gerçekleştirir.

• parsegirdiyi yarısı ayrıştırılmış form dediğim duruma göre işaretler ve ardından çıkarılan '/' noktasında keser. Kaçan ters eğik çizgileri karakterlerine bağlar, ancak ters eğik çizgiden kurtulmaz - bu nedenle geri çevirebilir veya istediğimize bağlı olarak bitirebiliriz.

  İlginç eserin büyük bir bölümünde oluşur ;:. Bu, (0;(0,:~1 0,.2);'\';&<1 0)soldaki makinenin ( ) ve sağdaki ayrıştırılacak bir şeyin tanımını alan sıralı bir makine yorumlayıcısıdır . Bu belirteci yapar. Bu özel makinenin aslında ilk karakterini, özel ve hatta \bağlanması gerekse bile özel olacağına dikkat edeceğim . Bunu birkaç sebepten dolayı yapıyorum: (1) devlet masası daha basit, bu yüzden daha fazla golf oynayabilir; (2) sorunu çözmek için kolayca öne bir kukla karakter ekleyebiliriz; ve (3) bu kukla karakter hiçbir ekstra ücret ödemeden yarı yarıya ayrıştırılır, bu yüzden daha sonra kesme aşamasına ayarlamak için kullanabilirim.

  Ayrıca <;._1, belirtilmemiş sonucu unescaped'de kesmek için de kullanıyoruz /(bu benim ilk karakter olmayı seçtim). Bu, çıktıyı, kalıbı ve değiştirmeyi out/patt/repl/resttek bir adımda çıkarmak için kullanışlıdır , ancak ne yazık ki aynı zamanda programın geri kalanını da keser ve /dokunulmadan kalmaları gerekir . Bunları tekrar ekliyorum evalçünkü <;._1onları yalnız bırakmak çok daha pahalıya geliyor.

• Çatal , yan etkileri nedeniyle elde edilen sonucu (eval [ print)çalıştırır ve sonra çalışır . ilk kutuyu açan (kesin olarak bildiğimiz bir çıktı) açılan basit bir fiil, ayrıştırmayı tamamlar ve STDOUT'a gönderir. Bununla birlikte, bir yardımcı fiil tanımlama şansını da kullanıyoruz .printparseevalprintp

  polarak tanımlanır >@{.@[, bu nedenle sol argümanını alır (yalnızca bir argüman verildiyse kimlik gibi davranır), bunun ilk öğesini alır (skaler verildiğinde özdeşlik) ve kutusundaki kutuları kaldırır (önceden kutusuzsa özdeşlik). Bu çok işe yarayacak sub.

• evalişlenen programın geri kalanını değerlendirir. Tam bir patern veya tam bir evalyeniliğe sahip değilsek, onu dışarı atar ve sadece bir sonraki yinelemede ;:(dan parse) hata yaparak değerlendirmeyi sonlandıran boş bir liste döndürür . Aksi halde, evaldeseni ve değişimi tamamen ayrıştırır, kaynağın kalanını düzeltir ve sonra her ikisine de geçer sub. Patlama ile:

                                                @}.  NB. throw out printed part
                                         @.(2<#)     NB. if we have a pattern and repl:
        2{.                                          NB.  take the first two cuts:
               &.>                                   NB.   in each cut:
           {:@>                                      NB.    drop escaping \ from chars
       (          )                                  NB.  (these are pattern and repl)
                                     &.>             NB.  in each cut:
                                    ;                NB.   revert to source form
                              '/';"0                 NB.  attach a / to each cut
                            &,                       NB.  linearize (/ before each cut)
                       5  }.                         NB.  drop '/pattern/repl/'
                        ;@                           NB.  splice together
      (            sub                  )            NB.  feed these into sub
     `                                               NB. else:
  0&$                                                NB.  truncate to an empty list
  

• subBir (muhtemelen sonsuz) ikame turunun gerçekleştiği yerdir. Kurma şeklimiz nedeniyle eval, kaynak doğru argümandır ve kalıp ve değişim solda bir araya toplanır. Argümanlar bu şekilde sıralandığından ve örüntü ve değişimin bir değişme turunda değişmediğini bildiğimiz için, iyalnızca doğru argümanı değiştirdiği ve aynı soldan geçmeye devam ettiği için - başka bir özelliği kullanabiliriz J'ye devleti takip etme konusunda endişe etme ihtiyacı duyuldu.

  Yine de iki sorun var. Birincisi, J fiillerinin en fazla iki argüman olabileceği, bu yüzden burada kalıp ve değiştirme gibi bir araya getirilmiş olanlara erişmek için kolay bir yolumuz yok. pTanımladığımız yardımcı programın akıllıca kullanılması sayesinde , bu büyük bir sorun değil. Aslında, desene tanımından pdolayı yalnızca karakter kullanarak tek bir karakterde erişebiliriz >@{.@[: Sol arg'in Birinci öğesinin Kutusundan Çıkarma. Değişimi elde etmek kandırmacadır, ancak en kısa yol p&|., elle çıkarmaktan 2 karakter kısadır.

  İkinci sorun, isonsuza dek döngü yapmak yerine sabit noktalardan çıkmasıdır; kalıp ve değiştirme eşitse ve bir ikame yaparsanız, J'ye sabit bir nokta gibi gözükürse, bunu 1'i ve üzerinde olumsuzlayan sonsuz bir döngü girerek hallederiz. eğer eşit olduklarını tespit edersek: bu -i@=`p@.~:~/, yerine geçen kısımdır p&|..

                                      p    E.]    NB. string search, patt in src
                                        I.@       NB. indices of matches
                                    0{            NB. take the first (error if none)
                                 j=.              NB. assign to j for later use
                             #@p+                 NB. add length of pattern
                         ]}.~                     NB. drop that many chars from src
                     /@[                          NB. between patt and repl:
                    ~                             NB.  patt as right arg, repl as left
                @.~:                              NB.  if equal:
          -i@=                                    NB.   loop forever
              `p                                  NB.  else: return repl
   (j{.])                                         NB. first j chars of src
         ,              ,                         NB. append all together
  (                                           )i  NB. iterate
  

• Bu döngü, kullanım nedeniyle hataların idışında bir şey çıkıncaya kadar tekrar eder sub. Bildiğim kadarıyla, bu yalnızca karakterlerin dışında olduğumuzda, eksik bir desen-değiştirme setini attığımızda olabilir.

Bu golf hakkında eğlenceli gerçekler:

• Bir kez kullanmak ;:, dizede manuel olarak yinelemekten daha kısa.
• 0{subSonsuz bir döngüye girmeden önce hata yapma şansına sahip olmalı , bu yüzden eğer kalıp değiştirme ile eşleşiyorsa ancak kaynağın geri kalanında hiçbir zaman görünmezse, bu iyi sonuç vermelidir. Ancak, bu belirtilmemiş bir davranış olabilir veya olmayabilir, çünkü dokümanlardaki herhangi bir alıntıyı bulamıyorum. Hay aksi.
• Klavye kesintileri, çalışan işlevlerin içinde kendiliğinden hatalar olarak işlenir. Bununla birlikte, doğası gereği ibu hatalar da kapana kısılır. Ctrl + C'ye ne zaman çarptığınıza bağlı olarak, şunları yapabilirsiniz:
  • Negate for forever döngüsünden çıkın, bir dizgeyle subbir sayı birleştirmeye çalışarak döngüden hata yapın ve /// bir dizgeyi kendisiyle sınırsız sayıda değiştirmeyi bitirdiniz gibi yorumlamaya devam edin.
  • subYarıda bırakın ve yarım-alt tablalı /// ifadeyi yorumlamaya devam edin.
  • Tercümandan ayrılın ve değerlendirilmemiş bir /// programı REPL'e geri gönderin (STDOUT hariç).

Örnek kullanım:

   f=:(0&$`((2{.{:@>&.>)((j{.]),-i@=`p@.~:~/@[,]}.~#@p+j=.0{p I.@E.])i 5;@}.&,'/';"0;&.>)@.(2<#)@}.[4:1!:2~{:@>@p=.>@{.@[)@((0;(0,:~1 0,.2);'\';&<1 0)<;._1@;:'/'&,)i=. ::](^:_)
   f 'no'
no
   f '/ world! world!/Hello,/ world! world! world!'
Hello, world!
   f '/foo/Hello, world!//B\/\\R/foo/B/\R'
Hello, world!
   f '//'  NB. empty string

   f '/\\/good/\/'
good

Perl - 190

$|=1;$/=undef;$_=<>;while($_){($d,$_)=/(.)(.*)/;eval(!$e&&({'/','$a++','\\','$e=1'}->{$d})||('print$d','$b.=$d','$c.=$d')[$a].';$e=0');if($a==3){while($b?s/\Q$b/$c/:s/^/$c/){}$a=0;$b=$c=''}}

Stdin'den ///EOF'ye kadar olan programı okur .

Pip , 100 102 bayt

Pip'in Turing'in tamamlandığını hiç ispatlamamıştım (oldukça açık olmasına rağmen) ve BF'nin normal yoluna gitmek yerine ilginç olacağını düşündüm. Çözüme ulaştığımda, golf oynayıp buraya göndereceğimi düşündüm.

101 bayt kod, -rbayrak için +1 :

i:gJnf:{a:xW#i&'/NE YPOia.:yQ'\?POiya}W#iI'\Q YPOiOPOiEIyQ'/{p:VfY0s:VfIyQ'/WpNi&YviR:Xp{++y?ps}}E Oy

İşte benim çok yorum yapan unungolfed versiyonum:

; Use the -r flag to read the /// program from stdin
; Stdin is read into g as a list of lines; join them on newline and assign to c for code
c : gJn

; Loop while c is nonempty
W #c {
 ; Pop the first character of c and yank into y
 Y POc
 ; If y equals "\"
 I yQ'\
  ; Pop c again and output
  O POc
 ; Else if y equals "/"
 EI yQ'/ {
  ; Build up pattern p from empty string
  p : ""
  ; Pop c, yank into y, loop while that is not equal to "/" and c is nonempty
  W #c & '/ NE Y POc {
   ; If y equals "\"
   I yQ'\
    ; Pop c again and add that character to p
    p .: POc
   ; Else, add y to p
   E p .: y
  }

  ; Yank 0 so we can reliably tell whether the /// construct was completed or not
  Y0
  ; Build up substitution s from empty string
  s : ""
  ; Pop c, yank into y, loop while that is not equal to "/" and c is nonempty
  W #c & '/ NE Y POc {
   ; If y equals "\"
   I yQ'\
    ; Pop c again and add that character to s
    s .: POc
   ; Else, add y to s
   E s .: y
  }

  ; If the last value yanked was "/", then we have a complete substitution
  ; If not, the code must have run out; skip this branch, and then the outer loop
  ; will terminate
  I yQ'/ {
   ; While pattern is found in code:
   W pNc {
    ; Set flag so only one replacement gets done
    i : 0
    ; Convert p to a regex; replace it using a callback function: if ++i is 1,
    ; replace with s; otherwise, leave unchanged
    c R: Xp {++i=1 ? s p}
   }
  }
 }
 ; Else, output y
 E Oy
}

Çevrimiçi deneyin! (Program sona ermediğinde TIO'nun herhangi bir çıktı vermediğini ve bunun da bir zaman sınırı olduğunu unutmayın. Daha büyük örnekler ve sonsuz döngüler için Pip'in komut satırından çalıştırılması önerilir.)

C ++: Visual C ++ 2013 = 423, g ++ 4.9.0 = 442

Bu asla kazanamayacak, ancak gelecekteki tüm yazılım projelerimin bu harika dilde yazılacağına karar verdiğim için, bir yorumlayıcıya ihtiyacım vardı ve yaptığım şeyi paylaşabileceğimi düşündüm ...

Skordaki fark, Visual C ++ 'ın ilk içermeye ihtiyacı olmadığı, ancak g ++' nın olması gerektiğidir. Skor, satır sonlarının 1 olduğunu kabul eder.

#include<string.h>
#include<string>
#define M(x)memset(x,0,99);
#define P o[i])
#define N(x)P;else if(n<x)(P==92?
#define O (o[++i]):(P==47?n++:
#define S std::string
int main(int n,char**m){S o=m[1];char p[99],*q=p,r[99],*s=r;M(p)M(r)for(int i=0,t;i<=o.size();++i){if(!N(3)putchar O putchar(N(4)*q++=O(*q++=N(5)*s++=O(*s++=P;if(n>4){for(;;){if((t=o.find(p,i+1))==S::npos)break;o=o.substr(0,t)+r+o.substr(t+strlen(p));}M(p)M(r)n=2;q=p;s=r;}}}

Python 2 (236), Python 3 (198?)

from __future__ import print_function
def d(i):
 t=0;p=['']*3+[1]
 while i:
  if'/'==i[0]:t+=1
  else:
   if'\\'==i[0]:i=i[1:]
   p[t]+=i[0]
  i=i[1:]
  print(end=p[0]);p[0]=''
  if t>2:
   while p[1]in i:i=i.replace(*p[1:])
   d(i);i=0

Denir d(r"""/foo/Hello, world!//B\/\\R/foo/B/\R"""). Üçlü tırnak sadece ///program yeni satırlar içeriyorsa gereklidir : aksi halde basit tırnaklar yolundadır.

EDIT: Bu tercüman şimdi beklendiği gibi şeyler basıyor (daha önce sadece en sonunda basıldı, yorumlara bakın). Python 3 için ilk satırı kaldırın (ancak eski yüklememde Python 3 yok, bu yüzden başka bir değişiklik olmadığından emin olamazsınız).

Kobra - 226

sig Z as String
def f(l='')
    m=Z(do=[l[:1],l=l[1:]][0])
    n as Z=do
        if'/'<>(a=m())>'',return if(a=='\\',m(),a)+n()
        else,return''
    print n()stop
    p,s=n(),n()
    if''<l
        while p in l,l=l[:l.indexOf(p)+1]+s+l[p.length:]
        .f(l)

Ruby , 119 110 bayt

İstisna ile sona erer

r=->s,o=$>{s[k=s[0]]='';k==?/?o==$>?s.gsub!([r[s,''],e=r[s,'']][0]){e}:t=o:o<<(k==?\\?s[0]+s[0]='':k);t||redo}

Çevrimiçi deneyin!

Temiz bir şekilde sonlandırır (116 bayt)

r=->s,o=$>{s[k=s[0]||exit]='';k==?/?o==$>?s.gsub!([r[s,''],e=r[s,'']][0]){e}:t=o:o<<(k==?\\?s[0]+s[0]='':k);t||redo}

Çevrimiçi deneyin!

Python 2/3 (211 bayt)

Bruno Le Floch'un cevabını temel alan aşağıdaki kod Python 2 ve Python 3 uyumludur.

Dahası, özyinelemeden ziyade yinelemeli olması, Python'un maksimum özyineleme derinliğine ulaşma riski taşımamaktadır.

def S(c):
 while c:
  B=["","",1]
  for m in 0,1,2:
   while c:
    if"/"==c[0]:c=c[1:];break
    if"\\"==c[0]:c=c[1:]
    if m:B[m-1]+=c[0]
    else:yield c[0]
    c=c[1:]
  while c and B[0]in c:c=c.replace(*B)

BaCon , 391 387 395 bayt

Bu sayfadaki katkılardan sadece Python programının çalışmasını sağladım. Diğerleri bazı /// örnekler için çalışır veya hiç çalışmaz. Bu nedenle, BASIC'te bir uygulama olan sürümümü eklemeye karar verdim.

BASIC bir CodeGolf yarışmasında rekabet etmek kolay değildir çünkü BASIC uzun kelimeler kullanır. BASIC'te yaygın olarak bulunan tek kısaltma '?' PRINT anlamına gelir işareti.

Bu yüzden aşağıdaki program asla kazanamaz, ancak en azından bu Codegolf sayfasındaki ve Esolangs Wiki'deki tüm tanıtım kodlarıyla çalışır . "99 şişe bira" nın tüm versiyonları dahil.

p$=""
r$=""
INPUT i$
WHILE LEN(i$)
t$=LEFT$(i$,1)
i$=MID$(i$,2)
IF NOT(e) THEN
IF t$="\\" THEN
e=1
CONTINUE
ELIF t$="/" THEN
o=IIF(o<2,o+1,0)
IF o>0 THEN CONTINUE
FI
FI
IF o=1 THEN
p$=p$&t$
ELIF o=2 THEN
r$=r$&t$
ELIF o=0 THEN
IF LEN(p$) THEN i$=REPLACE$(i$,p$,r$)
IF NOT(INSTR(t$&i$,"/")) THEN
?t$;
BREAK
ELSE
?LEFT$(i$,INSTR(i$,"/")-1);
i$=MID$(i$,INSTR(i$,"/"))
FI
p$=""
r$=""
FI
e=0
WEND
?i$