Les tests standardisés sont généralement fournis avec un scan-tron ou un type de document de réponse qui enregistre votre réponse. Un ordinateur ou des humains vérifieraient alors vos réponses et détermineraient votre note. Alors ici, étant donné un scan-tron et le corrigé, déterminez le score et les questions manquées le cas échéant. Un scan-tron n'est qu'un document de plusieurs lignes avec des réponses dans lesquelles l'utilisateur remplit (dans ce cas, encerclé). Exemple:

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

Comme vous pouvez le voir, il s'agit de la question 1 avec le choix de réponse asélectionné car il y a une boîte autour. Pour relever le défi, vous recevrez un scan-tron avec des nquestions ( 1 <= n <= 10) avec seulement quatre réponses notée a, b, cou d. La clé de réponse sera donnée sous la forme d'une chaîne sans espaces et en minuscules. Exemple de scan-tron avec corrigé:

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

Answer Key
abb

Vous pouvez prendre la clé de réponse et scan-tron comme entrées séparées ou dans un ordre choisi tant qu'elles peuvent être identifiées (c'est-à-dire que la clé de réponse est séparée de la scan-tron). Les scores seront arrondis au dixième de point le plus proche. Exemple de sortie pour ce qui précède:

Score: 66.7
Missed #: 3

Une autre réponse acceptable serait:

66.7 
3

ou si plusieurs questions sont manquées

66.7
3 4 5

tant que les numéros de question pour ceux manqués sont séparés des espaces par et non sur la même ligne que le score.

Règles et spécifications

• Le scan-tron peut être entré comme une chaîne multi-lignes ou une question à la fois (comme une chaîne avec des retours à la ligne est acceptable)
• Étant donné un scan-tron et une clé de réponse, vous devez afficher le score sur une ligne et la ou les questions manquées sur une autre, les nombres étant séparés par des espaces. Si aucune question n'est manquée, aucun numéro de question ne doit être fourni
• Les scores sont arrondis au dixième près

• Les réponses sélectionnées sont entourées de cette case:

  ---
  | |
  ---
  

• Sur le scan-tron, chaque question prend trois espaces (le haut et le bas de la boîte prennent deux lignes supplémentaires)
• Doit fonctionner pour l'exemple ci-dessus
• Supposons qu'il n'y aura toujours qu'une seule réponse dans une case

Critères gagnants

Le code le plus court gagne!

05AB1E , 43 octets

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

Essayez-le en ligne!

Explication

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

Empilé , 68 + 1 = 69 octets

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

Essayez-le en ligne! +1 pour le -pdrapeau (ce script peut être exécuté comme stacked -pe "...")

Prend deux entrées du haut de la pile.

Quelques fonctionnalités intéressantes:

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

Cela donne toutes les lettres entourées de tuyaux.

: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

Cela nous donne tous les numéros de questions incorrects.

Python 2 , 94 93 octets

^{-1 octet grâce à 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

Essayez-le en ligne!

Pip , 49 46 44 48 45 octets

Ugh, cet arrondi prend tellement d'octets ... 44 octets de code, +1 pour le -sdrapeau.

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

Prend les entrées en tant qu'arguments de ligne de commande (la page scan-tron devra citer et échapper des sauts de ligne si vous l'exécutez à partir d'une ligne de commande réelle). Sort d'abord les questions manquées, puis le score. Essayez-le en ligne!

Explication

Je vais le faire en deux parties: la liste des questions incorrectes et le score.

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 octets

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

Je pourrais économiser 5 octets en utilisant des virgules et en renvoyant le tout sur une seule ligne:

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

Lot, 242 octets

@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%

Lit d'abord le corrigé sur STDIN, puis les n*3lignes de questions. Remarque: la partition est imprimée sans zéro non significatif si elle est inférieure à 1.0. Les réponses manquées sont imprimées avec un espace de tête.

CJam , 47 45 octets

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

Essayez-le en ligne!

Explication

Le programme se compose de trois parties principales:

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

Après cette section, nous avons un tableau de 0s et 1s, où 0indique une mauvaise réponse et 1une bonne réponse.

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

Après cette section, la pile ne contient que la bonne / mauvaise liste et le score en pourcentage a été généré.

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 octets

Je n'arrive pas à casser 46 octets. J'ai deux solutions de cette longueur. Essayez-en un ici!

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

(Remplacer □par 0x7fdans le suivant)

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

Dans les deux cas, 15 octets pour arrondir: mX*~1/-lζlγlζ_1. Ils sont, pour la plupart, les mêmes, sauf que l'un utilise une correspondance d'expressions régulières pour obtenir les résultats, et l'autre se divise sur les tuyaux.