A veces, cuando hago garabatos, dibujo un rectángulo, empiezo con una diagonal desde una de las esquinas y luego trazo una línea "reflejándola" cada vez que golpeo un lado del rectángulo. Continúo con esto hasta que alcanzo otra esquina del rectángulo (y espero que la relación de aspecto de mi rectángulo no sea irracional;)). Esto es como trazar el camino de un láser que brilla en una caja. Debes producir el resultado de eso con el arte ASCII.

Como ejemplo, considere una caja de ancho 5y alto 3. Siempre comenzaremos en la esquina superior izquierda. El #marca el límite de la caja. Tenga en cuenta que el ancho y la altura se refieren a las dimensiones internas.

#######    #######    #######    #######    #######    #######    #######
#\    #    #\    #    #\   \#    #\  /\#    #\  /\#    #\/ /\#    #\/\/\#
# \   #    # \  /#    # \  /#    # \/ /#    # \/ /#    #/\/ /#    #/\/\/#
#  \  #    #  \/ #    #  \/ #    # /\/ #    #\/\/ #    #\/\/ #    #\/\/\#
#######    #######    #######    #######    #######    #######    #######

El reto

Dado el ancho y la altura (positivos) de la caja, debe producir el resultado final del trazado del láser. Puede escribir un programa o función, tomando la entrada a través de STDIN (o la alternativa más cercana), argumento de línea de comando, argumento de función y generar el resultado a través de STDOUT (o la alternativa más cercana), o mediante valores o argumentos de retorno de función.

Puede usar cualquier formato conveniente de lista, cadena o número para la entrada. El resultado debe ser una sola cadena (a menos que lo imprima en STDOUT, lo que, por supuesto, puede hacer gradualmente). Esto también significa que puede tomar el alto primero y el ancho segundo, solo especifique el formato de entrada exacto en su respuesta.

No debe haber espacios en blanco iniciales ni finales en ninguna línea de la salida. Opcionalmente, puede generar una nueva línea final.

Debe utilizar el espacio, /, \y #y reproducir los casos de prueba exactamente como se muestra.

Casos de prueba

2 2
####
#\ #
# \#
####

3 2
#####
#\/\#
#/\/#
#####

6 3
########
#\    /#
# \  / #
#  \/  #
########

7 1
#########
#\/\/\/\#
#########

1 3
###
#\#
#/#
#\#
###

7 5
#########
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#########

22 6
########################
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
# /\  /\  /\  /\  /\  /#
#/  \/  \/  \/  \/  \/ #
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
########################

Pyth, 43 41 39 bytes

K*\#+2QKVvzp<*QXX*dyivzQN\\_hN\/Q\#\#)K

Pruébelo en línea: Pyth Compiler / Executor . Ingrese los números en el siguiente orden: altura primera línea, ancho segunda línea.

Gracias a Isaac, que ayudó a salvar dos bytes.

Explicación:

Mi solución no rastrea el láser, usa un patrón simple que incluye el mcd. Si m, nson las dimensiones de la caja, deja d = gcd(m, n). El tamaño del patrón es exactamente 2*d x 2*d.

Por ejemplo, el patrón repetitivo para 7 5

#########
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#########

es

\/
/\

( gcd(7, 5) = 1, el tamaño del patrón es 2 x 2)

Y el patrón repetitivo para 22 6

########################
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
# /\  /\  /\  /\  /\  /#
#/  \/  \/  \/  \/  \/ #
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
########################

es

\  /
 \/ 
 /\
/  \

( gcd(22, 6) = 2, el tamaño del patrón es 4 x 4)

Mi solución hace lo siguiente para cada una de las líneas: simplemente genera una línea del patrón, la repite varias veces y la corta al final para que quepa en la caja.

K*\#+2QK   implicit: Q is the second input number (=width)
K          K = 
 *\#+2Q        "#" * (2 + Q)
       K   print K (first line)

