De-Snakify una cadena

58

Una cadena normal se ve así:

Hello,IAmAStringSnake!

Y una serpiente de cadena se ve así:

Hel         
  l      rin
  o,IAmASt g
           S
       !ekan

Tu tarea

Las serpientes de cadena son peligrosas, por lo que debe hacer un programa que tome una serpiente de cadena como entrada y la envíe como una cadena normal.

Especificaciones

  • La entrada puede ser una cadena multilínea o una matriz de cadenas.
  • Cada línea de la entrada se rellenará con espacios para formar una cuadrícula rectangular.
  • Los personajes de la serpiente solo pueden conectarse con los personajes adyacentes arriba, abajo, a la izquierda o a la derecha de ellos (al igual que en el juego Snake). No pueden ir en diagonal.
  • Los personajes de la serpiente nunca serán adyacentes a otra parte de la serpiente, solo los personajes conectados.
  • El primer carácter de la cadena es el carácter final con la distancia más corta de Manhattan desde la esquina superior izquierda de la cuadrícula de entrada (es decir, el número mínimo de movimientos necesarios para que una serpiente vaya directamente desde el carácter final a la esquina superior izquierda esquina). Ambos extremos nunca tendrán la misma distancia.
  • La cadena puede contener cualquier carácter ASCII entre los puntos de código 33 y 126 inclusive (sin espacios ni líneas nuevas).
  • La cadena tendrá entre 2 y 100 caracteres de longitud.
  • El código más corto en bytes gana.

Casos de prueba

(Cuadrícula de entrada, seguida de la cadena de salida)

Hel         
  l      rin
  o,IAmASt g
           S
       !ekan

Hello,IAmAStringSnake!

----------

Python

Python

----------

P  ngPu  Code 
r  i  z  d  G 
o  m  z  n  o 
gram  lesA  lf

ProgrammingPuzzlesAndCodeGolf

----------

   ~ zyx tsr XWVUTSR
   }|{ wvu q Y     Q
!          p Z `ab P
"#$ 6789:; o [ _ c O
  % 5    < n \]^ d N
('& 432  = m     e M
)     1  > lkjihgf L
*+,-./0  ?         K
         @ABCDEFGHIJ

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

----------

  tSyrep    
  r    p    
  in Sli    
   g    Sile
   Snakes  n
Ser      ylt
a eh   ilS  
fe w   t    
   emo h    
     Sre    

SlipperyStringSnakesSilentlySlitherSomewhereSafe
usuario81655
fuente
20
Dato curioso: ¡Según el artículo de Wikipedia vinculado, la distancia de Manhattan también se conoce como distancia de serpiente!
user81655
¿ Sería correcta una entrada como hastebin.com/asugoropin.vbs ?
FliiFe
@FliiFe No, partes de la serpiente no pueden estar una al lado de la otra porque no siempre es posible saber a dónde va la serpiente cuando esto sucede (y esto dificultaría mucho el desafío). Agregué una línea a la especificación para explicar esto.
user81655
¿Puede la entrada ser una matriz bidimensional (es decir, cada carácter como un elemento)?
FliiFe
29
¿Seguramente este rompecabezas necesita una respuesta en Python?
abligh

Respuestas:

11

APL, 55 bytes

{⍵[1↓(⊂0 0){1<⍴⍵:⍺,∆[⊃⍋+/¨|⍺-∆]∇∆←⍵~⍺⋄⍺}(,⍵≠' ')/,⍳⍴⍵]}

Esta función toma una matriz de caracteres con la serpiente de cadena.

Ejemplo:

      s1 s2 s3
┌────────────┬──────────────┬────────────────────┐
│Hel         │P  ngPu  Code │   ~ zyx tsr XWVUTSR│
│  l      rin│r  i  z  d  G │   }|{ wvu q Y     Q│
│  o,IAmAst g│o  m  z  n  o │!          p Z `ab P│
│           S│gram  lesA  lf│"#$ 6789;: o [ _ c O│
│       !ekan│              │  % 5    < n \]^ d N│
│            │              │('& 432  = m     e M│
│            │              │)     1  > lkjighf L│
│            │              │*+,-./0  ?         K│
│            │              │         @ABCDEFGHIJ│
└────────────┴──────────────┴────────────────────┘
      ↑ {⍵[1↓(⊂0 0){1<⍴⍵:⍺,∆[⊃⍋+/¨|⍺-∆]∇∆←⍵~⍺⋄⍺}(,⍵≠' ')/,⍳⍴⍵]} ¨ s1 s2 s3 
Hello,IAmAstringSnake!                                                                        
ProgrammingPuzzlesAndCodeGolf                                                                 
!"#$%&'()*+,-./0123456789;:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefhgijklmnopqrstuvwxyz{|}~

Explicación:

  • (,⍵≠' ')/,⍳⍴⍵: obtener las coordenadas de todos los no espacios
  • (⊂0 0): comienza en (0,0) (que es una coordenada no válida)
  • {... }: sigue a la serpiente, posición dada y serpiente:
    • 1<⍴⍵:: si queda más de 1 elemento:
      • ∆←⍵~⍺: elimina la posición actual de la serpiente y la almacena .
      • +/¨|⍺-∆: encuentra la distancia entre la posición actual y cada punto en el resto de la serpiente
      • ∆[⊃⍋...] `: obtener el punto más cercano en la serpiente
      • : ejecute la función nuevamente, con el punto más cercano como el nuevo punto actual y la serpiente acortada como la nueva serpiente.
      • ⍺,: agrega la posición actual al resultado de ese
    • ⋄⍺: de lo contrario, solo devuelve la posición actual
  • 1↓: suelta el primer elemento del resultado (que es la posición (0,0))
  • ⍵[... ]: obtener esos elementos de ⍵, en ese orden
marinus
fuente
24

JavaScript (ES6) + SnakeEx , 176 bytes

a=b=>snakeEx.run("s{A}:<+>([^ ]<P>)+",b).reduce((c,d)=>(e=c.marks.length-d.marks.length)>0?c:e?d:c.x+c.y>d.x+d.y?d:c).marks.reduce((c,d,e,f)=>e%2?c+b.split`\n`[d][f[e-1]]:c,"")

¿Recuerdas SnakeEx? Bien, porque yo tampoco! Sugerencias de golf bienvenidas.

LegionMammal978
fuente
19

MATL , 80 bytes

Gracias a @LevelRiverSt por una corrección

32>2#fJ*+X:4Mt1Y6Z+l=*2#fJ*+ttXjwYj+K#X<)wt!"tbb6#Yk2#)yw]xxvtXjwYjqGZy1)*+Gw)1e

La entrada es como una matriz 2D de caracteres, con filas separadas por ;. Los casos de prueba en este formato son

['Hel         ';'  l      rin';'  o,IAmASt g';'           S';'       !ekan']
['Python']
['P  ngPu  Code ';'r  i  z  d  G ';'o  m  z  n  o ';'gram  lesA  lf']
['   ~ zyx tsr XWVUTSR';'   }|{ wvu q Y     Q';'!          p Z `ab P';'"#$ 6789:; o [ _ c O';'  % 5    < n \]^ d N';'(''& 432  = m     e M';')     1  > lkjihgf L';'*+,-./0  ?         K';'         @ABCDEFGHIJ']
['  tSyrep    ';'  r    p    ';'  in Sli    ';'   g    Sile';'   Snakes  n';'Ser      ylt';'a eh   ilS  ';'fe w   t    ';'   emo h    ';'     Sre    ']

