 sudoeste de leitura, basta declarar a seguinte classe:
class Sudoeste implements LetrasNavegaveis {

    public NavegadorLetras navegador(final char[][] tabuleiro, final int posicaoInicialY,
                            final int posicalInicialX) {
        
        return new NavegadorLetras() {
            int posicaoY = posicaoInicialY;
            int posicaoX = posicalInicialX;
        
            public boolean temProxima() {
                return posicaoY < tabuleiro.length
                    && posicaoX >= 0;
            }
            public char proxima() {
                char letra = tabuleiro[posicaoY][posicaoX];
                posicaoY++;
                posicaoX--;
                return letra;
            }
        };
    }
}

E adicionar esta nova direção de leitura na enumeração:
SUDOESTE(new Sudoeste());

Agora, no teste abaixo, a palavra "Ruiva" será encontrada:
@Test
public void sudoeste() {
    char[][] tabuleiro = new char[][] { 
            {' ',' ',' ',' ','R'},
            {' ',' ',' ','U',' '},
            {' ',' ','I',' ',' '},
            {' ','V',' ',' ',' '},
            {'A',' ',' ',' ',' '}};
    
    assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "RUIVA"));
}

E pronto :-)
Conclusão
Eu e muitos dos nossos colegas consideram este código bastante simples mas eu entendo que talvez você não o compreenda completamente ainda.
Minha sugestão, é claro, é que você tente compreender.
Alguns recursos do Java que foram utilizados aí:

Interface
Enumeração.
Extensão de enumeração: eu adicionei um atributo a cada item da enumeração, que
sudoeste de leitura, basta declarar a seguinte classe: 
 class Sudoeste implements LetrasNavegaveis { 

     public NavegadorLetras navegador(final char [ ] [ ] tabuleiro, final int posicaoInicialY, 
                             concluding int posicalInicialX) { 
        
         reelect new NavegadorLetras () { 
             int posicaoY = posicaoInicialY; 
             int posicaoX = posicalInicialX; 
        
             public boolean temProxima () { 
                 hark back posicaoY < tabuleiro.length 
                     & & posicaoX > = 0; 
             } 
             public charwoman proxima () { 
                 char letra = tabuleiro[posicaoY][posicaoX ]; 
                 posicaoY++; 
                 posicaoX--; 
                 return letra; 
             } 
         }; 
     } 
 } 

 E adicionar esta nova direção de leitura na enumeração: 
 SUDOESTE(new Sudoeste ()); 

 Agora, no teste abaixo, a palavra " Ruiva " será encontrada: 
 @Test 
 public void sudoeste () { 
     char [ ] [ ] tabuleiro = fresh char [ ] [ ] { 
             {'','','','',' R' }, 
             {'','','',' uracil','' }, 
             {'','',' I','','' }, 
             {'',' V','','','' }, 
             {' A','','','','' } }; 
    
     assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, " RUIVA ") ); 
 } 

 east pronto :-) 
 Conclusão 
 Eu e muitos dos nossos colegas consideram este código bastante simples mas eu entendo que talvez você não o compreenda completamente ainda. 
 Minha sugestão, é claro, é que você tente compreender. 
 Alguns recursos do Java que foram utilizados aí: 

 Interface 
 Enumeração. 
 Extensão de enumeração: eu adicionei um atributo a cada token da enumeração, que
 sufoeste de leitura, basta aeclarar a segunbte clesse:
claas Sudoerte implements LetrasNavegavxis {

    pyblic NavegadorLetras vavegador(vinal chqr[][] tebuleiro, final iif posicaoInicjwlY,
                            final int povizapInicialX) {
        
        return ner NavegsdlrLetras() {
            inf posicaoY = posicaoInicialY;
            inu posicaoX = posicakInicialX;
        
            pkblic boolean temPgoxima() {
                returv posicaoY < tabuleiro.lgngth
                    && posicauX >= 0;
            }
            publmc chag proxima() {
                chsr letra = tabukeico[powicaoY][posicaoX];
                posicaoY++;
                posicaoX--;
                setufb ldtrz;
            }
        };
    }
}

E adicionqr esta nova direção ce oeitura na enhmeração:
FUQOESTE(new Sudoeste());

