Các thách thức

Cho một lưới các ký tự hình chữ nhật

ABCDE
FGHIJ
KLMNO
PQRST

và một lưới có cùng kích thước của dấu chấm và dấu cách

. . .
  . . .
  . .  
  . . .  

Xuất chuỗi được tạo bằng cách theo các dấu chấm qua lưới bắt đầu ở góc trên bên trái. Ví dụ này sẽ mang lạiABGLQRSNIJE

Ghi chú

• Bạn có thể lấy các lưới đầu vào dưới dạng các mảng 2D hoặc thay thế gần nhất trong ngôn ngữ của bạn thay vì một chuỗi nhiều dòng.
• Bạn có thể sử dụng giá trị NULL của ngôn ngữ của bạn thay vì khoảng trắng. Nhưng bạn phải sử dụng dấu chấm để đánh dấu đường dẫn.
• Bạn không cần tách các dấu chấm trên cùng một dòng với dấu cách. Tôi chỉ cần thêm chúng để dễ đọc.
• Lưới nhỏ nhất có thể có kích thước 1x1.
• Dấu chấm bắt đầu và kết thúc sẽ chỉ có một hàng xóm. Các chấm giữa chúng sẽ luôn có chính xác hai hàng xóm dọc hoặc ngang. Điều này đảm bảo rằng đường dẫn rõ ràng.
• Đường dẫn sẽ không đi chéo.
• Các ký tự trong lưới sẽ là tất cả các ký tự viết hoa hoặc viết thường trong phạm vi [a-z]bất cứ điều gì thuận tiện nhất cho bạn.
• Đường dẫn sẽ luôn bắt đầu ở góc trên bên trái.

Quy tắc

• Chức năng hoặc chương trình đầy đủ cho phép.
• Quy tắc mặc định cho đầu vào / đầu ra.
• Tiêu chuẩn áp dụng.
• Đây là môn đánh gôn , vì vậy, số byte thấp nhất sẽ thắng. Tiebreaker là trình trước đó.

Các trường hợp thử nghiệm

Lưới số 1

ABCABCW
DEFGHUQ
XLUSDQZ
ASUKWXI
WUKOAIM
AIAIOUP

. .          
  . . .      
      .      
. . . .      
.            
.            
=> ABEFGSKUSAWA

. . . . . . .
            .
. . . .
. . . .
. .
. . . . . . .
=> ABCABCWQZIMPUOIAIAWAXLUUK

Lưới 2

Lưu ý ba không gian trong dòng thứ hai của ví dụ thứ nhất và thứ hai.

AB
CD

.  
   
=> A

. .
   
=> AB

.  
. .
=> ACD

Lưới số 3

Một

.
=> A

Chúc mừng mã hóa!

APL, 63 byte

{⍺[(⊂1 1){×≢⍵:⍺,(V/⍵)∇⍵/⍨~V←(+=⌊/)+/¨2*⍨⍺-⍵⋄⍺}1↓(,⍵='.')/,⍳⍴⍵]}

Đây là một hàm lấy hai ma trận ký tự (chúng phải là ma trận), lưới ký tự làm đối số bên trái và lưới chấm làm đối số bên phải của nó. Ma trận điểm có thể nhỏ hơn ma trận ký tự.

Giải trình:

• (,⍵='.')/,⍳⍴⍵: lấy vị trí của các dấu chấm, theo thứ tự cột hàng
• 1↓: thả cái đầu tiên (được biết là tại 1 1)
• (⊂1 1){... }: bắt đầu từ 1 1, chạy hàm sau, đi theo đường dẫn (đối số bên trái của nó là vị trí hiện tại của nó, đối số bên phải của nó là các vị trí không được chú ý). Nó hoạt động bằng cách chọn dấu chấm không mong muốn gần nhất mỗi lần. (Nếu các giả định từ câu hỏi giữ, điều này là chính xác.)
  • ×≢⍵:: nếu vẫn còn các vị trí không mong muốn:
    • +/¨2*⍨⍺-⍵: tìm khoảng cách Manhattan giữa mỗi vị trí và vị trí hiện tại
    • V←(+=⌊/): cho mỗi vị trí, xem khoảng cách của nó có bằng khoảng cách nhỏ nhất không và lưu nó vào V.
    • ⍵/⍨~: chọn tất cả các vị trí không phải là trường hợp này, đây là các trường để truy cập tiếp theo
    • (V/⍵): Tìm vị trí mà nó là như vậy, đây sẽ là lĩnh vực tiếp theo
    • ∇: chạy lại hàm với các đối số mới này
    • ⍺,: kết quả là vị trí hiện tại, theo sau là kết quả của việc này cho phần còn lại của danh sách
  • ⋄⍺: nếu không, chỉ cần trả lại vị trí hiện tại và dừng lại (đó là vị trí cuối cùng)
