Perché non ne abbiamo mai abbastanza di golf in lingua esoterica, vero?

/// - barre pronunciate: è un linguaggio divertente basato sulla s///funzione di sostituzione regex della fama del Perl. Contiene solo due caratteri speciali, barra /e barra rovesciata \. Puoi trovare un articolo completo sul wiki di esolangs , ma riprodurrò una descrizione della lingua qui sotto, così come alcuni esempi.

In breve, funziona identificandosi /pattern/repl/restnel programma e effettuando la sostituzione il maggior numero di volte possibile. Nessun carattere è speciale tranne /e \: /delimita schemi e sostituzioni nel programma, mentre \ti permette di inserire letterali /o \caratteri nel tuo codice. In particolare, queste non sono espressioni regolari, ma semplici sostituzioni di stringhe.

La tua sfida è quella di produrre un interprete per il linguaggio ///, come un programma che legge STDIN o una funzione che prende un argomento stringa, nel minor numero di caratteri possibile.

È possibile utilizzare qualsiasi lingua tranne /// stessa. Non è possibile utilizzare librerie che interpretano ///; tuttavia, è possibile utilizzare regex, librerie regex o librerie di corrispondenza delle stringhe.

Esecuzione

Esistono quattro stati: stampa , modello , sostituzione e sostituzione . In ogni stato tranne la sostituzione :

• Se il programma è vuoto, l'esecuzione si interrompe.
• Altrimenti, se il primo personaggio è \, fai qualcosa con il personaggio successivo (se presente) e rimuovi entrambi dal programma.
• Altrimenti, se il primo personaggio è /, rimuovilo e passa allo stato successivo.
• Altrimenti, fai qualcosa con il primo personaggio e rimuovilo dal programma.
• Ripetere.

Gli stati si alternano tra stampa , modello , sostituzione e sostituzione in ordine.

• In modalità di stampa , "fai qualcosa" significa emettere il personaggio.
• In modalità Pattern , "fai qualcosa" significa aggiungere il personaggio al Pattern corrente.
• Nella modalità di sostituzione , "fare qualcosa" significa aggiungere il personaggio alla sostituzione corrente.

In modalità sostituzione , segui un diverso set di regole. Sostituire ripetutamente la prima occorrenza del modello corrente con la sostituzione corrente nel programma, fino a quando non sono più possibili sostituzioni. A quel punto, cancellare il motivo e la sostituzione e tornare alla modalità di stampa .

Nel programma /foo/foobar/foo foo foo, si verifica quanto segue:

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

Questo scorre per sempre e non esce mai dalla modalità di sostituzione . Allo stesso modo, se il Pattern è vuoto, allora la prima occorrenza della stringa vuota — all'inizio del programma — corrisponde sempre, quindi la modalità di sostituzione scorre per sempre, senza mai fermarsi.

Esempi

no

Uscita: no.

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

Uscita: Hello, world!.

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

Uscita: Hello, world!.

a/ab/bbaa/abb

Uscita: a. Il programma non si ferma.

//

Uscita: nessuna.

///

Uscita: nessuna. Il programma non si ferma.

/\\/good/\/

Uscita: good.

C'è anche un quine sul wiki che puoi provare.

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}

Questa è una funzione che prende il ///codice come argomento giusto.

Ungolfed, con spiegazione:

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

Questo è stato un incubo. L'ho riscritto da zero, due volte, perché continuava a infastidirmi. Questa è una funzione che accetta un singolo argomento stringa, in uscita su 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=. ::](^:_)

Per spiegare, lo spezzerò in sottoespressioni.

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(abbreviazione di iterate ) è un avverbio. Prende un argomento verbo a sinistra e restituisce un verbo (f)i, che quando applicato a un argomento, si applica fripetutamente all'argomento fino a quando non si verifica una delle due cose: trova un punto fisso ( y = f y) o genera un errore. Il comportamento a punto fisso è inerente ^:_, e ::]fa la gestione degli errori.

