Freestyle Sparring

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

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

		ArrayList<String> arr = new ArrayList<>();
		StringBuilder strFinal = new StringBuilder(str);

		for (int i = 0; i < str.length(); i++) {
			int nextIndex = (i + n) % str.length() ;

			if (str.charAt(i) != ' ' && str.charAt(nextIndex) != ' ') {

				nextIndex = (i + n) % str.length();
				strFinal.replace(i, i + 1, String.valueOf(str.charAt(nextIndex)));
				arr.add(strFinal.toString());
				strFinal.replace(0, str.length(), str);
			}

		}

		System.out.println(arr.toString());

		String[] array = arr.toArray(new String[arr.size()]);

		return array;

	}
 }

import java.util.*;

public class Kata {

public static String keyAlphabet(String str) {

  String[] arr = str.split(" ");
  List<String> listKey = new ArrayList<String>();
  PriorityQueue<String> listValue = new PriorityQueue<>();
  TreeMap<String, String> alphabet = new TreeMap<>();
  
  for (String item : arr) {
    if (item.length() == 1 && item.charAt(0) >= 'a' && item.charAt(0) <= 'z') {
      listKey.add(item);
    } else {
      listValue.add(item);
    }
  }
  
  List<String> values = new ArrayList<>(listValue);
  
  for (String value : values) {
    for (String s : listKey) {
      if (value.contains(s)) {
        if (alphabet.containsKey(s)) {
          alphabet.put(s, alphabet.get(s) + "," + value);
        } else {
          alphabet.put(s, value);
        }
      }
    }
  }
  StringBuilder result = new StringBuilder();
  for (Map.Entry<String, String> m : alphabet.entrySet()) {
    result.append(m.getKey()).append(":").append(m.getValue()).append(" ");
  }
  return result.toString().trim();
  }

}

const isAnagram = (s1, s2) => s1.length === s2.length && Object.values([...s1].reduce((o, k, i) => (k in o ? ++o[k] : o[k] = 1, s2[i] in o ? --o[s2[i]] : o[s2[i]] = -1, o), {})).every(v => !v);

function capitalize(sentence) {
  return sentence.split(' ').map(w => w[0].toUpperCase() + w.slice(1)).join(' ');
}

def decompose(num):
    return [int(i) for i in ''.join(map(str, num))]


def greatest(num):
    return int(''.join(sorted(''.join(map(str, decompose(num))), reverse=True)))

def binary_to_integer(b):
    # I didn't know that you don't need prefix '0b' for convertion, so I wrote it like this
    return int(f'0b{b}', 2)

def knight_move3d(pos=(0, 0, 0)) -> bool:
    if pos == (0, 0, 0):
        return True
    return [*sorted(map(abs, pos))] == [0, 1, 2]

def pyramid_of_x(n):
    if n < 2:
        return 'Not enough building blocks!'
    return '\n'.join(['*' * i for i in range(1, n + 1)])

import java.util.Arrays;
public class HighLow{
  public static int[] printLargestAndSmallest(int[] nums){
		return nums == null || nums.length==0 ? null : new int[]{Arrays.stream(nums).min()
      .getAsInt(),Arrays.stream(nums).max().getAsInt()};
	}
}

def foo(lst, i, n):
    done = i > n
    fb = not (i % 3 or i % 5)
    f = not i % 3
    b = not i % 5
    match (done, fb, f, b):
        case (1, _, _, _):
            return lst
        case (_, 1, _, _):
            return foo(lst + ["fizzbuzz"], i + 1, n)
        case (_, _, 1, _):
            return foo(lst + ["fizz"], i + 1, n)
        case (_, _, _, 1):
            return foo(lst + ["buzz"], i + 1, n)
        case _:
            return foo(lst + [str(i)], i + 1, n)

                
def fizzbuzz(n):
    return foo([],1,n)