Freestyle Sparring

import static org.junit.jupiter.api.Assertions.*;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

import org.junit.jupiter.api.RepeatedTest;
import org.junit.jupiter.api.Test;

class Tests {

		final String allChars = "abcdefghijklmnopqrstuvwxyz1234567890";
	@Test
	void test() {
		doTest(1, "12345 98212");
		doTest(1, "9999");
		doTest(-1, "abcdefg");
		doTest(-1,"zzzzzzz213 9ppppopppo2");
		doTest(0,"abcdef 12345");
	}
	@Test
	void hiddenTest() {
		doTest(0,"");
		doTest(0,"  ");
		doTest(0,"a1");
		doTest(1,"a1b2c3 d4e5f6");
		doTest(0,"a1b2c3 5y5");
		doTest(0,"a1b2c3     5y5");
		doTest(0,"5y5 a1b2c3   ");
		doTest(1,"9%$@");
		doTest(-1,"~$@#a");
		doTest(0,"~$@#");
		doTest(0,"0");
	}
	
	@RepeatedTest(100)
	void randomTests() {	
		String randomString = generateRandomString();
		int sol = sol(randomString);
		doTest(sol, randomString);
	}
	private String generateRandomString() {
		Random rnd = new Random();
		StringBuilder randomString = new StringBuilder(); 
		int finalStringLength =rnd.nextInt(100);
	    for(int i=0;i<finalStringLength;i++) {
	    	int currentWordLength = rnd.nextInt(20);
			for(int j=0;j<currentWordLength;j++) {
				randomString.append(allChars.charAt(rnd.nextInt(36)));
				}
			randomString.append(" ");
			}
	    return randomString.toString().trim();
	}
  private void doTest(int expected, String str) { 
		int actual = NumbersVsLetters.numbersVsLetters(str); 
		String msg = String.format( "Incorrect answer for String = %s\n Expected: %s\n Actual: %s\n", str, expected, actual); 
		assertEquals(expected, actual, msg); 
		}
  private static int sol(String str) {
	    if (str.isEmpty() || str.isBlank()) return 0;
	    Map<Character, Integer> allChars = fillMap();
	    int score = 0;
	    int numberMultiplication = -1;
	    int characterSum = 0;
	    for (char c : str.toCharArray()) {
	        if (c == ' ') {
	            if (numberMultiplication > 0) score += Integer.compare(numberMultiplication, characterSum);
	            else if (characterSum > 0) score--;
	            numberMultiplication = -1;
	            characterSum = 0;
	        } else if (Character.isDigit(c)) numberMultiplication = Character.getNumericValue(c) * Math.abs(numberMultiplication);
            else if (Character.isAlphabetic(c)) characterSum += allChars.get(c);
	    }
	    if (numberMultiplication > 0) score += Integer.compare(numberMultiplication, characterSum);
	    else if (characterSum > 0) score--;
	    return Integer.compare(score, 0);
	}

	private static Map<Character, Integer> fillMap(){
		Map<Character, Integer> allChars = new HashMap<>();
		for (int i = 0; i < 26; i++) {
			char c = (char) ('a' + i);
		    allChars.put(c, i + 1);
		}
		return allChars;
	}
}

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.RepeatedTest;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;

import java.util.Random;
import java.util.ArrayList;


class SolutionTest {
	@Test
	@Tag("BasicTest")
	void BasicTest() {

		String[] reverseLeterHello = { "lello", "hollo", "hehlo", "heleo", "helll" };
		String[] reverseLeterBye = { "eye", "bbe", "byy" };

		String[] reverseLeterThanks = { "Thanks", "Thanks", "Thanks", "Thanks", "Thanks", "Thanks" };
    String[] reverseLetterHellowWorld = { "lello  world", "Hlllo  world", "Heolo  world", "Helwo  world",
				"Hello  world", "Hello  rorld", "Hello  wlrld", "Hello  wodld", "Hello  worHd", "Hello  worle" };
    String[] reverseLetterHellowWorldLong = {"   rello world  ","   hlllo world  ","   hedlo world  ","   helho world  ","   helle world  ","   hello lorld  ","   hello wlrld  ","   hello woold  ","   hello worwd  ","   hello worlo  "};
    
		assertArrayEquals(reverseLeterHello, Kata.replaceLetter("hello", 3));
		assertArrayEquals(reverseLeterThanks, Kata.replaceLetter("Thanks", 0));
    assertArrayEquals(reverseLetterHellowWorld, Kata.replaceLetter("Hello  world", 2));
    assertArrayEquals(reverseLetterHellowWorldLong, Kata.replaceLetter("   hello world  ", 7));
	}

	@Test
	@Tag("SpecialCase")
	void SpecialCase() {
		String[] reverseLeterVoid = {};
		assertArrayEquals(reverseLeterVoid, Kata.replaceLetter(" ", 2));
    assertArrayEquals(new String[] { "  a  " }, Kata.replaceLetter("  a  ", 1));
		assertArrayEquals(new String[] { "   bb   ", "   aa   " }, Kata.replaceLetter("   ab   ", 7));

	}
  

  @Tag("RandomTest")
	@RepeatedTest(10)
	@DisplayName("RandomWord")
	void RandomTest() {
		String word = generate(new Random().nextInt(15) + 1);
		int letterRandom = new Random().nextInt(word.length());
		assertArrayEquals(replaceLetter(word, letterRandom), Kata.replaceLetter(word, letterRandom));

	}
  
	public static String generate(int length) {

		String strChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890     ^*¨_:;=?¿";
		StringBuilder sb = new StringBuilder();
    
		for (int i = 0; i < length; i++) {
			int nRandom = new Random().nextInt(strChars.length());
			sb.append(strChars.charAt(nRandom));
		}
		return sb.toString();
	}

  	public static String[] replaceLetter(String str, int n) {

		ArrayList<String> arr = new ArrayList<>();
		StringBuilder strFinal = new StringBuilder(str);
		int nextIndex = n - 1;
		int posSpaces = n;
		
		// Find first spaces
		for(int i =0; i<posSpaces; i++) if(str.charAt(i% str.length())==' ') {
			posSpaces++;
			nextIndex++;
		}
		
		// Iterate string 
		for (int i = 0; i < str.length(); i++) {
			nextIndex = (nextIndex + 1) % str.length();

			if (str.charAt(i) != ' ') {
				while (str.charAt(nextIndex) == ' ')  {
					nextIndex = (nextIndex + 1) % str.length();
				}

				// Replace letters
				strFinal.replace(i, i + 1, String.valueOf(str.charAt(nextIndex)));
				arr.add(strFinal.toString());
				// Reset string to add
				strFinal = new StringBuilder(str);
			} else{ // current index is white space
				nextIndex --;
			}

		}

		return arr.toArray(new String[arr.size()]);

	}
}