Vvzp<*QXX*dyivzQN\\_hN\/Q\#\#)K  implicit: vz is the first input number (=height)
VQ                               for N in [0, 1, ..., vz-1]:
           ivzQ                             gcd(vz,Q)
          y                               2*gcd(vz,Q)
        *d                           string with 2*gcd(vz,Q) space chars
       X       N\\                   replace the Nth char with \
      X           _hN\/              replace the -(N+1)th char with /
    *Q                               repeat Q times
   <                   Q           only use the first Q chars
  p                     \#\#       print "#" + ... + "#"
                            )    end for
                             K   print K

C, 256 bytes

f(w,h){int i,j,x=1,y=1,v=1,u=1;char b[h+2][w+3];for(i=0;i<w+3;i++)for(j=0;j<h+2;j++)b[j][i]=!i||!j||i>w||j>h?i>w+1?0:35:32;while((x||y)&&(x<=w||y<=h))v=x&&w+1-x?v:(x-=v,-v),u=y&&h+1-y?u:(y-=u,-u),b[y][x]=v/u<0?47:92,x+=v,y+=u;for(i=0;i<h+2;i++)puts(b[i]);}

Probablemente pueda obtener esto por debajo de 200, y agregaré una explicación más tarde, pero es posible que tenga que entregar un documento en unas pocas horas.

J, 85 bytes

Dejar g = gcd(w,h). La función llena los elementos de una w/g by h/gmatriz con g by gmosaicos, que tienen /'sy \' en su diagonal y anti-diagonal. La matriz 4D resultante se desgarra en una 2D (el interior de la caja) y luego se rodea con #'s. (Los números 0 1 2 3se usan en lugar de [space] / \ #y los números se cambian a caracteres al final).

Un cálculo directo basado en la posición de la coordenada interna podría producir una solución un poco más corta.

' \/#'echo@:{~3,.~3,.3,~3,,$[:,[:,"%.0 2 1 3|:((,:2*|.)@=@i.@+.){~[:(2&|@+/&:i.)/,%+.

Uso:

   6 (' \/#'echo@:{~3,.~3,.3,~3,,$[:,[:,"%.0 2 1 3|:((,:2*|.)@=@i.@+.){~[:(2&|@+/&:i.)/,%+.) 22
########################
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
# /\  /\  /\  /\  /\  /#
#/  \/  \/  \/  \/  \/ #
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
########################

Pruébelo en línea aquí.

Calculadora Desmos - No compite para ayudar a un mayor conocimiento

Pruébalo en línea!

Entradas:

h as height of box, with 0-indexing
w as width of box, with 0-indexing

Intermedios:

Let b = gcd(h,w),
Let c = |b-h%2b| Or |b-mod(h,2b)|

• mcd (h, w) representa el máximo común denominador
• A% B , como en Javascript, o mod (A, B) , como en Fortran, representa la operación del módulo , en el intervalo [0, B).

Fórmula, abreviada:

(|b-(x+y)%2b|-c)(|b-(x-y)%2b|-c)=0

Salidas:

x as x position, 0-indexed, where the ball will land when released
y as y position, 0-indexed, where the ball will land when released

Cómo funciona:

(|b-(x+y)%2b|-c)*(|b-(x-y)%2b|-c)=0
                ^ OR operation - |b-(x+y)%2b|-c=0 or |b-(x-y)%2b|-c=0
|b-(x+/-y)%2b|-c = 0
|b-(x+/-y)%2b| = c
|b-(x+/-y)%2b| = c means (b-(x+/-y))%2b = + or -c 
b-(x+/-y)%2b = +/- c -> b +/- c = (x+/-y)%2b -> (x+/-y) = n*2*b + b +/- c 
Where n is integer.  This will force patterns to repeat every 2b steps in x and y.  
Initial pattern n=0: (x +/- y) = b +/- c -> y = +/- x + b +/- c
In the x positive and y positive plane only, these correspond to lines of positive and 
negative slope, set at intercept b, offset by c on either side.

El programa no cumple con el criterio final: generar el arte ASCII de recuadro y líneas, por lo que estoy enviando información no competitiva para ayudar a otros a completar el desafío. Tenga en cuenta que para que Desmos funcione cuando c = 0 o c = b, se introdujo un pequeño factor de compensación de 0.01, ya que Desmos parece tener límites de Mod (A, B) de (0, B) en lugar de [0, B )