Karena kita tidak bisa mendapatkan cukup golf bahasa esoteris, bukan?

/// - slash yang diucapkan —adalah bahasa kecil yang menyenangkan berdasarkan s///fungsi penggantian-regex dari ketenaran Perl. Ini hanya berisi dua karakter khusus, garis miring /dan garis miring terbalik \. Anda dapat menemukan artikel lengkapnya di esolangs wiki , tetapi saya akan mereproduksi deskripsi bahasa di bawah ini, serta beberapa contoh.

Singkatnya, ini berfungsi dengan mengidentifikasi /pattern/repl/restdalam program dan membuat penggantian sebanyak mungkin. Tidak ada karakter yang khusus kecuali /dan \: /membatasi pola dan penggantian dalam program, sementara \memungkinkan Anda untuk memasukkan huruf /atau \karakter ke dalam kode Anda. Khususnya, ini bukan ekspresi reguler, hanya penggantian string biasa.

Tantangan Anda adalah menghasilkan penerjemah untuk bahasa ///, baik sebagai program yang membaca STDIN atau fungsi yang mengambil argumen string, dalam karakter sesedikit mungkin.

Anda dapat menggunakan bahasa apa pun kecuali /// sendiri. Anda tidak boleh menggunakan pustaka yang menafsirkan ///; Anda dapat, bagaimanapun, menggunakan regex, regex librari, atau pustaka pencocokan string.

Eksekusi

Ada empat negara bagian, cetak , pola , penggantian , dan penggantian . Di setiap negara kecuali penggantian :

• Jika program kosong, eksekusi terhenti.
• Lain, jika karakter pertama \, lakukan sesuatu dengan karakter berikutnya (jika ada) dan hapus keduanya dari program.
• Jika karakter pertama adalah /, hapus, dan ubah ke status berikutnya.
• Lain, lakukan sesuatu dengan karakter pertama dan hapus dari program.
• Ulangi.

Status menyatakan melalui cetak , pola , penggantian , dan penggantian secara berurutan.

• Dalam mode cetak , 'lakukan sesuatu' berarti mengeluarkan karakter.
• Dalam mode pola , 'lakukan sesuatu' berarti menambahkan karakter ke Pola saat ini.
• Dalam mode penggantian , 'lakukan sesuatu' berarti menambahkan karakter ke Penggantian saat ini.

Dalam mode substitusi , Anda mengikuti serangkaian aturan yang berbeda. Ganti secara berulang kejadian pertama dari Pola saat ini dengan Penggantian saat ini dalam program, sampai tidak ada lagi penggantian yang mungkin. Pada saat itu, hapus Pola dan Penggantian dan kembali ke mode cetak .

Dalam program ini /foo/foobar/foo foo foo, hal berikut terjadi:

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

Loop ini selamanya dan tidak pernah keluar dari mode substitusi . Demikian pula, jika Pola kosong, maka kemunculan pertama string kosong — di awal program — selalu cocok, sehingga mode substitusi berulang selamanya, tidak pernah berhenti.

Contohnya

no

Output: no.

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

Output: Hello, world!.

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

Output: Hello, world!.

a/ab/bbaa/abb

Output: a. Program tidak berhenti.

//

Output: tidak ada.

///

Output: tidak ada. Program tidak berhenti.

/\\/good/\/

Output: good.

Ada juga quine di wiki yang bisa Anda coba.

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}

Ini adalah fungsi yang mengambil ///kode sebagai argumen yang benar.

Tidak disatukan, dengan penjelasan:

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 char

Ini adalah mimpi buruk. Saya menulis ulang dari awal, dua kali, karena itu terus mengganggu saya. Ini adalah fungsi yang mengambil argumen string tunggal, mengeluarkan ke STDOUT.

(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=. ::](^:_)

Untuk menjelaskannya, saya akan memecahnya menjadi subekspresi.

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(kependekan dari iterate ) adalah kata keterangan. Dibutuhkan argumen kata kerja di sebelah kiri dan mengembalikan kata kerja (f)i, yang ketika diterapkan pada argumen, berlaku fberulang kali pada argumen sampai salah satu dari dua hal terjadi: ia menemukan titik tetap ( y = f y), atau melemparkan kesalahan. Perilaku titik tetap melekat ^:_, dan ::]melakukan penanganan kesalahan.

