Penyiaran modular


24

Tantangan ini terkait dengan beberapa fitur bahasa MATL, sebagai bagian dari acara Bahasa Bulan Mei 2018 .


pengantar

Dalam MATL, banyak fungsi dua-input berfungsi elemen dengan siaran . Ini berarti yang berikut:

  • Elemen-bijaksana (atau vektor ): fungsi mengambil input dua array dengan ukuran yang cocok. Operasi yang ditentukan oleh fungsi diterapkan pada setiap pasangan entri yang sesuai. Misalnya, menggunakan notasi pasca-perbaikan:

    [2 4 6] [10 20 30] +
    

    memberikan ouput

    [12 24 36]
    

    Ini juga berfungsi dengan array multi-dimensi. Notasi [1 2 3; 4 5 6]mewakili 2× 3array (matriks)

    1 2 3
    4 5 6
    

    yang memiliki ukuran 2sepanjang dimensi pertama (vertikal) dan 3sepanjang dimensi kedua (horizontal). Jadi misalnya

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

    memberi

    [20 80 180; 120 300 560]
    
  • Broadcasting or ( ekspansi tunggal ): dua array input tidak memiliki ukuran yang cocok, tetapi di setiap dimensi yang tidak cocok salah satu array memiliki ukuran 1. Array ini secara implisit direplikasi sepanjang dimensi lain untuk membuat ukuran cocok; dan kemudian operasi diterapkan berdasarkan elemen seperti di atas. Misalnya, pertimbangkan dua larik masukan dengan ukuran 1× 2dan 3× 1:

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

    Berkat penyiaran, ini setara dengan

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

    dan itu memberi

    [10 20; 5 10; 2 4]
    

    Demikian pula, dengan ukuran 3× 2dan 3× 1(penyiaran sekarang hanya berfungsi sepanjang dimensi kedua),

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

    memberi

    [19 18; 27 26; 35 34]
    

    Jumlah dimensi bahkan mungkin berbeda. Misalnya, input dengan ukuran 3 × 2 dan 3 × 1 × 5 kompatibel, dan memberikan hasil 3 × 2 × 5. Bahkan, ukuran 3 × 2 adalah sama dengan 3 × 2 × 1 (ada banyak dimensi trailing tunggal implisit yang sewenang-wenang).

    Di sisi lain, sepasang 2× 2dan 3× 1array akan memberikan kesalahan, karena ukuran sepanjang dimensi pertama adalah 2dan 3: mereka tidak sama dan tidak satupun dari mereka adalah 1.

Definisi penyiaran modular

Penyiaran modular adalah generalisasi penyiaran yang berfungsi meskipun tidak ada ukuran yang tidak cocok 1. Pertimbangkan misalnya 2× 2dan 3× 1array berikut sebagai input dari fungsi +:

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

Aturannya adalah sebagai berikut: untuk setiap dimensi, larik yang lebih kecil di sepanjang dimensi itu direplikasi secara modular (secara siklik) agar sesuai dengan ukuran larik lainnya. Ini akan membuat setara dengan di atas

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

dengan hasilnya

[12 14; 26 28; 32 34]

Sebagai contoh kedua,

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

akan menghasilkan

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

Secara umum, input dengan ukuran a× bdan c× dmemberikan hasil ukuran max(a,b)× max(c,d).

Tantangan

Terapkan penambahan untuk array dua dimensi dengan penyiaran modular seperti yang didefinisikan di atas.

Array akan berbentuk persegi panjang (tidak kasar), hanya akan berisi bilangan bulat non-negatif , dan akan memiliki ukuran setidaknya1 di setiap dimensi.

Aturan tambahan:

Uji kasus

Berikut ini digunakan ;sebagai pemisah baris (seperti pada contoh di atas). Setiap test case menunjukkan dua input dan kemudian output.

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

"Terapkan tambahan untuk array dua dimensi" - ada kasus uji satu dimensi.
Jonathan Allan

Bolehkah kita berasumsi bahwa kita tidak mendapatkan input array kasar? (kelihatannya seperti itu)
Jonathan Allan

1
@ JonathanAllan Maaf karena tidak jelas. Ya, Anda dapat mengasumsikan tidak ada array yang tidak rata. Mereka akan menjadi array persegi panjang. "Satu dimensi" harus dianggap sebagai dua dimensi dengan ukuran 1× n(seperti [1 2 3]) atau n× 1(seperti [1; 2; 3])
Luis Mendo

Siaran yang Anda gambarkan tampaknya lebih terbatas daripada siaran MATLAB atau NumPy; dalam deskripsi Anda, input harus memiliki jumlah dimensi yang sama, batasan tidak ada dalam MATLAB atau NumPy. Apakah ini batasan MATL, atau penyederhanaan untuk tujuan tantangan (karena tantangan terbatas pada input 2D)?
user2357112 mendukung Monica

