Inspirado y en memoria de nuestro querido genio,

Q.E.P.D

Él inventó e implementó dfns - su obra magna y el objeto de la impugnación.

Para los interesados: la última documentación completa de dfns y videos con John .

Tarea

Dado un código fuente ASCII, responda a cuál de las siguientes cuatro categorías pertenece:

1. Dopda diádica

2. Dop monádico

3. Dfn

4. Otro

Puede devolver cuatro valores consistentes, pero indique su asignación si no es obvio.

Detalles

Puede suponer que el código fuente siempre comienza con una llave de apertura {y termina con una llave de cierre }.

Pueden ocurrir llaves anidadas recursivamente (p {{{}}}. Ej. ), Pero las categorías 1–3 nunca pueden tener una profundidad de anidación de {}{}llaves debajo de 1 (también lo es "Otro") y todas las llaves deben estar equilibradas (también lo {{}es "Otro").

Se ignoran los caracteres en los siguientes contextos en una línea:

1. A la derecha de #(un comentario):significant#ignored

2. Entre comillas simples '... '(es decir, en una cadena): significant'ignored'significant(Esto se aplica a #demasiado: '#'significant)

3. A la derecha de una cotización no 'emparejada (emparejamiento de cotizaciones de la izquierda):significant'ignored

En el nivel uno de llaves (es decir, excluyendo llaves anidadas):

• Los dops diádicos contienen la frase ininterrumpida ww

• Dops monádicos no contienen ww, pero contienenaa

• Dfns no contienen wwniaa

Casos de prueba

DOPs diádicos

{ww}

{
    www
}

{
''ww'
}

{aa

ww}

{'#''#'ww?aa}

Dops monádicos

{aa}

{aaaa}

{aa{ww}'ww'}

{w#w'
aa'
}

{aaw*w}

{w'\'aa\''}

Dfns

{}

{a a}

{aA}

{
{aa}
}

{w
w''w#
w}

{{
}}

{w\'aa\'}

Otro

{}{}

{{}

{}}

{ww}}

{}
{}

{ww}{}

{#}

{'
'}

JavaScript (ES6),  145 ... 138  136 bytes

$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

Pruébalo en línea!

Versiones alternativas

• 131 bytes tomando una matriz de caracteres como entrada
• 132 bytes utilizando Buffer () (Node.js)

¿Cómo?

La cadena de entrada se analiza carácter por carácter.

Traducción de caracteres a códigos

$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$

Variables que describen el estado del analizador

Las siguientes variables se utilizan durante el análisis:

• $o$

  • bit 0: aase ha encontrado una frase válida
  • bit 1: wwse ha encontrado una frase válida

• $i$

  • bit 0: actualmente estamos ubicados dentro de un comentario
  • bit 1: actualmente estamos ubicados dentro de una cadena (este bit todavía se actualiza dentro de un comentario, pero esto es inofensivo)

• $s$

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

Resultado final

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

Jalea ,  50 48 46  45 bytes

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

Un enlace monádico que acepta una lista de caracteres que produce:

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

Pruébalo en línea! O ver un conjunto de pruebas .
_{usa citas de Python para evitar la posibilidad de evaluar la entrada como un conjunto o diccionario de Python}

¿Cómo?

Ỵµṣ”'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

Limpio , 309 293 284 bytes

Podemos salirse con sólo con 3 nombres de variables a la vez, por lo que llamaremos a, py 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]

Pruébalo en línea!

Define la función $ :: [Char] -> Inty algunos ayudantes, dando la asignación:

• 0: Otro
• 1: Dop Dádico
• 2: Dop monádico
• 3: Dfn

Ampliado (primera versión) y con más de 3 nombres de variables:

$ 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

Retina 0.8.2 , 91 bytes

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

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Explicación:

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

Eliminar cadenas y comentarios.

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

Retire los corchetes coincidentes, trabajando desde lo más interno, pero deje los primeros y últimos corchetes.

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

Si no tenemos corchetes coincidentes, entonces este es Otro.

^.+ww.+
2

De lo contrario, si tenemos, wwentonces este es Dyadic Dop.

^.+aa.+
1

De lo contrario, si tenemos, aaentonces este es Monadic Dop.

..+
0

De lo contrario, si esto es algo no cubierto anteriormente, entonces esto es Dfn.