범위의 행렬

18

도전

테스트 결과에 표시된 것처럼 ~ 에서 모든 정수를 포함 n>0하는 n+1 X n+1행렬 이 정수로 출력됩니다.12n

테스트 사례

n=1  

1  2  
2  2

n=2

1   2   4  
2   3   4  
4   4   4

n=5  

1   2   3   4   5   10  
2   3   4   5   6   10  
3   4   5   6   7   10   
4   5   6   7   8   10  
5   6   7   8   9   10  
10  10  10  10  10  10  

n=10  

1   2   3   4   5   6   7   8   9   10  20  
2   3   4   5   6   7   8   9   10  11  20  
3   4   5   6   7   8   9   10  11  12  20  
4   5   6   7   8   9   10  11  12  13  20  
5   6   7   8   9   10  11  12  13  14  20  
6   7   8   9   10  11  12  13  14  15  20  
7   8   9   10  11  12  13  14  15  16  20  
8   9   10  11  12  13  14  15  16  17  20  
9   10  11  12  13  14  15  16  17  18  20  
10  11  12  13  14  15  16  17  18  19  20  
20  20  20  20  20  20  20  20  20  20  20

패턴이 매우 쉽다고 생각하므로 누가 가장 짧은 답을 바이트 단위로 볼 수 있는지 봅시다.
이것은 코드 골프입니다

규칙

입력 은 정수 여야합니다 ( 1-indexed )

출력 은 행렬 (테스트 사례에 표시됨) 또는 목록 목록 일 수 있습니다.

code-golf  array-manipulation  matrix 

답변:

10

R , 53 바이트

function(n)rbind(cbind(outer(1:n,1:n,`+`)-1,2*n),2*n)

용도 outer범위의 전체 합을 생성하기 위해 "제품" 1,...,n행렬, 차감 1한 후, 각각의 binds의 2*n결과로서 매트릭스를 필요로 재활용, 우측 열 및 하단 로우로 되돌아 온다.

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

R , 78 바이트

보다 순진한 구현.

function(n){m=matrix(2*n,n+1,n+1)
for(i in seq(n))m[1:n,i]=(0:(2*n))[1:n+i]
m}

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

— 주세페
소스
+1 좋은, 나는 외부에 대해 생각하고 있었지만 꽤 도착하지 못했습니다
— MickyT
7

매스 매 티카, 61 46 바이트

