Mölkky

Mölkkyเป็นเกมการขว้างปาแบบฟินแลนด์ ผู้เล่นใช้ไม้พิน (เรียกอีกอย่างว่า "mölkky") เพื่อพยายามเคาะหมุดไม้ที่มีขนาดใกล้เคียงกับการโยนพินซึ่งมีตัวเลขตั้งแต่ 1 ถึง 12 ตำแหน่งเริ่มต้นของพินมีดังนี้:

   (07)(09)(08)
 (05)(11)(12)(06)
   (03)(10)(04)
     (01)(02)

^{คำอธิบายนี้และกฎระเบียบดังต่อไปนี้จะขึ้นอยู่กับวิกิพีเดีย}

กฎMölkkyประยุกต์

1. การเคาะมากกว่าหนึ่งพินจะทำคะแนนให้ได้ตามจำนวนที่กำหนดไว้บนพิน

2. การเคาะ2 พินขึ้นไปทำคะแนนจำนวนพินที่กระแทก (เช่นการกระแทก 3 พินทำคะแนน 3 คะแนน)

3. เป้าหมายของเกมคือการเข้าถึง50คะแนน การให้คะแนนมากกว่า 50 จะถูกลงโทษโดยกำหนดคะแนนกลับเป็น25คะแนน

4. สำหรับวัตถุประสงค์ของการท้าทายนี้เราจะทำให้สมมติฐานที่ว่าหมุดอยู่เสมอในลำดับที่แน่นอนอธิบายไว้ข้างต้น (ในเกมจริงหมุดจะยืนขึ้นอีกครั้งหลังจากโยนแต่ละครั้งในตำแหน่งที่พวกเขาลงจอด)

กฎของMölkkyอื่น ๆ ทั้งหมดจะถูกละเว้นและพิจารณาผู้เล่นเพียงคนเดียวเท่านั้น

อินพุต

รายการที่ไม่ว่างเปล่าของ 12 บูลีน แต่ละรายการของบูลีนอธิบายผลของการโยน: 1ถ้าพินนั้นล้มลงและ0 เป็นอย่างอื่น booleans จะได้รับในการสั่งซื้อที่แน่นอนของหมุดจากบนซ้ายไปขวาด้านล่าง: 7 , 9 , 8 , 5 , 11 , 12 , 6 , 3 , 10 , 4 , 1 , 2

เอาท์พุต

คะแนนหลังจากทั้งหมดโยนอธิบายในการป้อนข้อมูลซึ่งคำนวณโดยการใช้กฎที่ 1 , 2และ3

ตัวอย่างรายละเอียด

ลองพิจารณาอินพุตต่อไปนี้:

// 07 09 08 05 11 12 06 03 10 04 01 02
[ [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],  // scores 5 (rule #1)
  [ 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],  // scores 2 (rule #2), total: 7
  [ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 ],  // scores 7, total: 14
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],  // scores 12, total: 26
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],  // scores 12, total: 38
  [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],  // scores 11, total: 49
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],  // scores 7, total: 56 -> 25 (rule #3)
  [ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ] // scores 2, total: 27

การส่งออกที่คาดไว้คือ27

กฏท้าทาย

• คุณสามารถป้อนข้อมูลในรูปแบบที่เหมาะสม แทนที่จะเป็นรายการบูลีนคุณสามารถใช้จำนวนเต็มโดยบิตที่สำคัญที่สุดคือพิน # 7 และบิตที่สำคัญน้อยที่สุดคือพิน # 2 [ 256, 2304, 127, 64, 64, 128, 2048, 3072 ]ในรูปแบบนี้ตัวอย่างข้างต้นจะได้รับการส่งผ่านเป็น
• รายการอินพุทอาจมีการโยนโดยไม่มีการพินใด ๆ เลยในกรณีนี้คะแนนจะไม่เปลี่ยนแปลง
• คุณไม่ได้มีอะไรเป็นพิเศษจะทำอย่างไรเมื่อคะแนนถึงตรง 50 คะแนน แต่คุณสามารถสันนิษฐานได้ว่าจะไม่มีการโยนเกิดขึ้นอีกเมื่อเกิดขึ้น
• นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ

