Inspiriert von und in Erinnerung an unser geliebtes Genie,

RUHE IN FRIEDEN

Er hat dfns erfunden und umgesetzt - sein magnum opus und das thema der herausforderung.

Für die Interessierten: Aktuelle Voll-dfns-Dokumentation und Videos mit John .

Aufgabe

Beantworten Sie bei einem vorgegebenen ASCII-Quellcode, zu welcher der folgenden vier Kategorien er gehört:

1. Dyadic Dop

2. Monadic Dop

3. Dfn

4. Andere

Sie können vier beliebige konsistente Werte zurückgeben, geben Sie jedoch Ihre Zuordnung an, wenn dies nicht offensichtlich ist.

Einzelheiten

Sie können davon ausgehen, dass der Quellcode immer mit einer öffnenden geschweiften Klammer beginnt {und mit einer schließenden geschweiften Klammer endet }.

Rekursiv verschachtelte Klammern können vorkommen (z. B. {{{}}}), aber in den Kategorien 1 bis 3 darf die Schachtelungstiefe der Klammern niemals unter 1 liegen (also {}{}"Sonstige"), und alle Klammern müssen ausgeglichen sein (also {{}"Sonstige").

Zeichen in den folgenden Kontexten einer Zeile werden ignoriert:

1. Rechts von #(ein Kommentar):significant#ignored

2. In Apostrophe '... '(dh in einem String): significant'ignored'significant(Dies gilt #auch: '#'significant)

3. Rechts neben einem ungepaarten Anführungszeichen '(Anführungszeichen von links koppeln):significant'ignored

In der geschweiften Klammer Stufe 1 (dh ohne geschachtelte Klammern):

• Dyadische Dops enthalten die ununterbrochene Phrase ww

• Monadic Dops enthalten nicht ww, aber enthaltenaa

• Dfns enthalten weder wwnochaa

Testfälle

Dyadische Dops

{ww}

{
    www
}

{
''ww'
}

{aa

ww}

{'#''#'ww?aa}

Monadic Dops

{aa}

{aaaa}

{aa{ww}'ww'}

{w#w'
aa'
}

{aaw*w}

{w'\'aa\''}

Dfns

{}

{a a}

{aA}

{
{aa}
}

{w
w''w#
w}

{{
}}

{w\'aa\'}

Andere

{}{}

{{}

{}}

{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

Probieren Sie es online!

Alternative Versionen

• 131 Bytes, indem ein Array von Zeichen als Eingabe verwendet wird
• 132 Bytes mit Buffer () (Node.js)

Wie?

Die Eingabezeichenfolge wird zeichenweise analysiert.

Übersetzung von Zeichen in 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$

Variablen, die den Parser-Status beschreiben

Die folgenden Variablen werden beim Parsen verwendet:

• $o$

  • Bit 0: ein gültiger Ausdruck aaangetroffen wurde
  • Bit 1: ein gültiger Ausdruck wwangetroffen wurde

• $i$

  • Bit 0: Wir befinden uns derzeit in einem Kommentar
  • Bit 1: Wir befinden uns derzeit in einer Zeichenfolge (dieses Bit wird noch in einem Kommentar aktualisiert, aber das ist harmlos)

• $s$

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

Endergebnis

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

Jelly ,  50 48 46  45 Bytes

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

Ein monadischer Link, der eine Liste von Zeichen akzeptiert, die Folgendes ergibt:

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

Probieren Sie es online! Oder sehen Sie sich eine Testsuite an .
_{Verwendet Python-Anführungszeichen, um die Möglichkeit zu vermeiden, Eingaben als Python-Satz oder Wörterbuch auszuwerten}

Wie?

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

Sauber , 309 293 284 Bytes

Wir können mit nur mit drei Variablennamen in einer Zeit weg, so dass wir sie nennen wollen a, pund 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]

Probieren Sie es online!

Definiert die Funktion $ :: [Char] -> Intund einige Helfer und gibt das Mapping an:

• 0: Andere
• 1: Dyadic Dop
• 2: Monadic Dop
• 3: Dfn

Erweitert (erste Version) und mit mehr als 3 Variablennamen:

$ 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

Probieren Sie es online! Link enthält Testsuite. Erläuterung:

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

Entfernen Sie Zeichenfolgen und Kommentare.

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

Entfernen Sie die übereinstimmenden Klammern aus dem Innersten, lassen Sie jedoch die erste und die letzte Klammer frei.

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

Wenn wir keine passenden Klammern haben, ist dies Sonstige.

^.+ww.+
2

Ansonsten wwist das Dyadic Dop.

^.+aa.+
1

Andernfalls aaist dies Monadic Dop.

..+
0

Andernfalls ist dies Dfn, wenn dies etwas ist, das oben nicht behandelt wurde.