Leer un crucigrama

11

Inspirado por esta pregunta sobre cómo empacar en este formato.

Ocasionalmente veo un crucigrama completo y, como soy, no me molesto en averiguar cuáles fueron las soluciones a las pistas.

Entrada:

  • Una cadena 2D (cualquier formato, nueva línea separada, lista 2d, etc.)
  • Los cuadrados en blanco se representarán con un (carácter de espacio)
  • Cualquier otro cuadrado estará en minúscula.
  • Puede suponer que la entrada se rellenará con espacios para formar un rectángulo

Salida:

  • Cada palabra encontrada
    • Debes buscar palabras a lo largo y hacia abajo
    • Las palabras tendrán al menos dos letras
    • Si hay palabras duplicadas, debe emitirlas cada vez que aparecen
  • No tienes que hacer ninguna validación
  • Las palabras pueden salir en cualquier orden
  • No hay reglas de formato estrictas

Casos de prueba:

word
e e 
step
t d 

word, step, west, reed
---
pies
 not
  no
wasp

pies, not, no, wasp, in, eons, stop
---
igloo
    n
word

igloo, word, on
Azul
fuente

Respuestas:

8

Pyth - 11 10 8 7 bytes

guardado un byte gracias a @issacg.

t#cjsCB

Pruébelo en línea aquí .

t#               Filter by if len > 1
 c               Chop by whitespace by default
  j              Join by newlines
   sCB           Input, implicit and its transpose in one list
Maltysen
fuente
@Maltysen Maravilloso.
Monja Leaky
1
Pyth gana. Como siempre.
Leaky Nun
1
Puede guardar un byte quitando el d, lo que hace que la junión en las nuevas líneas, que aún están cortadas porc ... )
isaacg
@isaacg eso es realmente genial, gracias
Maltysen
2

CJam, 14 bytes

{_z+S*S%{,(},}

Un bloque sin nombre que espera una lista de cadenas (rellenas) en la parte superior de la pila y deja una lista de palabras en su lugar.

Pruébalo aquí.

Explicación

_z    e# Duplicate and transpose the grid.
+     e# Append the transpose to the original grid.
S*    e# Join all lines by spaces to ensure that we don't get words 
      e# spanning multiple lines.
S%    e# Split around spaces, discarding empty segments.
{,(}, e# Filter: keep only those strings with length 2 or greater.
Martin Ender
fuente
1

JavaScript (ES6), 83 bytes

s=>(s+` `+[...(t=s.split`
`)[0]].map((_,i)=>t.map(t=>t[i]).join``)).match(/\w\w+/g)
Neil
fuente
0

Pyth , 18 bytes

Lm:d"\S\S+"1byQyCQ

Pruébalo en línea!

Entrada de muestra:

["pies"," not","  no","wasp"," t  "]

Salida de muestra:

[['pies'], ['not'], ['no'], ['wasp'], []]
[[], ['in', 'at'], ['eons'], ['stop']]

Cómo funciona:

Lm:d"\S\S+"1byQyCQ                                 The "1" here is mode
                    assign('Q',eval_input())       "1" which means show
                    @memoized                      all matches
L                   def y(b):                               v
 m:d"\S\S+"1b           return map(lambda d:regex(d,"\S\S+",1),b)
             yQ     imp_print(y(Q))
               yCQ  imp_print(y(transpose(Q)))
Monja permeable
fuente
0

Haskell, 58 bytes

import Data.List
f x=[w|w@(_:_:_)<-words=<<x++transpose x]

Ejemplo de uso: f ["pies"," not"," no","wasp"]-> ["pies", "not", "no", "wasp", "in", "eons", "stop"].

Cómo funciona: divide cada una de las líneas de la entrada y su transposición en espacios en una sola lista de palabras. Mantenga los que coinciden (_:_:_), es decir, tienen al menos dos letras.

nimi
fuente
0

C ++ 14, 209 207 201 bytes

Cantidad ridículamente alta de bytes ... pero bueno. Matriz de transposición, cadena dividida. Fácil. Lástima que no haya una función nativa para transponer

[](vector<string>; m){auto t=m;int C=size(m[0]),j=0;for(;++j<C*C;)t[j%C][j/C]=m[j/C][j%C];for(j=0;++j<C+C;){stringstream Z(j<C?m[j]:t[j-C]);string s;while(getline(Z,s,' '))cout<<(size(s)>1?s+' ':"");}}

Sin golf:

using S=vector<string>;
[](S m){
  S t=m;
  int C=size(m[0]),j=0;
  for(;j<C*C;++j)t[j%C][j/C]=m[j/C][j%C]; // Transpose
  for(j=0;j<C+C;++j){ // since rectangle matrix, we can iterate like so
    stringstream Z(j<C?m[j]:t[j-C]); // Get string from m or t
    string s;
    while(getline(Z,s,' '))
      cout<<(size(s)>1?s+' ':"");
  }
}

Cómo usarlo (tenga en cuenta que debe aplicar el relleno como dice la pregunta):

using S = vector<string>;[](S m) { ... }({"pies", " not", "  no", "wasp"});
STDQ
fuente