Inspiré par cette question sur l'emballage dans ce format.

Parfois, je vois un mot croisé terminé et étant comme je suis, je ne peux pas être dérangé pour savoir quelles étaient les solutions aux indices.

Contribution:

• Une chaîne 2D (n'importe quel format, séparateur de nouvelle ligne, liste 2D, etc.)
• Les carrés vides seront représentés par un (caractère espace)
• Tous les autres carrés seront dans l'alphabet minuscule.
• Vous pouvez supposer que l'entrée sera complétée par des espaces pour former un rectangle

Production:

• Chaque mot trouvé
  • Vous devez rechercher des mots le long et le bas
  • Les mots compteront au moins deux lettres
  • S'il y a des mots en double, vous devez les sortir pour chaque fois qu'ils apparaissent
• Vous n'avez pas à faire de validation
• Les mots peuvent être sortis dans n'importe quel ordre
• Pas de règles de formatage strictes

Cas de 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 octets

sauvé un octet grâce à @issacg.

t#cjsCB

Essayez-le en ligne ici .

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 octets

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

Un bloc sans nom qui attend une liste de chaînes (rembourrées) au-dessus de la pile et laisse une liste de mots à la place.

Testez-le ici.

Explication

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

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

Pyth , 18 octets

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

Essayez-le en ligne!

Exemple d'entrée:

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

Exemple de sortie:

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

Comment ça fonctionne:

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 octets

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

Exemple d'utilisation: f ["pies"," not"," no","wasp"]-> ["pies", "not", "no", "wasp", "in", "eons", "stop"].

Comment ça marche: divisez chacune des lignes de l'entrée et la transposition de celui-ci à des espaces en une seule liste de mots. Gardez ceux qui correspondent (_:_:_), c'est à dire avoir au moins deux lettres.

C ++ 14, 209 207 201 octets

Quantité d'octets ridiculement élevée ... mais bon. Matrice de transposition, chaîne divisée. Facile. Dommage pas de fonction native pour la transposition

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

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

Comment l'utiliser (notez que vous devez appliquer le remplissage comme l'indique la question):

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

Pyke, 9 octets

,+Fdc#t(s

Essayez-le ici!

Ou 7 octets prettifiés

,+Fdc#t

Essayez-le ici!