การใช้รายการจำนวนเต็มเป็นอินพุต:

[ 0 ] --> 0
[ 528 ] --> 2
[ 4095 ] --> 12
[ 64, 0, 3208 ] --> 16
[ 16, 1907, 2048 ] --> 18
[ 2023, 2010, 1, 8 ] --> 29
[ 1726, 128, 35, 3136, 1024 ] --> 34
[ 32, 32, 2924, 2, 256, 16 ] --> 28
[ 64, 64, 2434, 1904, 3251, 32, 256 ] --> 25
[ 3659, 2777, 2211, 3957, 64, 2208, 492, 2815 ] --> 25
[ 2047, 1402, 2, 2599, 4, 1024, 2048, 3266 ] --> 50
[ 256, 2304, 127, 64, 64, 128, 2048, 3072 ] --> 27
[ 16, 8, 128, 1, 2048, 1, 2048, 513, 8, 3206 ] --> 30

คุณสามารถไปที่ลิงก์นี้เพื่อรับกรณีทดสอบเหล่านี้ในรูปแบบบูลีน

Python 2 , 126 111 108 104 ไบต์

-3 ไบต์ขอบคุณ Jonathan Allan

-4 ไบต์ขอบคุณ Kaya!

f=lambda A,t=0:t>50and f(A,25)or A and f(A[1:],t-~(sum(A[0])-1or 762447093078/12**A[0].index(1)%12))or t

ลองออนไลน์!

กำหนดฟังก์ชันแบบเรียกซ้ำที่ใช้อาร์เรย์ 2 มิติเป็น 1 วินาทีและ 0 วินาทีและส่งกลับค่าจำนวนเต็ม ไม่มีอะไรพิเศษในการก่อสร้างและฉันแน่ใจว่ามีวิธีที่ง่ายกว่า

คำอธิบาย:

