Giriş

Yan yana konan 3x3 alt matristen oluşan boş olmayan bir ikili matris.

Görev

Senin görevin 3x3 alt matrisler arasında geçerli zar kalıpları (aşağıda açıklandığı gibi) tanımlamaktır. Her geçerli desen, karşılık gelen zarların değerine değer. Geçersiz desenler 0 değerindedir.

Çıktı

Geçerli zar değerlerinin toplamı.

Zar desenleri

\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}) or (\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}) or (\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}) or (\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}$

Örnek

Aşağıdaki matris için beklenen çıktı 14'tür çünkü 5 , 6 ve 3 zarlarını , ardından geçersiz bir desen (soldan sağa ve yukarıdan aşağıya) içerir.

(\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}$

kurallar

Matrisin hem genişliğinin hem de yüksekliğinin 3 katları olduğu garanti edilir.
Izgaraya tam olarak hizalanmamış alt matrisleri görmezden gelmelisiniz (bkz. 3. test durumu). Daha resmi olarak ve 0 indekslemesi varsayıldığında: dikkate alınacak her bir alt matrisin sol üst hücresinin koordinatları formdadır . $(3x, 3y)$
Bu kod golfü .

Test durumları

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

5

Python 3 , 195 189 bayt

@Jo King sayesinde -6 bayt

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

Çevrimiçi deneyin! (189) ~~Çevrimiçi dene! (195)~~

İnsan tarafından okunabilir versiyonu:

# 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

— Kara baykuş Kai
kaynak

Matrisin devri üzerinde de aynı işlemi yaparak bunu biraz kısaltabilir misiniz acaba. Bu şekilde, haritanızda her biri 6 bayt ekleyen tüm girişleri kaldırabilirsiniz. Sadece

— devir

188 bayt .

— Jonathan Frech

Her iki örnekten kurtulun //3ve '0'+''.join...iki baytı kurtarmak için kullanın :)

— Jonathan Allan

... iki tane daha tasarruf etmek için bunu numaralandırmayla birleştirin: burada

— Jonathan Allan

2

165 bayt .

— Jonathan Frech

5

R , 134 bayt

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}

Çevrimiçi deneyin!

@ Heteira ile aynı fikre sahip olduğumu fark ettim.

Tarihçe :

~~171~~ : -10 byte, @JayCe!
@Giuseppe sayesinde ~~161~~ : -3 bayt!
~~158~~ : -13 bayt kaydedildi!
@Giuseppe sayesinde ~~145~~ : -2 bayt!
~~143~~ : -6 bayt kaydedildi!
@JayCe sayesinde ~~137~~ : -3 bayt!

— digEmAll
kaynak

1

sayı listesini sıkıştırarak 5 bayt tasarruf edin - yorum olarak gönderilemeyecek kadar uzun örneklerle bağlantı kurun

— JayCe 15

1

3 bayt kullanarakdim

— JayCe

iki bayt için daha fazla kara büyü

— JayCe,

1

Etrafından (2^(8:0))çıkarılabilen fazladan parantez çifti var .

— Giuseppe

1

Ben unutmuştum ekleyin catçıkışında intToUtf8: 3 bayt tasarrufu

— Jayce

4

Perl 6 , 113 105 97 94 bayt

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

Çevrimiçi deneyin!

Matrisi 3x3'lük alt matrislere böler, dokuz 1s ve 0s'ı taban 2'ye dönüştürür ve ardından değer için bir tamsayı listesine indeksler.

Açıklama:

{  #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
          }
}

— Jo King
kaynak

4

Jöle , 29 28 bayt

Bay Xcoder sayesinde -1 ( Ṁdeğiştirmek için kullanın ṢṪ)

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

Monadik bir bağlantı.

Çevrimiçi deneyin! Veya testleri yapın .

Nasıl?

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

Örneğin bir alt matris olduğunda:

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

Sonra ZU,Ɗverim:

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

... hangi düzlemden [0, 0, 0, 1, 1, 1, 1, 1, 1], hangi, ikiliden dönüştürme 63, kod sayfası dizin listesinde altıncı giriş olan “°€⁼-Ḍ?‘( Jelly'in kod sayfasında? bayt 3Folan )

— Jonathan Allan
kaynak

ṀṢṪ-1 yerine çalışabilir .

— Bay Xcoder,

... evet olacak ( M> kullanarak tasarruf ettiğimi sanıyordum . <). Akıllıca bir şey yapılabilir ŒṪmi acaba ...

— Jonathan Allan

3

Japt `-x` , 36 bayt

Şimdi ilginçleşiyor. Eminim daha da golf oynayabilirim

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

Çevrimiçi deneyin!

— Luis felipe De jesus Munoz
kaynak

2

Retina 0.8.2 , 90 bayt

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

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

Çevrimiçi deneyin! Açıklama:

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

$3\times 3$ $3\times n$

¶

M!`.{9}

Tüm blokları bir araya getirin ve ardından 9 sütunlu satırlara bölün.

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

(İki desenleri için geçerli zar desenleri tutmak 6dan sonra, bir kibrit herhangi bir sayı 0için 5de, 0elbette aşağıda sayımına katkıda bulunmaz.)

Geçerli zar üzerindeki pipleri sayın.

— Neil
kaynak

1

Ruby , 151 bayt

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

Çevrimiçi deneyin!

2d bir dizi diziyi (veya dizeleri, sanırım) kabul eden bir lambda. Jo King'in cevabından ilham alır . Giriş matrisinden zarları dilimlemek çok fazla yer aldı, bu yüzden ben de aşmış olabilirim. Neyse ki nillerle uğraşmak bana sadece bir avuç bayra mal oldu.

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
kaynak

1

Clojure, 197 bayt

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

Daha akıllıca bir şey bulmalıydım.

— NikoNyrh
kaynak

1

Python 2 , 159 bayt

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

Çevrimiçi deneyin!

Unicode kodlama yaklaşımı için Jonathan Frech'e şapka bahşişi .

— Chas Brown
kaynak

Zar matrisimin değeri nedir?

Giriş

Görev

Çıktı

Zar desenleri

Örnek

kurallar

Test durumları

Python 3 , 195 189 bayt

İnsan tarafından okunabilir versiyonu:

R , 134 bayt

Perl 6 , 113 105 97 94 bayt

Açıklama:

Jöle , 29 28 bayt

Nasıl?

Japt -x , 36 bayt

Retina 0.8.2 , 90 bayt

Ruby , 151 bayt

Clojure, 197 bayt

Python 2 , 159 bayt

Japt `-x` , 36 bayt