Weil wir nicht genug von esoterischen Golfspielen bekommen können, oder?

/// - Ausgesprochene Schrägstriche - ist eine lustige kleine Sprache, die auf der s///Regex-Ersetzungsfunktion von Perl Fame basiert . Es enthält nur zwei Sonderzeichen, Schrägstrich /und Backslash \. Sie können einen vollständigen Artikel im esolangs-Wiki finden , aber ich werde eine Beschreibung der Sprache unten sowie einige Beispiele wiedergeben.

Kurz gesagt, es funktioniert, indem es sich /pattern/repl/restim Programm identifiziert und die Substitution so oft wie möglich durchführt. Es gibt keine Sonderzeichen außer /und \: /Beschreibt Muster und Ersetzungen im Programm, während \Sie Literal /oder \Zeichen in Ihren Code einfügen können. Insbesondere handelt es sich hierbei nicht um reguläre Ausdrücke, sondern nur um einfache Zeichenfolgensubstitutionen.

Ihre Herausforderung besteht darin, einen Interpreter für die Sprache /// zu erstellen, entweder als Programm, das STDIN liest, oder als Funktion, die ein Zeichenfolgenargument mit möglichst wenigen Zeichen verwendet.

Sie können eine beliebige Sprache außer /// verwenden. Sie dürfen keine Bibliotheken verwenden, die ///; Sie können jedoch reguläre Ausdrücke, reguläre Ausdrücke oder Bibliotheken mit übereinstimmenden Zeichenfolgen verwenden.

Ausführung

Es gibt vier Zustände: Drucken , Muster , Ersetzen und Ersetzen . In jedem Staat außer Substitution :

• Wenn das Programm leer ist, wird die Ausführung angehalten.
• Ansonsten, wenn das erste Zeichen ist \, machen Sie etwas mit dem nächsten Zeichen (falls vorhanden) und entfernen Sie beide aus dem Programm.
• Andernfalls /entfernen Sie das erste Zeichen und wechseln in den nächsten Status.
• Ansonsten mache etwas mit dem ersten Zeichen und entferne es aus dem Programm.
• Wiederholen.

Die Zustände durchlaufen nacheinander Druck , Muster , Ersetzung und Ersetzung .

• Im Druckmodus bedeutet "etwas tun" die Ausgabe des Zeichens.
• Im Pattern- Modus bedeutet "etwas tun", das Zeichen zum aktuellen Pattern hinzuzufügen.
• Im Ersetzungsmodus bedeutet "etwas tun", dass das Zeichen zum aktuellen Ersetzungsmodus hinzugefügt wird.

Im Substitutionsmodus folgen Sie anderen Regeln. Ersetzen Sie wiederholt das erste Auftreten des aktuellen Patterns durch das aktuelle Replacement im Programm, bis keine Substitutionen mehr möglich sind. Löschen Sie zu diesem Zeitpunkt das Muster und den Ersatz und kehren Sie zum Druckmodus zurück .

Im Programm /foo/foobar/foo foo foopassiert folgendes:

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

Dies führt eine Endlosschleife durch und beendet den Substitutionsmodus nie . Wenn das Pattern leer ist, stimmt das erste Vorkommen der leeren Zeichenfolge - am Anfang des Programms - immer überein, sodass der Substitutionsmodus für immer wiederholt wird und niemals anhält.

Beispiele

no

Ausgang: no.

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

Ausgang: Hello, world!.

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

Ausgang: Hello, world!.

a/ab/bbaa/abb

Ausgang: a. Programm stoppt nicht.

//

Ausgabe: keine.

///

Ausgabe: keine. Programm stoppt nicht.

/\\/good/\/

Ausgang: good.

Es gibt auch eine Quine im Wiki, die du ausprobieren kannst.

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}

Dies ist eine Funktion, die den ///Code als das richtige Argument verwendet.

Ungolfed mit Erklärung:

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

Das war ein Albtraum. Ich habe es zweimal von Grund auf neu geschrieben, weil es mich immer wieder nervte. Dies ist eine Funktion, die ein einzelnes Zeichenfolgenargument verwendet und an STDOUT ausgibt.

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

Um es zu erklären, werde ich es in Unterausdrücke aufteilen.

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(kurz für iterate ) ist ein Adverb. Es nimmt ein Verbargument auf der linken Seite und gibt ein Verb zurück (f)i, das, wenn es auf ein Argument angewendet wird, fwiederholt auf das Argument angewendet wird, bis eines von zwei Dingen eintritt: Es findet einen festen Punkt ( y = f y) oder es löst einen Fehler aus. Das Festkommaverhalten ist inhärent ^:_und ::]führt die Fehlerbehandlung durch.

