Ispirato da questa domanda sull'imballaggio in questo formato.

Di tanto in tanto vedo un cruciverba completo ed essendo come sono, non posso preoccuparmi di scoprire quali fossero le soluzioni agli indizi.

Ingresso:

• Una stringa 2D (qualsiasi formato, newline separato, 2d list ecc.)
• I quadrati vuoti saranno rappresentati con un (carattere spazio)
• Ogni altro quadrato sarà in lettere minuscole.
• Si può presumere che l'input sarà riempito con spazi per formare un rettangolo

Produzione:

• Ogni parola trovata
  • È necessario cercare le parole lungo e in basso
  • Le parole saranno lunghe almeno due lettere
  • Se ci sono parole duplicate, devi emetterle per ogni volta che appaiono
• Non devi fare alcuna convalida
• Le parole possono essere emesse in qualsiasi ordine
• Nessuna regola di formattazione rigorosa

Casi test:

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

Pyth - 11 10 8 7 byte

salvato un byte grazie a @issacg.

t#cjsCB

Provalo online qui .

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

CJam, 14 byte

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

Un blocco senza nome che prevede un elenco di stringhe (imbottite) in cima allo stack e lascia invece un elenco di parole.

Provalo qui.

Spiegazione

_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.

JavaScript (ES6), 83 byte

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

Pyth , 18 byte

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

Provalo online!

Input di esempio:

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

Uscita campione:

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

Come funziona:

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

Haskell, 58 byte

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

Esempio di utilizzo: f ["pies"," not"," no","wasp"]-> ["pies", "not", "no", "wasp", "in", "eons", "stop"].

Come funziona: dividere ciascuna delle righe dell'input e la sua trasposizione negli spazi in una singola lista di parole. Mantieni quelli che corrispondono (_:_:_), cioè hanno almeno due lettere.

C ++ 14, 209 207 201 byte

Quantità ridicolmente alta di byte ... ma vabbè. Trasponi matrice, dividi stringa. Facile. Peccato che nessuna funzione nativa per la trasposizione

[](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+' ':"");}}

Ungolfed:

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+' ':"");
  }
}

Come usarlo (nota che devi applicare il riempimento come indicato nella domanda):

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

Pyke, 9 byte

,+Fdc#t(s

Provalo qui!

O 7 byte preimpostati

,+Fdc#t

Provalo qui!