การทดสอบที่ได้มาตรฐานมักจะมาพร้อมกับสแกน - ตรอนหรือเอกสารคำตอบบางประเภทที่บันทึกคำตอบของคุณ คอมพิวเตอร์หรือมนุษย์จะตรวจสอบคำตอบและตรวจสอบเกรดของคุณ ดังนั้นที่นี่รับสแกนตรอนและคีย์คำตอบกำหนดคะแนนและคำถามที่พลาดถ้ามี สแกนตรอนเป็นเพียงเอกสารที่มีหลายบรรทัดพร้อมคำตอบที่ผู้ใช้กรอก (ในกรณีนี้คือวงกลม) ตัวอย่าง:

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

อย่างที่คุณเห็นนี่คือคำถาม 1 ที่มีตัวเลือกคำตอบที่aเลือกเนื่องจากมีกล่องอยู่รอบ ๆ สำหรับความท้าทายที่คุณจะได้รับการสแกนทรอนกับnคำถาม ( 1 <= n <= 10) มีเพียงสี่คำตอบที่แสดงเป็นa, b, หรือc dคีย์คำตอบจะได้รับเป็นสตริงที่ไม่มีช่องว่างและมีตัวพิมพ์เล็กทั้งหมด ตัวอย่างสแกนตรอนพร้อมคำตอบสำคัญ:

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

Answer Key
abb

คุณสามารถรับคีย์คำตอบและสแกนตรอนเป็นอินพุตแยกต่างหากหรือในลำดับที่เลือกตราบเท่าที่พวกเขาสามารถระบุได้ (เช่นคีย์คำตอบถูกแยกออกจากสแกนตรอน) คะแนนจะถูกปัดเศษเป็นสิบที่ใกล้ที่สุดของจุด ตัวอย่างเอาต์พุตด้านบน:

Score: 66.7
Missed #: 3

คำตอบที่ยอมรับอื่น ๆ จะเป็น:

66.7 
3

หรือหากพลาดคำถามหลายข้อ

66.7
3 4 5

ตราบใดที่หมายเลขคำถามสำหรับผู้ที่พลาดจะถูกแยกออกจากช่องว่างโดยไม่ได้อยู่ในบรรทัดเดียวกันกับคะแนน

กฎและข้อกำหนด

• การสแกนตรอนสามารถป้อนเป็นสตริงหลายบรรทัดหรือหนึ่งคำถามในเวลา (เป็นสตริงที่มีการขึ้นบรรทัดใหม่เป็นที่ยอมรับ)
• ด้วยคีย์สแกน - ตรอนและคำตอบคุณต้องส่งคะแนนในหนึ่งบรรทัดและคำถามอื่นที่พลาดโดยแยกตัวเลขด้วยช่องว่าง หากไม่มีคำถามใด ๆ จะไม่สามารถแสดงหมายเลขคำถามได้
• คะแนนจะถูกปัดเศษเป็นสิบที่ใกล้ที่สุด

• คำตอบที่เลือกจะถูกล้อมรอบด้วยกล่องนี้:

  ---
  | |
  ---
  

• ในการสแกนตรอนคำถามทุกข้อใช้เวลาสามช่องว่าง (ด้านบนและด้านล่างของกล่องใช้สองบรรทัดพิเศษ)
• ต้องใช้กับตัวอย่างด้านบน
• สมมติว่าจะมีกล่องคำตอบเดียวเท่านั้นเสมอ

เกณฑ์การชนะ

รหัสที่สั้นที่สุดชนะ!

05AB1E , 43 ไบต์

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

ลองออนไลน์!

คำอธิบาย

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

ซ้อนกัน , 68 + 1 = 69 ไบต์

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

ลองออนไลน์! +1 สำหรับการ-pตั้งค่าสถานะ (สคริปต์นี้สามารถดำเนินการในฐานะstacked -pe "...")

รับสองอินพุตจากด้านบนของสแต็ก

คุณสมบัติที่น่าสนใจ:

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

นี่จะทำให้ตัวอักษรทั้งหมดล้อมรอบด้วยท่อ

: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

นี่ทำให้เราทุกคำถามหมายเลขไม่ถูกต้อง

Python 2 , 94 93 ไบต์

^{-1 ไบต์ขอบคุณ 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

ลองออนไลน์!

Pip , 49 46 44 48 45 ไบต์

เอ่อการปัดเศษนั้นใช้ไบต์จำนวนมาก ... 44 ไบต์ของโค้ด +1 สำหรับ-sแฟล็ก

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

รับอินพุตเป็นอาร์กิวเมนต์บรรทัดคำสั่ง (หน้าสแกนตรอนจะต้องมีการอ้างอิงและหลบเลี่ยงการขึ้นบรรทัดใหม่หากคุณเรียกใช้จากบรรทัดคำสั่งจริง) แสดงผลคำถามที่ไม่ได้รับก่อนจากนั้นจึงให้คะแนน ลองออนไลน์!

คำอธิบาย

ฉันจะทำเช่นนี้ในสองส่วน: รายการคำถามที่ไม่ถูกต้องและคะแนน

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 ไบต์

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

ฉันสามารถบันทึกได้ 5 ไบต์โดยใช้เครื่องหมายจุลภาคและส่งคืนทุกสิ่งภายในหนึ่งบรรทัด

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

แบตช์ 242 ไบต์

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

อ่านในปุ่มคำตอบบน STDIN ก่อนจากนั้นจึงn*3ถามคำถามแถว หมายเหตุ: 1.0คะแนนจะถูกพิมพ์โดยไม่ต้องเป็นศูนย์ชั้นนำถ้ามันน้อยกว่า คำตอบที่ไม่ได้รับจะถูกพิมพ์ด้วยพื้นที่ชั้นนำ

CJam , 47 45 ไบต์

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

ลองออนไลน์!

คำอธิบาย

โปรแกรมอยู่ในสามส่วนหลัก:

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

หลังจากส่วนนี้เรามีอาร์เรย์ของ0s และ1s ที่0ระบุคำตอบที่ไม่ถูกต้องและ1คำตอบที่ถูก

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

หลังจากส่วนนี้สแต็กมีเพียงรายการที่ถูก / ผิดและคะแนนร้อยละได้รับการส่งออก

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 ไบต์

ฉันไม่สามารถทำลาย 46 ไบต์ได้ ฉันมีคำตอบสองตัวสำหรับความยาวนี้ ลองที่นี่!

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

(แทนที่□ด้วย0x7fในถัดไป)

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

ในทั้งสองกรณี 15 mX*~1/-lζlγlζ_1ไบต์สำหรับการปัดเศษ: โดยส่วนใหญ่แล้วจะเหมือนกันยกเว้นจะใช้การจับคู่ regex เพื่อให้ได้ผลลัพธ์และการแยกอื่น ๆ บนไพพ์