Bu zorluk, Mayıs 2018 Ayın Dili etkinliğinin bir parçası olarak, bazı MATL dil özellikleri ile ilgilidir .

Giriş

MATL'de, birçok iki giriş işlevi , yayınla eleman olarak çalışır . Bu, şu anlama gelir:

• Element bilge (veya vectorized ): fonksiyon, eşleşen boyutlara sahip iki diziyi girdi olarak alır. İşlev tarafından tanımlanan işlem, karşılık gelen girişlerin her çiftine uygulanır. Örneğin, düzeltme sonrası gösterimini kullanarak:

  [2 4 6] [10 20 30] +
  

  verir çıktıya

  [12 24 36]
  

  Bu aynı zamanda çok boyutlu dizilerle de çalışır. Gösterim [1 2 3; 4 5 6], 2x 3dizisini temsil eder (matris)

  1 2 3
  4 5 6
  

  2birinci boyut (dikey) ve 3ikinci (yatay) boyunca büyüklüğe sahip olan . Yani

  [2 4 6; 3 5 7] [10 20 30; 40 60 80] *
  

  verir

  [20 80 180; 120 300 560]
  

• Yayın veya ( tekton genişletme ): iki giriş dizisinin eşleşen boyutları yoktur, ancak eşleşen her bir boyutta dizilerin birinin boyutu vardır 1. Bu dizi, boyutları eşleştirmek için diğer boyutlar boyunca örtük olarak çoğaltılır; ve daha sonra işlem, yukarıdaki gibi element şeklinde uygulanır. Örneğin, 1× 2ve 3× boyutlarında iki giriş dizisini göz önünde bulundurun 1:

  [10 20] [1; 2; 5] /
  

  Yayın sayesinde, bu eşdeğerdir

  [10 20; 10 20; 10 20] [1 1; 2 2; 5 5] /
  

  ve böylece verir

  [10 20; 5 10; 2 4]
  

  Benzer şekilde, 3× 2ve 3× boyutlarında 1(yayın şimdi yalnızca ikinci boyut boyunca etki eder),

  [9 8; 7 6; 5 4] [10; 20; 30] +
  

  verir

  [19 18; 27 26; 35 34]
  

  Boyutların sayısı bile farklı olabilir. Örneğin, 3 × 2 ve 3 × 1 × 5 boyutlarındaki girişler uyumludur ve 3 × 2 × 5 sonuç verir. Aslında, 3 × 2 büyüklüğü, 3 × 2 × 1 ile aynıdır (keyfi olarak çok sayıda takip eden tekil boyutlar vardır).

  Öte yandan, bir çift 2× 2ve 3× 1dizisi hata verirdi, çünkü birinci boyut boyunca boyutlar 2ve 3: eşit değiller ve hiçbiri değil 1.

Modüler yayının tanımı

Modüler yayın, eşleşmeyen boyutlardan hiçbiri olmasa bile çalışan yayınların genellemesidir 1. Örneğin , fonksiyonun girdisi olarak aşağıdaki 2× 2ve 3× 1dizilerini göz önünde bulundurun +:

[2 4; 6 8] [10; 20; 30] +

Kural şu ​​şekildedir: her boyut için, bu boyut boyunca daha küçük olan dizi , diğer dizinin boyutuyla eşleşecek şekilde modüler olarak (döngüsel olarak) çoğaltılır . Bu yukarıda belirtilen eşdeğer yapar

[2 4; 6 8; 2 4] [10 10; 20 20; 30 30] +

sonuçla beraber

[12 14; 26 28; 32 34]

İkinci bir örnek olarak,

[5 10; 15 20] [0 0 0 0; 1 2 3 4; 0 0 0 0; 5 6 7 8; 0 0 0 0] +

üretmek

[5 10 5 10; 16 22 18 24; 5 10 5 10; 20 26 22 28; 5 10 5 10]

Genel olarak, boyutları ile giriş ax bve cx dvermek büyüklükte bir sonucu max(a,b)x max(c,d).

Meydan okuma

