ฉันทำ IMC ในปีนี้ มีคนอื่นที่นี่ทำหรือไม่

ในกระดาษ UKMT Intermediate Maths Challenge มีคำถามยี่สิบห้าคำถาม คำถามสิบห้าข้อแรกให้คะแนนห้าคะแนนถ้าคุณทำให้ถูกต้อง สำหรับอีกสิบคำถามคุณจะได้รับหกคะแนนเพื่อทำให้ถูกต้อง ในสิบคำถามสุดท้ายคุณจะเสียคะแนนถ้าคุณทำผิด! สำหรับคำถามที่สิบหกถึงยี่สิบคุณสูญเสียหนึ่งคะแนนและสำหรับคำถามห้าข้อสุดท้ายคุณเสียสองคะแนน หากคุณปล่อยคำถามว่างไว้จะไม่มีการให้คะแนนหรือหักคะแนน ไม่มีการหักคะแนนใด ๆ สำหรับคำถามสิบห้าข้อแรกที่ผิด กระดาษมีหลายทางเลือก คุณสามารถเลือกคำตอบจาก A, B, C, D และ E สำหรับแต่ละคำถาม มีเพียงคำตอบเดียวที่ถูกต้องสำหรับคำถามแต่ละข้อ

สร้างโปรแกรม / ฟังก์ชั่นที่รับสองสายและให้คะแนน สตริงแรกจะเป็นคำตอบของคุณต่อกระดาษ หากคุณข้ามคำถามให้ใช้ช่องว่างไบต์ว่างหรือขีดล่าง มิฉะนั้นให้ใช้ตัวอักษร A, B, C, D หรือ E สำหรับคำตอบ คุณสามารถมีอินพุตเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก สตริงที่สองจะเป็นคำตอบที่ถูกต้องสำหรับคำถามแต่ละข้อในกระดาษ โปรแกรม / ฟังก์ชั่นของคุณจะส่งออกคะแนน ทำให้รหัสของคุณสั้น

กรณีทดสอบ:

DDDDDDDDDDDDDDDDDDDDDDDDD
ABCDEABCDEABCDEABCDEABCDE
15

BDBEACCECEDDBDABBCBDAEBCD
BDBEACCECEDDBDABBCBDAEBCD
135

DBACBDCDBAEDABCDBEECACDC_
DBADBDCDBAEDABCDBEEDACDCA
117

_________________________
DABDABDABDABDABDABDABDABD
0

DBADBDCDBAEDABCD_E__A__C_
DBADBDCDBAEDABCDBEEDACDCA
99

_______________BBBBBBBBBB
AAAAAAAAAAAAAAAAAAAAAAAAA
-15

C, 88 87 86 81 ไบต์

c,d;i(char*a,char*b){for(c=d=0;*b;c++,a++)d+=*a^*b++?*a?-c/15-c/20:0:5+c/15;d=d;}

ลองออนไลน์!

เยลลี่ , 26 23 22 ไบต์

=s5ị"“HHHQP‘D¤_2Fæ.n⁶¥

ลองออนไลน์!

มันทำงานอย่างไร

=s5ị"“HHHQP‘D¤_2Fæ.n⁶¥  Main link. Argument: t (answer to test), s (answer sheet)

=                       Test the characters of t and s for equality.
 s5                     Split into chunks of length 5.
             ¤          Combine the two preceding links into a niladic chain.
     “HHHQP‘              Yield the code points, i.e., [72, 72, 72, 81, 80].
            D             Decimal; yield [[7, 2], [7, 2], [7, 2], [8, 1], [8, 0]].
   ị"                   Index zipwith; use the Booleans in each chunk to index into
                        the corresponding pair. Indexing is 1-based and modular, so
                        1 gives the first element and 0 the last.
              _2        Subtract 2 from each result.
                F       Flatten the resulting 5x5 matrix.
                     ¥  Combine the two preceding links into a dyadic chain.
                   n⁶     Test the characters of t for inequality with space.
                 æ.     Take the dot product of the integers to the left and the
                        Booleans to the right.

JavaScript (ES6), 70 68 66 ไบต์

บันทึก 2 ไบต์ขอบคุณ Neil
บันทึก 2 ไบต์ขอบคุณ ETHproductions

