난해한 언어 골프를 충분히 얻을 수 없기 때문에 할 수 있습니까?

/// — 슬래시 로 발음 — s///은 Perl 명성 의 정규식 대체 기능을 기반으로하는 재미있는 언어 입니다. 슬래시 /와 백 슬래시 두 개의 특수 문자 만 포함합니다 \. esolangs wiki 에서 전체 기사를 찾을 수 있지만 아래 언어에 대한 설명과 예제를 재현 할 것입니다.

즉, /pattern/repl/rest프로그램에서 식별 하고 가능한 한 많이 대체하여 작동 합니다. 특수 문자는 다음을 제외 /하고 없습니다 \. : /프로그램에서 패턴과 대체 문자를 구분하고 코드에 \문자 /나 \문자 를 삽입 할 수 있습니다 . 특히, 이들은 정규 표현식이 아니라 일반 문자열 대체입니다.

당신의 도전 은 /// 언어에 대한 통역을 생산하는 것입니다 가능한 한 적은 수의 문자로 STDIN 또는 문자열 인수를 복용 함수에서 읽기 중 하나 프로그램으로.

/// 자체를 제외한 모든 언어를 사용할 수 있습니다. ///;을 해석하는 라이브러리를 사용할 수 없습니다. 그러나 정규식, 정규식 라이브러리 또는 문자열 일치 라이브러리를 사용할 수 있습니다.

실행

네 가지 상태가있다 인쇄 , 패턴 , 교체 및 대체 . 대체를 제외한 모든 주에서 :

• 프로그램이 비어 있으면 실행이 중지됩니다.
• 그렇지 않으면 첫 번째 문자가 \인 경우 다음 문자 (있는 경우)로 무언가를 수행하고 프로그램에서 두 문자를 모두 제거하십시오.
• 그렇지 않으면 첫 번째 문자가 인 /경우 제거하고 다음 상태로 변경하십시오.
• 그렇지 않으면 첫 번째 문자로 무언가를하고 프로그램에서 제거하십시오.
• 반복.

는 순환 상태 인쇄 , 패턴 , 교체 및 대체를 위해.

• 에서 인쇄 모드, 문자 수단의 출력 '뭔가를'.
• 에서 패턴 모드, 수단 현재 패턴에 문자를 추가 '뭔가 할'.
• 에서 교체 모드, 수단 현재 교체에 문자를 추가 '뭔가 할'.

대체 모드 에서는 다른 규칙 세트를 따릅니다. 더 이상 대체가 불가능할 때까지 현재 패턴의 첫 번째 발생을 프로그램의 현재 대체로 반복해서 대체하십시오. 이 시점에서 패턴 및 교체를 지우고 인쇄 모드로 돌아갑니다 .

프로그램 /foo/foobar/foo foo foo에서 다음이 발생합니다.

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

이것은 영원히 반복되며 대체 모드를 종료하지 않습니다 . 마찬가지로, 패턴이 비어있는 경우 프로그램 시작시 비어있는 문자열이 처음 나타나는 경우 항상 일치하므로 대체 모드는 영원히 반복되며 중단되지 않습니다.

예

no

출력 : no.

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

출력 : Hello, world!.

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

출력 : Hello, world!.

a/ab/bbaa/abb

출력 : a. 프로그램이 중단되지 않습니다.

//

출력 : 없음

///

출력 : 없음 프로그램이 중단되지 않습니다.

/\\/good/\/

출력 : good.

당신이 시도 할 수 있는 위키에 quine가 있습니다 .

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}

이것은 ///코드를 올바른 인수로 취하는 함수입니다 .

설명이없는 언 골프 드 :

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

이것은 악몽이었다. 나는 계속 나를 괴롭히기 때문에 처음부터 두 번 다시 썼다. 단일 문자열 인수를 사용하여 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=. ::](^:_)

설명하기 위해 하위 표현식으로 나누겠습니다.

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( 반복의 줄임말 ) 부사입니다. 왼쪽에 동사 인수를 사용하고 인수에 (f)i적용될 f때 두 가지 중 하나가 발생할 때까지 인수에 반복적으로 적용되는 동사를 반환 합니다. 고정 소수점 ( y = f y)을 찾거나 오류가 발생합니다. 고정 소수점 행동에 내재 ^:_하고 ::]오류 처리를 수행합니다.

