इनपुट

एक गैर-खाली बाइनरी मैट्रिक्स जिसमें 3x3 उप-मैट्रिसेस होते हैं, एक तरफ रख देते हैं।

कार्य

आपका कार्य 3x3 उप-मत्रियों के बीच मान्य पासा पैटर्न (जैसा कि नीचे वर्णित है) की पहचान करना है। प्रत्येक मान्य पैटर्न संबंधित पासा के मूल्य के लायक है। अमान्य पैटर्न 0 के लायक हैं।

उत्पादन

वैध पासा मानों का योग।

पासा पैटर्न

\begin{aligned} 1 : (\begin{matrix} 0, 0, 0 \\ 0, 1, 0 \\ 0, 0, 0 \end{matrix}) & 2 : (\begin{matrix} 1, 0, 0 \\ 0, 0, 0 \\ 0, 0, 1 \end{matrix}) या (\begin{matrix} 0, 0, 1 \\ 0, 0, 0 \\ 1, 0, 0 \end{matrix}) \\ 3 : (\begin{matrix} 1, 0, 0 \\ 0, 1, 0 \\ 0, 0, 1 \end{matrix}) या (\begin{matrix} 0, 0, 1 \\ 0, 1, 0 \\ 1, 0, 0 \end{matrix}) & 4 : (\begin{matrix} 1, 0, 1 \\ 0, 0, 0 \\ 1, 0, 1 \end{matrix}) \\ 5 : (\begin{matrix} 1, 0, 1 \\ 0, 1, 0 \\ 1, 0, 1 \end{matrix}) & 6 : (\begin{matrix} 1, 0, 1 \\ 1, 0, 1 \\ 1, 0, 1 \end{matrix}) या (\begin{matrix} 1, 1, 1 \\ 0, 0, 0 \\ 1, 1, 1 \end{matrix}) \end{aligned}

$\begin{align} &1:\pmatrix{\color{gray}0,\color{gray}0,\color{gray}0\\\color{gray}0,1,\color{gray}0\\\color{gray}0,\color{gray}0,\color{gray}0} &&2:\pmatrix{1,\color{gray}0,\color{gray}0\\\color{gray}0,\color{gray}0,\color{gray}0\\\color{gray}0,\color{gray}0,1}\text{or}\pmatrix{\color{gray}0,\color{gray}0,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,\color{gray}0,\color{gray}0}\\ &3:\pmatrix{1,\color{gray}0,\color{gray}0\\\color{gray}0,1,\color{gray}0\\\color{gray}0,\color{gray}0,1}\text{or}\pmatrix{\color{gray}0,\color{gray}0,1\\\color{gray}0,1,\color{gray}0\\1,\color{gray}0,\color{gray}0} &&4:\pmatrix{1,\color{gray}0,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,\color{gray}0,1}\\ &5:\pmatrix{1,\color{gray}0,1\\\color{gray}0,1,\color{gray}0\\1,\color{gray}0,1} &&6:\pmatrix{1,\color{gray}0,1\\1,\color{gray}0,1\\1,\color{gray}0,1}\text{or}\pmatrix{1,1,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,1,1} \end{align}$

उदाहरण

निम्नलिखित मैट्रिक्स के लिए अपेक्षित आउटपुट 14 है क्योंकि इसमें पासा 5 , 6 और 3 है , इसके बाद एक अमान्य पैटर्न (बाएं से दाएं और ऊपर से नीचे तक) है।

(\begin{matrix} 1, 0, 1, 1, 1, 1 \\ 0, 1, 0, 0, 0, 0 \\ 1, 0, 1, 1, 1, 1 \\ 1, 0, 0, 0, 0, 0 \\ 0, 1, 0, 0, 1, 0 \\ 0, 0, 1, 0, 1, 0 \end{matrix})

$\pmatrix{1,0,1,1,1,1\\ 0,1,0,0,0,0\\ 1,0,1,1,1,1\\ 1,0,0,0,0,0\\ 0,1,0,0,1,0\\ 0,0,1,0,1,0}$

नियम

मैट्रिक्स की चौड़ाई और ऊंचाई दोनों 3 के गुणक होने की गारंटी है।
आपको उप-मेट्रिक्स को अनदेखा करना चाहिए जो ग्रिड पर ठीक से संरेखित नहीं हैं (तीसरा परीक्षण मामला देखें)। अधिक औपचारिक रूप से और 0-इंडेक्सिंग: माना जाने वाला प्रत्येक उप-मैट्रिक्स के शीर्ष-बाएं सेल के निर्देशांक फॉर्म । $(3x, 3y)$
यह कोड-गोल्फ है ।

परीक्षण के मामलों

// 0
[ [ 1,0,0 ],
  [ 0,0,1 ],
  [ 1,0,0 ] ]

