Dada la entrada tilesXy tilesYcrear un método que haría un anillo rectangular de los mosaicos.

La función debe ordenar los mosaicos en un anillo como este:

• tilesXy tilesYsiempre son valores enteros positivos, no puede ser 0
• tilesXy tilesYno siempre son iguales, valores como esperar: 2x5, 6x3etc.
• No es necesario verificar la entrada no válida
• Puede usar cualquier forma de mostrar los mosaicos, incluidas las matrices 2d, el arte ASCII o el texto impreso.
• No hay una forma estricta de cómo se pasa la entrada siempre que sean dos enteros.
• No puede ser una línea, dibujar un rectángulo de tamaño tilesXy tilesYpíxeles no es válido
• El código más corto gana

Dyalog APL, 8 bytes

×/¨1<⊂|⍳

Este tren de funciones monádicas toma la altura y el ancho como argumentos correctos y devuelve una matriz 2D de 0 '(borde) y 1 ' s (interior). Pruébelo en TryAPL .

Cómo 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$(

Esto genera una matriz que contiene ceros y unos.

Pruébalo en línea!

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 la salida gráfica, agregue 1YGal final para mostrar la matriz como una imagen ( 13 bytes ):

2$Ol6Lt4$(1YG

¡Pruébalo en MATL Online! Por ejemplo,

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

produce

HTML / JS / CSS, 198 194 bytes

Versión de salida gráfica. El recuento de bytes no incluye f=ni los tres <input>elementos que se utilizan solo con fines de demostración. Guardado 3 bytes gracias 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=

Los argumentos de entrada son alto y ancho como enteros. La salida es una matriz de tamaño height x widthdonde los mosaicos límite son 0 y los valores internos son 1.

Pruébalo en línea!

Explicación

Misma lógica que mi otra respuesta con 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

Esto crea una función anónima que luego se puede ejecutar como ans([4 5])dentro del espacio de trabajo.

La entrada es [height, width] y la salida es una matriz con 1 en el centro y 0 para el límite.

La forma en que esto funciona es una matriz de unos, se crea el tamaño de la entrada. Luego se convoluciona con una matriz de identificación de 3 x 3 con unos en la diagonal. Usamos la sameentrada paraconv2 (acortada 's'aquí) para mantener el resultado del mismo tamaño que la entrada.

Luego queremos convertir la salida a un valor binario con 0 alrededor del límite y 1 dentro. Usamos la desigualdad>2 porque todos los píxeles de borde tendrán un resultado <3 y todos los elementos no limítrofes tendrán un resultado igual a 3.

Para salida gráfica:

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

Jalea , 10 bytes

p%€,>1P€G

Devuelve una cuadrícula de 0 's (borde) y 1 ' s (interior). Pruébalo en línea!

Cómo 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 es una función que acepta dos enteros y devuelve una matriz booleana bidimensional.

Construimos una matriz n × m usando una comprensión de matriz con un doble forbucle. Para cada índice de 1 a n y 1 a m , es decir, cada elemento de la matriz, establecemos el valor en truesi n > i > 1 y 1 < j < m . Esto es cierto en todas partes excepto en los límites, por lo que la matriz resultante tendrá trues en el medio falseys alrededor del borde.

Ejemplos:

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

¡Guardado 12 bytes gracias a Dennis!

CJam, 20 bytes

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

La entrada debe estar en la forma height width, la salida es una cuadrícula ASCII que usa espacios para el centro y #el límite.

Pruébalo aquí.

Explicación

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%!|

Pruébalo aquí!

Explicación:

                - 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 salida prettificada, use este código .

O 13 bytes con una máscara puesta a cero alrededor del borde (caracteres medios distintos de cero)

jQ]Uajt%RQt%&

Pruébalo aquí!

JavaScript (ES6), 80 82 85

Editar 3 bytes guardados gracias a @Neil
Editar 2 bytes guardados usandoreduce por una vez

Función anónima que devuelve una cadena de varias líneas

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

Prueba

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

Función anónima, imprime en STDOUT. Frontera es #.

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

Crea un anillo de 0s. Probablemente un enfoque terrible, pero quería 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`#`^.+|.+$|.?¶.

La entrada debe estar en la forma height width, la salida es una cuadrícula ASCII que se usa 1para el centro y #el límite.

Pruébalo en línea!

Explicación

\d+
$*

Convierta cada número Nen una cadena de Nunos (es decir, convierta la entrada en unario).

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

Relacionar cada 1en heighty sustituirla porwidth , al mismo tiempo que a juego todo lo demás y retirarlo. Hacemos esto abusando de una etapa dividida. Esto crea una w x hcuadrícula.

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

Finalmente, reemplazamos cada uno 1con uno #que se encuentra en la primera línea, la última línea o al principio o al final de una línea.

En realidad , 23 bytes

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

Pruébalo en línea!

Este enfoque es muy similar a mi enfoque en este desafío relacionado .

Explicación:

;'#*;))¬' *'#;)@+(+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 dimensiones como width,height. El valor booleano de la prueba is-it-on-the-border simplemente se imprime: -1para verdadero y 0para falso. Una ejecución de muestra se ve así:

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

Bonus: versión 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

Creo que esto cuenta como "no una línea". Cuando la MODexpresión es falsa (0), PSETtraza un píxel negro; cuando es cierto (-1), PSETaparentemente traza un píxel blanco. Aquí 17,31, se muestra en tamaño 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. generando primera línea
2. Agregar líneas huecas + saltos de línea
3. agregando la última línea (cuando sea necesario)

Unicornio , 26 23 bytes

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

^{¿Porque a quién no le gustan los unicornios?}

Explicación (salida del "programa de lista"):

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)

Salida para tilesX= 3, tilesY= 5:

Nota: Esta versión solo funciona para tilesXhasta 6 ytilesY hasta 5. Sin embargo, la pregunta no menciona qué rango debemos admitir, así que supongo que esto está bien. De lo contrario, una pequeña adición al programa produce esta alternativa, que admite un rango ligeramente mayor:

Unicornio, 30 27 bytes

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

Al agregar x0y9, que comienza el cuadro en (0,9), el programa funciona para tilesXhasta 9 y tilesYhasta 9 (porque la entrada solo sube a 9).

J, 16 bytes

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

Use la forma $para crear un rectángulo de todos del tamaño de las entradas, y luego use la forma complementaria de Enmendar }para convertir el interior en ceros.

Pruébalo en línea!

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

Pruébalo en línea!

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

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

los siguientes 45 bytes no manejan tileY = 1

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

Pruébalo en línea