• parse입력을 반 파싱 된 형식 으로 토큰 화 한 다음 이스케이프 처리되지 않은 '/'에서 잘라냅니다. 이스케이프 백 슬래시는 해당 문자에 바인드되지만 백 슬래시는 제거되지 않으므로이를 되돌 리거나 원하는대로 마무리 할 수 ​​있습니다.

  흥미로운 작업의 대부분은에서 이루어 ;:집니다. 이것은 (0;(0,:~1 0,.2);'\';&<1 0)왼쪽 의 기계 ( )와 오른쪽의 구문 분석 할 내용을 설명하는 순차 기계 해석기 기본 요소입니다 . 이것은 토큰 화를 수행합니다. 이 특정 머신은 첫 번째 문자를 특수하지 않고 \바인딩해야 하더라도 실제로 특수 문자로 취급합니다 . 나는 몇 가지 이유 때문에 이것을한다 : (1) 상태 테이블이 더 단순하여 더 골프를 타게된다; (2) 문제를 피하기 위해 더미 캐릭터를 쉽게 추가 할 수 있습니다. (3) 더미 캐릭터가 추가 비용없이 절반 파싱되므로 다음 단계로 커팅 단계를 설정하는 데 사용할 수 있습니다.

  우리는 또한 <;._1이스케이프 처리되지 않은 /(첫 번째 문자로 선택하는) 토큰 화 된 결과를 잘라내 는 데 사용 합니다 . 이것은 출력, 패턴 및 교체를 out/patt/repl/rest한 번에 모두 꺼내는 데 편리 하지만 불행히도 나머지 프로그램을 잘라내어 /그대로 유지 해야합니다 . 나는 그것들을 혼자 남겨두면 더 많은 비용이 들기 eval때문에에 다시 연결합니다 <;._1.

• 포크 는 부작용 에 대한 결과에서 (eval [ print)실행 print된 parse다음 실행됩니다 eval. print첫 번째 상자 (확실히 알고있는 것은 출력)를 열고 구문 분석을 마치고 STDOUT으로 보내는 간단한 동사입니다. 그러나 우리는 또한 유틸리티 동사를 정의 할 기회를 얻습니다 p.

  p로 정의 >@{.@[되므로 왼쪽 arg (하나의 arg 만 제공된 경우 ID와 같은 역할)를 수행하고 해당 항목의 첫 번째 항목 (스칼라가 제공된 경우 ID)을 가져 와서 상자를 해제합니다 (이미 boxed 된 경우 ID). 이것은 매우 유용합니다 sub.

• eval처리 된 프로그램의 나머지를 평가합니다. 전체 패턴이나 전체 교체 eval가없는 경우이를 버리고 빈 목록 만 반환 하면 다음 번 반복시 ;:(from parse) 오류가 발생하여 평가가 종료됩니다 . 그렇지 않으면 eval패턴과 대체를 완전히 구문 분석하고 나머지 소스를 수정 한 다음 둘 다에 전달합니다 sub. 폭발로 :

                                                @}.  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하나의 (아마도 무한한) 대체 라운드가 발생하는 곳입니다. 우리가 설정 한 방식으로 인해 eval소스가 올바른 인수이며 패턴과 교체가 왼쪽에 묶여 있습니다. 인수가 대체 라운드 내에서 변경되지 않는 패턴 및 교체를 같이 주문하고 우리가 알고 있기 때문에, 우리는 또 다른 기능을 사용할 수 i는 오른쪽 인자 만 수정하게 -THE 사실을 같은 왼쪽에서 위임 전달 유지 J에게 상태를 추적하는 것에 대해 걱정할 필요가 있습니다.

  그러나 두 가지 문제가 있습니다. 첫 번째는 J 동사가 최대 두 개의 인수를 가질 수 있으므로 여기에서 패턴 및 대체와 같이 묶여있는 것을 액세스 할 수있는 방법이 없습니다. p우리가 정의한 유틸리티 를 영리하게 사용 하면 큰 문제가되지 않습니다. 실제로, 우리는 정의 p때문에 >@{.@[Left arg의 첫 번째 항목의 Unbox를 사용하여 하나의 문자로 패턴에 액세스 할 수 있습니다 . 교체를 얻는 것이 까다 롭지 만 가장 짧은 방법은 p&|.수동으로 꺼내는 것보다 2 문자가 짧습니다.

  두 번째 문제는 i영원히 반복되는 대신 고정 된 지점에서 빠져 나가고 패턴과 교체가 동일하고 대체하는 경우 J에 대한 고정 된 점처럼 보입니다. 우리는 1을 부정하는 무한 루프를 입력하여이를 처리합니다. 우리가 동일하다고 감지하면 : 이것은 -i@=`p@.~:~/부분을 ​​대체 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
  

• 이 사이클은를 사용하지 않아서 오류 i이외의 것이 sub발생할 때까지 반복 됩니다. 내가 아는 한, 이것은 문자가 없거나 불완전한 패턴 및 교체 세트를 버릴 때만 발생할 수 있습니다.

이 골프에 대한 재미있는 사실 :

• 한 번만 사용 ;:하면 문자열을 수동으로 반복하는 것보다 짧습니다.
• 0{sub무한 루프로 들어가기 전에 오류가 발생할 가능성 이 있으므로 패턴이 대체와 일치하지만 소스의 나머지 부분에는 나타나지 않는 경우 제대로 작동합니다. 그러나 문서에서 인용을 찾을 수 없으므로 지정되지 않은 동작 일 수도 있고 아닐 수도 있습니다. Whoopsie.
• 키보드 인터럽트는 실행 기능 내에서 자발적인 오류로 처리됩니다. 그러나의 특성상 i이러한 오류도 발생합니다. Ctrl + C를 눌렀을 때에 따라 다음을 수행 할 수 있습니다.
  • negate-forever 루프를 종료하고 sub숫자를 문자열에 연결하여 루프에서 오류를 제거한 다음 문자열 자체를 무한한 횟수로 대체 한 것처럼 ///를 해석합니다.
  • sub반쯤 남겨 두고 반-서브 /// 표현식을 해석합니다.
  • 인터프리터를 중단하고 평가되지 않은 /// 프로그램을 STPLOUT이 아닌 REPL에 반환합니다.

사용법 예 :

   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

펄-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에서 EOF까지 프로그램을 읽습니다 .

핍 , 100 102 바이트

나는 Pip이 Turing-complete라는 것을 증명 한 적이 없었습니다. 솔루션을 얻은 후에는 골프를 치고 여기에 게시한다고 생각했습니다.

101 바이트의 코드, -r플래그의 경우 +1 :

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

풍부한 의견을 가진 내 ungolfed 버전은 다음과 같습니다.

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

온라인으로 사용해보십시오! (TIO는 프로그램이 종료되지 않을 때 출력을 제공하지 않으며 시간 제한도 있습니다. 더 큰 예제와 무한 루프의 경우 명령 행에서 Pip을 실행하는 것이 좋습니다.)

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

이것은 결코 이길 수 없지만 미래의 모든 소프트웨어 프로젝트 가이 멋진 언어로 작성 될 것이라고 결정했기 때문에 나는 그것을 위해 통역사가 필요했고 내가 만든 것을 공유 할 수도 있다고 생각했습니다 ...

점수 차이는 Visual C ++에는 첫 번째 include가 필요하지 않지만 g ++에는 필요하다는 것입니다. 점수는 줄 끝이 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;}}}

파이썬 2 (236), 파이썬 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

이라고합니다 d(r"""/foo/Hello, world!//B\/\\R/foo/B/\R"""). 트리플 따옴표는 ///프로그램에 줄 바꿈이 포함 된 경우에만 필요합니다 . 그렇지 않으면 간단한 따옴표가 좋습니다.

편집 :이 인터프리터는 이제 예상대로 물건을 인쇄합니다 (이전에는 주석, 끝 부분에만 인쇄 됨). Python 3의 경우 첫 번째 줄을 제거하십시오 (그러나 고대 설치에는 Python 3이 없으므로 다른 변경 사항이 있는지 확신 할 수 없습니다).

코브라-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)

루비 , 119110 바이트

예외로 종료

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}

온라인으로 사용해보십시오!

완전히 종료 (116 바이트)

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}

온라인으로 사용해보십시오!

파이썬 2/3 (211 바이트)

Bruno Le Floch의 답변을 기반으로 한 다음 코드 는 Python 2 및 Python 3과 호환됩니다.

또한 재귀가 아닌 반복적이므로 파이썬의 최대 재귀 깊이에 도달 할 위험이 없습니다.

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)

베이컨 , 391 387 395 바이트

이 페이지의 기여에서 나는 파이썬 프로그램 만 작동시켰다. 다른 것은 일부 /// 샘플에서 작동하거나 전혀 작동하지 않습니다. 따라서 BASIC에서 구현 한 버전을 추가하기로 결정했습니다.

BASIC은 긴 단어를 문장으로 사용하기 때문에 BASIC과 CodeGolf 경쟁에서 경쟁하는 것은 쉽지 않습니다. BASIC에서 일반적으로 사용되는 유일한 약어는 '?' 부호는 인쇄를 의미합니다.

따라서 아래 프로그램은 결코 이길 수는 없지만 최소한이 Codegolf 페이지 및 Esolangs Wiki의 모든 데모 코드와 함께 작동합니다 . "99 병의 맥주"의 모든 버전을 포함합니다.

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$