// 2
[ [ 0,0,1 ],
  [ 0,0,0 ],
  [ 1,0,0 ] ]

// 0 (0 + 0)
[ [ 0,0,1,0,1,0 ],
  [ 0,0,0,1,0,0 ],
  [ 0,0,1,0,1,0 ] ]

// 9 (3 + 3 + 3)
[ [ 1,0,0,0,0,1,1,0,0 ],
  [ 0,1,0,0,1,0,0,1,0 ],
  [ 0,0,1,1,0,0,0,0,1 ] ]

// 6 (6 + 0)
[ [ 1,0,1 ],
  [ 1,0,1 ],
  [ 1,0,1 ],
  [ 1,0,1 ],
  [ 1,0,0 ],
  [ 1,0,1 ] ]

// 14 (5 + 6 + 3 + 0)
[ [ 1,0,1,1,1,1 ],
  [ 0,1,0,0,0,0 ],
  [ 1,0,1,1,1,1 ],
  [ 1,0,0,0,0,0 ],
  [ 0,1,0,0,1,0 ],
  [ 0,0,1,0,1,0 ] ]

// 16 (1 + 2 + 3 + 4 + 0 + 6)
[ [ 0,0,0,1,0,0,1,0,0 ],
  [ 0,1,0,0,0,0,0,1,0 ],
  [ 0,0,0,0,0,1,0,0,1 ],
  [ 1,0,1,1,1,1,1,0,1 ],
  [ 0,0,0,1,0,1,1,0,1 ],
  [ 1,0,1,1,1,1,1,0,1 ] ]

code-golf array-manipulation binary-matrix

— Arnauld
स्रोत

5

पायथन 3 , 195 189 बाइट्स

-6 बाइट्स @Jo King को धन्यवाद

