Kiểm tra tiêu chuẩn thường đi kèm với quét tron ​​hoặc một số loại tài liệu trả lời ghi lại câu trả lời của bạn. Sau đó, một máy tính hoặc con người sẽ kiểm tra câu trả lời của bạn và xác định điểm số của bạn. Vì vậy, ở đây, đưa ra một quét-tron và phím trả lời, xác định điểm số và câu hỏi bỏ lỡ nếu có. Quét-tron chỉ là một tài liệu có nhiều dòng với câu trả lời mà người dùng điền vào (trong trường hợp này, được khoanh tròn). Thí dụ:

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

Như bạn có thể thấy, đây là câu hỏi 1 với lựa chọn câu trả lời ađược chọn vì nó có một hộp xung quanh nó. Đối với các thách thức, bạn sẽ nhận được một quét-tron với ncâu hỏi ( 1 <= n <= 10) với chỉ có bốn câu trả lời ký hiệu là a, b, c, hoặc d. Khóa trả lời sẽ được cung cấp dưới dạng một chuỗi không có khoảng trắng và với tất cả chữ thường. Ví dụ quét-tron với phím trả lời:

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

Answer Key
abb

Bạn có thể lấy khóa trả lời và quét tron ​​làm đầu vào riêng biệt hoặc theo thứ tự đã chọn miễn là chúng có thể được xác định (nghĩa là khóa trả lời được tách ra khỏi quét-tron). Điểm số sẽ được làm tròn đến một phần mười của điểm gần nhất. Ví dụ đầu ra cho ở trên:

Score: 66.7
Missed #: 3

Câu trả lời chấp nhận khác sẽ là:

66.7 
3

hoặc nếu nhiều câu hỏi bị bỏ lỡ

66.7
3 4 5

miễn là số câu hỏi cho những người bỏ lỡ được phân tách bằng khoảng trắng và không nằm trên cùng một dòng với điểm số.

Quy tắc và thông số kỹ thuật

• Quét tron ​​có thể được nhập vào dưới dạng một chuỗi nhiều dòng hoặc một câu hỏi tại một thời điểm (vì một chuỗi có dòng mới được chấp nhận)
• Đưa ra một phím quét và câu trả lời, bạn phải xuất điểm trên một dòng và (các) câu hỏi bị bỏ lỡ trên một dòng khác, với các số được phân tách bằng dấu cách. Nếu không có câu hỏi nào bị bỏ lỡ, không có số câu hỏi nào được xuất ra
• Điểm số được làm tròn đến phần mười gần nhất

• Các câu trả lời được chọn được bao quanh bởi ô này:

  ---
  | |
  ---
  

• Trên quét-tron, mỗi câu hỏi mất ba khoảng trắng (trên cùng và dưới cùng của hộp có thêm hai dòng)
• Phải làm việc cho ví dụ trên
• Giả sử rằng sẽ luôn có một câu trả lời được đóng hộp

Tiêu chí chiến thắng

Mã ngắn nhất sẽ thắng!

05AB1E , 43 byte

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

Hãy thử trực tuyến!

Giải trình

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

Xếp chồng lên nhau , 68 + 1 = 69 byte

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

Hãy thử trực tuyến! +1 cho -pcờ (tập lệnh này có thể được thực thi dưới dạng stacked -pe "...")

Lấy hai đầu vào từ đầu ngăn xếp.

Một số tính năng thú vị:

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

Điều này mang lại tất cả các chữ cái được bao quanh bởi các đường ống.

: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

Điều này cung cấp cho chúng tôi tất cả các số câu hỏi không chính xác.

Python 2 , 94 93 byte

^{-1 byte nhờ 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

Hãy thử trực tuyến!

Pip , 49 46 44 48 45 byte

Ugh, làm tròn đó cần rất nhiều byte ... 44 byte mã, +1 cho -scờ.

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

Đưa đầu vào dưới dạng đối số dòng lệnh (trang quét tron ​​sẽ cần trích dẫn và thoát dòng mới nếu bạn chạy nó từ một dòng lệnh thực tế). Đưa ra các câu hỏi bỏ lỡ đầu tiên, sau đó là điểm số. Hãy thử trực tuyến!

Giải trình

Tôi sẽ làm điều này trong hai phần: danh sách câu hỏi không chính xác và điểm số.

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

Tôi có thể lưu 5 byte bằng cách sử dụng dấu phẩy và trả lại mọi thứ một dòng:

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

Hàng loạt, 242 byte

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

Đọc trong phím trả lời trên STDIN trước, sau đó là n*3các hàng câu hỏi. Lưu ý: Điểm được in mà không có số 0 đứng đầu nếu nó nhỏ hơn 1.0. Câu trả lời bị bỏ lỡ được in với một không gian hàng đầu.

CJam , 47 45 byte

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

Hãy thử trực tuyến!

Giải trình

Chương trình gồm ba phần chính:

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

Sau phần này, chúng ta có một mảng 0s và 1s, trong đó 0chỉ ra một câu trả lời sai và 1một câu trả lời đúng.

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

Sau phần này, ngăn xếp chỉ chứa danh sách đúng / sai và điểm phần trăm đã được xuất ra.

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 byte

Tôi dường như không thể phá vỡ 46 byte. Tôi có hai giải pháp về độ dài này. Hãy thử một cái ở đây!

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

(Thay thế □bằng 0x7fcái tiếp theo)

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

Trong cả hai trường hợp, 15 byte để làm tròn : mX*~1/-lζlγlζ_1. Hầu hết chúng đều giống nhau, ngoại trừ một người sử dụng kết hợp regex để lấy kết quả và các phần khác trên đường ống.