ग्रेड मेरे स्कैन-ट्रॉन!

Question

मानकीकृत परीक्षण आमतौर पर स्कैन-ट्रॉन या किसी प्रकार के उत्तर दस्तावेज के साथ आता है जो आपके उत्तर को रिकॉर्ड करता है। एक कंप्यूटर या मानव (s) तब आपके उत्तरों की जाँच करेगा और आपके ग्रेड का निर्धारण करेगा। तो यहां, एक स्कैन-ट्रॉन और उत्तर कुंजी को देखते हुए, स्कोर का निर्धारण करें और यदि कोई प्रश्न छूट गया हो। स्कैन-ट्रॉन केवल एक दस्तावेज है जिसमें कई पंक्तियों के साथ उत्तर दिए गए हैं, जिसमें उपयोगकर्ता (इस मामले में, चक्कर लगाता है) भरता है। उदाहरण:

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

जब तक छूटे हुए लोगों के लिए प्रश्न संख्या स्थान से अलग हो जाती है और स्कोर के रूप में उसी पंक्ति पर नहीं।

नियम और विनिर्देश

• स्कैन-ट्रॉन को एक समय में एक बहु-पंक्ति स्ट्रिंग या एक प्रश्न के रूप में इनपुट किया जा सकता है (जैसा कि newlines के साथ एक स्ट्रिंग स्वीकार्य है)
• एक स्कैन-ट्रॉन और उत्तर कुंजी को देखते हुए, आपको स्कोर को एक पंक्ति में और आउटपुट को दूसरे पर याद किया जाना चाहिए, रिक्त स्थान से अलग संख्याओं के साथ। यदि कोई प्रश्न याद नहीं है, तो कोई प्रश्न संख्या आउटपुट नहीं होनी चाहिए
• स्कोर निकटतम दसवें के लिए गोल हैं

• चयनित उत्तर इस बॉक्स से घिरे हैं:

  ---
  | |
  ---
  

• स्कैन-ट्रॉन पर, प्रत्येक प्रश्न में तीन स्थान होते हैं (बॉक्स के ऊपर और नीचे दो अतिरिक्त लाइनें होती हैं)
• उपरोक्त उदाहरण के लिए काम करना चाहिए
• मान लें कि हमेशा केवल एक उत्तर बॉक्सिंग होगा

जीत का मानदंड

सबसे छोटा कोड जीतता है!

Comments

स्कैन-ट्रॉन सवालों की एक सूची हो सकती है? और प्रत्येक प्रश्न newlines के साथ एक ही स्ट्रिंग हो?

— रॉड

@Rod हाँ और मैं स्पष्ट करूंगा कि

— एंथनी फाम

"मिस्ड" की भाषा मेरे लिए भ्रामक है, क्योंकि एक "मिस्ड" प्रश्न का अर्थ एक ऐसा प्रश्न हो सकता है, जो छात्र उत्तर देने में विफल रहा (जैसा कि आपके स्पष्ट अर्थ के विपरीत, गलत तरीके से उत्तर दिया गया )।

— २२:०२ पर DLosc

@DLosc हमेशा एक ही उत्तर दिया जाएगा

— एंथनी फाम

क्या कोई स्कोर 50स्वीकार्य है, या उसे होना चाहिए 50.0?

— DLosc

Answer 1

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

Answer 2

स्टैक्ड , 68 + 1 = 69 बाइट्स

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

इसे ऑनलाइन आज़माएं! -pझंडे के लिए +1 (यह स्क्रिप्ट इस रूप में निष्पादित की जा सकती है 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

यह हम सभी को गलत प्रश्न संख्या देता है।

Answer 3

पायथन 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

इसे ऑनलाइन आज़माएं!

Comments

अच्छा है, मेरा बहुत अच्छा है। आप बदल सकते हैं 100.के साथ1e2

— L3viathan

मुझे विश्वास नहीं है कि यह "एक बिंदु के निकटतम दसवें," स्कोर को गोल करने की आवश्यकता को पूरा करता है?

— DLosc

Answer 4

पिप , 49 46 44 48 45 बाइट्स

उह, उस गोलाई में बहुत सारे बाइट्स लगते हैं ... कोड के 44 बाइट्स, -sझंडे के लिए +1 ।

(/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)

Answer 5

जावास्क्रिप्ट (ईएस 6), 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

Answer 6

बैच, 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। एक प्रमुख स्थान के साथ छूटे हुए उत्तर छपे हैं।

Answer 7

सीजेएम , 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

इस खंड के बाद, हम की एक सरणी है 0और 1रों है, जहां 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

Answer 8

जोल्फ, 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:। वे सबसे अधिक भाग के लिए हैं, वही, सिवाय एक को परिणाम प्राप्त करने के लिए एक रेगेक्स मैच का उपयोग करता है, और दूसरा पाइप पर विभाजन करता है।