Uygulama ilave için iki boyutlu diziler modüler yayın yukarıda tanımlandığı gibidir.

Diziler dikdörtgen olacak (düzensiz değil), yalnızca negatif olmayan tam sayılar içerecek ve en azından1 her boyutta boyutta olacaktır.

Ek kurallar:

• Giriş ve çıkış herhangi bir makul yoldan alınabilir . Biçimleri her zamanki gibi esnektir.

• Herhangi bir programlama dilinde programlara veya fonksiyonlara izin verilir . Standart boşluklar yasaktır .

• Bayt cinsinden en kısa kod kazanır.

Test durumları

Aşağıdaki ;satır ayırıcı olarak kullanılır (yukarıdaki örneklerde olduğu gibi). Her test durumu iki girişi ve ardından çıkışı gösterir.

[2 4; 6 8]
[10; 20; 30]
[12 14; 26 28; 32 34]

[5 10; 15 20]
[0 0 0 0; 1 2 3 4; 0 0 0 0; 5 6 7 8; 0 0 0 0]
[5 10 5 10; 16 22 18 24; 5 10 5 10; 20 26 22 28; 5 10 5 10]

[1]
[2]
[3]

[1; 2]
[10]
[11; 12]

[1 2 3 4 5]
[10 20 30]
[11 22 33 14 25]

[9 12 5; 5 4 2]
[4 2; 7 3; 15 6; 4 0; 3 3]
[13 14 9;12 7 9;24 18 20;9 4 6;12 15 8]

[9 12 5; 5 4 2]
[4 2 6 7; 7 3 7 3; 15 6 0 1; 4 0 1 16; 3 3 3 8]
[13 14 11 16; 12 7 9 8; 24 18 5 10; 9 4 3 21; 12 15 8 17]

[6 7 9]
[4 2 5]
[10 9 14]

Jöle , 10 bayt

ṁ€ZL$Z€Ɗ⁺S

Giriş olarak bir matris çifti (iki satır dizisi) alır ve bir matris döndürür.

Çevrimiçi deneyin!

Nasıl çalışır

ṁ€ZL$Z€Ɗ⁺S  Main link. Argument: [M, N] (matrix pair)

  Z $       Zip M with N (i.e., transpose the matrix of arrays [M, N], ...
   L            then take the length (number of rows) of the result.
ṁ€          Mold M and N like the indices, cyclically repeating their rows as many
            times as needed to reach the length to the right.
     Z€     Zip each; transpose both M and N.
       Ɗ⁺   Combine the three links to the left into a chain and duplicate it.
            The first run enlarges the columns, the second run the rows.
         S  Take the sum of the modified matrices.

Kömür , 25 23 bayt

ＡθＩＥ⌈ＥθＬιＥ⌈ＥθＬ§λ⁰ΣＥ觧νιλ

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Girdiyi 3 boyutlu bir dizi olarak alır. Açıklama:

Ａθ

Her şeyi gir.

    θ                   Input
   Ｅ                    Map over arrays
      ι                 Current array
     Ｌ                  Length
  ⌈                     Maximum
 Ｅ                      Map over implicit range
          θ             Input
         Ｅ              Map over arrays
             λ          Current array
            § ⁰         First element
           Ｌ            Length
        ⌈               Maximum
       Ｅ                Map over implicit range
                 θ      Input
                Ｅ       Map over arrays
                    ν   Current array
                   § ι  Cyclically index using outer loop index
                  §   λ Cyclically index using inner loop index
               Σ        Sum
Ｉ                       Cast to string
                        Implicitly print on separate lines and paragraphs

MATL , 25 24 bayt

,iZy]vX>XKx,@GK:KP:3$)]+

Çevrimiçi deneyin!

En sonunda! Ayın Dili ilham mücadelesinin Ayın Dili tarafından yanıtlanması sadece bir hafta sürdü !

Tahminime göre mümkün olduğu kadar kısa değil, ancak ilk sürümüm 40 bayttan fazla olduğu için yeterince mutluyum. düzenleme: Ben haklıydım, Luis sıkmak için başka bir bayt buldu!

