우리의 사랑하는 천재에 영감을 받아 기억합니다.

삼가 고인의 명복을 빕니다

그는 매그넘 작품과 도전 과제의 주제 인 dfns를 발명 하고 구현 했습니다.

관심있는 경우 : 최신 전체 dfns 문서 와 요한과 비디오 .

직무

ASCII 소스 코드가 주어지면 다음 네 가지 범주 중 어느 것이 속하는지 대답하십시오.

1. 이색 도프

2. 모나 딕 도프

3. Dfn

4. 다른

네 개의 일관된 값을 반환 할 수 있지만 명확하지 않은 경우 매핑을 명시하십시오.

세부

소스 코드는 항상 여는 중괄호로 시작 {하고 닫는 중괄호로 끝나는 것으로 가정 할 수 있습니다 }.

재귀 중첩 괄호가 발생할 수 {{{}}}있지만 (예 :) 카테고리 1–3은 괄호 중첩 깊이가 1보다 낮아질 수 없으며 ( {}{}"기타") 모든 괄호의 균형이 맞아야합니다 ( {{}"기타").

행에서 다음 컨텍스트의 문자는 무시됩니다.

1. #(댓글) 의 오른쪽에 :significant#ignored

2. 작은 따옴표로 묶여 '... '(즉, 문자열) : significant'ignored'significant(이 적용 #도 : '#'significant)

3. 짝을 이루지 않은 따옴표 오른쪽 '(왼쪽에서 따옴표를 묶음 ) :significant'ignored

중괄호 수준 1에서 (예 : 중첩 중괄호 제외) :

• Dyadic dops는 중단없는 문구를 포함합니다 ww

• 모나 딕 도프는 포함하지 않지만 ww포함aa

• Dfns 포함도 ww도aa

테스트 사례

이색 도프

{ww}

{
    www
}

{
''ww'
}

{aa

ww}

{'#''#'ww?aa}

모나 딕 도프

{aa}

{aaaa}

{aa{ww}'ww'}

{w#w'
aa'
}

{aaw*w}

{w'\'aa\''}

Dfn

{}

{a a}

{aA}

{
{aa}
}

{w
w''w#
w}

{{
}}

{w\'aa\'}

다른

{}{}

{{}

{}}

{ww}}

{}
{}

{ww}{}

{#}

{'
'}

자바 스크립트 (ES6),  145 ...  138136 바이트

$0$$1$$2$$3$

s=>[...s].map(c=>s=(n=`
aw}{#'`.indexOf(c))?n>5?i^=2:i?0:n>4?i=1:n>3?d++:n>2?x+=!d--:(o|=n<0|d|s!=c?0:n,c):i=0,o=i=0,x=d=-1)|x|~d?3:2>>o

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

대체 버전

• 문자 배열을 입력으로 사용하여 131 바이트
• Buffer () 를 사용하여 132 바이트 (Node.js)

어떻게?

입력 문자열은 문자별로 구문 분석됩니다.

문자를 코드로 변환

$c$$n$

 character | code | triggered operation
-----------+------+---------------------------------------------------------
    \n     |   0  | i = 0
     a     |   1* | o |= n < 0 | d | s != c ? 0 : n
     w     |   2* | o |= n < 0 | d | s != c ? 0 : n
     }     |   3* | x += !d--
     {     |   4* | d++
     #     |   5* | i = 1
     '     |   6  | i ^= 2
   other   |  -1* | same as 'a' or 'w', but always fails because of 'n < 0'

$*$$i\neq 0$

파서 상태를 설명하는 변수

구문 분석 중에 다음 변수가 사용됩니다.

• $o$

  • 비트 0 : 유효한 문구 aa가 발견되었습니다
  • 비트 1 : 유효한 문구 ww가 발견되었습니다

• $i$

  • 비트 0 : 현재 주석 안에 있습니다.
  • 비트 1 : 현재 문자열 안에 있습니다 (이 비트는 여전히 주석 내에서 업데이트되지만 무해합니다)

• $s$

• $d$$-1$
• $x$$0$$-1$$1$

최종 결과

$3$$x$$0$$d$$-1$$0$$1$$2$$o$

젤리 ,  50 48 46  45 바이트

Ỵµṣ”'m2Kṣ”#Ḣ)KµċⱮƤØ{IF©<-oµ⁾waż¤ẇ€‘Ḅ«5×®¬Ḅ⁼1¤

문자 목록을 허용하는 모나 딕 링크 :

5 - Dyadic dop
4 - Monadic dop
3 - Dfn
0 - Other

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.
_{Python 따옴표를 사용하여 입력을 Python 세트 또는 사전으로 평가할 가능성을 피합니다.}

어떻게?

Ỵµṣ”'m2Kṣ”#Ḣ)KµċⱮƤØ{IF©<-oµ⁾waż¤ẇ€‘Ḅ«5×®¬Ḅ⁼1¤ - Link: list of characters
                                              - breaking long Link up...
Ỵµṣ”'m2Kṣ”#Ḣ)K      - Replace any strings or comments with (single) spaces
Ỵ                   - split at newline characters
 µ          )       - monadic chain for each:
  ṣ”'               -   split at apostrophe characters
     m2             -   modulo 2 slice (i.e. every other part starting with the first
                    -   - that is, non-string code. Will remove strings from within comments)
       K            -   join with spaces
        ṣ”#         -   split at octothorp characters
           Ḣ        -   head (i.e. non-comment code)
             K      - join with spaces

µċⱮƤØ{IF©<-oµ       - Replace characters of code at depth > 1 with the integer 1
µ           µ       - monadic chain, call previous result A:
    Ø{              -   literal ['{','}']
   Ƥ                -   for prefixes of A:
  Ɱ                 -     map across right argument with:
 ċ                  -       count
      I             -   deltas (i.e. [count('}') - count('{')] for each prefix)
       F            -   flatten (i.e. count('}') - count('{') for each prefix)
                    -   -- i.e -1*depth of each character of A; closing braces at depth+1
        ©           -   (copy this list of depths to the register for later use)
         <-         -   less than -1? (vectorises)
           o        -   logical OR with A (vectorises, replacing deep code with 1s)

⁾waż¤ẇ€‘Ḅ«5×®¬Ḅ⁼1¤ - Categorise the result, R
    ¤              - nilad followed by link(s) as a nilad:
⁾wa                -   literal ['w', 'a']
   ż               -   zip with itself = [['w','w'],['a','a']]
     ẇ€            - for €ach: is a sublist of R?  i.e. one of: [0,0] [1,0] [0,1] [1,1]
       ‘           - increment (vectorises)                     [1,1] [2,1] [1,2] [2,2]
        Ḅ          - unbinary                                     3     5     4     6
         «5        - minimum with five                            3     5     4     5
                 ¤ - nilad followed by link(s) as a nilad:
            ®      -   recall depths from the register
             ¬     -   logical NOT (vectorises) (0->1, other depths->0)
              Ḅ    -   unbinary
               ⁼1  -   equal one -- i.e. depths ends with a 0 and contains no other zero 
           ×       - multiply

청소 , 309 293 284 바이트

우리는 우리가 전화 할게 있도록 만, 한 번에 3 변수 이름을 사용하여 멀리 얻을 수 있습니다 a, p하고 l.

import StdEnv,Text,Data.List
a=isInfixOf o zip2[2,2]
@ =['\'']
$p#p=join@[foldl((\[a:p]_|p>[]=a++[';':join@(tl p)]=split['#']a!!0)o split@)l l\\l<-mklines p]
#l=[(?a- ?l,p)\\a<-inits p&[p:l]<-tails p]
|{p\\(a,p)<-l|a<2}<>"{}"=0|a['ww']l=1|a['aa']l=2=3
?l=sum[1\\'{'<-l]-sum[1\\'}'<-l]

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

함수 $ :: [Char] -> Int와 일부 도우미를 정의하여 매핑을 제공합니다.

• 0: 기타
• 1: Dyadic dop
• 2: 모나 딕 도프
• 3: Dfn

확장 (첫 번째 버전) 및 3 개 이상의 변수 이름 :

$ s
    # s // remove strings and comments
        = join [';'] [ // join the second argument with semicolons
            limit ( // take the first repeated element of
                iterate // an infinite list of applications of the first argument
                    (
                        (
                            \(p, q) = p ++ case q of // join the first half with a modified second half
                                ['\'\'': q] = [';': q] // replace two quotes with a semicolon
                                [c, _: q] = [c: q] // drop the character after a quote or hash
                                _ = [] // leave unmatched strings unchanged
                        ) o span // split the string on the first occurrence of
                            \c = c <> '\'' && c <> '#' // a quote or hash
                    ) l // applied to l
                )
            \\ l <- mklines s // for line l in s split at newlines
        ]
    # b // generate a map of nesting levels
        = [
            ( // the pair of
                ?i - ?t, // the nesting level
                c // the character c
            ) 
            \\ i <- inits s // for init i of s
            & // synchronously iterated with 
                [c: t] <- tails s // character c at the start of tail [c:t] of s
        ]
    // determine what the code is
    | {c \\(n, c) <- b | n < 2} // if the string made of characters with nesting level of less than 2
        <> "{}" // is not the same as the paired braces at the beginning and end
        = 0 // return zero
    | m ['ww'] b // if there are two consecutive 'w's at nesting level 2
        = 1 // return 1
    | m ['aa'] b // if there are two consecutive 'a's at nesting level 2
        = 2 // return 2
    = 3 // otherwise return 3

레티 나 0.8.2 , 91 바이트

m`'.*?('|$)|#.*
¶
s(+`(?!^)\{[^{}]*\}(?!$)
¶
^(?!\{[^{}]*\}$).+
3
^.+ww.+
2
^.+aa.+
1
..+
0

온라인으로 사용해보십시오! 링크에는 테스트 스위트가 포함되어 있습니다. 설명:

m`'.*?('|$)|#.*
¶

문자열과 주석을 제거하십시오.

s(+`(?!^)\{[^{}]*\}(?!$)
¶

가장 안쪽부터 운동하면서 일치하는 브래킷을 제거하되 첫 번째와 마지막 브래킷은 그대로 두십시오.

^(?!\{[^{}]*\}$).+
3

일치하는 대괄호가 없으면 기타입니다.

^.+ww.+
2

그렇지 않다면 ww이것이 Dyadic Dop입니다.

^.+aa.+
1

그렇지 않으면 우리는 aa그렇다면 Monadic Dop입니다.

..+
0

그렇지 않으면 위에 언급되지 않은 것이 있으면 Dfn입니다.