Deskripsi

Tugas dari tantangan ini adalah untuk menyusun program atau fungsi yang melacak objek tertentu dalam ruang $n×n$ .

I / O

Program Anda akan diberikan 3 input, yang dapat diambil dengan cara apa pun yang masuk akal :

nakan menjadi ukuran sisi pesawat. (jadi, untuk , bidang Anda akan ). Anda mungkin menganggap akan selalu bilangan bulat ganjil.$n=5$$5×5$n

sakan menjadi posisi awal objek, diberikan sebagai pasangan $(x, y)$ koordinat.

Dakan menjadi vektor pasangan yang dipesan. Dakan mengikuti format , di mana akan selalu menjadi salah satu , untuk arah kardinal dan arah interardinal primer, dan akan menjadi bilangan bulat untuk jumlah 'kutu'.$D = [(d_0,t_0),(d_1,t_1),...,(d_n,t_n)]$$d_k$'N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW'$t_k$

Dengan input ini, program Anda harus menampilkan pelacakan objek di pesawat.

Aturan

Output harus berisi batas-batas pesawat. Misalnya:

- 21012 +
+ ┌─────┐
2│ │
1│ │
0│ │
1│ │
2│ │
-└─────┘

akan menjadi contoh pesawat 5 × $5×5$ kosong . Angka-angka di atas dan di samping hanya untuk referensi dan tidak perlu dicetak.

Anda dapat menggunakan karakter apa pun untuk batas, asalkan bukan spasi putih (atau diterjemahkan sebagai spasi putih). Karakter yang Anda pilih harus menggambarkan bidang penuh, yang berarti bahwa tidak ada celah di antara mereka.

Beberapa pesawat yang dapat diterima meliputi:

┌──┐ .... ---- + - +
│ │. . | | | |
│ │. . | | | |
└──┘; ....; ----; + - +

Pesawat yang tidak dapat diterima meliputi:

      .... .... ++++. .
            . . + +. .
            . + +. .
    ; ....; ....; + +; . .

Objek yang akan dilacak dapat berupa karakter apa pun yang Anda pilih, asalkan hanya menempati 1 ruang di pesawat dan berbeda dari karakter batas.

Jejak objek yang dilacak juga dapat berupa karakter apa pun yang Anda pilih, asalkan mereka hanya menempati 1 ruang di pesawat dan berbeda dari objek.

Untuk setiap elemen $(d_k,t_k)$ di $D$ , objek harus bergerak $t$ spasi menuju $d$ , dan meninggalkan jejak di belakang.

Jika objek akan mengenai batas, itu akan tercermin. Jika objek masih memiliki gerakan ke kiri, ia akan terus bergerak ke arah yang dipantulkannya.

Untuk referensi, petunjuk ini mencerminkan satu sama lain:

$N\rightleftharpoons S$ → ketika batas atas atau bawah dipenuhi;

$E\rightleftharpoons W$ → ketika batas lateral terpenuhi;

Hasil akhir akan berisi jejak terbaru yang mungkin, yaitu, jika objek akan meninggalkan jejak di ruang di mana sudah ada jejak, karakter jejak yang lebih baru akan menimpa yang lebih tua.

Seperti biasa, celah standar dilarang secara default .

Mencetak:

Ini adalah tantangan kode-golf .

Contoh:

Input: $n=5$ , $s=(0,0)$ , $D=[('NW',2),('S',2),('E',1)]$

Mengatasinya:

$t=0$

    0
 ┌─────┐
 │ │
 │ │
0│ ○ │
 │ │
 │ │
 └─────┘

$t=2$

    0
 ┌─────┐
 │ ○ │
 │ \ │
0│ \ │
 │ │
 │ │
 └─────┘

$t=4$

    0
 ┌─────┐
 │∧ │
 │ | \ │
0│ ○ \ │
 │ │
 │ │
 └─────┘

$t=5$ , yang akan menjadi output.

    0
 ┌─────┐
 │∧ │
 │ | \ │
0│└ ○ \ │
 │ │
 │ │
 └─────┘

(0s hanya untuk referensi, dan mereka tidak perlu berada di hasil akhir.)

Input: $n=9$ , $s=(3,-1)$ , $D=[('N',2),('SW',8),('SE',3),('NE',8)]$

Perhatikan bahwa ketika $t=10$ :

      0     
 ┌─────────┐
 │ │
 │ │
 │ │
 │ ∧ │
0│ / | │
 │ ○ / | │
 │⟨ / │
 │ \ / │
 │ ∨ │
 └─────────┘