@ user2357112 Ya, itu adalah penyederhanaan dalam deskripsi. Penyiaran MATL sama dengan di MATLAB: Anda dapat memiliki input 3 × 2 dan 3 × 1 × 5 dan mendapatkan hasil 3 × 2 × 5. Sebenarnya, 3 × 2 setara dengan 3 × 2 × 1 (dimensi trailing implisit). Saya pikir itu mirip di Numpy (tetapi dengan dimensi terkemuka). Saya sudah mengklarifikasi itu dalam pendahuluan
Luis Mendo

Jawaban:


4

Jelly , 10 byte

ṁ€ZL$Z€Ɗ⁺S

Mengambil pasangan matriks (dua array baris) sebagai input dan mengembalikan matriks.

Cobalah online!

Bagaimana itu bekerja

ṁ€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.

1
Tentu saja ... Saya melihat semua bahasa golf ini agak kompatibel dalam hal byte yang diperlukan untuk sebuah tantangan (Jelly, 05AB1E, Pyth, APL, dll.) Sebagian besar jawaban saat ini adalah sekitar 20 byte, dan di sinilah Wizard Dennis bersama dengan jawaban separuh dari itu ..;) Cukup lucu ketika meme dan kebenaran adalah satu dan sama: " Tidak ada yang mengalahkan Dennis! .. "
Kevin Cruijssen

1
@KevinCruijssen APL bukan bahasa golf.
Adám

1
@ Adám saya tahu, saya tahu. Tapi itu masih sangat singkat (meskipun dikembangkan pertama kali pada 1960-an). Mungkin saya seharusnya mengatakan bahasa pendek daripada bahasa golf. Ah well ..
Kevin Cruijssen

5

Arang , 25 23 byte

AθIE⌈EθLιE⌈EθL§λ⁰ΣE觧νιλ

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Mengambil input sebagai array 3 dimensi. Penjelasan:

Aθ

Masukkan semuanya.

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

: P (lebih lama>>>)
ASCII-hanya

5

MATL , 25 24 byte

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

Cobalah online!

Akhirnya! Hanya butuh satu minggu untuk tantangan yang terinspirasi oleh Bahasa Bulan ini untuk dijawab oleh Bahasa Bulan ini!

Dugaan saya adalah bahwa ini tidak sesingkat mungkin, tapi saya cukup senang karena versi awal saya lebih dari 40 byte. sunting: Saya benar, Luis menemukan byte lain untuk dimatikan!

,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

menunggu Luis Mendo bermain golf lebih dari 5 byte ;-)
Giuseppe

:-D Program saya untuk kasus uji memiliki 26 byte, bagus sekali! Penggunaan yang bagus :dengan input vektor
Luis Mendo

4

Python 3 , 127 126 125 byte

golf byte dengan mengubah sum(m)kem+n

Satu byte lagi berkat @Jonathan Frech

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

Mengambil input sebagai daftar dua array 2 dimensi.

  • The Zlambda mengambil dua array sebagai masukan dan mengembalikan sebuah iterator menghasilkan indeks dan digabung nilai-nilai dari kedua array, sampai indeks mencapai panjang array terbesar ini. Variabel indeks tidak berguna bagi saya dan saya biaya byte, tapi saya tidak tahu bagaimana melakukannya tanpa itu ... ( terkait )
  • Lambda utama hanya mengambil array input dan memanggil array Zluar dan dalam. Nilai-nilai terdalam ditambahkan bersama.

Cobalah online!

Menggunakan itertools.cycleterasa agak seperti curang tapi saya pikir saya sudah cukup dihukum dengan panjangnya pernyataan impor :)

Saya yakin ini bisa golf lagi, terutama metode iterasi yang membuat variabel idan tidak berguna ini j. Saya akan berterima kasih atas tips bagaimana golf itu, saya mungkin kehilangan sesuatu yang jelas.


Bisakah Anda menukar zipargumen, membalikkan fpenugasan pemahaman, dan dengan demikian menghapus satu spasi ( for i,*l-> for*l,i)? ( 125 byte )?
Jonathan Frech 3-18

Satu byte lagi, terima kasih! Saya akan memperbarui posting saya.
etene

3

JavaScript (ES6), 131 byte

Bukan alat yang tepat untuk pekerjaan itu, dan mungkin juga bukan pendekatan yang tepat. Oh well ... ¯ \ _ (ツ) _ / ¯

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

Cobalah online!

Bagaimana?

Fungsi helper g () membuat array yang sebesar array input terbesar ( a atau b ) dan memanggil fungsi callback c di atasnya:

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

Fungsi helper h () membaca 2D-array a at (x, y) dengan penyiaran modular:

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

Kode utama sekarang cukup dibaca sebagai:

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

Versi rekursif, 134 byte

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)

Cobalah online!


3

05AB1E , 15 byte

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

Cobalah online!


Versi lama, 25 byte

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

Cobalah online!

Penjelasan

15-byter:

2FεIζg∍ø] øεø¨} O - Program lengkap. Mengambil input sebagai daftar [A, B] 3D dari STDIN.
2F - Mendaftar dua kali:
  ε - Untuk masing-masing dalam [A, B]:
   Iζ - Transpose input (mengisi celah dengan spasi).
     g - Panjang (mengambil jumlah baris).
      ∍ - Perpanjang item saat ini (A atau B) dengan panjang yang diperlukan.
       ø - Transpose.
        ] - Tutup semua loop.
         ø - Transpos lagi.
          ε - Untuk setiap baris dalam ^ (kolom hasil loop):
           ø - Ubah posisi kolom.
            ¨} - Hapus elemen terakhir dan tutup loop peta.
              O - Jumlah.

25-byter:

é`DŠg∍) Σнg} `DŠнgδ∍ € ˜) ø € øO - Program lengkap. Mengambil input sebagai daftar 3D dari STDIN.
é - Urutkan daftar menurut panjangnya.
 `D - Membuang konten secara terpisah ke tumpukan, menduplikasi ToS.
   Š - Melakukan triple swap. a, b, c -> c, a, b.
    g - Dapatkan panjang ToS.
     ∍ - Perpanjang daftar yang lebih pendek (tingginya) sesuai.
      ) Σ} - Bungkus seluruh tumpukan ke dalam daftar dan urutkan berdasarkan:
        нg - Panjang item pertama.
           `DŠ - Sama seperti di atas.
              нg - Panjang elemen pertama.
                δ∍ € ˜ - Perpanjang daftar yang lebih pendek (lebar) sesuai. 
                    ) ø - Bungkus tumpukan ke dalam daftar dan transpos (zip) itu.
                      € ø - Kemudian poskan setiap daftar.
                        O - Terapkan penjumlahan vektor.

3

R , 136 104 103 95 93 byte

Golf turun 33 35 byte mengikuti saran Giuseppe. Berhasil mendapatkan di bawah 100 byte dengan menggunakan operator sebagai nama fungsi. Lihat riwayat untuk kode yang lebih mudah dibaca.

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)

Cobalah online!


Bagus! Saya telah menurunkan ini ke 104 byte tetapi menggunakan applydan rep.lenapa yang saya pertimbangkan, meskipun saya belum sempat untuk mengodekannya sendiri.
Giuseppe

@Giuseppe Terima kasih! Versi 104 tidak memberikan hasil yang diharapkan.
JayCe

1
Ugh, aku terus menyesatkanmu! yang ini seharusnya bekerja
Giuseppe

1
@Giuseppe Suka penggunaan dim, lebih bersih dan membuka pintu untuk generalisasi multi-dimensi dengan panggilan rekursif ker
JayCe

Saya sudah mencoba menggunakan outer(x,y,"+")yang berisi semua jumlah yang tepat, dan dalam pola yang jelas. Tidak dapat menemukan cara mengekstraknya secara efisien.
ngm


2

05AB1E , 18 byte

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

Cobalah online!

Penjelasan

é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

2

Pyth, 24 byte

KeSmlhdQmm+Fm@@bdkQKeSlM

Coba di sini

Penjelasan

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.

2

Java 8, 172 byte

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

Cobalah online.

Penjelasan:

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


2

Python 2 , 124 116 byte

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

Cobalah online!

Penjelasan:

Mengambil daftar dua daftar 2-d sebagai input.

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

Saya mengambil ide dari kedua solusi kami dan turun ke 105 byte . Saya harus menggunakan Python 2, dan saya mendapat trik multiplikasi dari kode Anda, jadi tidak akan terasa benar untuk memperbarui jawaban saya :)
etene

1
@etene Anda harus mempostingnya, ini solusi yang bagus!
Dead Possum

Sial, kesalahan yang sangat bodoh di pihak saya, terima kasih (lagi)!
etene

1
@etene Hanya memperhatikan, solusi ini memiliki masalah dengan 2 dan 6 kasus uji. Perlu menghapus referensi yang disalin
Dead Possum

1
@etene Kembali ke 105 byte : C
Dead Possum

2

Python 2 , 101 97 105 byte

Sunting: Terima kasih (lagi!) Ke Dead Possum karena menyimpan 4 byte

Sunting 2: kehilangan 8 byte, beberapa kasus uji tidak lulus

Gabungan antara solusi Dead Possum sebelumnya (terima kasih padanya!), Dan solusi Python 3 saya sendiri .

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

Cobalah online!

Masukan yang sama dengan solusi Python 3 saya (sepasang daftar 2 dimensi).

Kode yang dikomentari:

# 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

1

Julia 0,6 , 85 83 byte

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

Cobalah online!

(Ganti dengan \terima kasih kepada Jo King )

Bekerja dengan mengulangi setiap matriks secara horizontal dan vertikal sehingga mereka berdua memiliki ukuran yang sama (produk ukuran baris x produk ukuran kolom), menambahkan mereka ke atas dan mengekstraksi keluar daerah yang benar dari itu. (Input vektor baris atau input vektor kolom perlu reshapepanggilan untuk dilemparkan sebagai array 2 dimensi, yang saya asumsikan baik-baik saja karena pertanyaannya menentukan "Menerapkan penambahan untuk array dua dimensi" dan "Input dan output dapat diambil oleh cara yang masuk akal. Format mereka fleksibel seperti biasa. ")

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.