Standardisierte Tests werden normalerweise mit einem Scan-Tron oder einem Antwortdokument geliefert, das Ihre Antwort aufzeichnet. Ein Computer oder ein Mensch würde dann Ihre Antworten überprüfen und Ihre Note bestimmen. Bestimmen Sie hier anhand eines Scan-Trons und des Antwortschlüssels die Punktzahl und die fehlenden Fragen, falls vorhanden. Ein Scan-Tron ist nur ein Dokument mit mehreren Zeilen mit Antworten, die der Benutzer ausfüllt (in diesem Fall eingekreist). Beispiel:

   ---
1. |a| b c d
   --- 

Wie Sie sehen können, ist dies Frage 1 mit aausgewählter Antwortauswahl , da sie mit einem Kästchen versehen ist. Für die Herausforderung, werden Sie einen Scan-tron mit bestimmten nFragen ( 1 <= n <= 10) mit nur vier Antworten bezeichnet als a, b, c, oder d. Der Antwortschlüssel wird als Zeichenfolge ohne Leerzeichen und mit Kleinbuchstaben angegeben. Beispiel Scan-Tron mit Antwortschlüssel:

Scan-tron
   ---
1. |a| b c d
   ---
     ---
2. a |b| c d
     ---
       ---
3. a b |c| d
       ---

Answer Key
abb

Sie können den Antwortschlüssel und das Scan-Tron als separate Eingaben oder in einer ausgewählten Reihenfolge eingeben, solange sie identifiziert werden können (dh der Antwortschlüssel ist vom Scan-Tron getrennt). Die Punktzahlen werden auf das nächste Zehntel eines Punktes gerundet. Beispielausgabe für das Obige:

Score: 66.7
Missed #: 3

Eine andere akzeptable Antwort wäre:

66.7 
3

oder wenn mehrere Fragen fehlen

66.7
3 4 5

Solange die Fragenummern für die Versäumten von den Leerzeichen getrennt sind und nicht in derselben Zeile wie die Punktzahl stehen.

Regeln und Spezifikationen

• Das Scan-Tron kann als mehrzeilige Zeichenfolge oder als Frage eingegeben werden (da eine Zeichenfolge mit Zeilenumbrüchen zulässig ist).
• Bei einem Scan-Tron und einem Antwortschlüssel müssen Sie die Punktzahl in einer Zeile und die Frage (n) in einer anderen Zeile verpassen, wobei die Zahlen durch Leerzeichen getrennt sind. Wenn keine Fragen übersehen werden, sollten keine Fragenummern ausgegeben werden
• Die Punktzahlen werden auf das nächste Zehntel gerundet

• Ausgewählte Antworten sind von diesem Feld umgeben:

  ---
  | |
  ---
  

• Auf dem Scan-Tron benötigt jede Frage drei Leerzeichen (oben und unten im Feld werden zwei zusätzliche Zeilen benötigt).
• Muss für das obige Beispiel funktionieren
• Angenommen, es wird immer nur eine Antwortbox angezeigt

Gewinnkriterien

Der kürzeste Code gewinnt!

05AB1E , 43 Bytes

U|3ôø`\vyy'|k>èXNèQˆ}¯OXg/3°*2z+ïT/XgL¯_Ï‚»

Probieren Sie es online aus!

Erläuterung

U                                            # store the answer key in X
 |3ô                                         # split the question-rows in chunks of 3
    ø`                                       # zip and flatten
      \                                      # discard top of stack, leaving the list of
                                             # answer rows on top
       v                                     # for each answer row
         y'|k                                # get the index of the first "|"
        y    >è                              # get the character after that from the row
               XNèQ                          # compare it to the corresponding entry in 
                                             # the answer key
                   ˆ                         # add it to the global list
                    }                        # end loop
                     ¯O                      # calculate the number of correct answers
                       Xg/                   # divide by the length of the answer key
                          3°*                # multiply by 1000
                             2z+             # add 0.5
                                ï            # convert to integer
                                 T/          # divide by 10
                                   XgL       # push range [1 ... len(answer key)]
                                      ¯_Ï    # keep only numbers corresponding to 
                                             # wrong answers
                                          ‚» # format output

Gestapelt , 68 + 1 = 69 Bytes

