El reto

Dado un n>0resultado entero, a continuación se muestra una n+1 X n+1matriz que contiene todos los enteros de 1a 2ncomo se muestra en los casos de prueba

Casos de prueba

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  

Creo que el patrón es bastante fácil, así que veamos quién dará la respuesta más corta en bytes.
Este es el código de golf

Reglas

La entrada debe ser un número entero ( 1 indexado )

La salida puede ser una matriz (como se muestra en los casos de prueba) o una lista de listas

R , 53 bytes

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

Utiliza el outer"producto" para generar todas las sumas del rango 1,...,ncomo una matriz, resta 1de cada una, luego binds 2*ncomo una columna a la derecha y una fila en la parte inferior, reciclando según sea necesario, y devuelve una matriz como resultado.

Pruébalo en línea!

R , 78 bytes

Implementación más ingenua.

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}

Pruébalo en línea!

Mathematica, 61 46 bytes

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

Gracias @alephalpha por -15 bytes

MATL , 12 10 bytes

:&+q,!GEYc

Pruébalo en línea!

Explicación

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

Haskell , 48 bytes

f n=[[i..n-1+i]++[2*n]|i<-[1..n]]++[2*n<$[0..n]]

Pruébalo en línea!

Octava, 38 37 35 bytes

@(n)[(x=1:n)+x'-1 z=~x'+2*n;z' 2*n]

Pruébalo en línea!

o

@(n)~(k=blkdiag((x=1:n)+x'-1,0))*2*n+k

Pruébalo en línea!

Jalea , 11 bytes

+þḶ;€Ḥ;ḤzḤG

Pruébalo en línea!

JavaScript (ES6), 64 bytes

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>

Java 8, 99 bytes

Lambda de Integera int[][](p Function<Integer, int[][]>. Ej .). Sorprendentemente resistente al golf.

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

Pruébalo en línea

Lambda sin golf

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

Expresiones de gratitud

• -1 byte gracias a Kevin Cruijssen

Python 2 , 64 62 61 bytes

-3 bytes gracias al Sr. Xcoder.

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

Pruébalo en línea!

Sin embargo, probablemente me falta un patrón clave.

Python 2 , 76 bytes

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

Pruébalo en línea!

Pyth , 18 bytes

+m+rd+QdyQSQ]*]yQh

Tal vez me falta un patrón obvio (cc @totallyhuman ) ...

Banco de pruebas.

Suite de prueba "Pretty print".

Protón ,  48  44 bytes

-4 bytes gracias a @totallyhuman!

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

Pruébalo en línea!

R , 54 63 67 bytes

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

Pruébalo en línea!

Gracias a @Guiseppe por el puntero para sapply y los 9 bytes

Japt , 17 16 bytes

õ_óU pU*2ÃpUô@*2

Pruébalo en línea!

Recursiva , 50 bytes

• Solo 10 bytes más corto que Python y, por lo tanto, es oficial, Recursiva no es un lenguaje de golf en absoluto ... Sin embargo, es un esolang. :RE

|{Ba+++++'PJ"	"W+Z~}B+~}'Va'+}'Va'AD'VaJ"	"W*;aADa

Pruébalo en línea!

C (gcc) , 119 116 115 107 bytes

i,j;f(n){for(;j<n;j++,printf("%d\n",2*n))for(i=0;i++<n;printf("%d\t",j+i));for(;j=i--;printf("%d\t",n*2));}

Pruébalo en línea!

Röda , 44 bytes

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

Pruébalo en línea!

Explicació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    */

Dyalog APL, 29 bytes

Requiere ⎕IO←0

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

Pruébalo en línea!

¿Cómo?

• 1+¯1 ¯1↓∘.+⍨⍳⍵+1 la parte superior izquierda de la matriz
• (S,⍨...)⍪S←2×⍵ la esquina

> <>, 84 + 2 bytes

+2 para la bandera -v

Imprime con pestañas entre valores y líneas nuevas entre filas. También imprime una pestaña final en la última línea.

Pruébalo en línea

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

Pre-golf

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

SOGL V0.12 , 22 bytes

∫HA.∫a+}.«¹}¹.I.«r∙rο+

Pruébalo aquí!
deja la salida en la pila, que puede ver en la consola

Jalea, 14 bytes

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

Pruébalo en línea!

Perl 5 , 56 bytes

$,=$";say($_..$_+$"-1,$"*2)for 1..($"=<>);say(($"*2)x$")

Pruébalo en línea!

Kotlin , 59 bytes

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

Pruébalo en línea.

Clojure, 153 135 bytes

Lista de listas? 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))))

Sin golf:

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

Función anónima que toma la entrada como argumento y devuelve una lista de listas.

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

05AB1E , 17 bytes

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

Pruébalo en línea!

Explicación

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

J, 29 bytes

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

sin golf

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

explicación

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

Pruébalo en línea!

En realidad , 23 bytes

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

Pruébalo en línea!

Explicación:

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

Clojure v1.8, 97 bytes

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

Pruébalo en línea!

Explicación

(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

Fortran (GFortran) , 93 , 82 bytes

SUBROUTINE M(n)
PRINT*,(CHAR(10),(i-1+j,i=1,n),2*n,j=1,n)
PRINT*,(2*n,j=1,n+1)
END

Pruébalo en línea!