Kadang-kadang ketika saya mencoret-coret, saya menggambar persegi panjang, mulai dengan diagonal dari salah satu sudut, dan kemudian menelusuri garis dengan "memantulkan" setiap kali saya menekan sisi persegi panjang. Saya melanjutkan ini sampai saya menyentuh sudut lain dari persegi panjang (dan berharap bahwa aspek rasio persegi panjang saya tidak tidak rasional;)). Ini seperti menelusuri jalan sinar laser ke dalam kotak. Anda akan menghasilkan hasil itu dengan seni ASCII.

Sebagai contoh, perhatikan kotak lebar 5dan tinggi 3. Kami akan selalu mulai di sudut kiri atas. The #tanda batas kotak. Perhatikan bahwa lebar dan tinggi mengacu pada dimensi bagian dalam.

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

Tantangan

Mengingat (positif) lebar dan tinggi kotak, Anda harus menghasilkan hasil akhir dari penelusuran laser. Anda dapat menulis sebuah program atau fungsi, mengambil input melalui STDIN (atau alternatif terdekat), argumen baris perintah, argumen fungsi dan output hasilnya melalui STDOUT (atau alternatif terdekat), atau melalui fungsi mengembalikan nilai atau argumen.

Anda dapat menggunakan format daftar, string, atau angka yang mudah digunakan untuk input. Output harus berupa string tunggal (kecuali jika Anda mencetaknya ke STDOUT, yang tentu saja Anda lakukan secara bertahap). Ini juga berarti Anda dapat mengambil tinggi pertama dan lebar kedua - cukup tentukan format input yang tepat dalam jawaban Anda.

Tidak boleh ada spasi spasi awalan atau jejak pada output apa pun. Anda secara opsional dapat menampilkan satu baris baru.

Anda harus menggunakan ruang, /, \dan #dan mereproduksi kasus uji persis seperti yang ditunjukkan.

Uji Kasus

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

Cobalah online: Pyth Compiler / Executor . Masukkan angka dengan urutan sebagai berikut: tinggi baris pertama, lebar baris kedua.

Terima kasih kepada isaacg, yang membantu menghemat dua byte.

Penjelasan:

Solusi saya tidak melacak laser, menggunakan pola sederhana yang mencakup gcd. Jika m, ndimensi kotak, biarkan d = gcd(m, n). Ukuran polanya persis2*d x 2*d .

Misalnya pola berulang untuk 7 5

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

aku s

\/
/\

( gcd(7, 5) = 1, ukuran pola adalah2 x 2 )

Dan pola berulang untuk 22 6

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

aku s

\  /
 \/ 
 /\
/  \

( gcd(22, 6) = 2, ukuran pola adalah4 x 4 )

Solusi saya melakukan hal berikut untuk masing-masing garis: itu hanya menghasilkan satu garis pola, mengulanginya beberapa kali dan memotongnya di akhir sehingga masuk ke dalam kotak.

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

Saya mungkin bisa mendapatkan ini di bawah 200, dan saya akan menambahkan penjelasan nanti, tetapi saya mungkin punya makalah karena dalam beberapa jam saya harus melakukan sebaliknya.

J, 85 byte

Mari g = gcd(w,h). Fungsi ini mengisi elemen-elemen w/g by h/gmatriks dengan g by gubin, memiliki /'s dan \' di diagonal dan anti-diagonal. Array 4D yang dihasilkan diubah menjadi 2D (bagian dalam kotak) kemudian dikelilingi dengan #'s. (Angka 0 1 2 3digunakan sebagai ganti [space] / \ #dan nomor diubah menjadi karakter di akhir.)

Perhitungan berbasis posisi langsung dari koordinat dalam mungkin dapat menghasilkan solusi yang sedikit lebih pendek.

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

Pemakaian:

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

Cobalah online di sini.

Kalkulator Desmos - Non Bersaing untuk Membantu Pengetahuan Lebih Lanjut

Cobalah online!

Input:

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

Menengah:

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

• gcd (h, w) mewakili penyebut umum terbesar
• A% B , seperti dalam Javascript, atau mod (A, B) , seperti dalam Fortran, mewakili operasi modulus , pada interval [0, B).

Formula, disingkat:

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

Output:

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

Bagaimana itu bekerja:

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

Program gagal memenuhi kriteria akhir - menghasilkan seni ASCII kotak dan garis, jadi saya mengajukan sebagai tidak kompetitif untuk informasi untuk membantu orang lain menyelesaikan tantangan. Perhatikan bahwa untuk membuat Desmos bekerja ketika c = 0 atau c = b, faktor offset kecil 0,01 diperkenalkan, karena Desmos tampaknya memiliki batas Mod (A, B) dari (0, B) alih-alih [0, B )