Matriz no intervalo

18

O desafio

Dada uma n>0saída inteira, uma n+1 X n+1matriz contém todos os números inteiros de 1a 2ncomo mostrado nos casos de teste abaixo

Casos de teste

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

Eu acho que o padrão é bem fácil, então vamos ver quem dará a resposta mais curta em bytes.
Isso é código-golfe

Regras

A entrada deve ser um número inteiro ( indexado 1 )

A saída pode ser uma matriz (conforme mostrado nos casos de teste) ou uma lista de listas

code-golf array-manipulation matrix
fonte

Respostas:

10

R , 53 bytes

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

Usa o outer"produto" para gerar todas as somas do intervalo 1,...,ncomo uma matriz, subtrai 1de cada um e, em seguida, binds 2*ncomo uma coluna à direita e uma linha na parte inferior, reciclando conforme necessário e retornando uma matriz como resultado.

Experimente online!

R , 78 bytes

Implementação mais ingênua.

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}

Experimente online!

Giuseppe
fonte
+1 bom, eu estava pensando sobre o exterior, mas ainda não tinha chegou lá
MickyT
7

Mathematica, 61 46 bytes

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

thanx @alephalpha por -15 bytes

J42161217
fonte
ArrayFlatten@{{Array[+##-1&,{#,#}],2#},{2#,2#}}&
alephalpha
+##-1&pode ser ##-1&e você pode usar o infixo Array:ArrayFlatten@{{##-1&~Array~{#,#},2#},{2#,2#}}&
ngenisis
5

MATL , 12 10 bytes

:&+q,!GEYc

Experimente online!

Explicação

:       % 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
fonte
5

Haskell , 48 bytes

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

Experimente online!

jferard
fonte
4

Gelatina , 11 bytes

+þḶ;€Ḥ;ḤzḤG

Experimente online!

Freira Furada
fonte
Estava prestes a byte post para byte sem o Gque é supérfluo requisitos
Jonathan Allan
Bom uso do produto externo
Zacharý
@JonathanAllan que outra solução usa ;€ḤZ;€Ḥ... #
Leaky Nun 28/08
... e ainda outro Ḷ;Ḥ©µ+þ‘«®; p
Jonathan Allan
1
@JonathanAllan e outros usos +€Ḷ;Ḥṁ€;€Ḥ: p
Erik the Outgolfer
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 snippet

Neil
fonte
4

Java 8, 99 bytes

Lambda de Integeraté int[][](por exemplo Function<Integer, int[][]>). Surpreendentemente resistente ao golfe.

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

Experimente Online

Lambda ungolfed

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

Agradecimentos

  • -1 byte graças a Kevin Cruijssen
Jakob
fonte
Você pode obter um byte de golfe iniciando i=0e colocando o ++at [c=i++%p].
Kevin Cruijssen 29/08
3

Python 2 , 64 62 61 bytes

-3 bytes graças ao Sr. Xcoder.

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

Experimente online!

Provavelmente estou perdendo um padrão-chave.

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

Experimente online!

totalmente humano
fonte
1
Como sempre, *(n+1)é *-~n.
Xcoder 28/08
1
Alguns mais ofuscação para 61 bytes
Mr. Xcoder
Se você quiser adotar a versão Python 3 também, o mais curto eu poderia começar é de 64 bytes
Mr. Xcoder
A versão de 76 bytes pode ser reduzido para 72 bytes
Halvard Hummel
2

R , 54 63 67 bytes

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

Experimente online!

Graças a @Guiseppe pelo ponteiro para sapply e os 9 bytes

MickyT
fonte
Na verdade, esta abordagem pode ser melhorada bem: sapply(1:n-1,'+',1:n)mas então é um mero 1 byte mais do que usando outer(as aspas são, obviamente, backticks)
Giuseppe
1
\`obras para escapar backticks em um bloco de código delimitado por backticks @Giuseppe
Cyoce
2

Recursiva , 50 bytes

  • Apenas 10 bytes mais curtos que o python e, portanto, é oficial, o Recursiva não é uma linguagem de golfe ... É um esolang. : D
|{Ba+++++'PJ"	"W+Z~}B+~}'Va'+}'Va'AD'VaJ"	"W*;aADa

Experimente online!

officialaimm
fonte
1

Röda , 44 bytes

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

Experimente online!

Explicação:

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
fonte
1

Dyalog APL, 29 bytes

Requer ⎕IO←0

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

Experimente online!

Quão?

  • 1+¯1 ¯1↓∘.+⍨⍳⍵+1 a parte superior esquerda da matriz
  • (S,⍨...)⍪S←2×⍵ a esquina
Zacharý
fonte
1

> <>, 84 + 2 bytes

+2 para sinalizador -v

Imprime com guias entre valores e novas linhas entre linhas. Também imprime uma guia à direita na última linha.

Experimente online

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

Pré-golfe

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

Gelatina, 14 bytes

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

Experimente online!

Zacharý
fonte
0

Kotlin , 59 bytes

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

Experimente online.

Valentin Michalak
fonte
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))))

Ungolfed:

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

Função anônima que aceita a entrada como argumento e retorna uma lista de listas.

Saída 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
fonte
0

05AB1E , 17 bytes

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

Experimente online!

Explicação

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
fonte
0

J, 29 bytes

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

destroçado

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

explicação

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

Experimente online!

Jonah
fonte
Heh, minha resposta APL e sua resposta têm a mesma contagem de bytes! Você pode adicionar uma explicação, por favor?
Zacharý 30/08
@ Zacharý, atualizado. fwiw, isso provavelmente poderia ser jogado pelo menos um pouco mais por alguém como eu, e talvez por mais de 10 bytes adicionais por um especialista em J.
Jonah
0

Na verdade , 23 bytes

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

Experimente online!

Explicação:

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

Clojure v1.8, 97 bytes

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

Experimente online!

Explicação

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