f=lambda A,t=0:    #Define the function, initialising t to 0 on the first iteration
               t>50and f(A,25)      #If t>50 then iterate again with t=25
                              or    #Else
               A and                #If A exists
                     f(A[1:],       #Iterate again without the first list of A
                        t-~         #And add to t, either
                           (sum(A[0])-1   #The sum of all elements if that's not 1
                                         or
                           762447093078/12**A[0].index(1)%12   #Else the appropriate pin value (black magic!)
               or t       #Finally, if A is finished, just return t

เยลลี่ 25 ไบต์

“ñ€bḷ’œ?TLḢṖ?µ€+25¹>?50ɗ/

ลิงก์ monadic ยอมรับรายการของรายการและศูนย์ (แต่ละความยาว 12) ซึ่งส่งคืนจำนวนเต็ม

ลองออนไลน์! หรือดูชุดทดสอบ (ใช้ค่าจำนวนเต็มที่กำหนดใน OP)

อย่างไร?

วิธีนี้ทำให้การใช้, œ?ซึ่งได้รับหมายเลข n และรายการพบว่าเอ็น^TH lexicographical การเปลี่ยนแปลงของรายการที่รายการกำหนดลำดับการจัดเรียง ก่อนอื่นเราต้องหาวิธีนี้n:

 index:  1  2  3  4  5  6  7  8  9 10 11 12
 value:  7  9  8  5 11 12  6  3 10  4  1  2   (as defined by the question)
     P: 11 12  8 10  4  7  1  3  2  9  5  6   (our permutation lookup array)

... นั่นคือPที่ดัชนีมีการตั้งค่าดัชนีเดิมของมูลค่าi นี้มีดัชนี lexicographical ของ438337469 (นั่นคือถ้าคุณเอาทั้งหมด12!พีชคณิตของตัวเลข1ที่จะ12และจัดเรียงพวกเขา lexicographically ที่438337469 ^THจะเป็น) นี้อาจจะพบได้โดยใช้เจลลี่ของอะตอม ขั้นตอนทั้งสองอาจทำได้ในครั้งเดียวโดยใช้โปรแกรม Jellyi
PP
Œ¿
ĠŒ¿

“ñ€bḷ’œ?TLḢṖ?µ€+25¹>?50ɗ/ - Link: list of lists of zeros and ones
             µ€           - perform the monadic chain to the left for €ach list:
“ñ€bḷ’                    -   base 250 number = 438337469
      œ?                  -   nth permutation (reorder the 1s and 0s to their pin values)
        T                 -   truthy indices (get the pin values of the 1s)
            ?             -   if...
           Ṗ              -   ...condition: pop (length greater than 1 ?)
         L                -   ...then: length (the number of pins)
          Ḣ               -   ...else: head (the first (& only) pin value)
                        / - reduce the resulting list of integers with:
                       ɗ  -   last three links as a dyad:
               +          -     addition (add the two values together)
                     50   -     literal fifty
                    ?     -     if...
                   >      -     ...condition: greater than (sum greater than 50 ?)
                25        -     ...then: literal twenty-five
                  ¹       -     ...else: identity (do nothing - just yield the sum)

Python 2 , 90 ไบต์

^{แรงบันดาลใจจากPython 2 ของ Jo King ได้รับคำตอบอย่างหนักและใช้ประโยชน์จากความคิดเห็นการเป็นตัวแทนอันดับที่ 12 ของ Kaya}

t=0
for v in input():t+=sum(v)-1or 762447093078/12**v.index(1)%12;t=[t+1,25][t>49]
print t

ลองออนไลน์! หรือดูชุดทดสอบ

Pyth, 51 48 38 ไบต์

VQI>=+Z?qJsN1@.PC"îO&"S12xN1J50=Z25;Z

บันทึก 10 ไบต์ขอบคุณ Jonathan Allan รับข้อมูลเป็นรายการของบูลีน
ลองที่นี่

คำอธิบาย

VQI>=+Z?qJsN1@.PC"îO&"S12xN1J50=Z25;Z
VQ                                  ;     For each input...
    =+Z                                   ... add to the total...
       ?q sN1                             ... if one pin is down...
             @.PC"îO&"S12xN1              ... the score of that pin.
         J                    J           ... otherwise, the count.
  I>                           50         If we pass 50...
                                 =Z25     ... reset to 25.
                                     Z    Output the total.

05AB1E , 29 28 ไบต์

v•CÞŸαLć•13вyOΘmyÏOO25‚¬50›è

ลองออนไลน์!

คำอธิบาย

v                              # for each boolean list in input
 •CÞŸαLć•                      # push 13875514324986
         13в                   # convert to a list of base-13 numbers
            yO                 # push the sum of y
              Θm               # truthify and raise the pin-list to this number (0 or 1)
                yÏ             # keep those which are true in the current list
                  OO           # sum the list and the stack
                    25‚        # pair with 25
                       ¬50›    # check if the first number is larger than 50
                           è   # index into the pair with this result

Perl 5 , 74 70 ไบต์

$\+=y/1//-1||/1/g&&(0,6,8,7,4,10,11,5,2,9,3,0,1)[pos];$\=25if++$\>50}{

ลองออนไลน์!

รับอินพุตเป็นชุดของบิตการแยกบรรทัดใหม่

Haskell , 96 ไบต์

foldl(\s a->([s..50]++e)!!sum(last$zipWith(*)[7,9,8,5,11,12,6,3,10,4,1,2]a:[a|sum a>1]))0
e=25:e

ลองออนไลน์!

ห่อเป็นคนฉลาด: ฉันเป็นหลักดัชนีที่ตำแหน่งลงในรายการs+sum(…) ([0..50]++cycle[25])แต่เป็นวิธีที่สั้นกว่าจะเขียนที่มีการจัดทำดัชนีในตำแหน่งและเริ่มต้นรายการที่sum(…)s

Java 10, 131 130 129 ไบต์

m->{int r=0,i,s,t;for(var a:m){for(i=s=t=0;i<12;s+=a[i++])t=a[i]>0?"    \n".charAt(i):t;r+=s<2?t:s;r=r>50?25:r;}return r;}

มี 10 unprintables
ป้อนค่าเป็นจำนวนเต็มเมทริกซ์ของศูนย์และคน

-1 ไบต์ด้วย@JonathanFrechเปลี่ยน\tเป็นแท็บจริง (ทำงานใน TIO ไม่ทำงานใน IDE ท้องถิ่นของฉัน)

ลองออนไลน์

คำอธิบาย:

m->{                // Method with integer-matrix parameter and integer return-type
  int r=0,          //  Result-integer, starting at 0
      i,s,t;        //  Temp integers
  for(var a:m){     //  Loop over the integer-arrays of the input
    for(i=s=t=0;    //   Reset `i`, `s` and `t` to 0
        i<12;       //   Loop `i` in the range [0,12)
        s+=a[i++])  //    Increase `s` by the current value (0 or 1)
      t=a[i]>0?     //    If the current value is 1:
         "  \n".charAt(i)
                    //     Set `t` to the score at this position
        :t;         //    Else: Leave `t` the same
    r+=s<2?         //   If only a single pin was hit:
        t           //    Add its score `t` to the result
       :            //   Else:
        s;          //    Add the amount of pins `s` to the result
    r=r>50?         //   If the result is now above 50
       25           //    Penalize it back to 25
      :r;}          //   If not, it stays the same
  return r;}        //  Return the result

ถ่าน , 43 ไบต์

≔⁰ηＦθ«≧⁺⎇⊖ΣιΣι⌕᧔$｜#z⁸Ｕg⊗”⌕ι¹η¿›η⁵⁰≔²⁵η»Ｉη

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด รับอินพุตเป็นอาร์เรย์บูลีน คำอธิบาย:

≔⁰η

ตั้งคะแนนเป็น 0

Ｆθ«

ห่วงมากกว่าการขว้าง

⎇⊖Σι

จำนวนพิน 1 หรือไม่?

Σι

ถ้าไม่เช่นนั้นใช้จำนวนพิน

⌕᧔$｜#z⁸Ｕg⊗”⌕ι¹

มิฉะนั้นแปลตำแหน่งของพินเป็นค่า

≧⁺...η

เพิ่มไปยังคะแนน

¿›η⁵⁰≔²⁵η

หากคะแนนเกิน 50 ให้ตั้งค่ากลับเป็น 25

»Ｉη

พิมพ์ผลสุดท้ายหลังจากการโยนทั้งหมด

Haskell , 110 ไบต์

m s|sum s==1=sum$zipWith(*)[7,9,8,5,11,12,6,3,10,4,1,2]s|1>0=sum s
f l=foldl(\b->c.(b+).m)0l
c a|a>50=25|1>0=a

ความยาวเท่ากัน: f l=foldl(\b a->last$b+m a:[25|b+m a>50])0lแทนfและc

ลองออนไลน์!

Husk , 47 35 bytes

_{-12 ไบต์ขอบคุณH.PWiz (วิธีสร้างจุดเข้ารหัสรายการที่ดีกว่า)!}

F₅0
S?25>50+?←Lε`f`+Nm+3d4652893071

ลองออนไลน์!

คำอธิบาย

F₅0  -- input is a list of boolean lists
F    -- left fold by
 ₅   -- | the function flipped (overflowing label) on line 1
  0  -- | with initial value 0

S?25>50+?←Lε`f`+Nm+3d4652893071  -- example inputs: [0,0,0,1,0,0,0,0,0,0,0,0] 0
                     4652893071  -- integer literal: 4652893071
                    d            -- digits: [4,6,5,2,8,9,3,0,7,1]
                 m+3             -- map (+3): [7,9,8,5,11,12,6,3,10,4]
              `+N                -- append natural numbers: [7,9,8,5,11,12,6,3,10,4,1,2,3,...
            `f                   -- filter this list by argument: [5]
        ?  ε                     -- if it's of length 1
         ←                       -- | take first
          L                      -- | else the length
                                 -- : 5
       +                         -- add to argument: 5
 ?  >50                          -- if the value is > 50
  25                             -- | then 25
S                                -- | else the value
                                 -- : 5

สีแดง , 189 172 ไบต์

func[b][s: 0 foreach c b[d: 0 foreach e c[if e = 1[d: d + 1]]i: find c 1
n: either i[pick[7 9 8 5 11 12 6 3 10 4 1 2]index? i][0]if 50 < s: s + either 1 < d[d][n][s: 25]]s]

ลองออนไลน์!

คำอธิบายของรหัส ungolfed:

f: func[b][                                            ; a block of blocks of booleans
    s: 0                                               ; sets sum to 0
    foreach c b[                                       ; for each row of booleans 
        d: 0 foreach e c[if e = 1[d: d + 1]            ; count the number of 1s         
        i: find c 1                                    ; the index of the first 1
        n: either i[pick [7 9 8 5 11 12 6 3 10 4 1 2]  ; if there is 1, pick the number
                    index? i][0]                       ; at the index of 1
                                                       ; otherwise 0  
        if 50 < s: s + either 1 < d[d][n][s: 25]       ; if there is only one 1, add 
                                                       ; the number to the sum, otherwise
                                                       ; the number of 1s 
                                                       ; if the sum > 50, reset it to 25 
    ]
    s                                                  ; return the sum 
]

JavaScript (ES6), 98 ไบต์

a=>a.map(b=>b.map((m,i)=>(c+=m,d+=m*('0x'+'7985bc63a412'[i])),c=d=0)|(t+=c>1?c:d)>50?t=25:0,t=0)|t

กรณีทดสอบ:

f=
a=>a.map(b=>b.map((m,i)=>(c+=m,d+=m*('0x'+'7985bc63a412'[i])),c=d=0)|(t+=c>1?c:d)>50?t=25:0,t=0)|t

console.log(f([ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ])) // 0
 
console.log(f([ [ 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 ] ])) // 2
 
console.log(f([ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ])) // 12

console.log(f(
[ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 ] ]
)); // 16

console.log(f(
[ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],
  [ 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] 
])); // 18

console.log(f(
[ [ 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1 ],
  [ 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ] ] 
)); // 29

console.log(f(
[ [ 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0 ],
  [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 ],
  [ 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ] 
))  // 34
 
console.log(f( 
[ [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
  [ 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
  [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ] ] 
))  // 28
 
console.log(f( 
[ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0 ],
  [ 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0 ],
  [ 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1 ],
  [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ] ] 
))  // 25

console.log(f(
[ [ 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1 ],
  [ 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1 ],
  [ 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1 ],
  [ 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1 ],
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0 ],
  [ 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 ] ] 
)) // 25
 
console.log(f(
[ [ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
  [ 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
  [ 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ],
  [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0 ] ] 
)) // 50

console.log(f(
[ [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 ],
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ] 
)) // 27

console.log(f(  
[ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
  [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
  [ 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0 ] ] 
)) // 30

Stax , 37 ไบต์

├T<↓"♥←~;▌6»≥øF←î5░U╚_π○Q▒<│∟└ù║pε♀▀æ

เรียกใช้และแก้ไขข้อบกพร่อง

ลองออนไลน์!

คำอธิบาย

F:1"=EA5MQ9-I1%)"!s@c%1={h+}{%+}?c50>{d25}{}?    # Full program, unpacked

F                                                # Loop through every element
 :1                                              # Get indices of truthy elements
   "=EA5MQ9-I1%)"!                               # Push encoded [7,9,8,5,11,12,6,3,10,4,1,2]
                 s@                              # Swap the top 2 elements of stack and get elements at indexes
                   c%1=                          # Copy the top element, get length of array, compare to length of 1
                       {h+}{%+}?                 # If it has length of 1, add the element, otherwise add the length of the array to total
                                 c50>            # Compare total to 50, 
                                     {d25}{}?    # If it is greater, pop it off and push 25 to reset counter, otherwise do nothing

ไม่ใช่งานที่ดีที่สุดของฉัน แต่ใช้งานได้ ฉันแน่ใจว่ามีบางอย่างที่ฉันขาดหายไปเพื่อให้สั้นลงเล็กน้อย

Python 2 , 109 105 103 ไบต์

c=0
for l in input():a=sum(l);c+=int('7985bc63a412'[l.index(1)],16)if a==1else a;c=(25,c)[c<51]
print c

ลองออนไลน์!

ทางเลือกที่ไม่มีฟังก์ชั่นวนซ้ำ

-2 ขอบคุณ @Jo King