Dada a entrada tilesXe tilesYcrie um método que faça um anel retangular a partir dos ladrilhos.

A função deve ordenar os blocos em um anel como este:

• tilesXe tilesYsempre são valores inteiros positivos, não podem ser 0
• tilesXe tilesYnão são sempre iguais, esperar valores como: 2x5, 6x3etc.
• A verificação de entrada inválida não é necessária
• Você pode usar qualquer maneira de exibir os blocos, incluindo matrizes 2D, arte ASCII ou texto impresso.
• Não há uma maneira estrita de como a entrada é passada, desde que sejam dois números inteiros.
• Não pode ser uma linha, desenhar um tamanho de retângulo tilesXe tilesYpixels não é válido
• O código mais curto vence

Dyalog APL, 8 bytes

×/¨1<⊂|⍳

Esse trem monádico de função usa altura e largura como argumentos corretos e retorna uma matriz 2D de 0 's (borda) e 1 ' s (interior). Teste-o no TryAPL .

Como funciona

×/¨1<⊂|⍳  Right argument: h w

       ⍳  Generate all index pairs (1-based) of a h×w array.
     ⊂    Enclose (h w), so it depth matches the one of the index array.
      |   For each pair (i j) compute the remainders of the division by (h w).
   1<     Compare all remainders with 1.
×/¨       Reduce each pair of Booleans by multiplication.

MATL , 10 bytes