Pruébalo en línea!

Explicación

Las coordenadas de cada carácter no espacial se representan mediante un número complejo. Para cada carácter actual, el siguiente se obtiene como el más cercano (diferencia absoluta mínima de sus coordenadas complejas).

Para determinar el carácter inicial, se deben encontrar los dos puntos finales. Esto se hace de la siguiente manera. Un punto final es un carácter no espacial que tiene exactamente un vecino no espacial. El número de vecinos se obtiene por convolución 2D con una máscara adecuada. El punto inicial es el punto final cuya coordenada compleja tiene la menor suma de partes reales e imaginarias; es decir, es la distancia más cercana en Manhattan al número complejo 0, o equivalente a 1 + 1j, que es la coordenada compleja de la esquina superior izquierda.

32>      % Take input as 2D char array. Compute 2D array with true for nonspace,
         % false for space
2#f      % Arrays of row and column indices of nonspaces
J*+      % Convert to complex array. Real part is row, imaginary part is column
X:       % Convert to column array
4Mt      % Push arrays of zeros and ones again. Duplicate
1Y6      % Push array [0 1 0; 1 0 1; 0 1 0]. Used as convolution mask to detect
         % neighbours that are nonspace
Z+       % 2D convolution with same size as the input
1=       % True for chars that have only one neighbour (endpoints)
*        % Multiply (logical and): we want nonspaces that are endpoints
2#fJ*+   % Find complex coordinates (as before)
ttXjwYj  % Duplicate. Take real and imaginary parts
+        % Add: gives Manhattan distance to (0,0)
K#X<     % Arg min. Entry with minimum absolute value has least Manhattan
         % distance to (0,0), and thus to (1,1) (top left corner)
)        % Apply as an index, to yield complex coordinate of initial endpoint
wt!      % Swap, duplicate, transpose.
         % The stack contains, bottom to top: complex coordinates of initial
         % endpoint, column array with all complex coordinates, row array of all
         % coordinates. The latter is used (and consumed) by the next "for"
         % statement to generate that many iterations
"        % For loop. Number of iterations is number of nonspaces
  tbb    %   Duplicate, bubble up twice (rearrange is stack)
  6#Yk   %   Find which of the remaining points is closest to current point. This
         %   is the next char in the string
  2#)    %   Remove the point with that index from the array of complex
         %   coordinates. Push that point and the rest of the array
  yw     %   Duplicate extracted point, swap
]        % End for
xx       % Delete top two elements of the stack
v        % Concatenate all stack contents into a column array. This array
         % contains the complex coordinates of chars sorted to form the string
tXjwYj   % Extract real part and imaginary part
GZy1)    % Number of rows of input. Needed to convert to linear index
*+       % Convert rows and columns to linear index
Gw       % Push input below that
)        % Index to get the original chars with the computed order
1e       % Force the result to be a row array (string). Implicitly display
Luis Mendo
fuente
¿Asumiré que viene una explicación?
Matt
@Matt Sure ... más tarde en el día :-)
Luis Mendo
Explicación agregada @Matt
Luis Mendo
The initial point is the endpoint whose complex coordinate has the least absolute valueCuidado: ¡distancia euclidiana! = Distancia de Manhattan. por ejemplo, el punto 7 + 7j tiene una distancia euclidiana de 9.8994 y una distancia de Manhattan 14. 10j está más lejos por la distancia euclidiana pero considerablemente más cerca por la distancia de Manhattan. Aparte de eso, ¡gran concepto!
Level River St
@LevelRiverSt ¡Gracias! Corregido
Luis Mendo
14

C 198 190 179 180 181 bytes

Editar: Usé la sugerencia por user81655 y eliminé el paréntesis en el operador ternario, ¡gracias! También cambié la engorrosa prueba (S & 1) de uniformidad para el S% 2 más apropiado (¡y más corto!).

Edit2: el uso de * un estilo de direccionamiento en gran medida, me hizo ciego a las optimizaciones obvias en la definición de S, es decir, reemplazar * (a + m) por a [m] etc. Luego reemplacé S por T, lo que esencialmente hace la mitad de lo que hace S. El código ahora también aprovecha el valor de retorno de putchar.

Edit3: Se corrigió el error que existía desde el principio, el criterio de detención de búsqueda de Manhattan a <b + m es correcto solo si a ya se ha disminuido. Esto agrega 2 bytes, pero uno se recupera al hacer la definición de m global.

Edit4: Mi golf ha pasado el mínimo y ahora está yendo por el camino equivocado. Otra corrección de errores relacionada con la búsqueda de Manhattan. Originalmente tenía verificaciones entrantes en su lugar y sin ellas la búsqueda continúa para grandes conjuntos de entrada (en algún lugar alrededor de 50x50) más allá del conjunto b. Por lo tanto, esa matriz debe expandirse al menos al doble del tamaño anterior, lo que agrega un byte más.

#define T(x)+x*((a[x]>32)-(a[-x]>32))
m=103;main(){char b[m<<8],*e=b,*a=e+m;while(gets(e+=m));for(e=a;(T(1)T(m))%2**a<33;a=a<b+m?e+=m:a)a-=m-1;for(;*a;a+=T(1)T(m))*a-=putchar(*a);}

Ungolfed y explicó:

/* T(1)T(m) (formerly S) is used in two ways (we implicitly assume that each cell has
   one or two neighbors to begin with):
   1. (in the first for-loop) T(1)T(m) returns an odd (even) number if cell a has one (two)
      neighbors with ASCII value > 32. For this to work m must be odd.
   2. (in the second for-loop) at this stage each cell a in the array at which T(1)T(m) is
      evaluated has at most one neighboring cell with ASCII value > 32. T(1)T(m) returns the
      offset in memory to reach this cell from a or 0 if there is no such cell.
      Putting the + in front of x here saves one byte (one + here replaces two
      + in the main part)

#define T(x)+x*((a[x]>32)-(a[-x]>32))

  /* A snake of length 100 together with the newlines (replaced by 0:s in memory) fits
     an array of size 100x101, but to avoid having to perform out-of-bounds checks we
     want to have an empty line above and the array width amount of empty lines below
     the input array. Hence an array of size 202x101 would suffice. However, we save
     a (few) bytes if we express the array size as m<<8, and since m must be odd
     (see 1. above), we put m = 103. Here b and e point to the beginning of the (now)
     256x103 array and a points to the beginning of the input array therein */

m=103;
main()
{

  char b[m<<8],*e=b,*a=e+m;

  /* This reads the input array into the 256x103 array */

  while(gets(e+=m));

  /* Here we traverse the cells in the input array one
     constant-Manhattan-distance-from-top-left diagonal at a time starting at the top-left
     singleton. Each diagonal is traversed from bottom-left to top-right since the starting point
     (memory location e) is easily obtained by moving one line downwards for each diagonal
     (+m) and the stopping point is found by comparing the present location a to the input array
     starting position (b+m). The traversal is continued as long as the cell has either
     an ASCII value < 33 or it has two neighbors with ASCII value > 32 each (T(1)T(m)
     is even so that (T(1)T(m))%2=0).
     Note that the pointer e will for wide input arrays stray way outside (below) the
     input array itself, so that for a 100 cell wide (the maximum width) input array
     with only two occupied cells in the bottom-right corner, the starting cell
     will be discovered 98 lines below the bottom line of the input array.
     Note also that in these cases the traversal of the diagonals will pass through the
     right-hand side of the 103-wide array and enter on the left-hand side. This, however,
     is not a problem since the cells that the traversal then passes have a lower
     Manhattan distance and have thereby already been analyzed and found not to contain
     the starting cell. */

  for(e=a;(T(1)T(m))%2**a<33;a=a<b+m?e+=m:a)a-=m-1;

  /* We traverse the snake and output each character as we find them, beginning at the
     previously found starting point. Here we utilize the function T(1)T(m), which
     gives the offset to the next cell in the snake (or 0 if none), provided that
     the current cell has at most one neighbor. This is automatically true for the
     first cell in the snake, and to ensure it for the rest of the cells we put the
     ASCII value of the current cell to 0 (*a-=putchar(*a)), where we use the fact
     that putchar returns its argument. The value 0 is convenient, since it makes the
     stopping condition (offset = 0, we stay in place) easy to test for (*a == 0). */

  for(;*a;a+=T(1)T(m))
    *a-=putchar(*a);
}
Zunga
fuente
1
Esta respuesta es genial.
abligh
+1 Esto es genial. Me gustaría agregar una explicación a mi respuesta que muestre dónde eliminé bytes en comparación con su solución, ¿está bien?
mIllIbyte
mIllIbyte: siéntase libre de agregar los comentarios, ese es el camino hacia nuevas ideas.
Zunga
user81655: gracias por la sugerencia, redujo 6 bytes. De hecho, intenté eso ayer, además de usar S% 2 en lugar de (S & 1), lo que redujo otros 2 bytes, para la prueba de uniformidad, pero por alguna razón (mi código tenía errores en otro lugar) tampoco funcionó adecuadamente. Ahora, sin embargo, todo parece estar bien.
Zunga
Muy agradable. Ahorre un poco más con a[1], a[-m]etc., y haga mglobal - m=103;main().
ugoren
9

C, 272 bytes

#define E j+(p/2*i+1)*(p%2*2-1)
#define X(Y) a[Y]&&a[Y]-32
char A[999],*a=A+99;j,p,t;i;main(c){for(;gets(++j+a);j+=i)i=strlen(a+j);for(c=j;j--;){for(t=p=4;p--;)t-=X(E);t==3&&X(j)?c=c%i+c/i<j%i+j/i?c:j:0;}for(j=c;c;){putchar(a[j]),a[j]=0;for(c=0,p=4;!c*p--;)X(E)?c=j=E:0;}}

Mira la fuente de @ Zunga. Ahora mira el mío. ¿Quieres saber cómo obtuve los 91 bytes adicionales?
Sin golf:

#define E j+(p/2*i+1)*(p%2*2-1)
#define X(Y) a[Y]&&a[Y]-32  //can be more concise, see @Zunga's
  //and then doesn't need the define
char A[999],*a=A+99;j,p,t;i;
main(c){for(;gets(++j+a);j+=i)
i=strlen(a+j); //we don't need to know the length of a line
  //in @Zunga's solution, lines are spaced a constant distance apart
for(c=j;j--;){
for(t=p=4;p--;)t-=X(E);  //a ton of bytes can be saved with determining 
  //the neighbors, see @Zunga's source
t==3&&X(j)?
c=c%i+c/i<j%i+j/i?c:j:0;}  //we search for ends of the snake, 
  //and compute the Manhattan distance
for(j=c;c;){putchar(a[j]),a[j]=0;
for(c=0,p=4;!c*p--;)  //determining the neighbors again
X(E)?c=j=E:0;}}
milIbyte
fuente
5

Python (2 y 3), 640 624 604 583 575 561 546 538 bytes

Todavía soy un golf n00b, así que esto es un poco grande.

Editar: ¡Gracias a @porglezomp por las sugerencias! No eliminé todos los operadores 'y' ya que eso rompería Python 3.

Edit2: Gracias a @Aleksi Torhamo por el comentario sobre isspace (). La reducción resultante compensa la corrección de errores que puse. ¡También gracias a anónimo por el resaltado de sintaxis!

Edit3: Gracias a @ mbomb007 por algunos bytes adicionales.