,iZy]	# do twice: read input and find the size of each dimension
vX>	# find the maximum along each dimension
XKx	# save this into clipboard K and delete from stack. Stack is now empty.
,	# do twice:
 @G	# push the input at index i where i=0,1.
	# MATL indexes modularly, so 0 corresponds to the second input
 K:	# push the range 1...K[1]
 KP:	# push the range 1...K[2]
 3$)	# use 3-input ) function, which uses modular indexing
	# to expand the rows and columns to the appropriate broadcasted size
]	# end of loop
+	# sum the now appropriately-sized matrices and implicitly display

Python 3 , 127 126 125 bayt

değiştirerek byte golfed sum(m)içinm+n

@Jonathan Frech sayesinde bir bayt daha!

lambda y:[[m+n for n,m,j in Z(l)]for*l,i in Z(y)]
from itertools import*
Z=lambda y:zip(*map(cycle,y),range(max(map(len,y))))

İki 2 boyutlu dizinin bir listesi olarak girdi alır.

• ZGöstergesi en dizinin uzunluğuna gelene kadar lambda, girdi olarak iki dizi alır ve bir yineleyici bir endeksi oluşturuyordu ve her iki dizide değerleri birleştirilmiş döndürür. İndeks değişkeni benim için faydalı değil ve baytlara mal oluyor, ancak onsuz nasıl yapacağımı bilmiyorum ... ( ilgili )
• Ana lambda sadece giriş dizilerini alır Zve dış ve iç dizileri çağırır . En içteki değerler birbirine eklenir.

Çevrimiçi deneyin!

Kullanımı itertools.cyclebiraz hile yapmak gibi hissettiriyor ama sanırım saf ithalat beyanı uzunluğu ile yeterince ceza aldım :)

Eminim bu biraz daha golf oynayabilir, özellikle de bunları işe yaramaz ive jdeğişken bırakan yineleme yöntemi . Nasıl golf oynayacağına dair herhangi bir ipucu için minnettar olurum, muhtemelen bariz bir şeyleri özlüyorum.

JavaScript (ES6), 131 bayt

İş için doğru araç değil ve muhtemelen doğru yaklaşım da değil. Oh iyi ... ¯ \ _ (ツ) _ / ¯

a=>b=>(g=(a,b,c)=>[...Array((a[b[L='length']]?a:b)[L])].map(c))(a,b,(_,y)=>g(a[0],b[0],(_,x)=>(h=a=>a[y%a[L]][x%a[0][L]])(a)+h(b)))

Çevrimiçi deneyin!

Nasıl?

Yardımcı fonksiyon gr () , bir büyük giriş dizi olarak büyük (gibidir dizi oluşturur , bir ya da b ) ve çalıştırır geri arama işlevi C üzerinde:

g = (a, b, c) =>
  [...Array(
    (a[b[L = 'length']] ? a : b)[L]
  )].map(c)

Yardımcı fonksiyon h () 2D-dizi okuma a de (x, y), modüler bir yayın ile:

h = a => a[y % a[L]][x % a[0][L]]

Ana kod şimdi basitçe şöyle okur:

a => b =>
  g(a, b, (_, y) =>
    g(a[0], b[0], (_, x) =>
      h(a) + h(b)
    )
  )

Özyinelemeli sürümü, 134 bayt

a=>b=>(R=[],g=x=>a[y]||b[y]?a[0][x]+1|b[0][x]+1?g(x+1,(R[y]=R[y]||[])[x]=(h=a=>a[y%a.length][x%a[0].length])(a)+h(b)):g(+!++y):R)(y=0)

Çevrimiçi deneyin!

05AB1E , 15 bayt

2FεIζg∍ø]øεø¨}O

Çevrimiçi deneyin!

Eski versiyon, 25 bayt

é`DŠg∍)Σнg}`DŠнgδ∍€˜)ø€øO

Çevrimiçi deneyin!

açıklama