2$lO6Lt4$(

Isso gera uma matriz contendo zeros e uns.

Experimente online!

2$l    % Implicit inputs M, N. Generate M×N array of ones
O      % Push number 0
6Lt    % Push [2 -1] twice, corresponding to index "2:end-1"
4$(    % Fill the center of the array with value 0. Implicit display

Para saída gráfica, adicione 1YGno final para exibir a matriz como uma imagem ( 13 bytes ):

2$Ol6Lt4$(1YG

Experimente no MATL Online! Por exemplo,

>> matl 2$Ol6Lt4$(1YG
> 5
> 7

produz

HTML / JS / CSS, 198 194 bytes

Versão de saída gráfica. A contagem de bytes não inclui f=nem os três <input>elementos que são usados ​​apenas para fins de demonstração. Economizou 3 bytes graças a @IsmaelMiguel.

f=(n,m)=>{with(d.style)width=n*25+'px',height=m*25+'px'}

<input id=w placeholder=width><input id=h placeholder=height><input type=button value=Go! onclick=f(w.value,h.value)>
<div id=d style="border-image:radial-gradient(#fff 0,#fff 0)0 fill/25px;background:radial-gradient(#000 0,#000 8px,#fff 9px)0 0/25px 25px">

MATL , 10 bytes

2$l3XyZ+3=

Os argumentos de entrada são altura e largura como números inteiros. A saída é uma matriz de tamanho em height x widthque os blocos de limite são 0 e os valores internos são 1.

Experimente Online!

Explicação

Mesma lógica que minha outra resposta com menos bytes.

        % Grab two input parameters implicitly
2$l     % Create a matrix of ones that has the dimensions specified as inputs
3       % Number literal 3
Xy      % Create a 3x3 identity matrix
Z+      % Perform 2D convolution (preserving size)
3=      % Create a logical matrix where values == 3 are 1 and 0 otherwise (boundary)
        % Implicitly display output.

MATLAB, 32 31 bytes

@(x)conv2(ones(x),eye(3),'s')>2

Isso cria uma função anônima que pode ser executada como ans([4 5])dentro da área de trabalho.

Entrada é [height, width]e saída é uma matriz com 1 no centro e 0 para o limite.

A maneira como isso funciona é uma matriz de unidades do tamanho da entrada criada. Em seguida, convolve-se com uma matriz de identificação 3 x 3 com as da diagonal. Usamos a sameentrada para conv2(reduzida 's'aqui) para manter o resultado do mesmo tamanho da entrada.

Em seguida, queremos converter a saída em um valor binário com 0 ao redor do limite e 1 dentro. Usamos a desigualdade >2porque todos os pixels de borda terão um resultado <3 e todos os elementos não-limite terão um resultado igual a 3.

Para saída gráfica:

@(x)imagesc(conv2(ones(x),eye(3),'s')>8)
ans([6,9])

Gelatina , 10 bytes

p%€,>1P€G

Retorna uma grade de 0 (borda) e 1 (interior). Experimente online!

Como funciona

p%€,>1P€sG  Main link. Arguments: h (height), w (width)

p           Cartesian product; return all pairs in [1, ..., h] × [1, ..., w].
   ,        Yield the pair [h, w].
 %€         For each pair [i, j] in the product, compute [i % h, j % w].
    >1      Compare all resulting moduli with 1.
      P€    Compute the product of each pair of Booleans.
        s   Split the resulting flat list into rows of length w.
         G  Display the results in a 2D grid.

Julia, 46 34 bytes

f(n,m)=[n>i>1<j<m for i=1:n,j=1:m]

Esta é uma função que aceita dois números inteiros e retorna uma matriz booleana bidimensional.

Construímos uma matriz n × m usando uma compreensão de matriz com um forloop duplo . Para cada índice de 1 a ne 1 a m , ou seja, cada elemento da matriz, definimos o valor para truese n > i > 1 e 1 < j < m . Isso é verdade em qualquer lugar, exceto nos limites, portanto a matriz resultante terá trues no meio e falses ao redor da borda.

Exemplos:

julia> f(n,m)=[n>i>1<j<m for i=1:n,j=1:m]
f (generic function with 1 method)

julia> f(4,4)
4x4 Array{Bool,2}:
 false  false  false  false
 false   true   true  false
 false   true   true  false
 false  false  false  false

julia> f(1,1)
1x1 Array{Bool,2}:
 false

julia> f(2,5)
2x5 Array{Bool,2}:
 false  false  false  false  false
 false  false  false  false  false

Economizou 12 bytes graças a Dennis!

CJam, 20 bytes

l~S*a*{3a.f|W%z}4*N*

A entrada deve estar no formato height width, a saída é uma grade ASCII usando espaços para o centro e #para o limite.

Teste aqui.

Explicação

l~       e# Read and evaluate input, dumping h and w on the stack.
S*       e# Create a string of w spaces.
a*       e# Create an array of h copies of that string.
{        e# Repeat this block 4 times...
  3a.f|  e#   For each character in the first row, take its bitwise OR with 3, turning
         e#   spaces into # and leaving # unchanged.
  W%z    e#   Reverse and transpose the grid, rotating it by 90 degrees.
}4*
N*       e# Join the lines of the result with linefeeds.

Pyke, 16 15 bytes

jQ]Uajt%!RQt%!|

Experimente aqui!

Explicação:

                - Q = eval_input()
j               - j = eval_input()
jQ]             - [Q,j]
   U            - create a 3d array sized Q by j with coords
    a           - for each coord (2d for)
     jt%!       -   not (coord_1 % j-1)
              | -  ^ or V
          Qt%!  -   not (coord_2 % Q-1)

Para saída prettificada, use este código .

Ou 13 bytes com uma máscara zerada na borda (caracteres do meio diferentes de zero)

jQ]Uajt%RQt%&

Experimente aqui!

JavaScript (ES6), 80 82 85

Edite 3 bytes salvos thx @Neil
Edite 2 bytes salvos usando reducepela primeira vez

Função anônima retornando uma sequência de linhas múltiplas

(w,h)=>[...Array(h)].reduce(o=>o+(w>1?'O'+' O'[!--h|!o].repeat(w-2):'')+`O
`,'')

Teste

f=(w,h)=>[...Array(h)].reduce(o=>o+(w>1?'O'+' O'[!--h|!o].repeat(w-2):'')+`O
`,'')

function test(){
  var [w,h] = I.value.match(/\d+/g)
  w=+w,h=+h // convert to numeric
  O.textContent=f(w,h)
}  

test()

<input value='5 4' id=I><button onclick='test()'>Test</button><pre id=O></pre>

Ruby, 63 bytes

Função anônima, imprime em STDOUT. Border is #.

->x,y{h=?#;puts t=h*x,y>1?[[h+(x<2?'':' '*(x-2)+h)]*(y-2),t]:p}

JavaScript (ES6), 97 bytes

(n,m)=>Array(n).fill(' '.repeat(m).replace(/^ | $/g,0)).join`
`.replace(/^.+|.+$/g,'0'.repeat(m))

Cria um anel de 0s. Provavelmente uma abordagem terrível, mas eu queria evitar casos extremos.

JavaScript (ES6), 77 bytes

h=>w=>[...Array(i=h)].map(_=>(a=Array(w).fill(h-i--&&i?0:1),a[0]=a[w-1]=1,a))

Retina , 45 43 bytes

\d+
$*
S_`1(?=.* (1+))|.
T`1`#`^.+|.+$|.?¶.

A entrada deve estar no formato height width, a saída é uma grade ASCII usada 1para o centro e #para o limite.

Experimente online!

Explicação

\d+
$*

Converta cada número Nem uma sequência de Nuns (por exemplo, converta a entrada em unário).

S_`1(?=.* (1+))|.

Combinar cada 1em heighte substituí-lo width, ao mesmo tempo, combinando tudo e removê-lo. Fazemos isso abusando de um estágio dividido. Isso cria uma w x hgrade.

T`1`#`^.+|.+$|.?¶.

Finalmente, substituímos todos 1por um #que seja encontrado na primeira linha, na última linha ou no início ou no final de uma linha.

Na verdade , 23 bytes

;'#*;))¬' *'#;)@+(+nXX(

Experimente online!

Essa abordagem é muito semelhante à minha abordagem neste desafio relacionado .

Explicação:

;'#*;))¬' *'#;)@+(+nXX(
                         (implicit) push all input to stack
;'#*                     push a string containing X #s
    ;))                  dupe, and push both to bottom of stack
       ¬' *              push a string containing (X-2) spaces
           '#;)@+(+      add a # to the front and the back of the string
                   nXX   make (Y-2) copies
                      (  bring one of the "#"*X strings back to the top
                         (implicit) pop and print each stack item, separated by newlines

QBasic, 69 bytes

INPUT x,y
FOR i=1TO y
FOR j=1TO x
?i MOD y<2OR j MOD x<2;
NEXT
?
NEXT

Toma dimensões como width,height. O valor booleano do teste is it it on the border é simplesmente impresso: -1para true e 0para false. Uma amostra de execução é semelhante a:

? 5,3
-1 -1 -1 -1 -1 
-1  0  0  0 -1 
-1 -1 -1 -1 -1 

Bônus: Versão gráfica, 88 bytes

INPUT x,y
SCREEN 9
FOR i=1TO y
FOR j=1TO x
PSET(j*3,i*3),i MOD y<2OR j MOD x<2
NEXT
NEXT

Eu acredito que isso conta como "não é uma linha". Quando a MODexpressão é falsa (0), PSETplota um pixel preto; quando é verdade (-1), PSETaparentemente plota um pixel branco. Aqui 17,31, mostrado em tamanho 2x:

TSQL, 107 105 97 bytes

DECLARE @ INT=3,@y INT=5

PRINT REPLICATE(1,@)+ISNULL('
'+REPLICATE('1'+ISNULL(SPACE(@-2),'')+'1
',@y-2)+REPLICATE(1,@),'')

1. gerando primeira linha
2. adicionando linhas ocas + quebras de linha
3. adicionando a última linha (quando necessário)

Unicórnio , 26 23 bytes

P3G$PG@PS@S$L2B$T1B@T1N

^{Porque quem não gosta de unicórnios ?!}

Explicação (saída "list program"):

P3  Paint current square with 3
G$P Get: sets $ from input P
G@P Get: sets @ from input P
S@  Subtract 1 from @
S$  Subtract 1 from $
L2  ~Loop 2 times
B$  ~Brush $ more square
T1  ~Turn 1 right angle clockwise
B@  ~Brush @ more square
T1  ~Turn 1 right angle clockwise
N   ~Next (loop)

Saída para tilesX= 3, tilesY= 5:

Nota: Esta versão funciona apenas para tilesXaté 6 e tilesYaté 5. A questão não menciona que intervalo precisamos oferecer suporte; portanto, estou assumindo que isso está correto. Caso contrário, uma pequena adição ao programa produz essa alternativa, que suporta uma faixa um pouco maior:

Unicórnio, 30 27 bytes

x0y9P3G$PG@PS@S$L2B$T1B@T1N

Adicionando x0y9, que inicia a caixa em (0,9), o programa funciona para tilesXaté 9 e tilesYaté 9 (porque a entrada só sobe para 9).

J, 16 bytes

0(<2#<<0 _1)}$&1

Use a forma $para criar um retângulo com todas as dimensões do tamanho das entradas e, em seguida, use a forma complementar de Alterar }para transformar o interior em zeros.

Experimente online!

Perl 5 , 76 + 1 ( -a) = 77 bytes

print(1x($a=$F[0]),$/,((1,$"x($a-2),1 x($a>1),$/)x($F[1]-2),1x$a)x($F[1]>1))

Experimente online!

Perl 5, 45 + 1 ( -p) = 46 bytes

$_=join$/,(1x$_)x<>;1while s/
.+\K1(?=.+
)/ /

45 bytes a seguir não manipula tileY = 1

$_=1x<>.$/;say$_.s/(?!^.|.$)./ /gr x(<>-2).$_

Experimente online