• parsetokenizza l'input in quello che chiamo forma semi-analizzata , quindi lo interrompe in corrispondenza del carattere "/" senza caratteri di escape. Vincola le barre rovesciate ai loro personaggi, ma non si sbarazza delle barre rovesciate, quindi possiamo ripristinarle o finirle a seconda di ciò che vogliamo.

  La maggior parte del lavoro interessante si verifica in ;:. Questa è una primitiva dell'interprete macchina sequenziale, che prende una descrizione della macchina ( (0;(0,:~1 0,.2);'\';&<1 0)) a sinistra e qualcosa da analizzare a destra. Questo fa la tokenizzazione. Noterò che questa macchina specifica tratta effettivamente il primo personaggio non speciale, anche se è un \e dovrebbe legarsi. Lo faccio per alcuni motivi: (1) la tabella di stato è più semplice, quindi può essere ulteriormente giocata a golf; (2) possiamo facilmente aggiungere un carattere fittizio in primo piano per evitare il problema; e (3) quel personaggio fittizio viene semi-analizzato senza costi aggiuntivi, quindi posso usarlo per impostare per la fase di taglio, successiva.

  Usiamo anche <;._1per tagliare il risultato tokenizzato su senza caratteri di escape /(che è quello che scelgo di essere il primo carattere). Questo è utile per estrarre l'output, il pattern e la sostituzione da out/patt/repl/restun unico passaggio, ma sfortunatamente taglia anche il resto del programma, dove abbiamo bisogno /che rimangano intatti. Li ricolloco durante eval, perché <;._1lasciarli soli finisce per costare molto di più.