15-Byter:

2FεIζg∍ø] øεø¨} O - Tam program. STDIN'den girişi 3B [A, B] listesi olarak alır.
2F - İki kez uygulayın:
  ε - [A, B] 'deki her biri için:
   Iζ - Girişi çeviriniz (boşluklarla boşluk doldurunuz).
     g - Uzunluk (satır sayısını almak).
      İtem - Geçerli öğeyi (A veya B) gereken uzunluğa uzatın.
       ø - Devrik yap.
        ] - Tüm döngüleri kapat.
         ø - Tekrar devrik yapın.
          ε - ^ deki her satır için (döngü sonucunun sütunu):
           ø - Sütunu çeviriniz.
            ¨} - Son elemanı kaldır ve harita döngüsünü kapat.
              O - Sum.

25-Byter:

é`DŠg∍) Σнg} `DŠнgδ∍ € ˜) ø € øO - Tam program. STDIN'den girişi bir 3D listesi olarak alır.
- Listeyi uzunluğa göre sıralayın.
 `D - İçeriği yığına ayrı olarak dağıtın, ToS'yi çoğaltın.
   Š - Üçlü değişim gerçekleştirin. a, b, c -> c, a, b.
    g - KYS'nin uzunluğunu alın.
     List - Kısa listeyi (yükseklik olarak) uygun şekilde uzatın.
      ) Σ} - Yığının tamamını bir listeye sarın ve sırala:
        нg - İlk öğesinin uzunluğu.
           `DŠ - Yukarıdaki ile aynı.
              нg - İlk elemanın uzunluğu.
                δ∍ € ˜ - Kısa listeyi (genişlikte) uygun şekilde uzatın. 
                    ) ø - Yığını bir listeye sarın ve transpoze edin (sıkıştırın).
                      € ø - Sonra her listeyi sıkıştırın.
                        O - Vektörel toplamı uygulayın.

R , 136 104 103 95 93 bayt

Giuseppe'nun tavsiyesine göre bir kuyruklu 33 35 bayt golf oynadı . Bir işlev adı olarak bir işleci kullanarak 100 bayttan daha azına erişildi. Daha okunaklı kod için geçmişe bakınız.

function(x,y,d=pmax(dim(x),dim(y)))y/d[2]/d[1]+x/d[2]/d[1]
"/"=function(x,j)apply(x,1,rep,,j)

Çevrimiçi deneyin!

K (ngn / k) , 23 bayt

