Le défi

Étant donné une grille rectangulaire de caractères

ABCDE
FGHIJ
KLMNO
PQRST

et une grille avec les mêmes dimensions de points et d'espaces

. . .
  . . .
  . .  
  . . .  

Sortez la chaîne qui est générée en suivant les points à travers la grille en commençant dans le coin supérieur gauche. Cet exemple donneraitABGLQRSNIJE

Remarques

• Vous pouvez prendre les grilles d'entrée comme des tableaux 2D ou l'alternative la plus proche dans votre langue au lieu d'une chaîne multiligne.
• Vous pouvez utiliser la valeur NULL de votre langue au lieu d'espaces. Mais vous devez utiliser des points pour marquer le chemin.
• Vous n'avez pas besoin de séparer les points sur la même ligne avec les espaces. Je viens de les ajouter pour plus de lisibilité.
• La grille la plus petite possible a la taille 1x1.
• Le point de début et de fin n'aura qu'un seul voisin. Les points entre eux auront toujours exactement deux voisins verticaux ou horizontaux. Cela garantit que le chemin est sans ambiguïté.
• Le chemin ne passera pas en diagonale.
• Les caractères de la grille seront tous des caractères en majuscules ou en minuscules dans la plage [a-z]qui vous convient le mieux.
• Le chemin commencera toujours dans le coin supérieur gauche.

Règles

• Fonction ou programme complet autorisé.
• Règles par défaut pour les entrées / sorties.
• Des échappatoires standard s'appliquent.
• C'est le code-golf , donc le nombre d'octets le plus bas l'emporte. Tiebreaker est une soumission antérieure.

Cas de test

Grille # 1

ABCABCW
DEFGHUQ
XLUSDQZ
ASUKWXI
WUKOAIM
AIAIOUP

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

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

Grille 2

Notez les espaces triples dans les deuxièmes lignes des premier et deuxième exemples.

UN B
CD

.  
   
=> A

. .
   
=> AB

.  
. .
=> ACD

Grille # 3

UNE

.
=> A

Codage heureux!

APL, 63 octets

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

Il s'agit d'une fonction qui prend deux matrices de caractères (elles doivent être des matrices), la grille de caractères comme argument de gauche et la grille de points comme argument de droite. La matrice de points peut être plus petite que la matrice de caractères.

Explication:

• (,⍵='.')/,⍳⍴⍵: obtenir les positions des points, dans l'ordre ligne-colonne
• 1↓: laissez tomber le premier (il est connu pour être à 1 1)
• (⊂1 1){... }: à partir de 1 1, exécutez la fonction suivante, qui suit le chemin (son argument de gauche est sa position actuelle, son argument de droite sont des positions non visitées). Cela fonctionne en sélectionnant le point non visité le plus proche à chaque fois. (Si les hypothèses de la question se vérifient, c'est correct.)
  • ×≢⍵:: s'il reste des postes non visités:
    • +/¨2*⍨⍺-⍵: trouver la distance Manhattan entre chaque position et la position actuelle
    • V←(+=⌊/): pour chaque position, voyez si sa distance est égale à la plus petite distance et enregistrez-la dans V.
    • ⍵/⍨~: sélectionnez toutes les positions pour lesquelles ce n'est pas le cas, voici les champs à visiter ensuite
    • (V/⍵): Trouver la position pour laquelle il est le cas, ce sera le champ suivant
    • ∇: réexécutez la fonction avec ces nouveaux arguments
    • ⍺,: le résultat est la position actuelle, suivi du résultat de cette opération pour le reste de la liste
  • ⋄⍺: sinon, retournez simplement la position actuelle et arrêtez (c'est la dernière)
• ⍺[... ]: pour chaque position, sélectionnez l'élément correspondant dans la grille de caractères.

Cas de test:

      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 octets

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

Explication

Prend les grilles sous forme de chaînes multilignes.

Cela ressemble à une tentative décente, mais j'ai manqué de temps en jouant au golf, donc cela pourrait probablement être amélioré.

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 octets

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

Essayez-le en ligne!