Inspiré par et en mémoire de notre génie bien-aimé,

DÉCHIRURE

Il a inventé et mis en œuvre des dfns - son magnum opus et le sujet du défi.

Pour les intéressés: dernières documentations et vidéos dfns complètes avec John .

Tâche

Étant donné un code source ASCII, répondez à laquelle des quatre catégories suivantes il appartient:

1. Dop dyadique

2. Dop monadique

3. Dfn

4. Autre

Vous pouvez renvoyer quatre valeurs cohérentes, mais veuillez indiquer votre mappage s'il n'est pas évident.

Détails

Vous pouvez supposer que le code source commence toujours par une accolade ouvrante {et se termine par une accolade fermante }.

Des accolades imbriquées récursivement peuvent se produire (par exemple {{{}}}), mais les catégories 1 à 3 ne peuvent jamais avoir une profondeur d'imbrication d'accolade inférieure à 1 (tout {}{}comme "Autre") et toutes les accolades doivent être équilibrées (tout {{}comme "Autre").

Les caractères dans les contextes suivants sur une ligne sont ignorés:

1. À droite de #(un commentaire):significant#ignored

2. Apostrophes '... '( par exemple dans une chaîne): significant'ignored'significant(Cela vaut pour #trop: '#'significant)

3. À droite d'un devis non apparié '(couplage de devis à partir de la gauche):significant'ignored

Dans le premier accolade (c'est-à-dire à l'exclusion des accolades imbriquées):

• Les dops dyadiques contiennent la phrase ininterrompue ww

• Les dops monadiques ne contiennent pas ww, mais contiennentaa

• Les dfns ne contiennent wwniaa

Cas de test

Dops dyadiques

{ww}

{
    www
}

{
''ww'
}

{aa

ww}

{'#''#'ww?aa}

Dops monadiques

{aa}

{aaaa}

{aa{ww}'ww'}

{w#w'
aa'
}

{aaw*w}

{w'\'aa\''}

Dfns

{}

{a a}

{aA}

{
{aa}
}

{w
w''w#
w}

{{
}}

{w\'aa\'}

Autre

{}{}

{{}

{}}

{ww}}

{}
{}

{ww}{}

{#}

{'
'}

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

$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

Essayez-le en ligne!

Versions alternatives

• 131 octets en prenant un tableau de caractères en entrée
• 132 octets en utilisant Buffer () (Node.js)

Comment?

La chaîne d'entrée est analysée caractère par caractère.

Traduction de caractères en codes

$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 décrivant l'état de l'analyseur

Les variables suivantes sont utilisées lors de l'analyse:

• $o$

  • bit 0: une phrase valide aaa été rencontrée
  • bit 1: une phrase valide wwa été rencontrée

• $i$

  • bit 0: nous sommes actuellement situés dans un commentaire
  • bit 1: nous sommes actuellement situés à l'intérieur d'une chaîne (ce bit est toujours mis à jour dans un commentaire, mais cela est inoffensif)

• $s$

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

Résultat final

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

Gelée ,  50 48 46  45 octets

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

Un lien monadique acceptant une liste de caractères qui donne:

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

Essayez-le en ligne! Ou consultez une suite de tests .
_{utilise des guillemets Python pour éviter la possibilité d'évaluer l'entrée en tant qu'ensemble ou dictionnaire Python}

Comment?

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

Propre , 309 293 284 octets

Nous pouvons sortir avec seulement 3 en utilisant les noms de variables à la fois, donc nous allons les appeler a, pet 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]

Essayez-le en ligne!

Définit la fonction $ :: [Char] -> Intet certains assistants, donnant le mappage:

• 0: Autre
• 1: Dop dyadique
• 2: Dop monadique
• 3: Dfn

Développé (première version), et avec plus de 3 noms 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 octets

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

Essayez-le en ligne! Le lien inclut une suite de tests. Explication:

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

Supprimez les chaînes et les commentaires.

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

Retirez les crochets assortis, en vous entraînant à l'intérieur, mais laissez les premier et dernier crochets.

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

Si nous n'avons pas de parenthèses correspondantes, alors c'est Autre.

^.+ww.+
2

Sinon, si c'est le cas, wwc'est Dyadic Dop.

^.+aa.+
1

Sinon, si c'est le cas, aac'est Monadic Dop.

..+
0

Sinon, si ce n'est pas couvert ci-dessus, c'est Dfn.