Matryca w zakresie

18

Wyzwanie

Biorąc pod uwagę całkowitą n>0wyprowadzeniu n+1 X n+1matrycę zawierającą wszystkie liczby całkowite od 1celu 2n, jak pokazano w testach mieszkowy

Przypadki testowe

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

Myślę, że wzór jest dość łatwy, więc zobaczmy, kto udzieli najkrótszej odpowiedzi w bajtach.
To jest golf golfowy

Zasady

Dane wejściowe muszą być liczbą całkowitą ( indeksowane 1 )

Wyjściem może być macierz (jak pokazano w przypadkach testowych) lub lista list

code-golf array-manipulation matrix
źródło

Odpowiedzi:

10

R , 53 bajty

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

Używa outer„produktu” do generowania wszystkich sum zakresu 1,...,njako macierzy, odejmuje 1od nich, a następnie binds 2*njako kolumnę po prawej stronie i wiersz na dole, w razie potrzeby recyklinguje i zwraca macierz w wyniku.

Wypróbuj online!

R , 78 bajtów

Bardziej naiwne wdrożenie.

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}

Wypróbuj online!

Giuseppe
źródło
+1 fajnie, myślałem o zewnętrznym, ale nie całkiem tam dotarłem
MickyT
7

Mathematica, 61 46 bajtów

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

thanx @alephalpha dla -15 bajtów

J42161217
źródło
ArrayFlatten@{{Array[+##-1&,{#,#}],2#},{2#,2#}}&
alephalpha
+##-1&może po prostu być ##-1&i możesz użyć ArrayArrayFlatten@{{##-1&~Array~{#,#},2#},{2#,2#}}&
infix
5

MATL , 12 10 bajtów

:&+q,!GEYc

Wypróbuj online!

Wyjaśnienie

:       % 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)
Luis Mendo
źródło
4

Galaretka , 11 bajtów

+þḶ;€Ḥ;ḤzḤG

Wypróbuj online!

Leaky Nun
źródło
Już miał pisać bajt po bajcie bez Gzbędnego wymagania
Jonathan Allan
Dobre wykorzystanie produktu zewnętrznego
Zacharý
@JonathanAllan korzysta z innego rozwiązania ;€ḤZ;€Ḥ...
Leaky Nun
... a jeszcze innym jest Ḷ;Ḥ©µ+þ‘«®; p
Jonathan Allan
1
@JonathanAllan i inne zastosowania +€Ḷ;Ḥṁ€;€Ḥ: p
Erik the Outgolfer
4

JavaScript (ES6), 64 bajty

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>
Rozwiń fragment kodu

Neil
źródło
4

Java 8, 99 bajtów

Lambda od Integerdo int[][](np Function<Integer, int[][]>.). Zaskakująco odporny na golfa.

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

Wypróbuj online

Niegolfowana lambda

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

Podziękowanie

  • -1 bajt dzięki Kevin Cruijssen
Jakob
źródło
Można golf bajt zaczynając i=0i kładzenie ++się [c=i++%p].
Kevin Cruijssen
3

Python 2 , 64 62 61 bajtów

-3 bajty dzięki Mr. Xcoder.

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

Wypróbuj online!

Prawdopodobnie brakuje mi jednak klucza.

Python 2 , 76 bajtów

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

Wypróbuj online!

całkowicie ludzki
źródło
1
Jak zwykle *(n+1)jest *-~n.
Mr. Xcoder
1
Trochę więcej zaciemnienia dla 61 bajtów
Mr. Xcoder
Jeśli chcesz również przyjąć wersję Python 3, najkrótsze, jakie mogłem uzyskać, to 64 bajty
Mr. Xcoder
Wersję 76 bajtów można zmniejszyć do 72 bajtów
Halvard Hummel
2

Proton ,  48  44 bajtów

-4 bajty dzięki @totallyhuman!

n=>[(i+1..i-~n)+[n*2]for i:0..n]+[[n*2]*-~n]

Wypróbuj online!

Pan Xcoder
źródło
44 bajty.
całkowicie ludzki,
@ całkowicie ludzkie dzięki.
Pan Xcoder,
2

R , 54 63 67 bajtów

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

Wypróbuj online!

Dzięki @Guiseppe za wskaźnik dla sapply i 9 bajtów

MickyT
źródło
W rzeczywistości to podejście można również ulepszyć: sapply(1:n-1,'+',1:n)ale wtedy jest to zaledwie 1 bajt więcej niż użycie outer(cytaty są oczywiście odwrotne)
Giuseppe
1
\`działa na ucieczkę backticks w bloku kodu ograniczonym backticks @Giuseppe
Cyoce
2

Recursiva , 50 bajtów

  • Tylko 10 bajtów krótszych niż python, a zatem jest oficjalny, Recursiva wcale nie jest językiem golfowym ... Jest to jednak esolang. :RE
|{Ba+++++'PJ"	"W+Z~}B+~}'Va'+}'Va'AD'VaJ"	"W*;aADa

Wypróbuj online!

Officialaimm
źródło
1

Röda , 44 bajty

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

Wypróbuj online!

Wyjaśnienie:

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
źródło
1

Dyalog APL, 29 bajtów

Wymaga ⎕IO←0

{(S,⍨1+¯1 ¯1↓∘.+⍨⍳⍵+1)⍪S←2×⍵}

Wypróbuj online!

W jaki sposób?

  • 1+¯1 ¯1↓∘.+⍨⍳⍵+1 lewa górna część tablicy
  • (S,⍨...)⍪S←2×⍵ róg
Zacharý
źródło
1

> <>, 84 + 2 bajty

+2 dla flagi -v

Drukuje z tabulatorami między wartościami i znakami nowej linii między wierszami. Drukuje także tabulację końcową w ostatnim wierszu.

Wypróbuj online

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

Gra w golfa

1>:r:&r&)?\0>    :r:&r&(?\~$:@2*nao1+\
            \+1o9n+@:$@:$/
 \                                   /
          \~0>:r:&r&)?;$:@2*n9o1+\
             \                   /
Sasha
źródło
0

Galaretka, 14 bajtów

R+’r@R;€Ḥz0;€Ḥ

Wypróbuj online!

Zacharý
źródło
0

Kotlin , 59 bajtów

Array(n+1){c->Array(n+1){r->when(n){c,r->n*2;else->1+c+r}}}

Wypróbuj online.

Valentin Michalak
źródło
0

Clojure, 153 135 bajtów

Lista list? Yay, 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))))

Nie golfowany:

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

Anonimowa funkcja, która przyjmuje dane wejściowe jako argument i zwraca listę list.

Wyjście 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)]
Jozuego
źródło
0

05AB1E , 17 bajtów

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

Wypróbuj online!

Wyjaśnienie

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
Emigna
źródło
0

J, 29 bajtów

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

bez golfa

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

wyjaśnienie

(}:@(] [\ 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

Wypróbuj online!

Jonasz
źródło
Heh, moja odpowiedź APL i twoja odpowiedź mają tę samą liczbę bajtów! Czy możesz dodać wyjaśnienie?
Zacharý
@ Zacharý, zaktualizowano. fwiw, może to być gra w golfa przynajmniej trochę dalej przez kogoś takiego jak ja, a być może dodatkowe 10+ bajtów przez eksperta J.
Jonasz
0

Właściwie 23 bajty

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

Wypróbuj online!

Wyjaśnienie:

;;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
Mego
źródło
0

Clojure v1.8, 97 bajtów

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

Wypróbuj online!

Wyjaśnienie

(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
Chris
źródło