이 과제는 2018 년 5 월 Language of the Month 이벤트 의 일부로 일부 MATL 언어 기능과 관련이 있습니다 .

소개

MATL에서 많은 2 입력 함수 는 broadcast 와 함께 요소별로 작동 합니다. 이것은 다음을 의미합니다.

• 요소 별 (또는 벡터화 ) :이 함수는 크기가 일치하는 두 개의 배열을 입력으로받습니다. 함수에 의해 정의 된 작업은 해당 항목의 각 쌍에 적용됩니다. 예를 들어, 수정 후 표기법 사용 :

  [2 4 6] [10 20 30] +
  

  출력을 제공 합니다

  [12 24 36]
  

  이것은 다차원 배열에서도 작동합니다. 표기법 [1 2 3; 4 5 6]은 2× 3배열 (행렬)을 나타냅니다.

  1 2 3
  4 5 6
  

  2첫 번째 치수 (수직)와 3두 번째 (수평)를 따라 크기가 있습니다 . 예를 들어

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

  준다

  [20 80 180; 120 300 560]
  

• 브로드 캐스팅 또는 ( 단일 확장 ) : 두 입력 배열의 크기는 일치하지 않지만 각 비 일치 차원에서 배열 중 하나의 크기는 size 1입니다. 이 배열은 다른 차원을 따라 암시 적으로 복제되어 크기를 일치시킵니다. 그런 다음 작업이 위와 같이 요소별로 적용됩니다. 예를 들어, 크기가 1× 2및 3× 인 두 개의 입력 배열을 고려하십시오 1.

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

  방송 덕분에 이것은

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

  그래서 그것은 준다

  [10 20; 5 10; 2 4]
  

  마찬가지로 3× 2및 3× 크기 1(방송은 이제 두 번째 측정 기준에만 적용됨),

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

  준다

  [19 18; 27 26; 35 34]
  

  차원 수는 다를 수도 있습니다. 예를 들어, 크기가 3 × 2 및 3 × 1 × 5 인 입력은 호환 가능하며 3 × 2 × 5 결과를 제공합니다. 실제로, 크기 3 × 2는 3 × 2 × 1과 동일하다 (임의적으로 많은 암시 적 후행 싱글 톤 치수가있다).

  반면에, 2x 2및 3x 1배열 쌍은 첫 번째 차원의 크기가 2and 이므로 크기 3가 같고 같지 않기 때문에 오류가 발생 합니다 1.

모듈 식 방송의 정의

모듈 식 방송은 일치하지 않는 크기가없는 경우에도 작동하는 방송의 일반화입니다 1. 예를 들어 함수의 입력으로 다음 2× 2및 3× 1배열을 고려하십시오 +.

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

규칙은 다음과 같습니다. 각 차원마다 해당 차원을 따라 더 작은 배열이 다른 배열의 크기와 일치하도록 모듈 식 (순환)으로 복제 됩니다. 이것은 위의 내용을

[2 4; 6 8; 2 4] [10 10; 20 20; 30 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]

일반적으로, 크기와 입력 a× b와 c× d주고 크기의 결과 max(a,b)× max(c,d).

도전

위에서 정의한대로 모듈 식 브로드 캐스트 로 2 차원 어레이에 대한 추가 를 구현 합니다 .

배열은 직사각형 (비정형이 아님)이며 음이 아닌 정수만 포함 하며 최소한1 각 차원에서 크기를 갖습니다 .

추가 규칙 :

• 입력 및 출력은 합리적인 방법 으로 수행 할 수 있습니다 . 그들의 형식은 평소처럼 유연합니다.

• 모든 프로그래밍 언어의 프로그램 또는 기능이 허용 됩니다 . 표준 허점은 금지되어 있습니다.

• 바이트 단위의 최단 코드가 이깁니다.

테스트 사례

다음은 ;행 분리 자로 사용 됩니다 (위 예에서와 같이). 각 테스트 사례에는 두 개의 입력과 출력이 표시됩니다.

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

젤리 , 10 바이트

ṁ€ZL$Z€Ɗ⁺S

행렬 쌍 (행의 두 배열)을 입력으로 받아서 행렬을 반환합니다.

온라인으로 사용해보십시오!

작동 원리

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

숯 , 25 23 바이트

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

온라인으로 사용해보십시오!링크는 자세한 버전의 코드입니다. 입력을 3 차원 배열로받습니다. 설명:

Ａθ

모든 것을 입력하십시오.

    θ                   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 바이트

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

온라인으로 사용해보십시오!

마침내! 이 달의 언어에서이 달 의 언어 로 답을 얻는 데 1 주일 밖에 걸리지 않았습니다!

내 생각 엔 가능한 한 짧지는 않지만 초기 버전이 40 바이트를 초과했기 때문에 나는 행복합니다. 편집 : 내가 맞아, 루이스가 짜낼 다른 바이트를 발견했습니다!

,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

파이썬 (3) , 127 (126) 125 바이트

로 변경 sum(m)하여 바이트를 골프m+n

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

두 개의 2 차원 배열 목록으로 입력을받습니다.

• Z인덱스가 가장 큰 어레이의 길이에 도달 할 때까지, λ는, 입력으로서 두 배열을 취하고 반복자 인덱스를 산출하고 두 배열에서 값을 병합 반환한다. 인덱스 변수는 나에게 유용하지 않고 바이트 비용이 들지만, 그것 없이는 어떻게 해야할지 모르겠다 ... ( related )
• 기본 람다는 입력 배열을 가져 와서 Z외부 및 내부 배열을 호출 합니다. 가장 안쪽 값이 함께 추가됩니다.