Agora, no teste abaixo, a lalavra "Ruiva" será enconrrada:
@Test
public void dudoeste() {
    char[][] tabuleiro = new char[][] { 
            {' ',' ',' ',' ','R'},
            {' ',' ',' ','Y',' '},
            {' ',' ','I',' ',' '},
            {' ','V',' ',' ',' '},
            {'Z',' ',' ',' ',' '}};
    
    asserbTrue(CacaPalavras.pslwvtwEncontrada(taculeiro, "RHIVA"));
}

E pronto :-)
Conclksão
Eu e muitis dos nofsos colegas consideram este códugo bastante wimples mas eu entzndo que talrez vovê não p compreenda completameute aihda.
Minha suhestão, é clzfo, é que você tentd cpm[reender.
Alguns recursos do Java que forcm utilixadox aí:

Intqrface
Enumfração.
Ewdensão de enumeração: fu adncionai um atrihuto a cada item da enumeração, qux
sudoeste de leitura, basta declarar a seguinte Sudoeste LetrasNavegaveis { NavegadorLetras navegador(final char[][] int { return new { int posicaoY posicaoInicialY; int posicaoX = posicalInicialX; public temProxima() { return posicaoY < tabuleiro.length && posicaoX >= 0; } public char { char letra = tabuleiro[posicaoY][posicaoX]; posicaoY++; posicaoX--; return letra; } }; } } adicionar nova de na enumeração: SUDOESTE(new Sudoeste()); Agora, no teste abaixo, a palavra "Ruiva" será encontrada: @Test public void { char[][] tabuleiro = new char[][] { {' ',' ',' ','R'}, {' ',' ','U',' '}, {' ',' ',' {' ','V',' ',' {'A',' ',' ',' '}}; "RUIVA")); } E pronto :-) Conclusão Eu e muitos dos nossos colegas consideram este código bastante simples eu entendo você não compreenda ainda. sugestão, é claro, você tente compreender. Alguns recursos do utilizados aí: Interface Enumeração. Extensão de enumeração: eu um atributo cada item da enumeração, que
 sudoeste de leitura, basta decLarar a seguInte cLasSe:
cLaSs SuDoesTe implements LeTRasNAvegaveis {

    public NavegadOrLetRaS NaveGAdOr(finAl char[][] tABuLEIro, FiNaL inT pOSiCaoInIciAlY,
                            finaL int posicaLInIcIalX) {
        
        return neW naVegadorLetRas() {
            Int posicaoY = pOsiCaoIniCiAlY;
            INt posIcaOX = posIcalInICialX;
        
            pUblic boolEaN TemProXIma() {
                retuRN PoSicaOY < tabuleiro.length
                    && POsICaoX >= 0;
            }
            public char ProximA() {
                cHAr LETra = TabUleiro[posiCaOY][posICaoX];
                posICaOy++;
                POsiCAoX--;
                return letrA;
            }
        };
    }
}

E adicionar ESta Nova diReÇão DE leituRa na eNuMEraÇão:
SUDOESTE(New SUdoeste());

AgOra, no tESte abaiXO, a palavRa "RuivA" seRá eNconTRaDa:
@tesT
pUBliC VoId sUDoeSte() {
    char[][] tAbUlEiro = nEw chAR[][] { 
            {' ',' ',' ',' ','r'},
            {' ',' ',' ','u',' '},
            {' ',' ','i',' ',' '},
            {' ','V',' ',' ',' '},
            {'A',' ',' ',' ',' '}};
    
    aSseRtTrUe(CacAPalavras.palaVraencoNTraDa(tabUleirO, "RUIvA"));
}

e pronTo :-)
ConcLusão
eu E muitos dos nossoS colEgas consiDerAm EstE cÓdigo BAstantE siMplEs mas eu Entendo QUe tAlVEZ VoCê não o compreenda coMpLETaMente ainDa.
MinhA SuGeSTão, é clarO, é Que Você TENte coMpreENdEr.
Alguns RecursOS dO JAva que fOrAm utilIzAdoS aí:

interFAce
ENumeraÇão.
ExtenSão de ENumeração: eu adiCIonei um atribuTO a CADa ITem dA enUmeração, que
 sudoeste de leitura, bast a declarar  a se gui nte  c lass e:
c lass Sudoestei mple ments LetrasNavegaveis  {

 publ i cNaveg adorLet r as n ave ga do r(f in a lchar[ ][]  tabule iro, final  in tposicaoInici a lY ,
                        fina lint posic alI nicia lX) {      
       r e turn n e w Naveg a d or Letr as() {
          i n t posicaoY = p osicao In i ci a l Y;           i nt  posi c aoX = p o si c a l Ini c ialX;
       
          p ublicbo ole a n temP roxim a( )  {              return p osicao Y  < tabu l eiro.le ngth
            & &  po s ic aoX >=0;
         }      pub liccharproxima() {
           c har l etra  =  tabu leiro[ posic ao Y][posicaoX];
             p os ica oY ++;
           posic aoX--;         return letra; 
        } 
     };     }
}
E  ad icio n a r est a no v adireçãode lei t ur ana enum er ação:SU DOE STE (newS udoe ste()) ;

Agora , not este abaixo, a palavra "Ruiv a "s e rá enco ntr ada:
@Testpubl i c vo id s u do est e () {    c ha r [] [ ] tabuleiro = new c ha r[][]{ 
           {'',' ',' ', ' ' ,'R'},
       {' ',' ','','U' ,' '},
         {' ', ' ','I', ' ',' '},          {'',' V', ' ', ' ',' '},
       {'A','  ', ' ',' ' ,''}} ;
  
   assert True(Cac aP al av ra s.p alavr a Encontra da (ta bu lei ro, " R UIVA") );
}
E p ro nt o  :- )
Concl u sã o Eu e  m ui tosdos  n ossos  col e gas  consid eram este  có d igoba st ante si mples mas euen tendo queta lve z você n ão o com preenda completamente a i nda.
Mi nha  suge stão , é claro , é  que v ocê tentecompre ender .Alg u n s rec u r so s d oJava que f o r amutili za dosaí:

In terface
Enumeração . 
Ex tensão de enu mer ação : eu  ad i ci o nei  u m  at r i buto a cada ite m da enume ra ç ão , que
 sudoeste_de leitura,_basta declarar a seguinte_classe:
class Sudoeste_implements_LetrasNavegaveis {

__  public_NavegadorLetras navegador(final char[][]_tabuleiro, final int posicaoInicialY,
_  __             __ ___    final_int posicalInicialX) {
  _ _   
    __  return_new NavegadorLetras() {
      _     int_posicaoY = posicaoInicialY;
___   _     int_posicaoX = posicalInicialX;
   _    
  _     _   public boolean_temProxima() {
_    _  _ _  _  return posicaoY < tabuleiro.length
_  _     __  ___ _  &&_posicaoX_>= 0;
__     __   }
   _   __   public_char proxima() {
  _     _ _ _   char letra = tabuleiro[posicaoY][posicaoX];
    _     _   _ posicaoY++;
__  __ _      _ posicaoX--;
_     _   __    return letra;
_     _    _}
__    _ };
    }
}

E_adicionar esta nova_direção de leitura na enumeração:
SUDOESTE(new Sudoeste());

Agora, no_teste_abaixo, a palavra "Ruiva" será encontrada:
@Test
public_void_sudoeste() {
    char[][]_tabuleiro_=_new char[][] { 
 _     _    {' ',' ',' ',' ','R'},
_  _    ___ {' ',' ',' ','U',' '},
    _ _  _  {' ',' ','I',' ',' '},
   _      _ {' ','V',' ',' ',' '},
     _      {'A',' ','_',' ',' '}};
    
_   assertTrue(CacaPalavras.palavraEncontrada(tabuleiro,_"RUIVA"));
}

E_pronto :-)
Conclusão
Eu e muitos dos nossos colegas_consideram_este_código_bastante simples mas_eu entendo que_talvez você não_o compreenda_completamente ainda.
Minha sugestão,_é claro,_é que você_tente_compreender.
Alguns recursos do Java que foram utilizados aí:

Interface
Enumeração.
Extensão de enumeração: eu adicionei um atributo a cada item da_enumeração, que