'|'split[#'1-]NO neq::size:@z~>*[]YES' '#`out is0 sum z/100*1 nround

Probieren Sie es online aus! +1 für -pFlag (dieses Skript kann ausgeführt werden als stacked -pe "...")

Nimmt zwei Eingaben von der Oberseite des Stapels.

Einige interessante Funktionen:

[#'1-]NO
[    ]NO   do not keep members where
 #'          its length
   1-          -1
             is truthy (in this case, not equal to zero).

Dies ergibt alle Buchstaben, die von Rohren umgeben sind.

:size:@z~>*[]YES
:                 duplicate indices of incorrect answers
 size             length of incorrect answers
     :@z          (stored into z)
        ~>        range from 1 to this length
          *       and multiply by this range
           []YES  keep truthy elements

Dies gibt uns alle falschen Fragenummern.

Python 2 , 94 93 Bytes

^{-1 Byte dank L3viathan}

s,a=input()
l=len(s)
w=[i+1for i in range(l)if"|%s|"%a[i]not in s[i]]
print(l-len(w))*1e2/l,w

Probieren Sie es online aus!

Pip , 49 46 44 48 45 Bytes

Ugh, diese Rundung benötigt so viele Bytes ... 44 Bytes Code, +1 für -sFlag.

(/2+m-m/#b*#P_FI{++nbNa?un}MZa@`\|..`b)//1/t

Übernimmt Eingaben als Befehlszeilenargumente (auf der Scan-Tron-Seite müssen Zeilenumbrüche in Anführungszeichen gesetzt und maskiert werden, wenn Sie sie über eine tatsächliche Befehlszeile ausführen). Gibt zuerst die fehlenden Fragen und dann die Punktzahl aus. Probieren Sie es online aus!

Erläuterung

Ich mache das in zwei Teilen: der Liste der falschen Fragen und der Punktzahl.

P_FI{++nbNa?un}MZa@`\|..`b
                            a,b are cmdline args, u is nil, n is newline (implicit)
                            Note that a string like n, in math contexts, is equivalent to 0
                 a@`\|..`   Find all occurrences in a of | followed by 2 chars
                            Because regex matches don't overlap, this does what we need
    {         }MZ        b  Zip with b and map this function to each pair of items:
     ++n                     Increment n (so the first time through, it's 1)
        bNa                  Is 2nd arg a substring of 1st?
           ?un               If so, return nil; if not, return n
                            Now we have a list containing nil for correct questions
                            and the question number for incorrect questions
 _FI                        Filter on identity function (keep only truthy values)
P                           Print, joining on spaces (-s flag)

(/2+m-m/#b*#...)//1/t
                       a,b are cmdline args, m is 1000 (implicit)
            ...        The code from the first part
           #           Length of that list (i.e. number of incorrect questions)
      m/#b*            Times 1000/(number of questions)
    m-                 Subtracted from 1000
 /2+                   Plus 1/2 (= 0.5)
                       We now have a number like 667.1666666666667
(              )//1    Int-divide by 1 to truncate
                   /t  and divide that by 10
                       Print (implicit)

JavaScript (ES6), 88 Byte

x=>y=>x.replace(/\w(?=\|)/g,c=>c==y[i++]?t++:a+=i+" ",a=i=t="")&&(t/i*1e3+.5|0)/10+`
`+a

Ich könnte 5 Bytes sparen, indem ich Kommas verwende und alles in einer Zeile zurückgebe:

x=>y=>x.replace(/\w(?=\|)/g,c=>c==y[i++]?t++:a+=[,i],a=i=t="")&&(t/i*1e3+.5|0)/10+a

Stapel, 242 Bytes

@echo off
set/as=c=0
set m=
set/pk=
:l
set/ac+=1
set/pt=
set/pl=
set/pt=
set "l=%l:*|=%
if %l:~,1%==%k:~,1% (set/as+=1)else set m=%m% %c%
set k=%k:~1%
if not "%k%"=="" goto l
set/as=(s*2000/c+1)/2
echo(%s:~,-1%.%s:~-1%
echo(%m%

Liest zuerst den Antwortschlüssel auf STDIN und dann die Fragenzeilen ein n*3. Hinweis: Die Punktzahl wird ohne führende Null gedruckt, wenn sie kleiner als ist 1.0. Verpasste Antworten werden mit einem führenden Leerzeichen gedruckt.

CJam , 47 45 Bytes

lqN/(;3%_'|f#:).=.=__:+\,d/e2XmOn:!_,,:).*0-p

Probieren Sie es online aus!

Erläuterung

Das Programm besteht aus drei Hauptteilen:

Right/wrong list

l                    e# Read the first line of input (answer key)
 qN/                 e# Read the rest of the input and split it on newlines
    (;3%             e# Delete the first line, then select every 3rd line 
        _            e# Duplicate the array
         '|f#        e# Find the index of the first | in each answer
             :)      e# Increment each, gives the index of the selected letter for each answer
               .=    e# Vectorized get-element-at with the answer strings
                 .=  e# Vectorized equality check with the answer key

Nach diesem Abschnitt haben wir ein Array von 0s und 1s, wobei 0eine falsche und 1eine richtige Antwort angezeigt werden .

Score

__              e# Duplicate the right/wrong list twice
  :+            e# Take the sum of it (number of right answers)
    \,          e# Swap top elements and take the length (total number of questions)
      d/        e# Divide (casting to double so it's not integer division)
        e2      e# Multiply by 10^2
          XmO   e# Round to 1 decimal place
             n  e# Pop and print with a newline

Nach diesem Abschnitt enthält der Stapel nur die richtige / falsche Liste, und die prozentuale Bewertung wurde ausgegeben.

Wrong answers

:!            e# Logically negate each element of the right/wrong list
  _,,:)       e# Generate the inclusive range 1...length(list)
       .*     e# Vectorized multiplication of the two lists
         0-   e# Remove any 0s from the result
           p  e# Print it

Jolf, 46 Bytes

Ich kann nicht scheinen, 46 Bytes zu brechen. Ich habe zwei Lösungen dieser Länge. Probieren Sie es hier aus!

ΆRγψ~mΖ mi«\|..»d?=€H.xSEhSdHήSmX*~1/-lζlγlζ_1

(Ersetzen □mit 0x7fin der nächsten)

ΆRγψΜΖψGi'|d=1lHd?□=H.xShSEdHήSmX*~1/-lζlγlζ_1

In beiden Fällen 15 Bytes zum Runden : mX*~1/-lζlγlζ_1. Sie sind größtenteils gleich, außer dass einer eine Regex-Übereinstimmung verwendet, um die Ergebnisse zu erhalten, und der andere Teil auf Rohren.