• Il fork (eval [ print)viene eseguito printsul risultato parseper i suoi effetti collaterali, quindi viene eseguito eval. printè un semplice verbo che apre il primo riquadro (quello che sappiamo per certo è l'output), finisce di analizzarlo e lo invia a STDOUT. Tuttavia, cogliamo anche la possibilità di definire un verbo di utilità p.

  pè definito come >@{.@[, quindi prende il suo arg sinistro (agisce come l'identità se viene dato solo un arg), prende il primo elemento di quell'identità (identità quando viene dato uno scalare), e lo deseleziona (identità se già unboxed). Questo sarà molto utile in sub.

• evalvaluta il resto del programma elaborato. Se non abbiamo un modello completo o un rimpiazzo completo, lo evalbutta fuori e restituisce solo un elenco vuoto, che termina la valutazione facendo ;:(da parse) errore la prossima iterazione. Altrimenti, evalanalizza completamente il modello e la sostituzione, corregge il resto della sorgente e quindi passa entrambi a sub. Per esplosione:

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

• subè il luogo in cui si verifica una (o forse infinita) serie di sostituzioni. A causa del modo in cui abbiamo impostato eval, l'origine è l'argomento giusto e il modello e la sostituzione sono raggruppati insieme a sinistra. Dato che gli argomenti sono ordinati in questo modo e sappiamo che il modello e la sostituzione non cambiano in un giro di sostituzioni, possiamo usare un'altra caratteristica del ifatto che modifica solo l'argomento giusto e continua a passare nella stessa sinistra per delegare a J la necessità di preoccuparsi di tenere traccia dello stato.

  Vi sono tuttavia due punti problematici. Il primo è che i verbi J possono avere al massimo due argomenti, quindi non abbiamo un modo semplice per accedere a quelli raggruppati insieme, come modello e sostituzione, qui. Attraverso un uso intelligente pdell'utilità che abbiamo definito, questo non è un grosso problema. In effetti, possiamo accedere al modello in un personaggio, semplicemente usando p, per via della sua >@{.@[definizione: la Unbox del Primo oggetto dell'Arg di Sinistra. Ottenere la sostituzione è più complicato, ma il modo più breve sarebbe p&|., 2 caratteri in meno rispetto alla sua uscita manuale.

  Il secondo problema è che iesce su punti fissi invece di eseguire un ciclo continuo per sempre, e se lo schema e la sostituzione sono uguali e si effettua una sostituzione, questo sembra un punto fisso su J. Gestiamo questo inserendo un ciclo infinito di negando 1 su e se rileviamo che sono uguali: questa è la -i@=`p@.~:~/porzione che sostituisce 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
  

• Questo ciclo si ripete a causa dell'uso di i, fino a quando fuori da qualcosa fuori suberrori. Per quanto ne so, questo può succedere solo quando siamo a corto di personaggi, di quando buttiamo fuori una serie incompleta di schemi e sostituzioni.

Fatti divertenti su questo golf:

• Per una volta, l'utilizzo ;:è più breve dell'iterazione manuale della stringa.
• 0{dovrebbe avere una possibilità di errore prima di subentrare in un ciclo infinito, quindi dovrebbe funzionare bene se il modello corrisponde alla sostituzione ma non si presenta mai nel resto del sorgente. Tuttavia, questo potrebbe essere o meno un comportamento non specificato, dal momento che non riesco a trovare una citazione in entrambi i documenti. Whoopsie.
• Gli interrupt di tastiera vengono elaborati come errori spontanei all'interno delle funzioni in esecuzione. Tuttavia, a causa della natura di i, anche questi errori vengono intrappolati. A seconda di quando premi Ctrl + C, potresti:
  • Esci dal ciclo negate-forever, errore fuori dal subciclo cercando di concatenare un numero in una stringa, quindi continua a interpretare /// come se avessi finito di sostituire una stringa con se stessa un numero infinito di volte.
  • Lascia a submetà strada e continua a interpretare un'espressione /// sottotitolata.
  • Uscire dall'interprete e restituire un programma /// non valutato al REPL (ma non STDOUT).

Esempio di utilizzo:

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

Legge il ///programma da stdin fino a EOF.

Pip , 100 102 byte

Non avevo mai dimostrato che Pip fosse completo di Turing (anche se ovviamente è così), e invece di seguire la solita via di BF ho pensato che /// sarebbe stato interessante. Una volta che ho avuto la soluzione, ho pensato che avrei golf e postato qui.

101 byte di codice, +1 per -rflag:

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

Ecco la mia versione non rigata con commenti copiosi:

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

Provalo online! (Si noti che TIO non fornisce alcun output quando il programma non è terminato e ha anche un limite di tempo. Per esempi più grandi e cicli infiniti, si consiglia di eseguire Pip dalla riga di comando.)

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

Questo non vincerà mai, ma dato che ho deciso che tutti i miei progetti software futuri saranno scritti in questo fantastico linguaggio, avevo bisogno di un intero per questo e ho pensato che avrei potuto condividere anche quello che ho realizzato ...

La differenza nel punteggio è che Visual C ++ non ha bisogno della prima inclusione ma g ++ lo fa. Il punteggio presuppone che i finali delle righe contino come 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

Chiamato come d(r"""/foo/Hello, world!//B\/\\R/foo/B/\R"""). Le virgolette triple sono necessarie solo se il ///programma contiene nuove righe: altrimenti citazioni semplici sono ok.

EDIT: Questo interprete ora stampa le cose come previsto (in precedenza è stato stampato solo alla fine, cfr. Commenti). Per Python 3, rimuovi la prima riga (ma non ho Python 3 sulla mia antica installazione, quindi non posso essere sicuro che non ci siano altre modifiche).

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)

Rubino , 119 110 byte

Termina con eccezione

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}

Provalo online!

Termina in modo pulito (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}

Provalo online!

Python 2/3 (211 byte)

Il codice seguente, basato sulla risposta di Bruno Le Floch , è compatibile con Python 2 e Python 3.

Inoltre, essendo iterativo piuttosto che ricorsivo, non rischia di colpire la massima profondità di ricorsione di 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

Dai contributi di questa pagina ho avuto solo il funzionamento del programma Python. Gli altri funzionano per alcuni /// campioni o non funzionano affatto. Pertanto, ho deciso di aggiungere la mia versione, che è un'implementazione in BASIC.

Competere in un concorso CodeGolf con BASIC non è facile, poiché BASIC usa parole lunghe come dichiarazioni. L'unica abbreviazione che si trova comunemente in BASIC è il '?' segno, che significa STAMPA.

Quindi il programma qui sotto potrebbe non vincere mai, ma almeno funziona con tutto il codice dimostrativo su questa pagina di Codegolf e sul Wiki di Esolangs . Comprese tutte le versioni delle "99 bottiglie di birra".

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$