A volte, quando scarabocchio, disegno un rettangolo, comincio con una diagonale da uno degli angoli, e poi traccia solo una linea "riflettendola" ogni volta che colpisco un lato del rettangolo. Continuo fino a quando non raggiungo un altro angolo del rettangolo (e spero che le proporzioni del mio rettangolo non siano irrazionali;)). Questo è come tracciare il percorso di un raggio laser in una scatola. Devi produrre il risultato con l'arte ASCII.

Ad esempio, considera una scatola di larghezza 5e altezza 3. Inizieremo sempre nell'angolo in alto a sinistra. I #segna il confine della scatola. Si noti che la larghezza e l'altezza si riferiscono alle dimensioni interne.

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

La sfida

Data la larghezza (positiva) e l'altezza della scatola, dovresti produrre il risultato finale del tracciamento del laser. È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), l'argomento della riga di comando, l'argomento della funzione e l'output del risultato tramite STDOUT (o l'alternativa più vicina) o tramite valori o argomenti di ritorno della funzione.

È possibile utilizzare qualsiasi elenco conveniente, stringa o formato numerico per l'input. L'output deve essere una singola stringa (a meno che non lo si stampi su STDOUT, cosa che si può ovviamente fare gradualmente). Questo significa anche che puoi prendere prima l'altezza e la larghezza in secondo luogo - specifica semplicemente il formato di input esatto nella tua risposta.

Non ci deve essere spazio bianco iniziale o finale su nessuna riga dell'output. È possibile facoltativamente generare una nuova riga finale finale.

È necessario utilizzare lo spazio, /, \ed #e riprodurre i test esattamente come mostrato.

Casi test

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

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

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

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

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

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

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

Pyth, 43 41 39 byte

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

Provalo online: Pyth Compiler / Executor . Immettere i numeri nel seguente ordine: altezza prima riga, larghezza seconda riga.

Grazie a isaacg, che ha contribuito a salvare due byte.

Spiegazione:

La mia soluzione non traccia il laser, utilizza un modello semplice che include gcd. Se m, nsono le dimensioni della scatola, lascia d = gcd(m, n). La dimensione del motivo è esattamente 2*d x 2*d.

Ad esempio il motivo ripetuto per 7 5

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

è

\/
/\

( gcd(7, 5) = 1, la dimensione del modello è 2 x 2)

E lo schema ripetitivo per 22 6

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

è

\  /
 \/ 
 /\
/  \

( gcd(22, 6) = 2, la dimensione del modello è 4 x 4)

La mia soluzione fa la seguente cosa per ciascuna delle linee: genera semplicemente una linea del modello, la ripete alcune volte e la taglia alla fine in modo che si adatti alla scatola.

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 byte

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

Probabilmente riesco a ottenere questo sotto 200, e aggiungerò una spiegazione più tardi, ma potrei avere un documento dovuto tra poche ore che dovrei fare invece.

J, 85 byte

Let g = gcd(w,h). La funzione riempie gli elementi di una w/g by h/gmatrice di g by gtessere, avendo /"s \" e "s" nella loro diagonale e anti-diagonale. L'array 4D risultante viene diviso in uno 2D (l'interno della scatola), quindi circondato da #'s. (I numeri 0 1 2 3vengono utilizzati al posto di [space] / \ #e i numeri vengono cambiati in caratteri alla fine.)

Un calcolo diretto basato sulla posizione delle coordinate interne potrebbe forse fornire una soluzione un po 'più breve.

' \/#'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
########################
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
# /\  /\  /\  /\  /\  /#
#/  \/  \/  \/  \/  \/ #
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
########################

Provalo online qui.

Desmos Calculator - Non competere per aiutare ulteriori conoscenze

Provalo online!

ingressi:

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

intermedi:

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

• gcd (h, w) rappresenta il massimo comune denominatore
• A% B , come in Javascript, o mod (A, B) , come in Fortran, rappresenta l' operazione del modulo , sull'intervallo [0, B).

Formula, abbreviata:

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

Uscite:

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

Come funziona:

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

Il programma non soddisfa il criterio finale: generare arte ASCII di box e linee, quindi sto presentando come non competitivo per informazioni per aiutare gli altri a completare la sfida. Si noti che per far funzionare Desmos quando c = 0 o c = b, è stato introdotto un piccolo fattore di offset di 0,01, poiché Desmos sembra avere limiti di Mod (A, B) di (0, B) anziché [0, B )