• parseTokenisiert die Eingabe in das, was ich als halb geparste Form bezeichne, und schneidet sie dann am nicht entkoppelten '/' ab. Es bindet entstehende Backslashes an ihre Charaktere, entfernt die Backslashes jedoch nicht - wir können sie also entweder rückgängig machen oder beenden, je nachdem, was wir wollen.

  Der Großteil der interessanten Arbeit fällt in ;:. Dies ist ein sequentielles Maschineninterpreter-Grundelement, (0;(0,:~1 0,.2);'\';&<1 0)das links eine Beschreibung der Maschine ( ) und rechts eine Analyse vornimmt. Dies führt die Tokenisierung durch. Ich werde bemerken, dass diese spezielle Maschine tatsächlich das erste Zeichen unspezifisch behandelt, auch wenn es sich um ein handelt \und binden sollte. Ich mache das aus ein paar Gründen: (1) die Zustandstabelle ist einfacher, so dass man weiter Golf spielen kann; (2) Wir können der Vorderseite ganz einfach einen Dummy-Charakter hinzufügen, um dem Problem auszuweichen. und (3) dieses Dummy-Zeichen wird ohne zusätzliche Kosten zur Hälfte analysiert, damit ich es als nächstes für die Schneidephase einrichten kann.

  Wir verwenden <;._1diese Option auch , um das Token-Ergebnis auf "Unescaped" zu schneiden /(was ich als erstes Zeichen auswähle). Dies ist praktisch, um die Ausgabe, das Muster und den Austausch out/patt/repl/restin einem Schritt zu erledigen, schneidet aber leider auch den Rest des Programms ab, wo wir diese benötigen /, um unangetastet zu bleiben. Ich spleiße diese währenddessen wieder ein eval, weil es <;._1viel mehr kostet, sie in Ruhe zu lassen.

• Die Fork (eval [ print)führt printdas Ergebnis parsefür seine Nebenwirkungen aus und läuft dann eval. printist ein einfaches Verb, das die erste Box öffnet (die, von der wir sicher wissen, dass sie ausgegeben wird), die Analyse beendet und sie an STDOUT sendet. Wir nutzen jedoch auch die Möglichkeit, ein Utility-Verb zu definieren p.

  pist definiert als >@{.@[, also nimmt es sein linkes Argument (verhält sich wie die Identität, wenn nur ein Argument angegeben wird), nimmt das erste Element davon (Identität, wenn ein Skalar angegeben wird) und entpackt es (Identität, wenn es bereits entpackt ist). Dies wird sehr praktisch sein sub.

• evalwertet den Rest des abgearbeiteten Programms aus. Wenn wir kein vollständiges Muster oder keine vollständige Ersetzung haben, evalwirft es aus und gibt nur eine leere Liste zurück, die die Auswertung beendet, indem bei der nächsten Iteration ein ;:(from parse) -Fehler ausgegeben wird. Else, evalparst vollständig um das Muster und den Ersatz, korrigiert den Rest der Quelle, und übergibt dann sowohl an sub. Durch Explosion:

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

• subHier findet eine (möglicherweise unendliche) Substitutionsrunde statt. Aufgrund der Art und Weise, wie wir eingerichtet haben eval, ist die Quelle das richtige Argument, und das Muster und die Ersetzung sind in der linken Spalte zusammengefasst. Da die Argumente in dieser Reihenfolge angeordnet sind und wir wissen, dass sich Muster und Ersetzung innerhalb einer Ersetzungsrunde nicht ändern, können wir ein weiteres Merkmal der iDelegierung verwenden - nämlich die Tatsache, dass nur das richtige Argument geändert wird und weiterhin dasselbe links übergeben wird für J die Notwendigkeit, sich Sorgen zu machen, den Staat im Auge zu behalten.

  Es gibt jedoch zwei Probleme. Das erste ist, dass J-Verben höchstens zwei Argumente haben können, so dass wir keinen einfachen Weg haben, auf alle zuzugreifen, die hier gebündelt sind, wie Muster und Ersetzung. Durch den geschickten Einsatz des von puns definierten Dienstprogramms ist dies kein so großes Problem. Tatsächlich können wir auf das Muster in einem Zeichen zugreifen, indem wir paufgrund seiner >@{.@[Definition einfach Folgendes verwenden: das Unbox-Feld des ersten Elements des linken Arguments. Das Erhalten des Ersatzes ist schwieriger, aber der kürzeste Weg wäre p&|., 2 Zeichen kürzer als manuelles Herausholen .

  Das zweite Problem ist, dass es iauf festen Punkten endet, anstatt für immer zu schleifen. Wenn das Muster und die Ersetzung gleich sind und Sie eine Ersetzung vornehmen, sieht das für J wie ein fester Punkt aus. Wir behandeln dies, indem wir eine Endlosschleife von 1 über und negieren Wenn wir feststellen, dass sie gleich sind, ist dies der -i@=`p@.~:~/Teil, der ersetzt 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
  

• Dieser Zyklus wiederholt sich aufgrund der Verwendung von i, bis etwas außerhalb von subFehlern herauskommt. Soweit mir bekannt ist, kann dies nur passieren, wenn wir keine Charaktere mehr haben oder wenn wir einen unvollständigen Satz von Mustern und Ersetzungen wegwerfen.

Wissenswertes über diesen Golf:

• Diesmal ist using ;:kürzer als das manuelle Durchlaufen der Zeichenfolge.
• 0{sollten die Möglichkeit haben, Fehler zu machen, bevor sie subin eine Endlosschleife geraten. Dies sollte also funktionieren, wenn das Muster mit der Ersetzung übereinstimmt, aber im Rest der Quelle nie auftaucht. Dies kann jedoch ein nicht angegebenes Verhalten sein oder auch nicht, da ich in den Dokumenten kein Zitat finde. Whoopsie.
• Tastaturinterrupts werden als spontane Fehler in laufenden Funktionen verarbeitet. Aufgrund der Art idieser Fehler werden diese jedoch ebenfalls abgefangen. Abhängig davon, wann Sie Strg + C drücken, können Sie:
  • Verlassen Sie die Negate-forever-Schleife, verlassen Sie die subSchleife, indem Sie versuchen, eine Zahl mit einer Zeichenfolge zu verknüpfen, und interpretieren Sie /// dann so, als ob Sie eine Zeichenfolge unendlich oft durch sich selbst ersetzt hätten.
  • Lass die subHälfte hinter dir und interpretiere einen halb untergeordneten /// Ausdruck weiter.
  • Brechen Sie aus dem Interpreter aus und geben Sie ein nicht ausgewertetes /// Programm an die REPL zurück (jedoch nicht an STDOUT).

Anwendungsbeispiel:

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

Liest das ///Programm von stdin bis EOF.

Pip , 100 102 Bytes

Ich hatte noch nie bewiesen, dass Pip Turing-vollständig ist (obwohl es ziemlich offensichtlich ist), und anstatt den üblichen Weg von BF zu gehen, dachte ich, /// wäre interessant. Sobald ich die Lösung gefunden hatte, dachte ich, ich würde Golf spielen und es hier posten.

101 Byte Code, +1 für -rFlag:

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

Hier ist meine ungolfed Version mit vielen Kommentaren:

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

Probieren Sie es online! (Beachten Sie, dass TIO keine Ausgabe ausgibt, wenn das Programm nicht beendet wird. Es gibt auch ein Zeitlimit. Für größere Beispiele und Endlosschleifen wird empfohlen, Pip über die Befehlszeile auszuführen.)

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

Das wird nie gewinnen, aber da ich beschlossen habe, dass alle meine zukünftigen Softwareprojekte in dieser großartigen Sprache geschrieben werden, brauchte ich einen Dolmetscher dafür und dachte, ich könnte den, den ich gemacht habe, genauso gut teilen ...

Der Unterschied in der Punktzahl besteht darin, dass Visual C ++ nicht das erste Include benötigt, sondern g ++. Die Punktzahl setzt voraus, dass die Zeilenenden mit 1 gewertet werden.

#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

Genannt als d(r"""/foo/Hello, world!//B\/\\R/foo/B/\R"""). Die dreifachen Anführungszeichen werden nur benötigt, wenn das ///Programm Zeilenumbrüche enthält. Andernfalls sind einfache Anführungszeichen in Ordnung.

BEARBEITEN: Dieser Interpreter druckt nun wie erwartet (zuvor nur ganz am Ende, siehe Kommentare). Entfernen Sie für Python 3 die erste Zeile (ich habe jedoch kein Python 3 in meiner alten Installation, kann also nicht sicher sein, dass es keine andere Änderung gibt).

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)

Rubin , 119 110 Bytes

Beendet mit Ausnahme

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}

Probieren Sie es online!

Endet sauber (116 Bytes)

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}

Probieren Sie es online!

Python 2/3 (211 Bytes)

Der folgende Code basiert auf der Antwort von Bruno Le Floch ist kompatibel mit Python 2 und Python 3.

Darüber hinaus riskiert es nicht, die maximale Rekursionstiefe von Python zu erreichen, da es eher iterativ als rekursiv ist.

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 Bytes

Von den Beiträgen auf dieser Seite habe ich nur das Python-Programm zum Laufen gebracht. Die anderen arbeiten für einige /// Samples oder überhaupt nicht. Aus diesem Grund habe ich mich entschlossen, meine Version hinzuzufügen, die eine Implementierung in BASIC ist.

Die Teilnahme an einem CodeGolf-Wettbewerb mit BASIC ist nicht einfach, da BASIC lange Wörter als Anweisungen verwendet. Die einzige in BASIC gebräuchliche Abkürzung ist das '?' Zeichen, was PRINT bedeutet.

Das folgende Programm wird vielleicht nie gewinnen, aber es funktioniert zumindest mit dem gesamten Demo-Code auf dieser Codegolf-Seite und im Esolangs-Wiki . Einschließlich aller Versionen der "99 Flaschen Bier".

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$