Garabatos ASCII: láser en una caja

31

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
########################
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
# /\  /\  /\  /\  /\  /#
#/  \/  \/  \/  \/  \/ #
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
########################
Martin Ender
fuente
1
Tal vez una buena pregunta de seguimiento, una vez que esta haya seguido su curso, es hacer este desafío con cajas de forma arbitraria y puntos de partida.
Sanchises
@sanchises En realidad lo había considerado (y aún podría publicarlo), pero decidí seguir con el rectángulo con la esperanza de que alguien pudiera llegar a una fórmula explícita. También estaba considerando múltiples puntos de partida que Xserían necesarios para los cruces. Quizás la próxima vez. ;)
Martin Ender
2
Relevante: i.imgur.com/6tXrIfw.webm
orlp
Esto sería perfecto para un punto de animación. "Animar 1 ráfaga (una barra) 1 ciclo / interminable"
Martijn

Respuestas:

20

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
Jakube
fuente
Desde Xsoportes "asignación" para cuerdas, se puede cambiar m\ a *dy retirar s.
isaacg
@isaacg Buena llamada. Pensé en usar en *\ lugar de en m\ breve, pero lo descarté porque tiene el mismo tamaño. No pensé en la variable dy lo innecesario s.
Jakube
11

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.

BrainSteel
fuente
27
Los puntos de Internet falsos valen más que un título educativo, estoy seguro.
Adam Davis
230 bytes
ceilingcat
5

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í.

randomra
fuente
0

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

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 )

marca
fuente