{+/2{+:'(|/#:'x)#'x}/x}

Çevrimiçi deneyin!

05AB1E , 18 bayt

éR`UvXNèy‚é`©g∍®+ˆ

Çevrimiçi deneyin!

açıklama

éR                  # sort by length, descending
  `U                # store the shorter list in X
    v               # for each list y, index N in the longer list
     XNè            # get the nth element of the shorter list
        y‚é         # pair with y and sort by length
           `©g∍     # repeat the shorter list to the same length as the longer
               ®+   # elementwise addition of the lists
                 ˆ  # add to global list
                    # implicitly print global list

Pyth, 24 bayt

KeSmlhdQmm+Fm@@bdkQKeSlM

Burada dene

açıklama

KeSmlhdQmm+Fm@@bdkQKeSlM
                    eSlMQ  Get the maximum length of (implicit) input...
KeSmlhdQ           K       ... and the maximum row length.
        mm                 For each 2d index ...
          +Fm@@bdkQ        ... get the sum of the appropriate elements.

Java 8, 172 bayt

A->B->{int m=A.length,o=A[0].length,d=B.length,u=B[0].length,l=m>d?m:d,a=o>u?o:u,r[][]=new int[l][a],$;for(;l-->0;)for($=a;$-->0;)r[l][$]=A[l%m][$%o]+B[l%d][$%u];return r;}

Çevrimiçi deneyin.

Açıklama:

A->B->{                   // Method with integer-matrix as both parameters and return-type
  int m=A.length,         //  Rows of `A`                        (we got an     M)
      o=A[0].length,      //  Columns of `A`                     (we got an     O)
      d=B.length,         //  Rows of `B`                        (we got a      D)
      u=B[0].length,      //  Columns of `B`                     (we got a      U)
      l=m>d?m:d,          //  Maximum of both rows               (we got an     L)
      a=o>u?o:u,          //  Maximum of both columns            (we got an     A)
      r[][]=new int[l][a],//  Result-matrix of size `l` by `a`   (and we got an R)
      $;                  //  Temp integer                       (which $pells? ;P)
  for(;l-->0;)            //  Loop over the rows
    for($=a;$-->0;)       //   Inner loop over the columns
      r[l][$]=            //    Set the current cell in the result-matrix to:
        A[l%m][$%o]       //     The value at {`l` modulo-`m`, `$` modulo-`o`} in `A`
        +B[l%d][$%u];     //     Plus the value at {`l` modulo-`d`, `$` modulo-`u`} in `B`
  return r;}              //  Return the result matrix

APL (Dyalog Classic) , 23 21 bayt

↑{+⌿⍺[⍵|[0]⍳⍴⍺]}2,¨⍴¨

Çevrimiçi deneyin!

Bu, kullanma şansım olan tek zaman olabilir. |[0]

Python 2 , 124 116 bayt

l=len
A,B=sorted(input(),key=l)
A*=l(B)
for i in eval(`zip(A,B)`):a,b=sorted(i,key=l);a*=l(b);print map(sum,zip(*i))

Çevrimiçi deneyin!

Açıklama:

Giriş olarak iki 2 boyutlu listenin listesini alır.

l=len
A,B=sorted(input(),key=l)         # Sort inputed lists by length
A*=l(B)                           # Extend shorter list
for i in eval(`zip(A,B)`):        # Zip and remove copied references
  a,b=sorted(i,key=l)             # Sort lists in each pair (keep references)
  a*=l(b)                         # Extend shorter list
  print map(sum,zip(*i))          # Zip and sum

Python 2 , 101 97 105 bayt

Düzenleme: 4 bayt kaydetmek için Dead Possum'a (tekrar!) Teşekkürler

Düzenleme 2: 8 bayt kaybetti, bazı test durumları geçmedi

Dead Possum'un daha önceki çözümü (onun sayesinde!) Ve kendi Python 3 çözümü arasında bir karışım .

lambda y:[map(sum,P(i))for i in P(y)]
def P(y):y=sorted(y,key=len);y[0]*=len(y[1]);return eval(`zip(*y)`)

Çevrimiçi deneyin!

Python 3 çözümümle aynı girdi (bir çift 2 boyutlu liste).

Yorumlanan kod:

# Iterate over the nested lists, resized & joined by P(),
# and sum the inner joined items
lambda y:[map(sum,P(i))for i in P(y)]
def P(y):
 y=sorted(y,key=len)  # Sort the two input lists by length
 y[0]*=len(y[1])      # Multiply the smallest one by the biggest one's length
                      # (The smallest list is now the previously largest one)
 return eval(`zip(*y)`)  # Return paired list elements up to the smallest list's length

Julia 0.6 , 85 83 bayt

M\N=(((r,c),(s,d))=size.((M,N));repmat(M,s,d)+repmat(N,r,c))[1:max(r,s),1:max(c,d)]

Çevrimiçi deneyin!

(Değiştir ⧻ile \sayesinde Jo Kral )

Her bir matrisi yatay ve dikey olarak tekrarlayarak çalışır, böylece her ikisi de aynı boyuta sahip olur (satır boyutları x sütun boyutunun ürünü), bunları ekler ve ondan doğru bölgeyi çıkarırlar. (Satır vektör girişleri veya sütun vektör girişleri reshape, "iki boyutlu diziler için ek uygulama" ve "Girdi ve çıktı herhangi bir kişi tarafından alınabildiğinden", 2 boyutlu diziler olarak alınacak bir çağrıya ihtiyaç duyar. makul araçlar. Biçimleri her zamanki gibi esnek. ")