• parsetokenizes input ke dalam apa yang saya sebut formulir setengah-parsing , dan kemudian memotongnya di '/' unescaped. Itu mengikat melarikan diri garis miring terbalik ke karakter mereka, tetapi tidak menghilangkan garis miring terbalik — jadi kita dapat mengembalikannya atau menyelesaikannya tergantung yang kita inginkan.

  Sebagian besar pekerjaan menarik terjadi di ;:. Ini adalah primitif juru mesin sekuensial, mengambil deskripsi mesin ( (0;(0,:~1 0,.2);'\';&<1 0)) di sebelah kiri dan sesuatu untuk diurai di sebelah kanan. Ini melakukan tokenizing. Saya akan perhatikan bahwa mesin khusus ini benar-benar memperlakukan karakter pertama tidak khusus, bahkan jika itu adalah \dan harus mengikat. Saya melakukan ini karena beberapa alasan: (1) tabel negara lebih sederhana, sehingga dapat di-golf lebih lanjut; (2) kita dapat dengan mudah menambahkan karakter dummy ke depan untuk menghindari masalah; dan (3) bahwa karakter-dummy menjadi setengah-parsing tanpa biaya tambahan, jadi saya dapat menggunakannya untuk mengatur fase pemotongan, selanjutnya.

  Kami juga menggunakan <;._1untuk memotong hasil tokenized pada unescaped /(yang saya pilih untuk menjadi karakter pertama). Ini berguna untuk mengeluarkan output, pola, dan penggantian dari out/patt/repl/restsemua dalam satu langkah, tetapi sayangnya juga memotong seluruh program, di mana kita membutuhkan mereka /untuk tetap tidak tersentuh. Saya menyambungkan ini kembali selama eval, karena membuat <;._1mereka sendirian berakhir dengan biaya lebih banyak.

• Garpu (eval [ print)mengeksekusi printpada hasil dari parsekarena efek sampingnya, dan kemudian berjalan eval. printadalah kata kerja sederhana yang membuka kotak pertama (yang kita tahu pasti adalah keluaran), selesai menguraikannya, dan mengirimkannya ke STDOUT. Namun, kami juga mengambil kesempatan untuk mendefinisikan kata kerja utilitas p.

  pdidefinisikan sebagai >@{.@[, sehingga dibutuhkan arg kiri (bertindak seperti identitas jika hanya diberi satu arg), mengambil item pertama dari itu (identitas saat diberi skalar), dan menghapus kotaknya (identitas jika sudah dibuka kotaknya). Ini akan sangat berguna sub.

• evalmengevaluasi sisa program yang diproses. Jika kita tidak memiliki pola penuh atau penggantian penuh, evalbuang saja dan hanya mengembalikan daftar kosong, yang mengakhiri evaluasi dengan membuat ;:(dari parse) kesalahan pada iterasi berikutnya. Lain, evalsepenuhnya mem-parsing pola dan penggantian, memperbaiki sisa sumber, dan kemudian melewati keduanya sub. Dengan ledakan:

                                                @}.  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
  

• subadalah di mana satu (mungkin tak terbatas) pergantian terjadi. Karena cara kita mengatur eval, sumbernya adalah argumen yang tepat, dan pola serta penggantiannya digabungkan menjadi satu di sebelah kiri. Karena argumen diperintahkan seperti ini dan kita tahu pola dan penggantian tidak berubah dalam putaran pergantian, kita dapat menggunakan fitur lain i— fakta bahwa itu hanya mengubah argumen yang benar dan terus lewat di kiri yang sama — untuk mendelegasikan untuk J perlu khawatir tentang melacak negara.

  Ada dua titik masalah. Yang pertama adalah bahwa kata kerja J dapat memiliki paling banyak dua argumen, jadi kami tidak memiliki cara mudah untuk mengakses sembarang yang dibundel bersama, seperti pola dan penggantian, di sini. Melalui penggunaan cerdas dari putilitas yang kami tetapkan, ini bukan masalah besar. Faktanya, kita dapat mengakses pola dalam satu karakter, hanya dengan menggunakan p, karena >@{.@[definisinya: Unbox of the First item dari Left arg. Mendapatkan penggantian itu lebih sulit, tetapi cara tersingkat adalah p&|., 2 karakter lebih pendek daripada secara manual.

  Masalah kedua adalah bahwa ikeluar pada titik-titik tetap alih-alih berulang selamanya, dan jika polanya dan penggantiannya sama dan Anda membuat substitusi, itu terlihat seperti titik tetap untuk J. Kami menangani ini dengan memasukkan loop tak terbatas dengan meniadakan 1 ke atas dan berakhir jika kami mendeteksi mereka sama: ini adalah -i@=`p@.~:~/bagian, menggantikan 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
  

• Siklus ini berulang karena penggunaan i, sampai sesuatu di luar subkesalahan keluar. Sejauh yang saya ketahui, ini hanya bisa terjadi ketika kita kehabisan karakter, ketika kita membuang serangkaian pola-dan-penggantian yang tidak lengkap.

Fakta menyenangkan tentang golf ini:

• Untuk sekali, menggunakan ;:lebih pendek dari iterasi secara manual melalui string.
• 0{harus memiliki kesempatan untuk kesalahan sebelum submasuk ke loop tak terbatas, jadi ini harus bekerja dengan baik jika pola cocok dengan penggantian tetapi tidak pernah muncul di sisa sumber. Namun, ini mungkin atau mungkin bukan perilaku yang tidak ditentukan, karena saya tidak dapat menemukan kutipan di dokumen. Whoopsie.
• Gangguan keyboard diproses sebagai kesalahan spontan di dalam fungsi yang sedang berjalan. Namun, karena sifatnya i, kesalahan itu juga terperangkap. Bergantung pada saat Anda menekan Ctrl + C, Anda mungkin:
  • Keluar dari loop negate-forever, kesalahan keluar dari subloop dengan mencoba menyatukan angka ke string, dan kemudian terus menafsirkan /// seolah-olah Anda selesai mengganti string dengan dirinya sendiri dengan jumlah kali yang tak terbatas.
  • Biarkan subsetengah jalan dan terus menafsirkan ekspresi /// setengah sub.
  • Keluar dari penerjemah dan kembalikan program /// yang tidak dievaluasi ke REPL (bukan STDOUT).

Contoh penggunaan:

   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=''}}

Membaca ///program dari stdin hingga EOF.

Pip , 100 102 byte

Saya tidak pernah membuktikan bahwa Pip adalah Turing-complete (walaupun jelas sekali begitu), dan alih-alih menggunakan rute BF yang biasa, saya pikir /// akan menarik. Setelah saya memiliki solusinya, saya pikir saya akan golf dan mempostingnya di sini.

101 byte kode, +1 untuk -rbendera:

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

Inilah versi saya yang tidak diserang dengan komentar berlebihan:

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

Cobalah online! (Perhatikan bahwa TIO tidak memberikan output apa pun ketika program tidak berhenti, dan juga memiliki batas waktu. Untuk contoh yang lebih besar dan loop tak terbatas, disarankan menjalankan Pip dari baris perintah.)

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

Ini tidak akan pernah menang, tetapi karena saya telah memutuskan bahwa semua proyek perangkat lunak saya di masa depan akan ditulis dalam bahasa yang luar biasa ini, saya memerlukan intepreter untuk itu dan saya pikir saya mungkin juga membagikan yang saya buat ...

Perbedaan skornya adalah bahwa Visual C ++ tidak perlu menyertakan pertama tetapi g ++ tidak. Skor tersebut mengasumsikan bahwa akhir baris dihitung sebagai 1.

#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

Disebut sebagai d(r"""/foo/Hello, world!//B\/\\R/foo/B/\R"""). Kutipan rangkap hanya diperlukan jika ///program berisi baris baru: jika tidak, kutipan sederhana tidak masalah.

EDIT: Penerjemah ini sekarang mencetak hal-hal seperti yang diharapkan (sebelumnya hanya dicetak di akhir, lih komentar). Untuk Python 3, hapus baris pertama (tapi saya tidak punya Python 3 pada instal lama saya, jadi tidak bisa memastikan tidak ada perubahan lain).

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

Berakhir dengan pengecualian

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}

Cobalah online!

Berakhir bersih (116 byte)

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}

Cobalah online!

Python 2/3 (211 byte)

Kode berikut, berdasarkan pada jawaban Bruno Le Floch , adalah Python 2 dan Python 3 yang kompatibel.

Selain itu, menjadi berulang daripada rekursif itu tidak berisiko memukul kedalaman rekursi maksimum Python.

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 byte

Dari kontribusi di halaman ini saya hanya menjalankan program Python. Yang lain bekerja untuk beberapa /// sampel, atau tidak bekerja sama sekali. Oleh karena itu, saya memutuskan untuk menambahkan versi saya, yang merupakan implementasi di BASIC.

Untuk bersaing dalam kontes CodeGolf dengan BASIC tidak mudah, karena BASIC menggunakan kata-kata panjang sebagai pernyataan. Satu-satunya singkatan yang biasa ditemukan di BASIC adalah '?' tanda, yang berarti PRINT.

Jadi program di bawah ini mungkin tidak pernah menang, tetapi setidaknya ia bekerja dengan semua kode demonstrasi pada halaman Codegolf ini dan pada Esolangs Wiki . Termasuk semua versi "99 botol bir".

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$