นำคำตอบที่ผู้ยื่นคำขอaและคำตอบที่ถูกต้องในไวยากรณ์ความดีความชอบc (a)(c)คาดว่าคำถามที่ข้ามไปจะถูกทำเครื่องหมายด้วยเว้นวรรค

a=>c=>a.replace(/\S/g,(a,i)=>s+=a==c[j=i>14,i]?5+j:-j^i>19,s=0)&&s

กรณีทดสอบ

let f =

a=>c=>a.replace(/\S/g,(a,i)=>s+=a==c[j=i>14,i]?5+j:-j^i>19,s=0)&&s

console.log(f
  ("DDDDDDDDDDDDDDDDDDDDDDDDD")
  ("ABCDEABCDEABCDEABCDEABCDE")
);
console.log(f
  ("BDBEACCECEDDBDABBCBDAEBCD")
  ("BDBEACCECEDDBDABBCBDAEBCD")
);
console.log(f
  ("DBACBDCDBAEDABCDBEECACDC ")
  ("DBADBDCDBAEDABCDBEEDACDCA")
);
console.log(f
  ("                         ")
  ("DABDABDABDABDABDABDABDABD")
);
console.log(f
  ("DBADBDCDBAEDABCD E  A  C ")
  ("DBADBDCDBAEDABCDBEEDACDCA")
);
console.log(f
  ("               BBBBBBBBBB")
  ("AAAAAAAAAAAAAAAAAAAAAAAAA")
);

Python 2 , 86 85 83 77 ไบต์

f=lambda t,s,i=24:~i and(i/10*-(14<i<t[i]<'_'),5+i/15)[t[i]==s[i]]+f(t,s,i-1)

ลองออนไลน์!

มันทำงานอย่างไร

นี่เป็นการกำหนดฟังก์ชันแบบเรียกซ้ำfซึ่งรับอาร์กิวเมนต์ที่ไม่เหมาะสมสองข้อ: t (คำตอบสำหรับการทดสอบ) และs (แผ่นคำตอบ) เมื่อเรียกเฉพาะกับทั้งสองมีปากเสียงฉเริ่มต้นผมจะ24ดัชนีสุดท้ายของทั้งเสื้อและs

ทุกครั้งที่มีการเรียกfมันจะตรวจสอบก่อนว่า~ i (bitwise NOT ของi ) เป็นความจริง / ไม่เป็นศูนย์ ตั้งแต่~ (-1) = 0นี้เกิดขึ้นเมื่อฉันถึงค่า-1 ถ้าi = -1 , ~ i = 0จะถูกส่งกลับ แต่เมื่อฉันรับค่าจาก24ถึง0 (ดัชนีทั้งหมดของtและs ) รหัสต่อไปนี้andจะถูกดำเนินการและfส่งคืนผลลัพธ์

ในขณะที่ฉันไม่เป็นลบ ครั้งแรก

(i/10*-(14<i<t[i]<'_'),5+i/15)

สร้างความยาวของ tuple 2 :

• เชาวน์i/10เป็น0ถ้า0 ≤ฉัน <10 , 1ถ้า10 ≤ฉัน <20และ2ถ้า20 ≤ฉัน <25 การเปรียบเทียบที่ถูกล่ามโซ่14<i<t[i]<'_'จะส่งกลับค่าTrueหากและเฉพาะเมื่อการเปรียบเทียบแต่ละรายการกลับเป็นTrueเช่นถ้าและเฉพาะเมื่อi ≥ 15 (ช่วงของคำถามที่มีการลงโทษ) ฉันมีขนาดเล็กกว่าt [i] (จริงเสมอเนื่องจากตัวเลขทั้งหมดมีขนาดเล็กกว่า iterables ทั้งหมดใน Python 2) และt [i]ไม่ใช่ขีดล่าง

  หากเปรียบเทียบผลตอบแทนที่เป็นเท็จที่เอก-ผลตอบแทน0และประเมินการแสดงออกทั้งหมด0 อย่างไรก็ตามถ้าการเปรียบเทียบส่งกลับเป็นTrue unary -จะส่งกลับ-1ดังนั้นนิพจน์ทั้งหมดจะประเมินเป็น0ถ้า0 ≤ i <10 , -1ถ้า10 ≤ i <20และ-2ถ้า20 ≤ i <25 ; เหล่านี้เป็นผลสุทธิสำหรับคำตอบที่ไม่ถูกต้องหรือขาดหายไปสำหรับดัชนีทั้งหมดฉัน