import sys;s=sys.stdin.read().split('\n');m={};q=[];o=len;j=o(s);r=range;g='!'
for y in r(j):
 v=s[y];f=o(v);d=y+1
 for x in r(f):
  n=[];a=n.append;U=s[y-1]
  if v[x]>=g:j>=y>0==(U[x]<g)<=x<o(U)and a((x,y-1));j>y>=0==(v[x-1]<g)<x<=f and a((x-1,y));j>y>-1<x+1<f>(v[x+1]<g)<1and a((x+1,y));j>d>-1<x<o(s[d])>(s[d][x]<g)<1and a((x,d));m[x,y]=[v[x],n];o(n)-1or q.append((x,y))
t=min(q,key=sum);w=sys.stdout.write;w(m[t][0]);c=m[t][1][0]
while o(m[c][1])>1:
 b=m[c][1];w(m[c][0])
 for k in r(o(b)):
  if b[k]!=t:t=c;c=b[k];break
print(m[c][0])

Y aquí está mi versión previa al golf

import sys

lines = sys.stdin.read().split('\n')
startend = []
mydict = {}
for y in range( 0, len(lines)):
  for x in range( 0, len(lines[y])):
    if not lines[y][x].isspace():
      neighbors = []
      if x>=0 and x<len(lines[y-1]) and y-1>=0 and y-1<len(lines):
        if not lines[y-1][x].isspace():
          neighbors.append( (x,y-1) )
      if x-1>=0 and x-1<len(lines[y]) and y>=0 and y<len(lines):
        if not lines[y][x-1].isspace():
          neighbors.append( (x-1,y) )
      if x+1>=0 and x+1<len(lines[y]) and y>=0 and y<len(lines):
        if not lines[y][x+1].isspace():
          neighbors.append( (x+1,y) )
      if x>=0 and x<len(lines[y+1]) and y+1>=0 and y+1<len(lines):
        if not lines[y+1][x].isspace():
          neighbors.append( (x,y+1) )
      mydict[(x,y)] = [ lines[y][x], neighbors ]

      if len( neighbors ) == 1:
        startend.append( (x,y) )

startend.sort( key=lambda x : x[0]*x[0] + x[1]*x[1] )

last = startend[0]
sys.stdout.write( mydict[ last ][0] )
current = mydict[last][1][0]
while len( mydict[current][1] ) > 1:
  sys.stdout.write( mydict[current][0] )
  for k in range( 0, len( mydict[current][1] ) ):
    if mydict[current][1][k] != last:
      last = current
      current = mydict[current][1][k]
      break

print(mydict[current][0])
techo
fuente
1
Ahorré 12 bytes introduciendo S=lambda s:s.isspace()y luego haciendo en S(s)lugar de s.isspace().
porglezomp
1
Creo que también puede cambiar todo and a <, ya que f() < g() < h()es lo mismo g = g(); f() < g and g < h()en términos de efectos secundarios (cortocircuito de cadenas de comparación), y de todos modos está ignorando el resultado de las comparaciones.
porglezomp
1
m[(x,y)]=es lo mismo que el más cortom[x,y]=
porglezomp
2
@porglezomp: es aún más corto decirS=str.isspace
Aleksi Torhamo el
1
Eliminar Sy, en cambio, usarlo <'!'en cada caso puede tener la misma longitud, posiblemente abriendo la oportunidad de ahorrar más. Cambiar if 1-S(v[x]):a if(v[x]<'!')<1:, por ejemplo. Y tal vez podría eliminar algunos paréntesis en las comparaciones posteriores al hacerlo de esa manera.
mbomb007
4

JavaScript (ES6), 195

Ver explicación dentro del fragmento de prueba

s=>[...s].map((c,i)=>{if(c>' '&([n=-1,1,o=-~s.search('\n'),-o].map(d=>n+=s[i+d]>' '&&!!(e=d)),n<1)&m>(w=i/o+i%o|0))for(m=w,r=c,p=i+e;r+=s[i=p],[e,o/e,-o/e].some(d=>s[p=i+(e=d)]>' '););},m=1/0)&&r

Prueba

f=s=>[...s].map((c,i)=>{if(c>' '&([n=-1,1,o=-~s.search('\n'),-o].map(d=>n+=s[i+d]>' '&&!!(e=d)),n<1)&m>(w=i/o+i%o|0))for(m=w,r=c,p=i+e;r+=s[i=p],[e,o/e,-o/e].some(d=>s[p=i+(e=d)]>' '););},m=1/0)&&r

// Less golfed

u=s=>(
  o = -~s.search('\n'), // offset between lines
  m = 1/0, // current min manhattan distance, init at infinity
  // scan input looking for the 2 ends of the string
  [...s].map((c,i)=>{ // for each char c at position i
     if(c > ' ' // check if part of the string
        & ( [-1,1,o,-o] // scan in 4 directions and count neighbors
             .map(d=> n+=s[i+d]>' '&&!!(e=d), n=0), // remember direction in e
          n < 2) // if at end of string will have exactly 1 neighbor
        & (w = i/o + i%o |0) < m) // manhattan distance in w, must be less than current min
       // found one of the ends, follow the path and build the string in r
       for(m = w, r = c, p = i+e; 
           r += s[i=p], 
           [e,o/e,-o/e] // check 3 directions, avoiding to go back
           .some(d=>s[p=i+(e=d)]>' '); // save candidate position and direction in p and e
          ); // empty for body, all the work is inside the condition
  }),
  r
)  

console.log=x=>O.textContent+=x+'\n'

;[`Hel         
  l      rin
  o,IAmASt g
           S
       !ekan`,
 `   ~ zyx tsr XWVUTSR
   }|{ wvu q Y     Q
!          p Z \`ab P
"#$ 6789:; o [ _ c O
  % 5    < n \\]^ d N
('& 432  = m     e M
)     1  > lkjihgf L
*+,-./0  ?         K
         @ABCDEFGHIJ`].forEach(t=>{
  console.log(t+'\n\n'+f(t)+'\n')
  })
<pre id=O></pre>

edc65
fuente
¿Son necesarios los punto y coma ););}?
Cees Timmerman
1
@CeesTimmerman sí. El primero está dentro del forencabezado donde se necesitan 2 puntos. El segundo es el delímetro para el forcuerpo
edc65
3

Lua, 562 535 529 513 507 504 466 458 Bytes

Con mucho, mi golf más masivo en este momento, creo que todavía puedo cortar 100 bytes, para lo cual trabajaré, pero lo publico como respuesta, ya que ya me tomó un tiempo :) Tenía razón, ¡he reducido más de 100 bytes! No creo que haya mucho margen de mejora.

Esta función debe llamarse con una matriz 2D que contiene un carácter por celda.

