Inspiriert von dieser Frage zum Verpacken in dieses Format.

Gelegentlich sehe ich ein vollständiges Kreuzworträtsel und da ich so bin, kann ich mir nicht die Mühe machen, herauszufinden, welche Lösungen für die Hinweise tatsächlich vorhanden waren.

Eingang:

• Eine 2D-Zeichenfolge (beliebiges Format, Newline getrennt, 2D-Liste usw.)
• Leere Quadrate werden mit einem (Leerzeichen) dargestellt.
• Jedes zweite Quadrat wird in Kleinbuchstaben geschrieben.
• Sie können davon ausgehen, dass die Eingabe mit Leerzeichen aufgefüllt wird, um ein Rechteck zu bilden

Ausgabe:

• Jedes Wort gefunden
  • Sie müssen entlang und nach Wörtern suchen
  • Die Wörter sind mindestens zwei Buchstaben lang
  • Wenn es doppelte Wörter gibt, müssen Sie sie jedes Mal ausgeben, wenn sie erscheinen
• Sie müssen keine Validierung durchführen
• Wörter können in beliebiger Reihenfolge ausgegeben werden
• Keine strengen Formatierungsregeln

Testfälle:

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 Bytes

dank @issacg ein Byte gespart.

t#cjsCB

Probieren Sie es hier online aus .

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 Bytes

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

Ein unbenannter Block, der eine Liste von (aufgefüllten) Zeichenfolgen oben auf dem Stapel erwartet und stattdessen eine Liste von Wörtern hinterlässt.

Testen Sie es hier.

Erläuterung

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

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

Probieren Sie es online aus!

Beispieleingabe:

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

Beispielausgabe:

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

Wie es funktioniert:

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 Bytes

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

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

So funktioniert es: Teilen Sie jede Zeile der Eingabe und deren Umsetzung in Leerzeichen in einzelne Listenwörter auf. Behalten Sie die passenden bei (_:_:_), dh haben Sie mindestens zwei Buchstaben.

C ++ 14, 209 207 201 Bytes

Lächerlich viele Bytes ... aber na ja. Transponieren Sie die Matrix, teilen Sie die Zeichenfolge. Einfach. Schade, keine native Funktion zum Transponieren

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

Verwendung (Beachten Sie, dass Sie das Auffüllen erzwingen müssen, wie in der Frage angegeben):

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

Pyke, 9 Bytes

,+Fdc#t(s

Probieren Sie es hier aus!

Oder 7 Bytes verschönert

,+Fdc#t

Probieren Sie es hier aus!