ArrayFlatten@{{##-1&~Array~{#,#},2#},{2#,2#}}&

-15 바이트의 경우 @alephalpha

— J42161217
소스
ArrayFlatten@{{Array[+##-1&,{#,#}],2#},{2#,2#}}&
— alephalpha
+##-1&그냥있을 수 ##-1&있고 당신은 infix를 사용할 수 있습니다 Array:ArrayFlatten@{{##-1&~Array~{#,#},2#},{2#,2#}}&
— ngenisis
5

MATL , 12 10 바이트

:&+q,!GEYc

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

설명

:       % Input n (implicit). Push range [1 2 ... n]
&+      % matrix of pairwise additions
q       % Subtract 1
,       % Do twice
  !     %   Transpose
  GE    %   Push 2*n
  Yc    %   Concatenate that value to all rows, thus extending the matrix
        % End (implicit). Display (implicit)
— 루이스 멘도
소스
4

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

f=
n=>[...Array(n+1)].map((_,i,a)=>a.map((_,j)=>n-i&&n-j?i-~j:n+n))
<input type=number min=0 oninput="t.innerHTML=f(+this.value).map(a=>`<tr>${a.map(b=>`<td>${b}</td>`).join``}</tr>`).join``"><table id=t>
스 니펫 확장

— 닐
소스
4

자바 8, 99 바이트

발 람다 Integer에 int[][](예 Function<Integer, int[][]>). 놀랍게도 골프에 강하다.

n->{int p=n+1,o[][]=new int[p][p],i=0,r,c;while(i<p*p)o[r=i/p][c=i++%p]=r<n&c<n?r-~c:2*n;return o;}

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

언 골프 람다

n -> {
    int
        p = n + 1,
        o[][] = new int[p][p],
        i = 0,
        r, c
    ;
    while (i < p * p)
        o[r = i / p][c = i++ % p] =
            r < n & c < n ?
                r - ~c
                : 2 * n
        ;
    return o;
}

감사의 말

  • Kevin Cruijssen 덕분에 -1 바이트
— 야콥
소스
at를 시작 i=0하고 넣어서 바이트를 골프화 할 수 있습니다 . ++[c=i++%p]
— Kevin Cruijssen에서
3

파이썬 2 , 64 62 61 바이트

Mr. Xcoder 덕분에 -3 바이트.

lambda n:[range(i+1,i-~n)+[n*2]for i in range(n)]+[[n*2]*-~n]

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

그래도 키 패턴이 누락되었을 수 있습니다.

파이썬 2 , 76 바이트

lambda n:[[[n*2,i-~j][n-i and n-j>0]for j in range(n+1)]for i in range(n+1)]

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

— 완전히 인간적인
소스
1
평소와 같이 *(n+1)입니다 *-~n.
— Mr. Xcoder
1
— Mr. Xcoder
Python 3 버전도 채택하고 싶다면 64 바이트입니다
— Mr. Xcoder
76 바이트 버전을 72 바이트
— Halvard Hummel
2

R , 54 63 67 바이트

function(n)cbind(rbind(sapply(1:n-1,'+',1:n),2*n),2*n)

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

sapply 및 9 바이트에 대한 포인터에 대한 @Guiseppe 덕분에

— 미키
소스
실제로,이 접근법은 또한 향상 될 수 있습니다 : sapply(1:n-1,'+',1:n)그러나 그것은 사용하는 것보다 단지 1 바이트 더 큽니다 outer(따옴표는 분명히 역틱입니다)
— Giuseppe
1
\`백틱으로 구분 된 코드 블록에서 백틱을 이스케이프 처리 @Giuseppe
— Cyoce
1

로다 , 44 바이트

f n{seq 1,n|[[seq(_,_1+n-1)]+2*n];[[2*n]*n]}

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

설명:

f n{seq 1,n|[[seq(_,_1+n-1)]+2*n];[[2*n]*n]}
f n{                                       } /* Function f(n)         */
    seq 1,n                                  /* Sequence 1..n         */
           |                                 /* For each _1:          */
              seq(_,_1+n-1)                  /*   Sequence _1.._1+n-1 */
             [             ]                 /*   As list             */
                            +2*n             /*   Append 2*n          */
            [                   ]            /*   Push to the stream  */
                                   [2*n]     /* List [2*n]            */
                                        *n   /* Multiplied by n       */
                                  [       ]  /* Push to the stream    */
— fergusq
소스
1

> <>, 84 + 2 바이트

-v 플래그에 +2

값 사이에 탭이 있고 행 사이에 줄 바꿈이 인쇄됩니다. 또한 마지막 줄에 후행 탭을 인쇄합니다.

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

1:r:&r&)?\0:r:&r&(?\~$:@2*nao1+!
a0./:r:0~<.17+1o9\ \$:@$:@+n9o1+
   \&r&)?;$:@2*n /

프리 골프

1>:r:&r&)?\0>    :r:&r&(?\~$:@2*nao1+\
            \+1o9n+@:$@:$/
 \                                   /
          \~0>:r:&r&)?;$:@2*n9o1+\
             \                   /
— 사샤
소스
0

클로저, 153135 바이트

목록의 목록? 예, Lisp

(fn[n](loop[r[] i 0 d (* 2 n)](if(= i n)(conj r(conj(repeat n d)d))(recur(conj r(conj(vec(map #(+ i %)(range 1(inc n))))d))(inc i)d))))

언 골프 드 :

(defn a[n]
  (loop [r[] i 0 d (* 2 n)]
    (if(= i n)
      (conj r(conj(repeat n d)d))
      (recur
        (conj r
            (conj (vec (map #(+ i %)(range 1(inc n)))) d))
        (inc i)
        d))))

입력을 인수로 받아서 목록 목록을 리턴하는 익명 함수.

n = 5의 출력 :

[[1 2 3 4 5 10] [2 3 4 5 6 10] [3 4 5 6 7 10] [4 5 6 7 8 10] [5 6 7 8 9 10] (10 10 10 10 10 10)]
— 여호수아
소스
0

05AB1E , 17 바이트

FLN+I·¸«ˆ}·¸I>.׈

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

설명

F                   # for N in [0 ... input-1]
 L                  # push range [1 ... input]
  N+                # add N to each
    I·¸«            # append input*2
        ˆ           # add to global list
         }          # end loop
          ·¸        # push [input*2]
            I>.×    # repeat it input+1 times
                ˆ   # add to global list
                    # implicitly output global list
— 에미 냐
소스
0

J, 29 바이트

(}:@(][\1+i.@+:),]#+:),.>:#+:

언 골프

(}:@(] [\ 1+i.@+:) , ]#+:) ,. >:#+:

설명

(}:@(] [\ 1+i.@+:)                   NB. make the inner part of the matrix
          1+i.@+:                      NB. 1..2*n, where n is the input
    (] [\ 1+i.@+:)                     NB. fork: infixes (sliding window) of length n, over 1..2*n
(}:@                                   NB. remove last element
                   , ]#+:)           NB. add a row of 2*n to the end
                           ,. >:#+:  NB. add a column of 2*n to entire result above

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

— 요나
소스
Heh, 내 APL 답변과 답변의 바이트 수가 동일합니다! 설명을 추가해 주시겠습니까?
— Zacharý
@ Zacharý가 업데이트되었습니다. FWIW, 이것은 아마도 golfed 수 적어도 자신과 같은, 그리고 아마도 J 전문가에 의해 추가로 10 개 이상의 바이트에 의해 사람이 조금 더합니다.
— 요나
0

실제로 23 바이트

;;Rnkp@;r♀+@;τ;(♀q)@α@q

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

설명:

;;Rnkp@;r♀+@;τ;(♀q)@α@q
;;                       two copies of input
  R                      range(1, input+1)
   n                     copy input times
    kp@                  push stack to list, remove first element
       ;r                push range(input)
         ♀+              pairwise addition (add the value in the range to each value in the corresponding list)
           @;            duplicate input again
             τ;          input*2, duplicate that
               (♀q)      append input*2 to each list
                   @α@q  append a row of input*2
— 메고
소스
0

클로저 v1.8, 97 바이트

#(conj(mapv(fn[i](conj(vec(range i(+ % i)))(* 2 %)))(range 1(inc %)))(vec(repeat(inc %)(* 2 %))))

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

설명

(range 1(inc %))                           Numbers from 1 to 'n'
(mapv ... (range 1(inc %)))                For each one of these numbers
(fn[i](conj(vec(range i(+ % i)))(* 2 %)))  Create the numbers from 'i' to (n+i-1), convert to vector and insert '2*n' to the vector
#(conj ... (vec(repeat(inc %)(* 2 %))))    Insert to the previous vector a vector of repeated '2*n's
— 크리스
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.