Вдохновленный и в память о нашем любимом гении,

ПОКОЙСЯ С МИРОМ

Он изобрел и внедрил DFS - его опус и предмет вызова.

Для заинтересованных: последняя полная документация по DFS и видео с Джоном .

задача

Учитывая исходный код ASCII, ответьте, к какой из следующих четырех категорий он относится:

1. Диадический доп

2. Монадный доп

3. Dfn

4. Другой

Вы можете вернуть любые четыре последовательных значения, но, пожалуйста, укажите свое отображение, если оно не очевидно.

Детали

Вы можете предположить, что исходный код всегда начинается с открывающей фигурной скобки {и заканчивается закрывающей фигурной скобкой }.

Могут возникать рекурсивно вложенные фигурные скобки (например {{{}}}), но категории 1–3 никогда не могут иметь глубину вложенности фигурных скобок ниже 1 ( {}{}как и «Другое»), и все фигурные скобки должны быть сбалансированы ( {{}как и «Другое»).

Символы в следующих контекстах в строке игнорируются:

1. Справа от #(комментарий):significant#ignored

2. Заключено в одинарных кавычках '... '(то есть в строке): significant'ignored'significant(Это относится и к #слишком: '#'significant)

3. Справа от непарной кавычки '(парные кавычки слева):significant'ignored

На первом уровне фигурных скобок (т.е. исключая вложенные скобки):

• Dyadic допы содержат непрерывную фразу 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\''}

Dfns

{}

{a a}

{aA}

{
{aa}
}

{w
w''w#
w}

{{
}}

{w\'aa\'}

Другой

{}{}

{{}

{}}

{ww}}

{}
{}

{ww}{}

{#}

{'
'}

JavaScript (ES6),  145 ... 138  136 байт

$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 байт , принимая массив символов в качестве входных данных
• 132 байта с помощью Buffer () (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.