Objek telah tercermin dua kali : sekali ketika mencapai bagian bawah dari pesawat saat akan menuju $SW$ , di mana itu mencerminkan ke $NW$ ; kemudian sekali lagi ketika mencapai sisi kiri dari pesawat, di mana $NW$ mencerminkan ke $NE$ .

Hasil akhir datang pada $t=21$ :

      0     
 ┌─────────┐
 │ ○ │
 │ \ │
 │ \ │
 │ \ │
0│ / | ⟩│
 │ ∧ / / │
 │⟨ \ / / │
 │ \ \ / │
 │ ∨ ∨ │
 └─────────┘

Kasus uji:

Input: n = 5 , s = ( 0 , 0 ) , D = [ ( ′ N W ′ , 2 ) , ( ′ S ′ , 2 ) , ( ′ E ′ , 1 ) $n=5$$s=(0,0)$$D=[('NW',2),('S',2),('E',1)]$

Keluaran:

    0
 ┌─────┐
 │∧ │
 │ | \ │
0│└ ○ \ │
 │ │
 │ │
 └─────┘

Keluaran:

      0     
 ┌─────────┐
 │ ○ │
 │ \ │
 │ \ │
 │ \ │
0│ / | ⟩│
 │ ∧ / / │
 │⟨ \ / / │
 │ \ \ / │
 │ ∨ ∨ │
 └─────────┘

Keluaran:

   0
 ┌───┐
 │ | │
0│- ○ ┐│
 │ | │
 └───┘

Keluaran:

       0
 ┌───────────┐
 │ ∧ │
 │ / \ │
 │┌ - / - \ \ │
 │ \ | / \ \ │
 │ \ | \ \ │
0│ | / ⟩│
 │ | \ / / │
 │ | / ○ │
 │ | / \ │
 │ ∨ \ │
 │ \ │
 └───────────┘

JavaScript (ES6), 228 byte

(n,x,y,[[dir,len],[dir,len],...])$0$$7$

Menghasilkan string dengan 0untuk batas, 1untuk jejak dan 3untuk posisi akhir.

(n,x,y,a)=>(g=X=>Y>n?'':(Y%n&&X%n&&a.map(([d,l],i)=>(M=H=>(h-X|v-Y||(k|=a[i+!l]?1:3),l--&&M(H=(h+H)%n?H:-H,h+=H,v+=V=(v+V)%n?V:-V)))(~-(D='12221')[d],V=~-D[d+2&7]),h=x+n/2,v=n/2-y,k=' ')&&k)+(X<n?'':`
`)+g(X++<n?X:!++Y))(Y=!++n)

Cobalah online!

Bagaimana?

Menginisialisasi dan menggambar ke dalam 'kanvas' (yaitu matriks karakter) agak membosankan dan panjang dalam JavaScript.

Kode ini menggunakan strategi yang berbeda: alih-alih menyimpan output dalam array 2D, ia membangun karakter string dengan karakter, dari kiri ke kanan dan dari atas ke bawah. Pada setiap iterasi:

• Kami menampilkan a 0jika kami melewati batas.
• Jika tidak, kami mensimulasikan jalur lengkap dan melihat apakah itu melintasi posisi kami saat ini. Kami menampilkan salah satu 1atau 3jika ya, atau spasi sebaliknya.
• Kami menambahkan umpan baris jika kami telah mencapai batas yang benar.

Secara keseluruhan, ini mungkin bukan pendekatan terpendek, tapi saya pikir itu layak untuk dicoba.

Java 10, 350 343 340 336 byte

(n,s,S,D)->{int N=n+2,x=N/2+s,y=N/2-S,i=N*N;var r=new char[N][N];for(;i-->0;)r[i/N][i%N]=i/N*(i%N)<1|i/N>n|i%N>n?'#':32;r[y][x]=42;for(var d:D)for(i=d[0];d[1]-->0;r[y+=i%7<2?1/y*2-1:i>2&i<6?y<n?1:-1:0][x+=i>0&i<4?x<n?1:-1:i>4?1/x*2-1:0]=42)i=y<2&i<2|y>=n&i>2&i<5?4-i:x<2&i>4|x>=n&i>0&i<4?8-i:y<2&i>6?5:y<n|i!=5?i:7;r[y][x]=79;return r;}

Dadalah 2D bilangan bulat-array di mana arah adalah 0-diindeks bilangan bulat: N=0, NE=1, E=2, SE=3, S=4, SW=5, W=6, NW=7. Awal- x,ykoordinat akan menjadi dua parameter terpisah sdan S. Outputnya adalah karakter-matriks.
Ini digunakan #sebagai perbatasan, *sebagai jejak, dan Ountuk posisi akhir (tetapi bisa ketiganya menjadi karakter ASCII dalam kisaran unicode [33,99]untuk byte-count yang sama jika Anda mau).

Cobalah online.

-4 byte terima kasih kepada @ceilingcat .
Pasti bisa bermain golf lagi dengan menyederhanakan gerakan dan ke arah mana kita bepergian lagi.

Penjelasan:

(n,s,S,D)->{           // Method with `n`,`s,S`,`D` parameters & char-matrix return-type
  int N=n+2,           //  Set `N` to `n+2`, since we use it multiple times
      x=N/2+s,         //  Calculate the starting `x` coordinate
      y=N/2-S,         //  Calculate the starting `y` coordinate
      i=N*N;           //  Index integer
  var r=new char[N][N];//  Result char-matrix of size `N` by `N`
  for(;i-->0;)         //  Loop `i` in the range (`N**2`, 0]
    r[i/N][i%N]=       //    Set the cell at position `i` divmod-`N` to:
      i/N*(i%N)<1|i/N>n|i%N>n?
                       //     If we're at a border:
       '#'             //      Set the current cell to '#'
      :                //     Else:
       32;             //      Set the current cell to ' ' (a space) instead
  r[y][x]=42;          //  Then set the starting position `x,y` to a '*'
  for(var d:D)         //  Loop over the `D` input:
    for(i=d[0];        //   Set `i` to the current direction
        d[1]-->0       //   Inner loop the current `d` amount of times
        ;              //     After every iteration:
         r[y+=         //      Change `y` based on the current direction
            i%7<2?     //       If the current direction is N, NE, or NW
             1/y*2-1   //        If we're at the top border:
                       //         Go one row down
                       //        Else
                       //         Go one row up
            :i>2&i<6?  //       Else-if the current direction is S, SE, or SW
             y<n?      //        If we're at the bottom border
              1        //         Go one row up
             :         //        Else
              -1       //         Go one row down
            :          //       Else (directions E or W)
             0]        //        Stay in the same row
          [x+=         //      Change `x` based on the current direction
            i>0&i<4?   //       If the current direction is E, NE, or SE
             x<n?      //        If we're NOT at the right border
              1        //         Go one column to the right
             :         //        Else:
              -1       //         Go one column to the left
            :i>4?      //       Else-if the current direction is W, NW, or SW
             1/x*2-1   //        If we're NOT at the left border:
                       //         Go one column to the left
                       //        Else:
                       //         Go one column to the right
            :          //       Else (directions N or S)
             0]        //        Stay in the same column
               =42)    //      And fill this new `x,y` cell with a '*'
      i=               //    Determine the new direction
        y<2&i<2|y>=n&i>2&i<5?4-i:x<2&i>4|x>=n&i>0&i<4?8-i:y<2&i>6?5:y<n|i!=5?i:7;
                       //     (See loose explanation below)
  r[y][x]=79;          //  And finally set the last `x,y` cell to 'O'
  return r;}           //  And return the result-matrix

y<2&i<2|y>=n&i>2&i<5?4-i:x<2&i>4|x>=n&i>0&i<4?8-i:y<2&i>6?5:y<n|i!=5?i:7adalah versi golf dari ini di bawah ini dengan menggunakan 4-idan 8-iuntuk sebagian besar perubahan arah:

y<2?     // If we're at the top border
 i==0?   //  If the current direction is N
  4      //   Change it to direction S
 :i==1?  //  Else-if the current direction is NE
  3      //   Change it to SE
 :i==7?  //  Else-if the current direction is NW
  5      //   Change it to SW
 :       //  Else
  i      //   Leave the direction the same
:x<2?    // Else-if we're at the left border
 i==7?   //  If the current direction is NW
  1      //   Change it to NE
 :i==6?  //  Else-if the current direction is W
  2      //   Change it to E
 :i==5?  //  Else-if the current direction is SW
  3      //   Change it to SE
 :       //  Else
  i      //   Leave the direction the same
:y>=n?   // Else-if we're at the bottom border
 i==3?   //  If the current direction is SE
  1      //   Change it to NE
 :i==4?  //  Else-if the current direction is S
  0      //   Change it to N
 :i==5?  //  Else-if the current direction is SW
  7      //   Change it to NW
 :       //  Else
  i      //   Leave the direction the same
:x>=n?   // Else-if we're at the right border
 i==1?   //  If the current direction is NE
  7      //   Change it to NW
 :i==2?  //  Else-if the current direction is E
  6      //   Change it to W
 :i==3?  //  Else-if the current direction is SE
  5      //   Change it to SW
 :       //  Else
  i      //   Leave the direction the same
:        // Else
 i       //  Leave the direction the same

Arang , 74 byte

ＮθＪ⊘⊕θ⊘⊕θＵＲ±⊕⊕θＪＮ±ＮＦＡ«≔⊟ιζＦ⊟ι«≔ζδ↷δ¶Ｆ›⊗↔ⅈθ≦±ζＦ›⊗↔ⅉθ≦⁻⁴ζ≧﹪⁸ζ↷⁴¶↶⁴↶δ↷ζ*¶↶ζＰo

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Mengambil input dalam format n, x, y, d di mana d adalah array array [jarak, arah] pasangan di mana arahnya adalah pengkodean numerik 0 = selatan searah jarum jam ke 7 = selatan timur. Penjelasan:

ＮθＪ⊘⊕θ⊘⊕θＵＲ±⊕⊕θ

Input ndan gambar sebuah kotak yang interiornya seukuran itu berpusat pada asal.

ＪＮ±Ｎ

Input dan melompat ke xdan y(tetapi meniadakan ykarena sumbu y Charcoal meningkat ke bawah).

ＦＡ«

Ulangi entri di d.

≔⊟ιζ

Ekstrak arah awal.

Ｆ⊟ι«

Ulangi untuk jarak yang diinginkan.

≔ζδ

Simpan arahnya.

↷δ¶

Buat langkah eksperimental ke arah itu.

Ｆ›⊗↔ⅈθ≦±ζ

Jika ini tidak aktif maka balikkan arah secara horizontal.

Ｆ›⊗↔ⅉθ≦⁻⁴ζ

Jika ini terjadi dari atas atau bawah maka balikkan arah secara vertikal.

≧﹪⁸ζ

Kurangi modulo 8 arah (perintah Pivot hanya menerima nilai dari 0 hingga 7).

↷⁴¶↶⁴

Batalkan langkah eksperimental.

↶δ↷ζ*¶

Hadapi arah yang benar, lalu cetak jejak dan gerakkan.

↶ζＰo

Menghadap ke belakang ke arah default, dan cetak objek pada posisi saat ini.

JavaScript, 206 byte

Mengambil input sebagai (n, x, y, [[dir, len], [dir, len], ...]) di mana arah dikodekan menggunakan bitmask:

S : 1  
N : 2   
E : 4  
W : 8  
SE: 5 (1|4)  
SW: 9 (1|8)
NE: 6 (2|4)
NW:10 (2|8)

Menghasilkan string dengan

- 1 for top and bottom boundary
- 4 for left and right boundary 
- 5 for corners 
- 0 for trace
- 8 for the final position.

Nilai-nilai yang berbeda untuk batas digunakan untuk mengevaluasi arah selanjutnya

(n,x,y,d)=>(Q=[e=`
5`+'1'[R='repeat'](n)+5,o=n+3,-o,c=[...e+(`
4`+' '[R](n)+4)[R](n)+e],1,1+o,1-o,,-1,o-1,~o],p=1-o*(~n/2+y)-~n/2+x,c[d.map(([q,s])=>{for(a=q;s--;p+=Q[a^=c[p+Q[a]]*3])c[p]=0}),p]=8,c.join``)

Kurang golf

F=(n,x,y,d) => (
  o = n+3, // vertical offset, accounting for boundaries and newline
  // Q = offsets for different directions, bitmask indexed 
  Q = [,  // 0000 no direction
     o,   // 0001 S
     -o,  // 0010 N
     ,    // 0011 NS - invalid
     1 ,  // 0100 E
     1+o, // 0101 SE
     1-o, // 0110 NE
     ,    // 0111 NSE - invalid
     -1,  // 1000 W
     o-1, // 1001 SW
    -o-1],// 1010 NW

  e = `\n5`+'1'.repeat(n)+5, // top and bottom boundary
  c = [...e + (`\n4` + ' '.repeat(n) + 4).repeat(n) + e], // canvas
  p = 1 - o*(~n/2+y) - ~n/2 + x, // start position
  d.map( ([q,s]) => { // repeat for each element in 'd'
    a = q; // starting offset pointer - will change when bounce
    while( s-- )
    {
      c[p] = 0; // trace
      b = c[p + Q[a]] // boundary value or 0 (space count 0)
      a ^= b * 3 // xor with 0 if no bounce, else 3 or 12 or 15
      p += Q[q]  // advance position
    }
  })
  c[p] = 8, // set end position
  c.join``
)

UJI

var F=
(n,x,y,d)=>(Q=[e=`
5`+'1'[R='repeat'](n)+5,o=n+3,-o,c=[...e+(`
4`+' '[R](n)+4)[R](n)+e],1,1+o,1-o,,-1,o-1,~o],p=1-o*(~n/2+y)-~n/2+x,c[d.map(([q,s])=>{for(a=q;s--;p+=Q[a^=c[p+Q[a]]*3])c[p]=0}),p]=8,c.join``)

var out=x=>O.textContent+=x

var test=(n,x,y,d)=>{
  var dd = d.map(([d,s])=>[,'S','N',,'E','SE','NE',,'W','SW','NW'][d]+' '+s)
  out([n,x,y]+' ['+dd+']')
  out(F(n,x,y,d))
  out('\n\n')
}

test(5,0,0,[[10,2],[1,2],[4,1]])
test(9,3,-1,[[2,2],[9,8],[5,3],[6,8]])
test(11,3,-5,[[10,8],[4,5],[5,2],[9,5],[2,6],[6,10]])

<pre id=O></pre>

C (gcc) , 352 323 byte

Golf turun 29 byte berkat ceilingcat.

#define G(x,a)x+=a=x<2|x>m-3?-a:a
#define A(p)atoi(v[p])
m,r,c,x,y,s,a,b;main(q,v)int**v;{m=A(1)+2;int f[r=m*m];for(x=A(2)+m/2;r--;f[r]=32);for(y=A(s=3)+m/2;++s<q;)for(a=cos(A(s)*.8)*2,b=sin(A(s)*.8)*2,c=A(++s);c--;G(y,b),f[y*m+x]=42)G(x,a);for(f[y*m+x]=64;++r<m;puts(""))for(c=0;c<m;c++)putchar(c%~-m&&r%~-m?f[r*m+c]:35);}

Cobalah online!

Program ini mengambil input sebagai argumen baris perintah (seperti a.out 10 1 1 3 5 0 4 7 2):

• argumen pertama adalah ukuran bidang,
• dua berikutnya adalah koordinat awal $(x,y)$ aktor,
• semua pasangan argumen mulai dari yang keempat adalah $(d, t)$ berpasangan dimana $d$adalah arah (direpresentasikan sebagai angka 0..7, mulai dari 0 = Edan berputar searah jarum jam) dan$t$ adalah sejumlah langkah.

Penjelasan

// Update the coordinate AND simultaneously modify the direction (if needed)
#define G (x, a) x += a = x < 2 || x >= m - 2 ? -a : a

// Get the numeric value of an argument
#define A (p) atoi (v[p])

// variables
m, // width and height of the array with field data
r, c, // helpers
x, y, // current coordinates of the actor
s, // helper
a, b; // current direction of the movement

main (q, v) char **v;
{
    // array size is field size + 2 (for borders)
    m = A (1) + 2;

    // allocate the array
    int f[r = m * m];

    // fill the array with spaces,
    for
    (
        // but first get x of the actor
        x = A (2) + m / 2;

        r--;

        f[r] = 32
    );

    // trace: iterate over remaining commandline argument pairs
    for
    (
        // but first get y of the actor
        y = A (s = 3) + m / 2;

        ++s < q; // loop until no args left
    )
        // for each such pair
        for
        (
            a = cos (A (s) * .8) * 2,  // get the x-increment
            b = sin (A (s) * .8) * 2, // get the y-increment
            c = A (++s);  // then get the number of steps

            c--;

            // after each step:
            G (y, b), // update y and maybe the y-direction
            f[y * m + x] = 42 // draw the trail
        )
            G (x, a); // update x and maybe the x-direction

   // output
   for
   (
       f[x * m + y] = 64; // put a @ to the current position of the actor
       ++r < m; // r == -1 at the beginning of the loop so preincrement

       puts("") // terminate each row with newline
   )
       // iterate over columns in the row
       for (c = 0; c < m; c++)
           putchar
           (
               c % ~ -m && r % ~ -m ? // if it is not a border cell,
               f[r * m + c] // output the character from the array
               : 35 // otherwise output the #
           );
}