Matriz en rango

18

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

code-golf  array-manipulation  matrix 

Respuestas:

10

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!

— Giuseppe
fuente
1 agradable, estaba pensando en el exterior, pero aún no había llegado allí
— MickyT
7

Mathematica, 61 46 bytes

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

Gracias @alephalpha por -15 bytes

— J42161217
fuente
ArrayFlatten@{{Array[+##-1&,{#,#}],2#},{2#,2#}}&
— alephalpha
+##-1&puede ser ##-1&y puede usar infijo Array:ArrayFlatten@{{##-1&~Array~{#,#},2#},{2#,2#}}&
— ngenisis
5

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)
— Luis Mendo
fuente
4

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>
Expandir fragmento

— Neil
fuente
4

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
— Jakob
fuente
Puede jugar golf en un byte iniciando i=0y poniendo el ++at [c=i++%p].
— Kevin Cruijssen
3

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!

— totalmente humano
fuente
1
Como de costumbre, *(n+1)es *-~n.
— Sr. Xcoder
1
— Sr. Xcoder
Si también quieres adoptar la versión de Python 3, lo más corto que puedo obtener es 64 bytes
— Sr. Xcoder
La versión de 76 bytes se puede reducir a 72 bytes
— Halvard Hummel
2

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

— MickyT
fuente
En realidad, este enfoque también se puede mejorar: sapply(1:n-1,'+',1:n)pero es solo 1 byte más que usar outer(las comillas son obviamente backticks)
— Giuseppe
1
\`funciona para escapar backticks en un bloque de código delimitado por backticks @Giuseppe
— Cyoce
2

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!

— officialaimm
fuente
1

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    */
— fergusq
fuente
1

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
— Zacharý
fuente
1

> <>, 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+\
             \                   /
— Sasha
fuente
0

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)]
— Joshua
fuente
0

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
— Emigna
fuente
0

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!

— Jonás
fuente
¡Heh, mi respuesta APL y tu respuesta tienen el mismo número de bytes! ¿Puedes agregar una explicación por favor?
— Zacharý
@ Zacharý, actualizado. fwiw, esto probablemente podría ser jugado al menos un poco más por alguien como yo, y quizás por más de 10 bytes adicionales por un experto J.
— Jonás
0

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
— Mego
fuente
0

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
— Chris
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.