온라인으로 사용해보십시오!

사용 itertools.cycle하는 것은 부정 행위와 같은 느낌이 들지만 나는 단순한 수입 명세서 길이로 충분히 벌을 받았다고 생각합니다. :)

나는 확실히이 특히 반복 방법, 좀 더 golfed 수있어 잎이 쓸모없는 그 i와 j변수. 골프를 치는 방법에 대한 조언에 감사 할 것입니다.

자바 스크립트 (ES6), 131 바이트

작업에 적합한 도구가 아니며 올바른 방법도 아닙니다. 오 잘 ... ¯ \ _ (ツ) _ / ¯

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

온라인으로 사용해보십시오!

방법?

헬퍼 함수 g () 는 가장 큰 입력 배열 ( a 또는 b ) 만큼 큰 배열을 작성하고 그 위에 콜백 함수 c 를 호출 합니다.

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

도우미 함수 h ( ) 는 모듈 식 브로드 캐스팅을 사용 하여 2D 배열 a at (x, y) 를 읽습니다 .

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

기본 코드는 이제 다음과 같이 간단하게 읽습니다.

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

재귀 버전, 134 바이트

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)

온라인으로 사용해보십시오!

05AB1E , 15 바이트

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

온라인으로 사용해보십시오!

이전 버전, 25 바이트

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

온라인으로 사용해보십시오!

설명

15 바이 터 :

2FεIζg∍ø] øεø¨} O – 전체 프로그램. STDIN에서 3D [A, B] 목록으로 입력을받습니다.
2F – 두 번 적용 :
  ε – [A, B] 각각에 대해 :
   Iζ – 입력을 바꿉니다 (공백으로 간격 채우기).
     g – 길이 (행 수 검색).
      ∍ – 현재 항목 (A 또는 B)을 필요한 길이로 확장합니다.
       ø – 조옮김.
        ] – 모든 루프를 닫습니다.
         ø – 다시 바꿉니다.
          ε – ^의 각 행에 대해 (루프 결과 열) :
           ø – 열을 바꿉니다.
            ¨} – 마지막 요소를 제거하고 맵 루프를 닫습니다.
              O – 합계

25 바이 터 :

é`DŠg∍) Σнg}`DŠнgδ∍ € ~) ø € øO – 전체 프로그램. STDIN에서 3D 목록으로 입력을받습니다.
é – 목록을 길이별로 정렬합니다.
 `D – 내용물을 스택에 따로 덤프하고 ToS를 복제합니다.
   – 트리플 스왑을 수행합니다. a, b, c-> c, a, b.
    g – ToS의 길이를 얻습니다.
     ∍ – 짧은 목록 (높이)을 적절히 확장하십시오.
      ) Σ} – 전체 스택을 목록으로 묶고 다음을 기준으로 정렬합니다.
        нg – 첫 번째 항목의 길이입니다.
           `DŠ – 위와 동일합니다.
              нg – 첫 번째 요소의 길이입니다.
                δ∍ € ~ – 짧은 목록 (너비)을 적절히 확장합니다. 
                    ) – 스택을 목록으로 감싸서 바꿉니다 (zip).
                      € ø-그런 다음 각 목록을 압축하십시오.
                        O – 벡터화 된 합계를 적용합니다.

R , 1361041039593 바이트

주세페의 조언에 따라 무려 33 35 바이트를 기록했습니다. 연산자를 함수 이름으로 사용하여 100 바이트 미만이되도록 관리했습니다. 더 읽기 쉬운 코드는 히스토리를 참조하십시오.

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)

온라인으로 사용해보십시오!

K (ngn / k) , 23 바이트

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

온라인으로 사용해보십시오!

05AB1E , 18 바이트

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

온라인으로 사용해보십시오!

설명

é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 바이트

KeSmlhdQmm+Fm@@bdkQKeSlM

여기 사용해보십시오

설명

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.

자바 8, 172 바이트

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

온라인으로 사용해보십시오.

설명:

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 바이트

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

온라인으로 사용해보십시오!

이것은 내가 사용할 수있는 유일한 시간이 될 수 있습니다. |[0]

파이썬 2 , 124116 바이트

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

온라인으로 사용해보십시오!

설명:

두 개의 2 차원 목록을 입력으로 사용합니다.

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

파이썬 2 , 101 97105 바이트

편집 : 4 바이트 저장에 대한 Dead Possum에게 감사합니다 (다시!)

편집 2 : 8 바이트를 잃어 버렸습니다. 일부 테스트 사례는 통과하지 못했습니다.

사이의 혼합 죽은 좀도둑의 이전 솔루션 (그 덕분에!), 그리고 내 자신의 파이썬 3 솔루션 .

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

온라인으로 사용해보십시오!

내 Python 3 솔루션과 동일한 입력 (2 차원 목록 쌍).

주석이 달린 코드 :

# 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

줄리아 0.6 , 85 83 바이트

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

온라인으로 사용해보십시오!

(교체 ⧻로 \덕분에 조 왕 )

각 행렬을 가로 및 세로로 반복하여 동일한 크기 (행 크기의 곱 x 열 크기의 곱)를 가짐으로써 행렬을 더하고 올바른 영역을 추출합니다. (행 벡터 입력 또는 열 벡터 입력 reshape은 2 차원 배열로 캐스트하기 위해 호출이 필요합니다. 이 질문은 "2 차원 배열에 대한 구현 추가"와 "입력 및 출력은 합리적인 수단. 그들의 형식은 평소처럼 유연합니다. ")