¡ Ahorré 40 bytes mientras trabajaba con @KennyLau , gracias a él!

Woohoo! ¡Menos de 500!

function f(m)t=2u=1i=1j=1s=" "::a::if s~=m[i][j]and(i<#m and m[i+1][j]~=s)~=(j<#m[i]and m[i][j+1]~=s)~=(i>1 and m[i-1][j]~=s)~=(j>1 and m[i][j-1]~=s)then goto b end
i,t=i%t+1,#m>t and t==i and t+1or t j=j>1 and j-1or u u=u<#m[1]and j==1 and u+1or u goto a::b::io.write(m[i][j])m[i][j]=s
i,j=i<#m and s~=m[i+1][j]and i+1or i>1 and s~=m[i-1][j]and i-1or i,j<#m[i]and s~=m[i][j+1]and j+1or j>1 and s~=m[i][j-1]and j-1or j
if s==m[i][j]then return end goto b end

Sin golf

Las explicaciones vendrán una vez que termine de jugar golf, por el momento, le prestaré una versión legible de este código fuente: D ¡ Aquí vienen las explicaciones!

Editar: no actualizado con la última modificación, todavía jugando golf antes de actualizar. Lo mismo ocurre con las explicaciones.

function f(m)                    -- declare the function f which takes a matrix of characters
  t=2                            -- initialise the treshold for i
                                 -- when looking for the first end of the snake
  u=1                            -- same thing for j
  i,j=1,1                        -- initialise i and j,our position in the matrix
  s=" "                          -- shorthand for a space
  ::a::                          -- label a, start of an infinite loop
    if m[i][j]~=s                -- check if the current character isn't a space
      and(i<#m                   -- and weither it is surrounded by exactly
          and m[i+1][j]~=s)      -- 3 spaces or not
      ~=(j<#m[i]
          and m[i][j+1]~=s)      -- (more explanations below)
      ~=(i>1 
          and m[i-1][j]~=s)
      ~=(j>1
          and m[i][j-1]~=s)
      then goto b end            -- if it is, go to the label b, we found the head
    i,t=                         -- at the same time
      i%t+1,                     -- increment i
      #m>t and t==i and t+1or t  -- if we checked all chars in the current range, t++
    j=j>1 and j-1or u            -- decrement j
    u=u>#m[1]and j==1 and u+1or u-- if we checked all chars in the current range, u++
  goto a                         -- loop back to label a

  ::b::                          -- label b, start of infinite loop
  io.write(m[i][j])                    -- output the current char
    m[i][j]=s                    -- and set it to a space
    i,j=i<#m                     -- change i and j to find the next character in the snake
          and m[i+1][j]~=s       -- this nested ternary is also explained below
            and i+1              -- as it takes a lot of lines in comment ^^'
          or i>1 
            and m[i-1][j]~=s
            and i-1
          or i,
       j<#m[i] 
         and m[i][j+1]~=s
           and j+1
         or j>1 
           and m[i][j-1]~=s 
           and j-1
         or j
    if m[i][j]==s                -- if the new char is a space
    then                         -- it means we finished
      return                  -- exit properly to avoid infinite
    end                          -- printing of spaces
  goto b                         -- else, loop back to label b
end

Así que aquí vienen algunas explicaciones detalladas sobre cómo funciona este programa.

En primer lugar, consideremos el ciclo etiquetado a, nos permite encontrar el extremo más cercano a la esquina superior izquierda. Se repetirá para siempre si no hay un final, pero eso no es un problema: D.

En una cuadrícula de 4x4, aquí están las distancias de las serpientes (izquierda) y el orden en que se miran (derecha)

1  2  3  4    |     1  2  4  7
2  3  4  5    |     3  5  8 11
3  4  5  6    |     6  9 12 14
4  5  6  7    |    10 13 15 16

Para cada uno de estos personajes, para ser el final, debe verificar dos condiciones: - No ser un espacio - Estar rodeado por exactamente 3 espacios (o exactamente 1 sin espacio)

Estas condiciones se verifican en el siguiente código

r=m[i][j]~=s
    and(i<#m and m[i+1][j]~=s)
    ==not(j<#m[i] and m[i][j+1]~=s)
    ==not(i-1>0 and m[i-1][j]~=s)
    ==not(j-1>0 and m[i][j-1]~=s)
    and m[i][j]
    or r
  -- special note: "==not" is used as an equivalent to xor
  -- as Lua doesn't know what is a xor...

Comprobar si el carácter no es un espacio se logra mediante la expresión m[i][j]~=s.

Verificando si estamos rodeados de solo 1 no espacio se logra al xor-re las condiciones anteriores para nuestro entorno, esto podría escribirse como

m[i+1][j]~=" "  m[i][j+1]~=" "  m[i-1][j]~=" "  m[i][j-1]~=" "

Y finalmente, si todo lo anterior se evalúa como verdadero, el ternario devolverá lo que está en el último and-> m[i][j]. De lo contrario, dejamos rdesarmado :)

Ahora que tenemos la cabeza de la serpiente, ¡vamos al otro extremo! La iteración de la serpiente se logra principalmente mediante los siguientes terneros anidados:

i,j=i<#m and m[i+1][j]~=s and i+1or i-1>0 and m[i-1][j]~=s and i-1or i,
    j<#m[i]and m[i][j+1]~=s and j+1or j-1>0 and m[i][j-1]~=s and j-1or j

Reestablecemos iy jal mismo tiempo para evitar la necesidad de dummies para almacenar los valores antiguos. Ambos tienen exactamente la misma estructura y usan condiciones simples, por lo que los presentaré en forma de anidados if, debería permitirle leerlos. más fácilmente. :)

i=i<#m and m[i+1][j]~=s and i+1or i-1>0 and m[i-1][j]~=s and i-1or i

Se puede traducir a:

if(i<#m)
then
  if(m[i+1][j]~=" ")
  then
    i=i+1
  end
elseif(i-1>0)
then
  if(m[i-1][j]~=" ")
  then
    i=i-1
  end
end

¡Pruébalo!

Aquí está el código que uso para ejecutar esto, puede probarlo en línea copiando y pegando.

function f(m)t=2u=1i=1j=1s=" "::a::if s~=m[i][j]and(i<#m and m[i+1][j]~=s)~=(j<#m[i]and m[i][j+1]~=s)~=(i>1 and m[i-1][j]~=s)~=(j>1 and m[i][j-1]~=s)then goto b end
i,t=i%t+1,#m>t and t==i and t+1or t j=j>1 and j-1or u u=u<#m[1]and j==1 and u+1or u goto a::b::io.write(m[i][j])m[i][j]=s
i,j=i<#m and s~=m[i+1][j]and i+1or i>1 and s~=m[i-1][j]and i-1or i,j<#m[i]and s~=m[i][j+1]and j+1or j>1 and s~=m[i][j-1]and j-1or j
if s==m[i][j]then return end goto b end


test1={}
s1={
"  tSyrep    ",
"  r    p    ",
"  in Sli    ",
"   g    Sile",
"   Snakes  n",
"Ser      ylt",
"a eh   ilS  ",
"fe w   t    ",
"   emo h    ",
"     Sre    ",
     }
for i=1,#s1
do
  test1[i]={}
  s1[i]:gsub(".",function(c)test1[i][#test1[i]+1]=c end)
end
f(test1)
Katenkyo
fuente
1
A tiene un punto débil para respuestas más largas que tienen poco para elegir ahora debido a la elección del idioma.
Matt
@ Matt muchas gracias por el apoyo! en realidad, todavía estoy encontrando formas de jugar golf, ¡pero cada vez es más difícil!
Katenkyo
2

Lua, 267 bytes

Se requiere Lua 5.3.

e=" "w=#arg[1]+1i=1/0q=0s=table.concat(arg,e)s=e:rep(#s)..s
m,n=i,{}for p in s:gmatch"()%g"do u=-1
for _,d in ipairs{-1,1,-w,w}do u=u+(s:find("^%S",d+p)or 0)end
n[p]=u+1m=math.min(m,p*i^(u//#s)+(p%w*w+p)*#s)end
p=m%#s repeat q,p=p,n[p]-q io.write(s:sub(q,q))until p<1

Uso:

$ lua desnakify.lua \
>    "  tSyrep    " \
>    "  r    p    " \
>    "  in Sli    " \
>    "   g    Sile" \
>    "   Snakes  n" \
>    "Ser      ylt" \
>    "a eh   ilS  " \
>    "fe w   t    " \
>    "   emo h    " \
>    "     Sre    "
SlipperyStringSnakesSilentlySlitherSomewhereSafe
Egor Skriptunoff
fuente
2

Python 3, 245 243 241 236 bytes

ses la cadena de entrada, nes la salida impresa en stdout:

f=s.find
w,l=f('\n')+1,len(s)
t=1,w,-1,-w
y=z=f(s.strip()[0]);n=s[y];v={y}
for i in range(l*l):
 i%=l;c=s[i]
 if c>' 'and i not in v:
  if i-y in t:y=i;n=c+n;v|={i}
  elif i-z in t:z=i;n+=c;v|={i}
if y%w+y//w>z%w+z//w:n=n[::-1]
print(n)

Editar: ¡ Gracias a @Cees Timmerman por guardar 5 bytes!

pgks
fuente
c>' 'andy print nen Python 2.
Cees Timmerman
¿No puedes hacer en iflugar de elif?
clismique
@ Qwerp-Derp lamentablemente no, lo he probado antes, pero imprime, por ejemplo, "! EkanSgnirtSAmAI, olleHello, IAmAStringSnake!" y "SlipperyStSyreppilS".
pgks
¿Cuál es el formato de entrada?
clismique
@ Qwerp-Derp svariable es una cadena multilínea; el último carácter de la cadena debe ser una nueva línea (esto es necesario para aprobar el Pythoncaso de prueba)
pgks
1

Python, 537

Mi solución inicial:

from itertools import chain, product, ifilter
from operator import add
moves = ((1,0),(0,1),(-1,0),(0,-1))
h = dict(ifilter(lambda (p,v):not v.isspace(),chain(*map(lambda (i,r):map(lambda (j,c):((i,j),c),enumerate(r)),enumerate(s)))))
n = defaultdict(list)
for m,p in product(moves, h):
    np = tuple(map(add,m,p))
    if np in h:
        n[p].append(np)
def pr(nx):
    return(lambda l:(h[l[0]], h.pop(l[0]))[0] + pr(l[0]) if l else '')([x for x in n[nx] if x in h])
(lambda y: h[y]+ pr(y))(next(x for x in n if len(n[x])==1))

Compactado un poco, pero lo dejó como método:

from itertools import chain, product
from operator import add
def unsnake(s):
    (h,n) = (dict(filter(lambda (p,v):not v.isspace(),chain(*map(lambda (i,r):map(lambda (j,c):((i,j),c),enumerate(r)),enumerate(s))))),defaultdict(list))
    for m,p in product(((1,0),(0,1),(-1,0),(0,-1)), h):(lambda np: n[p].append(np) if np in h else 0)(tuple(map(add,m,p)))
    def pr(nx):return(lambda l:(h[l[0]], h.pop(l[0]))[0] + pr(l[0]) if l else '')([x for x in n[nx] if x in h])
    return(lambda y: h[y]+ pr(y))(next(x for x in n if len(n[x])==1))
topkara
fuente
1

Java 7, 927 924 923 bytes

import java.util.*;int l,k;char[][]z;Set p=new HashSet();String c(String[]a){int x=0,y=0,n,t,u,v,w=t=u=v=-1;l=a.length;k=a[0].length();z=new char[l][k];for(String s:a){for(char c:s.toCharArray())z[x][y++]=c;}x++;y=0;}for(x=0;x<l;x++)for(y=0;y<k;y++){n=0;if(z[x][y]>32){if(x<1|(x>0&&z[x-1][y]<33))n++;if(y<1|(y>0&&z[x][y-1]<33))n++;if(x>l-2|(x<l-1&&z[x+1][y]<33))n++;if(y>k-2|(y<k-1&&z[x][y+1]<33))n++;}if(n>2&t<0){t=x;u=y;}if(n>2&t>v){v=x;w=y;}}if(v+w>t+u){p(t,u);return n(""+z[t][u],t,u);}p(v,w);return n(""+z[v][w],v,w);}String n(String r,int x,int y){int a,b;if(x>0&&z[a=x-1][b=y]>32&q(a,b)){p(a,b);return n(r+z[a][b],a,b);}if(y>0&&z[a=x][b=y-1]>32&q(a,b)){p(a,b);return n(r+z[a][b],a,b);}if(x<l-1&&z[a=x+1][b=y]>32&q(a,b)){p(a,b);return n(r+z[a][b],a,b);}if(y<k-1&&z[a=x][b=y+1]>32&q(a,b)){p(a,b);return n(r+z[a][b],a,b);}return r;}boolean q(int x,int y){return!p.contains(x+","+y);}void p(int x,int y){p.add(x+","+y);}

Ok, eso tomó un tiempo ... En algunos lenguajes de programación no importa si su matriz x e y están fuera de los límites de una matriz 2D, pero con Java arrojará ArrayIndexOutOfBoundsExceptions, por lo que todo debe ser verificado ...

Primero determino el punto de partida, y luego uso un método recursivo para construir la cadena desde allí. Además, utilizo una lista para realizar un seguimiento de las coordinaciones que ya he encontrado, por lo que no entrará en un bucle de ida y vuelta (resultando en una excepción StackOverflowException).

Esta es probablemente la respuesta más larga que he publicado hasta ahora, pero aunque algunas partes se pueden jugar al golf, no creo que este desafío pueda ser mucho más corto en Java. Java simplemente no es adecuado para seguir un camino en una cuadrícula. No obstante, fue un desafío divertido descubrir. :)

Sin golf y casos de prueba:

Pruébalo aquí

import java.util.*;
class M{
  static int l,
             k;
  static char[][] z;
  static Set p = new HashSet();

  static String c(String[] a){
    int x=0,
        y=0,
        n,
        t,
        u,
        v,
        w = t = u = v = -1;
    l = a.length;
    k = a[0].length();
    z = new char[l][k];
    for(String s:a){
      for(char c:s.toCharArray()){
        z[x][y++] = c;
      }
      x++;
      y = 0;
    }
    for(x=0; x<l; x++){
      for(y=0; y<k; y++){
        n = 0;
        if(z[x][y] > 32){ // [x,y] is not a space
          if(x < 1 | (x > 0 && z[x-1][y] < 33)){
            n++;
          }
          if(y < 1 | (y > 0 && z[x][y-1] < 33)){
            n++;
          }
          if(x > l-2 | (x < l-1 && z[x+1][y] < 33)){
            n++;
          }
          if(y > k-2 | (y < k-1 && z[x][y+1] < 33)){
            n++;
          }
        }
        if(n > 2 & t < 0){
          t = x;
          u = y;
        }
        if(n > 2 & t > v){
          v = x;
          w = y;
        }
      }
    }
    if(v+w > t+u){
      p(t, u);
      return n(""+z[t][u], t, u);
    }
    p(v, w);
    return n(""+z[v][w], v, w);
  }

  static String n(String r, int x, int y){
    int a,b;
    if(x > 0 && z[a=x-1][b=y] > 32 & q(a,b)){
      p(a, b);
      return n(r+z[a][b], a, b);
    }
    if(y > 0 && z[a=x][b=y-1] > 32 & q(a,b)){
      p(a, b);
      return n(r+z[a][b], a, b);
    }
    if(x < l-1 && z[a=x+1][b=y] > 32 & q(a,b)){
      p(a, b);
      return n(r+z[a][b], a, b);
    }
    if(y < k-1 && z[a=x][b=y+1] > 32 & q(a, b)){
      p(a, b);
      return n(r+z[a][b], a, b);
    }
    return r;
  }

  static boolean q(int x, int y){
    return !p.contains(x+","+y);
  }

  static void p(int x, int y){
    p.add(x+","+y);
  }

  public static void main(String[] a){
    System.out.println(c(new String[]{ "Hel         ",
      "  l      rin",
      "  o,IAmASt g",
      "           S",
      "       !ekan" }));
    p = new HashSet();
    System.out.println(c(new String[]{ "Python" }));
    p = new HashSet();
    System.out.println(c(new String[]{ "P  ngPu  Code ",
      "r  i  z  d  G",
      "o  m  z  n  o",
      "gram  lesA  lf" }));
    p = new HashSet();
    System.out.println(c(new String[]{ "   ~ zyx tsr XWVUTSR",
      "   }|{ wvu q Y     Q",
      "!          p Z `ab P",
      "\"#$ 6789:; o [ _ c O",
      "  % 5    < n \\]^ d N",
      "('& 432  = m     e M",
      ")     1  > lkjihgf L",
      "*+,-./0  ?         K",
      "         @ABCDEFGHIJ" }));
    p = new HashSet();
    System.out.println(c(new String[]{ "  tSyrep    ",
      "  r    p   ",
      "  in Sli   ",
      "   g    Sile",
      "   Snakes  n",
      "Ser      ylt",
      "a eh   ilS ",
      "fe w   t   ",
      "   emo h   ",
      "     Sre    " }));
  }
}

Salida:

Hello,IAmAStringSnake!
Python
ProgrammingPuzzlesAndCodeGolf
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
SlipperyStringSnakesSilentlySlitherSomewhereSafe
Kevin Cruijssen
fuente
924 bytes, jesucristo ... lol
Shaun Wild
@BasicallyAlanTuring Hehe. Simplemente hice el desafío, lo codifiqué y luego miré el conteo de bytes. De hecho, fue mucho más alto de lo esperado, pero bueno, al menos está por debajo de 1k ... Si ve algo para mejorar, avíseme, y si tiene un enfoque alternativo con (muchos) menos bytes, siéntase libre de hacer un enviar; Me interesaría verlo. PD: ahora son 923 bytes. XD
Kevin Cruijssen
No es necesario verificar todo , solo agregue un poco de relleno a su cadena. Probablemente, usar una sola cadena multilínea lo haga más fácil. Eche un vistazo a mi respuesta C # portada desde javascript
edc65
1

PHP, 199 184 182 bytes

aún puede tener un poco de golf

for($w=strpos($i=$argv[1],"
");;)for($y=++$n;$y--;)if($i[$p=$y*$w+$n-1]>" ")break 2;for($p-=$d=$w++;$d&&print$i[$p+=$e=$d];)foreach([-$w,-1,1,$w,0]as$d)if($d+$e&&" "<$i[$d+$p])break;

toma la entrada como una cadena multilínea desde la línea de comando, espera saltos de línea de estilo Linux.
Correr php -r '<code>' '<string>'; escapar de los saltos de línea.

Descompostura

for(
    // find width
    $w=strpos($i=$argv[1],"\n")
    ;
    // find first character: initialize $p(osition)
    ;
)
    for($y=++$n             // increase distance
        ;$y--;)             // loop $y from (old)$n to 0
        if(" "<$i[$p=$y*$w+$n   // if character at $y*($width+1)+$x(=$d-$y) is no space
            -1                  // (adjust for the premature increment)
        ])
            break 2;                    // break loops

for(
    $p-=            // b) reverse the increment that follows in the pre-condition
    $d=             // a) initialize $d to anything!=0 to enable the first iteration
    $w++;           // c) increase $w for easier directions
    $d              // loop while direction is not 0 (cursor has moved)
    &&
    print$i[$p+=$e=$d]              // remember direction, move cursor, print character
    ;
)
    foreach([-$w,-1,1,$w,0]as$d)// loop through directions
        if($d+$e                    // if not opposite previous direction
            &&" "<$i[$d+$p]         // and character in that direction is not space
        )break;                     // break this loop
Titus
fuente
1

C #, 310

(Editar: corrección de errores)

Una función con un parámetro de cadena multilínea, que devuelve una cadena.

Incluyendo lo solicitado usingen el recuento de bytes.

Esta es una portabilidad de mi respuesta de JavaScript.

using System.Linq;
string f(string s){int o=-~s.IndexOf('\n'),m=99;var r=new string(' ',o);(s=r+s+r).Select((c,i)=>{int n=2,e=0,p,w=i%o+i/o;if(c>' '&w<m&&new[]{-1,1,o,-o}.All(d=>(s[i+d]>' '?(e=d)*--n:n)>0))for(m=w,r=""+c+s[p=i+e];new[]{e,o/e,-o/e}.Any(d=>s[p+(e=d)]>' ');)r+=s[p+=e];return i;}).Max();return r;}

Prueba de ideona

Con espacios

    string f(string s)
    {
        int o = -~s.IndexOf('\n');
        var r = new string(' ', o);
        var m = 99;
        (s = r + s + r).Select((c, i) =>
        {
            int n = 2, e = 0, p, w = i % o + i / o;
            if (c > ' ' & w < m & new[] { -1, 1, o, -o }.All(d => (s[i + d] > ' ' ? (e = d) * --n : n) > 0))
                for (m = w, r = "" + c + s[p = i + e]; 
                     new[] { e, o / e, -o / e }.Any(d => s[p + (e = d)] > ' '); 
                     ) 
                   r += s[p += e];
            return i;
        }
        ).Max();
        return r;
    }
edc65
fuente
1

Python 2, 251 bytes

w=s.find('\n')+1;q=' ';p=q*w+'\n';s=list(p+s+p);d=-w,1,w,-1
def r(x):c=s[x];s[x]=q;v=[c+r(x+o)for o in d if s[x+o]>q];return v[0]if v else c
e=[x for x in range(len(s))if s[x]>q and sum([s[x+o]>q for o in d])<2]
print r(e[e[0]/w+e[0]%w>e[1]/w+e[1]%w])

O, si desea nuevas líneas principales en sus casos de prueba, 257 bytes:

w=s.find('\n',1);q=' ';p=q*-~w+'\n';s=list(p+s[1:]+p);d=-w,1,w,-1
def r(x):c=s[x];s[x]=q;v=[c+r(x+o)for o in d if s[x+o]>q];return v[0]if v else c
e=[x for x in range(len(s))if s[x]>q and sum([s[x+o]>q for o in d])<2]
print r(e[e[0]/w+e[0]%w>e[1]/w+e[1]%w])

Pasa todos los casos de prueba.

s="""
  tSyrep    
  r    p    
  in Sli    
   g    Sile
   Snakes  n
Ser      ylt
a eh   ilS  
fe w   t    
   emo h    
     Sre    
"""

Resultados en:

SlipperyStringSnakesSilentlySlitherSomewhereSafe
Cees Timmerman
fuente
3
Creo que puede reemplazar b.append(...)con b+=[...]y def n(x,y):return ...conn=lambda x,y:...
acrolith
1
Crea una variable para ' '.
pacholik
1
y use en ~-xlugar de x-1, no tendrá que usar paréntesis.
pacholik
0

Japt -P , 106 bytes

K=U·ÌÊÄ ç iU ¬mx T=[-KJ1K]
ËÊ*Tm+E è@gX
[]V£YÃf@gXÃrQ@WpQ Tm+Q kW fZ Ì}V£[XYuK YzK]ÃkÈv ÉÃñx v rÈ+Y*K
W£gX

Pruébalo en línea!

Es ... um ... una abominación.

Desempaquetado y cómo funciona

K=UqR gJ l +1 ç iU q mx
  UqR gJ l +1            Split the input by newline, take last item's length +1
K=                       Assign to K
              ç iU       Generate a string of K spaces, and append to U
                   q mx  Split into chars, and trim whitespaces on each item
                         Implicit assign to U

T=[-KJ1K]  Assign an array [-K, -1, 1, K] to T (this represents 4-way movement)
           I could use implicit assignment, but then 4-argument function below is broken

UmDEF{Dl *Tm+E èXYZ{UgX
UmDEF{                   Map over the list of one- or zero-length strings...
      Dl *                 If the length is zero, return zero
          Tm+E             Add the index to each element of T
               èXYZ{UgX    Count truthy elements at these indices
                         The result is an array of 0(space/newline), 1(start/end), or 2(body)
                         Implicit assign to V

[]  Implicit assign to W

VmXYZ{Y} fXYZ{UgX} rQXYZ{WpQ Tm+Q kW fZ gJ }
VmXYZ{Y}                                      Map V into indices
         fXYZ{UgX}                            Filter the indices by truthiness of U's element
                   rQXYZ{                     Reduce on the indices... (Q=last item, Z=array)
                         WpQ                    Push Q to W
                             Tm+Q               Take 4-way movements from Q
                                  kW fZ gJ }    Exclude visited ones, take last one in Z

VmXYZ{[XYuK YzK]} kXYZ{Xv -1} ñx v rXYZ{X+Y*K  Starting point of reduce
VmXYZ{[XYuK YzK]}                              Convert elements of V to [elem, col, row]
                  kXYZ{Xv -1}                  Take the ones where elem(popped)=1
                              ñx v             Sort by row+col and take first one
                                   rXYZ{X+Y*K  Convert [row,col] back to the index

WmXYZ{UgX  Map indices back to chars

-P  Join with empty string

Un punto notable es que utilicé la precedencia del operador entre los operadores de asignación y coma en JS, para empacar algunas líneas y mantener el atajo @( XYZ{) utilizable.

Bubbler
fuente