lambda m:sum({16:1,257:2,68:2,273:3,84:3,325:4,341:5,455:6,365:6}.get(int(''.join(str(e)for c in m[3*i:][:3]for e in c[3*j:][:3]),2),0)for i in range(len(m)//3)for j in range(len(m[0])//3))

इसे ऑनलाइन आज़माएं! (189) ~~इसे ऑनलाइन आज़माएं! (195)~~

मानव पठनीय संस्करण:

# 3x3 part matrix to dice, beginning at coordinates 3*i, 3*j
def single_matrix_to_dice(matrix, i, j):
    # Example: matrix = [[0, 0, 0], [0, 1, 0], [0, 0, 0]], i=0, j=0 (result is 1)

    matrix_string = ''.join(
        str(e) for column in matrix[3*i:3*i+3] 
        for entry in column[3*j:3*j+3]
    ) # Slicing the matrix so that only the valid entries remain, here '000010000'

    # Interpreting the matrix string as binary number, here 16
    binary_number = int(matrix_string,2)

    # binary representations of all valid dice rolls
    dct = {16:1,257:2,68:2,273:3,84:3,325:4,341:5,455:6,365:6}

    return dct.get(binary_number, 0)

def f(matrix):
    return sum(
        single_matrix_to_dice(matrix, i, j) for i in range(len(m)//3) 
        for j in range(len(m[0])//3))
    ) # len(m)/3 would generate a float, so len(m)//3 is used

— काला उल्लू काई
स्रोत

मुझे आश्चर्य है कि यदि आप मैट्रिक्स के ट्रांसपोज़िशन पर भी यही ऑपरेशन करके इसे थोड़ा छोटा कर सकते हैं। इस तरह से आप अपने मानचित्र में सभी डुप्लिकेट प्रविष्टियों को हटा सकते हैं जो प्रत्येक में 6 बाइट्स जोड़ते हैं। बस 16 18 पर <18 बाइट्स

— ईस्टन बोर्नमेइयर

188 बाइट्स ।

— जोनाथन फ्रेच

दोनों उदाहरणों से छुटकारा पाएं //3और '0'+''.join...दो बाइट्स बचाने के लिए उपयोग करें :)

— जोनाथन एलन

... दो और को बचाने के लिए किन्नर के साथ गठबंधन करें

— जोनाथन एलन

2

165 बाइट्स ।

— जोनाथन फ्रेच

5

आर , 134 बाइट्स

function(m,d=dim(m)/3-1){for(a in 0:d)for(b in 0:d[2])F=F+sum(y<-m[1:3+a*3,1:3+b*3])*sum(y*2^(8:0))%in%utf8ToInt("āDđTŅŕǇŭ");F}

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

मैंने देखा कि मेरे पास @Heteira का एक ही विचार था

इतिहास :

~~171~~ : -10 बाइट्स @JayCe को धन्यवाद!
~~161~~ : -3 बाइट्स @Giuseppe को धन्यवाद!
~~158~~ : -13 बाइट्स बचाए!
~~145~~ : -2 बाइट्स @Giuseppe को धन्यवाद!
~~143~~ : -6 बाइट्स बचाए!
~~137~~ : -3 बाइट्स @JayCe को धन्यवाद!

— digEmAll
स्रोत

1

संख्याओं की सूची को संक्षिप्त करके 5 बाइट्स

— बचाएं

1

3 और बाइट्स का उपयोग करते हुएdim

— JayCe

दो और बाइट्स के लिए अधिक काला जादू

— JayCe

1

चारों ओर कोष्ठक की एक अतिरिक्त जोड़ी है (2^(8:0))जिसके चारों ओर हटाया जा सकता है।

— Giuseppe

1

मैं catइसके उत्पादन में भूल गया intToUtf8: सेव 3 बाइट्स

— JayCe

4

पर्ल 6 , 113 105 97 94 बाइट्स

{sum (|@_[*;^3+3*$_]for ^@_[0]).rotor(9).map:{"@āđŅŕǇ@@DT@@ŭ".ords.first(:2[$_],:k)%7}}

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

मैट्रिक्स को 3x3 के सब मैट्रिसेस में विभाजित करता है, नौ 1s और 0s को बेस 2 में परिवर्तित करता है और फिर इसे वैल्यू के लिए पूर्णांकों की सूची में अनुक्रमित करता है।

स्पष्टीकरण:

{  #Start anonymous code block
  sum   # Sum of all
     (|@_[*;^3+3*$_]   # Get the n*3 to n*3+3th elements in every sub-list
           for ^@_[0]) # For n in the range 0 to width (divide by 3 to avoid warnings)
     .rotor(9)  # Split this list into groups of 9 (split the dice up)
     .map:{     # And map each die to 
        "@āđŅŕǇ@@DT@@ŭ".ords  # In the list of integers
           .first(      # The first appearance of 
               :2[$_],  # The dice converted from a list of 0s and 1s to base 2
                 :k     # Returning the index
             )%7        # And modulo by 7 to get the alternate versions of 2, 3 and 6
          }
}

— मजाक कर रहा है
स्रोत

4

जेली , 29 28 बाइट्स

-1 श्री एक्सकोडर ( Ṁप्रतिस्थापित करने के लिए उपयोग ṢṪ) के लिए धन्यवाद

s€3ZẎs3µZU,ƊṀṙ1FḄ“°€⁼-Ḍ?‘i)S

एक मोनडिक लिंक।

इसे ऑनलाइन आज़माएं! या परीक्षण चलाते हैं ।

कैसे?

s€3ZẎs3µZU,ƊṀṙ1FḄ“°€⁼-Ḍ?‘i)S - Link: list of lists of 1s and 0s
s€3                          - split each into threes
   Z                         - transpose
    Ẏ                        - tighten
     s3                      - split into threes -> the sub-matrices in column-major order
       µ                  )  - for each sub-matrix, say D:
           Ɗ                 -   last three links as a monad:
        Z                    -     transpose D
         U                   -     reverse each -> D rotated a quarter turn clockwise
          ,                  -     pair with D
            Ṁ                -   get the maximum of the two orientations
             ṙ1              -   rotate left by one (to ensure FḄ will yield integers <256 for all non-zero valued D)
               F             -   flatten
                Ḅ            -   convert from binary
                         i   -   first 1-based index in (0 if not found):
                 “°€⁼-Ḍ?‘    -     code-page indices list = [128,12,140,45,173,63]
                           S - sum

उदाहरण के लिए जब एक उप-मैट्रिक्स है:

[[1,0,1],
 [1,0,1],
 [1,0,1]]

फिर ZU,Ɗपैदावार:

[[[1, 1, 1],
  [0, 0, 0],
  [1, 1, 1]],   ...which has maximum (Ṁ):    ...and after ṙ1:
 [[1, 0, 1],                   [[1, 1, 1],         [[0, 0, 0],
  [1, 0, 1],                    [0, 0, 0],          [1, 1, 1],
  [1, 0, 1]]]                   [1, 1, 1]]          [1, 1, 1]]

... जो [0, 0, 0, 1, 1, 1, 1, 1, 1]बाइनरी से परिवर्तित होता है, 63जो कोड-पेज इंडेक्स सूची में छठी प्रविष्टि है “°€⁼-Ḍ?‘( जेली के कोड-पेज में ?बाइट होने पर )3F

— जोनाथन एलन
स्रोत

ṀṢṪ-1 के बजाय काम कर सकते हैं ।

— श्री एक्सकोडर

... हाँ यह होगा (मुझे लगा कि मैं M>> <) का उपयोग करके बचत कर रहा हूं । क्या ŒṪमुझे आश्चर्यचकित करने के साथ कुछ चतुर किया जा सकता है ...

— जोनाथन एलन

3

जाप `-x` , 36 बाइट्स

अब यह दिलचस्प हो रहा है। मुझे यकीन है कि और भी नीचे गोल्फ हो सकती है

ò3 ®®ò3Ãy f@"0ıtŵġdťƍǧ"øºXm¬¬Í+H)d
c

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत

