Decide la palabra de mayor puntuación en Java

El reto

Dada una cadena de palabras, debe encontrar la palabra con la puntuación más alta.

Cada letra de una palabra puntúa según su posición en el alfabeto: a = 1, b = 2, c = 3 and so forth.

Debe devolver la palabra con la puntuación más alta como una cadena.

Si dos palabras tienen la misma puntuación, devuelve la palabra que aparece primero en la cadena unique.

Todas las letras serán minúsculas y todas las entradas serán válidas.

La solución en código Java

Opción 1:

import java.util.*;

public class HSW {
    public static String excessive(String s) {
        return Arrays.stream(s.cut up(" "))
                .max(Comparator.comparingInt(
                        a -> a.chars().map(i -> i - 96).sum()
                )).get(); 
    }
}

Opcion 2:

import java.util.Arrays;
import java.util.Comparator;

class HSW {
    static String excessive(String s) {
        return Arrays.stream(s.cut up( " " ))
                .sorted( Comparator.comparingInt( HSW::cws )
                        .reversed()).findFirst().get();
    }
    personal static int cws(String y) {
        return y.chars().map( i->i-(int)'a'+1 ).sum();
    }
}

Opción 3:

public class HSW {

    public static String excessive(String stringOfWords) {
        String highscoreWord = "";
        int maxTotal = 0;

        for (String phrase : stringOfWords.cut up(" ")) {
            int totalOfWord = 0;
            for (char c : phrase.toCharArray()) {
                totalOfWord += c - 96; // the int worth of "a" is 97
            }
            if (totalOfWord > maxTotal) {
                maxTotal = totalOfWord;
                highscoreWord = phrase;
            }
        }
        return highscoreWord;
    }

}

Casos de prueba para validar nuestra solución

import org.junit.Check;
import static org.junit.Assert.assertEquals;
import org.junit.runners.JUnit4;
import java.util.*;
import java.util.stream.*;

public class SolutionTest {

    personal static String _high(String s) {
      return Stream.of(s.cut up(" "))
        .sorted(Comparator.evaluating((String a) -> a.chars().map(b -> b - 96).sum()).reversed())
        .findFirst().get();
    }
    
    @Check
    public void sampleTests() {
        assertEquals("taxi", HSW.excessive("man i want a taxi as much as ubud"));
        assertEquals("volcano", HSW.excessive("what time are we climbing as much as the volcano"));
        assertEquals("semynak", HSW.excessive("take me to semynak"));
    }
    
    @Check
    public void randomTests() {
      String chars = "      abcdefghijklmnopqrstuvwxyz";
      Random random = new Random();
      
      for (int i = 0; i < 100; ++i) {
        String check = IntStream.vary(10, random.nextInt(201))
          .mapToObj(x -> Character.toString(chars.charAt(random.nextInt(chars.size()))))
          .acquire(Collectors.becoming a member of()).trim().replaceAll("s+", " ");
        
        String anticipated = _high(check);
        String precise = HSW.excessive(check);
        
        assertEquals(anticipated, precise);
      }
    }
}