• 5+i/15ผลตอบแทนที่5 + 0 = 5ถ้า0 ≤ฉัน <15และ5 + 1 = 6ถ้า15 ≤ฉัน <25 เหล่านี้เป็นผลสุทธิสำหรับคำตอบที่ถูกต้องสำหรับทุกดัชนีฉัน

สุดท้าย[t[i]==s[i]]เลือกองค์ประกอบแรกของ tuple สร้างถ้าt [ผม]และs [ผม]แตกต่างกัน (ผิดหรือคำตอบที่หายไป) และคนที่สองถ้าพวกเขามีค่าเท่ากัน (คำตอบที่ถูกต้อง) แล้วเพิ่มค่าตอบแทนของฉเรียกว่ามี decremented ฉันถึงผลลัพธ์นั้น เมื่อฉันถึง-1 , คะแนนสุดท้ายได้รับการคำนวณและถูกส่งกลับโดยฉ

Mathematica, 114 ไบต์

Tr@(m=MapThread)[#/.True->#2/.False->-#3&,{Tr/@Partition[m[Equal,#/."_"->u]/.u==_->0,5],{5,5,5,6,6},{0,0,0,1,2}}]&

ฟังก์ชั่นการถ่ายรายการของตัวละครและสั่งกลับจำนวนเต็ม m[Equal,#/."_"->u]ส่งคืนรายการบูลีนยกเว้นรายการที่ไม่ได้ประเมินค่าของแบบฟอร์มu=="B"ในสถานที่ที่คำตอบเท่ากับ"_"; จากนั้นทันทีu==_->0เปลี่ยนรายการที่ไม่ได้ประเมินเหล่านั้นเป็น0s Tr/@Partition[...,5]เพิ่มรายการเหล่านี้ครั้งละ 5 รายการทำให้เกิดรายการเช่น{4False+True, 4False+True, 4False+True, 4False+True, 4False+True}สำหรับกรณีทดสอบครั้งแรกหรือ{5True, 5True, 5True, 2True, 2True}สำหรับกรณีทดสอบล่าสุด จากนั้นในแต่ละพิกัดTrueและFalseถูกแมปไปยังคะแนนที่เหมาะสมและผลลัพธ์จะถูกรวมเข้าด้วยกัน

เยลลี่ , 22 21 ไบต์

Zm0ṁ135µ;t€⁶E€’;E€ṫ⁹S

ลองออนไลน์!

ฉันคิดว่าคำตอบของ @ Dennis น่าจะเอาชนะได้ และหลังจากลองใช้ความเป็นไปได้ที่แตกต่างกันจำนวนมากและได้รับประโยชน์จากความบังเอิญที่น่าทึ่งฉันก็จัดการมันในที่สุด

โปรแกรมนี้ใช้คู่ [คำตอบของนักเรียนคำตอบที่ถูกต้อง] เป็นอินพุตและใช้ช่องว่างเพื่อระบุคำตอบที่หายไป

คำอธิบาย

โปรแกรมนี้ใช้รูปแบบอินพุตภายในที่แปลกประหลาดบางอย่างเพื่อติดตามสิ่งที่เกิดขึ้นดังนั้นเราจะดำเนินการทีละขั้นตอน

1. Z

   นี่เป็นการแปลงอินพุตดังนั้นเราจะจบลงด้วยรายการ 25 องค์ประกอบหนึ่งรายการสำหรับแต่ละคำถาม แต่ละองค์ประกอบมีรูปแบบ [คำตอบของนักเรียนคำตอบที่ถูกต้อง] เราจะระบุองค์ประกอบของแบบฟอร์มนี้ด้วยอักษรตัวใหญ่; Aสำหรับคำถามที่ 1 Bสำหรับคำถามที่ 2 และอื่น ๆ ดังนั้นคำตอบจะถูกเก็บไว้เป็น

   ABCDEFGHIJKLMNOPQRSTUVWXY
   

2. m0

   นี่เป็นการดำเนินการ "palindrome ที่มากกว่า" เราผนวกการย้อนกลับของค่าปัจจุบันกับค่าของมันเองโดยให้สิ่งนี้:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   

3. ṁ135

   ตัวดำเนินการṁ(โมลด์) ทำสิ่งต่าง ๆ มากมาย แต่ในบริบทนี้มันใช้องค์ประกอบ 135 รายการแรกของรายการที่ไม่มีที่สิ้นสุดที่สร้างขึ้นโดยผนวกค่าปัจจุบันเข้ากับตัวเองอย่างต่อเนื่อง ที่ให้เราต่อไปนี้ (ซึ่งฉันแบ่งออกเป็น 50 กลุ่มเพื่อความสะดวกนี่เป็นเพียงรายการภายใน 135 คู่ภายใน):

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

4. µ;

   µตั้งค่าปัจจุบันเป็นค่าเริ่มต้นใหม่สำหรับตัวถูกดำเนินการหายไป จากนั้นเราจะเห็นตัวบิวอินในทันทีที่ไม่มีตัวถูกดำเนินการ ;ผนวก แต่เราไม่ได้ระบุสิ่งที่จะผนวก ดังนั้นค่าปัจจุบันจะถูกผนวกเข้ากับค่าล่าสุดµ(ซึ่งเป็นค่าปัจจุบันด้วย) ทำให้เรามีค่าปัจจุบัน 270 องค์ประกอบต่อไปนี้:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQP
   

5. t€⁶

   โปรดจำไว้ว่าตัวพิมพ์ใหญ่ทั้งหมดข้างต้นแสดงถึงคู่ของ [คำตอบของนักเรียนคำตอบที่ถูกต้อง] การt€⁶ทำงานดำเนินการกับแต่ละ ( €) คู่และลบ ( t) ช่องว่าง ( ⁶) จากทั้งสองด้านของคู่ (เช่นช่องว่างใด ๆ ที่ปรากฏในคู่) ดังนั้นเราจึงยังคงมีรายการคำถามที่ซับซ้อนจำนวน 270 คำถามที่มีการทำซ้ำหลายครั้ง แต่พวกเขาอยู่ในรูปแบบ [คำตอบที่ถูกต้อง] (นักเรียนไม่ตอบ) หรือ [คำตอบของนักเรียนคำตอบที่ถูกต้อง] (นักเรียนตอบแล้ว)

6. E€’

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

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqp
   

7. ;E€

   เราเคยเห็นทั้งก่อนE€และ;หลัง; เรากำลังต่อท้ายบางอย่างกับค่าปัจจุบันและเราใช้รูปแบบ 1 ถ้าองค์ประกอบทั้งหมดเท่ากันหรือ 0 ถ้าบางอย่างแตกต่างกัน (ไม่มี’ในเวลานี้!) มีตัวถูกดำเนินการที่ขาดหายไปที่นี่ดังนั้นเราจึงใช้ค่าล่าสุดµ(เช่นผลลัพธ์ของขั้นตอนที่ 3) ย้อนกลับไปในขั้นตอนที่ 3 เราไม่ได้ลบช่องว่างออกจากองค์ประกอบดังนั้นเราจะมี 1 สำหรับคำตอบที่ถูกต้องหรือ 0 สำหรับคำตอบที่ไม่ถูกต้องหรือขาดหายไป (เนื่องจากช่องว่างไม่ตรงกับคำตอบที่ถูกต้อง) จากนี้ไปฉันจะใช้ตัวพิมพ์ใหญ่สำหรับ 1 = ถูกต้อง, 0 = รูปแบบที่ไม่ถูกต้อง / หายไปและใช้ตัวอักษรตัวพิมพ์เล็กต่อไปสำหรับ 0 = ถูกต้อง / หายไป, -1 = ไม่ถูกต้อง ค่าผลลัพธ์มีองค์ประกอบ 405 รายการและมีลักษณะดังนี้:

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQP
   

8. ṫ⁹

   นี่เป็นเรื่องบังเอิญที่น่าอัศจรรย์ที่ฉันพูดถึงมาก่อน ก่อนที่จะพูดถึงรหัสบิตนี้ฉันต้องการเก็บสต็อคที่เราต้องไป

   อักษรตัวใหญ่แต่ละตัวแทน +1 สำหรับคำตอบที่ถูกต้อง 15 คำถามแรก ( Aผ่านO) ปรากฏขึ้น 5 ครั้งในแต่ละข้อความและ 10 คำถามสุดท้าย ( Pผ่านY) ปรากฏขึ้น 6 ครั้งต่อคำถาม บิตนั้นไม่ได้วิเศษจริงๆ ฉันออกแบบมันอย่างนั้นเมื่อฉันเลือกหมายเลข 135 ก่อนหน้านี้ในโปรแกรม (ซึ่งคือ 5 × 15 + 6 × 10) และจังหวะแห่งโชคเดียวที่นี่คือ 5 เกิดขึ้นเป็นเลขคี่ (ดังนั้นจึงเป็น 10 ครั้งสุดท้าย คำถามที่ปรากฏในช่วงต่อเวลาพิเศษมากกว่า 10 ข้อแรก) 15 ตัวอักษรทันทีก่อนหน้านี้มีpผ่านt(คำถาม -1 โทษ) ครั้งและuผ่านy(คำถาม -2 โทษ) สองครั้ง นั่นไม่ใช่เรื่องบังเอิญเช่นกัน เพราะเราใช้m0ก่อนหน้านี้สำเนาเพิ่มเติมของคำถามอยู่ในลำดับPQRSTUVWXYYXWVUTSRQPและคำถามที่ตามมาจะเกิดขึ้นใกล้กับกึ่งกลางของสตริงนั้น (ดังนั้นการใช้คำถาม "พิเศษ" 15 ข้อสุดท้ายจะทำให้ซ้ำคำถามที่ใกล้ขอบน้อยลงและ แน่นอนว่าไม่ใช่คำถามที่น่าแปลกใจว่าคำถามพิเศษจะมาเป็นคำถามสุดท้าย

   เนื่องจากตัวอักษรตัวเล็กแต่ละตัวลบ 1 จากคะแนนสำหรับคำตอบที่ไม่ถูกต้องและไม่หายไปและตัวอักษรตัวพิมพ์ใหญ่แต่ละตัวเพิ่ม 1 คะแนนสำหรับคำตอบที่ถูกต้องดังนั้นเราจึงจำเป็นต้องใช้องค์ประกอบ 135 + 15 = 150 ครั้งสุดท้ายเพื่อให้ได้ องค์ประกอบแต่ละประเภทมีจำนวนครั้งที่ถูกต้อง คำสั่งของวุ้นสำหรับการรับสายอักขระย่อยที่ส่วนท้ายของรายการคือṫ; อย่างไรก็ตามมันไม่ได้ระบุจำนวนองค์ประกอบที่คุณต้องการ แต่เป็นดัชนีขององค์ประกอบแรกที่คุณต้องการ เรามีองค์ประกอบ 405 ณ จุดนี้และต้องการ 150 ดังนั้นเราต้องเริ่มที่ดัชนี (405 - 150 + 1) หรือ 256 ในเรื่องบังเอิญที่น่าทึ่ง 256 เกิดขึ้นเป็นจำนวนออคเต็ตที่แตกต่างกันซึ่งมีอยู่ การเป็นตัวแทนระยะสั้นใน Jelly (⁹) มีน้อยมากที่ฉันสามารถทำได้เพื่อทำให้สิ่งนี้เกิดขึ้น; ขั้นตอนที่ 4 เพิ่มองค์ประกอบอีก 135 รายการเข้าไปที่จุดเริ่มต้นของรายการเพื่อให้ได้จำนวนรอบ แต่ความจริงที่ว่ามันคือ 135 องค์ประกอบที่ฉันต้องเพิ่ม (ค่าที่พร้อมใช้งาน ณ จุดนั้นในโปรแกรม) นั้นสะดวกมาก โดยพื้นฐานแล้วหมายเลขอื่นใดที่ไม่ช่วยเหลืออย่างสมบูรณ์ในสถานการณ์นี้

   นี่คือลักษณะของค่าภายในตอนนี้:

   uvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

9. S

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

Python 2 , 93 91 bytes

f=lambda a,b,n=0:a>""and((a[0]==b[0])*(5+n/15)or-(n/15*n/10)*(a[0]<"^"))+f(a[1:],b[1:],n+1)

ลองออนไลน์!

-2 ไบต์ขอบคุณ @KritixiLithos

การป้อนข้อมูล:

• a: คำตอบของนักเรียนเป็นสตริง_สำหรับคำถามที่ข้ามไป
• b : คำตอบที่ถูกต้อง
• n: จำนวนคำถามปัจจุบันที่0ใช้ค่าเริ่มต้นเป็น0

k, 52 ไบต์

ฟังก์ชั่นใช้เวลา 2 สายรูปแบบต่อกรณีทดสอบ

{+/(~x="_")*(+,/'(15 5 5#'0 -1 -2;15 10#'5 6))@'x=y}

ตัวอย่าง:

k){+/(~x="_")*(+,/'(15 5 5#'0 -1 -2;15 10#'5 6))@'x=y}["DBADBDCDBAEDABCD_E__A__C_";"DBADBDCDBAEDABCDBEEDACDCA"]
99

Haskell, 84 ไบต์

i x a b|a>'Z'=0|a==b=6-0^x|1<2= -x
w x=x<$[1..5*3^0^x]
(sum.).zipWith3 i(w=<<[0..2])

ตัวอย่างการใช้งาน: ->((sum.).zipWith3 i(w=<<[0..2])) "DBADBDCDBAEDABCD_E__A__C_" "DBADBDCDBAEDABCDBEEDACDCA" ลองออนไลน์! .99

มันทำงานอย่างไร: i x a bคำนวณคะแนนสำหรับคำตอบเดียวaด้วยผลลัพธ์ที่ถูกต้องbและโทษxสำหรับคำตอบที่ผิด (ค่าที่ไม่เป็นลบ) ถ้าคุณข้าม ( a>'Z') คะแนนคือ0ถ้าคำตอบที่ถูกต้อง ( a==b) คะแนนคืออื่นคะแนนคือ6-0^x-x

w=<<[0..2]ทำให้รายการของการลงโทษทั้งหมด 25 คำถามโดยใช้wการ0, 1และ2นั่นคือการทำ5*3^0^xสำเนาของแต่ละหมายเลข (-> 15 ครั้ง0, 5 ครั้ง1และครั้งที่ 5 2)

zipWith3นำiไปใช้กับรายการของการลงโทษรายการคำตอบและรายการผลลัพธ์ที่ถูกต้อง ในที่สุดคะแนนทั้งหมดจะถูกเพิ่ม ( sum)

อ็อกเทฟ61 61ไบต์

@(a,b)[a==b,-(a<95&a~=b)]*[(x=1:25>15)+5,(1:25>20)+x]'

ลองออนไลน์!

คำตอบก่อนหน้า:

@(a,b)(m=a==b)*(((f=kron(z=[0 0 0:2],z|1)')&1)+5)-(a<95&~m)*f

JavaScript (ES6), 105 103 101 94 89 88 85 84 78 77 77 ไบต์

ทางออกแรกของฉันใน ES6 อาจเป็นครั้งแรกใน Javascript Oo

f=(s,a,i=24)=>i+1&&(s[i]>'Z'?0:s[i]==a[i]?5+(i>14):~(i>19)*(i>14))+f(s,a,i-1)

sคือทางออกที่ส่งมาและaเป็นวิธีแก้ไขที่ถูกต้อง ทั้งสองจะถูกนำมาเป็นสตริง

ต่อไปนี้เป็นโซลูชันที่ไม่เรียกซ้ำที่ 78 ไบต์:

s=>a=>eval([...s].map((c,i)=>c>'Z'?0:c==a[i]?5+(i>14):~(i>19)*(i>14)).join`+`)

รับอินพุตผ่านทางไวยากรณ์การแกง

ขอบคุณ@ETHproductionsสำหรับการบันทึก 9 ไบต์! s[i]ไปcและ(-1-(i>19|0))ไป~(i>19)การ

ขอบคุณ@Kritixi Lithosสำหรับการบันทึกไบต์! ไปยังc=='_'c>'Z'

ลองออนไลน์!