2

रेटिना 0.8.2 , 90 बाइट्स

+`(...)(.+¶)(...)(.+¶)(...)
$1¶$3¶$5¶$2$4
¶

M!`.{9}
G`111000111|(101){3}|(.)0(.0).0\3\2
1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

+`(...)(.+¶)(...)(.+¶)(...)
$1¶$3¶$5¶$2$4

बार-बार हटाते हैं $3\times 3$ प्रत्येक से ब्लॉक $3\times n$ पंक्ति जब तक सभी पंक्तियों में 3 कॉलम न हों।

¶

M!`.{9}

सभी ब्लॉकों को एक साथ मिलाएं और फिर 9 कॉलम की पंक्तियों में वापस विभाजित करें।

G`111000111|(101){3}|(.)0(.0).0\3\2

केवल मान्य पासा पैटर्न रखें (दो पैटर्न के लिए 6, फिर एक से किसी भी संख्या से मेल खाता 0है 5, हालांकि 0निश्चित रूप से नीचे की गिनती में योगदान नहीं करेगा।)

पिप्स को मान्य पासा पर गिनें।

— नील
स्रोत

1

रूबी , 151 बाइट्स

->m{m.each_slice(3).flat_map{|r|r.transpose.each_slice(3).map{|d|" \x10āđŅŕǇ  DT  ŭ".chars.map(&:ord).index(d.flatten.join.to_i 2)&.%7}-[p]}.sum}

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

एक लैम्ब्डा 2ts (या तार, मुझे लगता है) की सरणी को स्वीकार करते हुए। जो किंग के जवाब से प्रेरणा लेता है । मुझे ऐसा लग रहा है कि इनपुट मैट्रिक्स से पासा खिसकने के कारण बहुत जगह हो गई है, इसलिए मैं अच्छी तरह से आउटगोल्फ हो सकता हूं। सौभाग्य से, निलों के साथ व्यवहार करने से मुझे केवल एक मुट्ठी भर बाइट मिलती है।

Ungolfed:

->m{
  m.each_slice(3).flat_map{|r|             # Split into groups of 3 rows
    r.transpose.each_slice(3).map{|d|      # Split into groups of 3 columns
      " \x10āđŅŕǇ  DT  ŭ".chars.map(&:ord) # [0,16,257,273,325,341,455,0,0,68,84,0,0,365]
        .index(                            # Find in that array
          d.flatten.join.to_i 2            #   the die flattened into a bitstring (nil if not found)
        )&.%7                              # Safe-modulo 7 (leaves nils as nil)
    }-[p]                                  # Remove nils
  }.sum                                    # Add 'em up
}

— benj2240
स्रोत

1

क्लोजर, 197 बाइट्स

#(apply +(for[R[range]i(R 0(count %)3)j(R 0(count(% 0))3)](case(apply +(map *(iterate(partial * 2)1)(for[x(R 3)y(R 3)]((%(+ i x))(+ j y)))))16 1 257 2 68 2 273 3 84 3 325 4 3 4 1 5 455 6 365 6 0)))

मुझे कुछ होशियार आना चाहिए था।

— NikoNyrh
स्रोत

1

पायथन 2 , 159 बाइट्स

f=lambda a:a>[]and sum(u'ȀāDđTŅȀŕȀǇŭ'.find(unichr(int(J(J(map(str,r[i:i+3]))for r in a[:3]),2)))/2+1for i in range(0,len(a[0]),3))+f(a[3:])
J=''.join

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

यूनिकोड एन्कोडिंग दृष्टिकोण के लिए जोनाथन फ्रेच को टोपी टिप ।

— चास ब्राउन
स्रोत

मेरे पासा मैट्रिक्स का मूल्य कितना है?

इनपुट

कार्य

उत्पादन

पासा पैटर्न

उदाहरण

नियम

परीक्षण के मामलों

पायथन 3 , 195 189 बाइट्स

मानव पठनीय संस्करण:

आर , 134 बाइट्स

पर्ल 6 , 113 105 97 94 बाइट्स

स्पष्टीकरण:

जेली , 29 28 बाइट्स

कैसे?

जाप -x , 36 बाइट्स

रेटिना 0.8.2 , 90 बाइट्स

रूबी , 151 बाइट्स

क्लोजर, 197 बाइट्स

पायथन 2 , 159 बाइट्स

जाप `-x` , 36 बाइट्स