• ⍺[... ]: cho mỗi vị trí, chọn thành phần tương ứng trong lưới ký tự.

Các trường hợp thử nghiệm:

      f←{⍺[(⊂1 1){×≢⍵:⍺,(V/⍵)∇⍵/⍨~V←(+=⌊/)+/¨2*⍨⍺-⍵⋄⍺}1↓(,⍵='.')/,⍳⍴⍵]}
      ⍝ example
      g0  ← 4 5⍴'ABCDEFGHIJKLMNOPQRST'
      d0  ← 4 5⍴'..  . . .. . .  ... '
      ⍝ test case 1
      g1  ← 6 7⍴'ABCACBWDEFGHUQXLUSDQZASUKWXIWUKOAIMAIAIOUP'
      d1a ← 6 7⍴'..      ...      .   ....   .      .      '
      d1b ← 6 7⍴'.......      ....   .. ..  ..     ........'
      ⍝ test case 2
      g2  ← 2 2⍴'ABCD'
      d2a ← 1 1⍴'.'
      d2b ← 1 2⍴'..'
      d2c ← 2 2⍴'. ..'
      ⍝ test case 3
      g3  ← 1 1⍴'A'
      d3  ← 1 1⍴'.'

      g0 f d0
ABGLQRSNIJE
      (⊂g1) f¨ d1a d1b
┌────────────┬─────────────────────────┐
│ABEFGSKUSAWA│ABCACBWQZIMPUOIAIAWAXLUUK│
└────────────┴─────────────────────────┘
      (⊂g2) f¨ d2a d2b d2c
┌─┬──┬───┐
│A│AB│ACD│
└─┴──┴───┘
      g3 f d3
A

JavaScript (ES6), 122 byte

c=>g=>c[l=~c.search`
`,i=p=0]+[...g].map(_=>i|!p?c[i=(d=n=>g[i-n-p?i-n:c]>" "&&(p=i)-n)(1)||d(-1)||d(l)||d(-l)]:"").join``

Giải trình

Lấy các lưới như các chuỗi đa dòng.

Cảm thấy như một nỗ lực tốt nhưng tôi đã hết thời gian trong khi chơi golf để nó có thể được cải thiện.

var solution =

c=>g=>
  c[                            // add the starting letter to the output
    l=~c.search`
`,                              // l = line length
    i=p=0                       // i = current index, p = previous index
  ]+
  [...g].map(_=>                // loop
    i|!p?                       // if we have not finished yet
      c[i=                      // find the next index and return it's letter
        (d=n=>                  // d = function to check for a dot at offset n
          g[
            i-n-p?i-n           // if i - n != p, get the character at index i - n
            :c                  // else get index "c" (will return undefined, not a dot)
          ]>" "                 // if the character is a dot
          &&(p=i)-n             // set p to i and return i - n
        )
        (1)||d(-1)||d(l)||d(-l) // search for the next adjacent dot
      ]
    :""                         // if we have finished, return no letter
  )
  .join``                       // output all the returned letters

<textarea id="Characters" rows="6" cols="30">ABCABCW
DEFGHUQ
XLUSDQZ
ASUKWXI
WUKOAIM
AIAIOUP</textarea>
<textarea id="Grid" rows="6" cols="30">.......
      .
...   .
. ..  .
.     .
.......</textarea><br />
<button onclick="result.textContent=solution(Characters.value)(Grid.value)">Go</button>
<pre id="result"></pre>

APL (Dyalog Classic) , 43 byte

{⍺[11 9∘○¨{⍵∪⍺∩∊⍵+⊂0j1*⍳4}⍣≡∘⊃⍨0j1⊥¨⍸⍵=⊃⍵]}

Hãy thử trực tuyến!