Kumite (ko͞omiˌtā) is the practice of taking techniques learned from Kata and applying them through the act of freestyle sparring.
You can create a new kumite by providing some initial code and optionally some test cases. From there other warriors can spar with you, by enhancing, refactoring and translating your code. There is no limit to how many warriors you can spar with.
A great use for kumite is to begin an idea for a kata as one. You can collaborate with other code warriors until you have it right, then you can convert it to a kata.
Write a function that takes an integer array, and without sorting the array returns its largest and smallest number as a two element array.
INPUT: OUTPUT:
{-1,-2,-3,-4,-5,-6,-7,-8,-9,-1} -> {-9,-1}
public class HighLow{
public static int[] printLargestAndSmallest(int[] nums){
int low[] = nums;
int high[] = nums;
int lowest = nums[0];
int highest = nums[0];
int count = 0;
for(int i = 0; i < nums.length;i+=2){
int num1 = nums[i];
int num2 = nums[i+1];
if(num1<num2){
low[count] = num1;
high[count] = num2;
count++;
}else{
low[count] = num2;
high[count] = num1;
count++;
}
lowest = low[0];
highest = high[0];
for(int j = 1; j < low.length; j++){
if(low[j] < lowest){
lowest = low[j];
}
}
for(int j = 1; j < high.length; j++){
if(high[j] > highest){
highest = high[j];
}
}
}
int[] finalHighLow = new int[2];
finalHighLow[0] = lowest;
finalHighLow[1] = highest;
return finalHighLow;
}
}import org.junit.Test;
import static org.junit.Assert.*;
import org.junit.runners.JUnit4;
// TODO: Replace examples and use TDD by writing your own tests
public class SolutionTest {
int[] input = new int[]{-1,-2,-3,-4,-5,-6,-7,-8,-9,-1};
int[] output = new int[]{-9,-1};
@Test
public void allNegatives() {
assertArrayEquals(output, HighLow.printLargestAndSmallest(input));
}
int[] input2 = new int[]{1,-2,3,-4,-5,-6,-7,-8,-9};
int[] output2 = new int[]{-9,3};
@Test
public void test2() {
assertArrayEquals(output, HighLow.printLargestAndSmallest(input));
}
}Write a function that takes a string as input and removes all variations of the phrase "yasss".
Variations of yass include a single y followed by any number of a's followed by any number of s.
Words are all separated by spaces, but may have punctuation at the end.
The function should return the string with each letter of the offending yass replaced with a '*'.
Some Examples:
yass -> ****
remove the yaaass -> remove the ******
yas? -> ***?
import java.util.regex.*;
public class YasRemover{
public static String remove(String orig){
String[] words = orig.split(" ");
String output = "";
for(int i=0;i<words.length;i++){
boolean cut = false;
String[] letters = words[i].split("");
if(letters[0].equalsIgnoreCase("y") && letters[1].equalsIgnoreCase("a")){
for(int j=1;j<letters.length;j++){
if(letters[j].equalsIgnoreCase("a")){
}else if(letters[j].equalsIgnoreCase("s") || letters[j].matches("[.!?,]")){
if(j == letters.length-1){
cut = true;
}else{
for(int x = j+1;x<letters.length;x++){
if(letters[x].equalsIgnoreCase("s") || letters[x].matches("[.!?,]")){
cut = true;
}else{
cut = false;
}
}
}
}else{
cut = false;
}
}
}
if(cut){
words[i] = words[i].replaceAll("[a-zA-Z]","*");
cut = false;
}
}
for(int i=0;i<words.length-1;i++){
output += words[i] + " ";
}output+= words[words.length-1];
return output;
}
}import org.junit.Test;
import static org.junit.Assert.assertEquals;
import org.junit.runners.JUnit4;
public class SolutionTest {
@Test
public void basicTest() {
assertEquals("***", YasRemover.remove("yas"));
}
@Test
public void falsePositiveTest() {
assertEquals("whats yasu to you?", YasRemover.remove("whats yasu to you?"));
}
@Test
public void endingPunctTest() {
assertEquals("punctuation is sneaky ****?", YasRemover.remove("punctuation is sneaky yaas?"));
}
@Test
public void punctTest() {
assertEquals("*****, I did put a comma there.", YasRemover.remove("yasss, I did put a comma there."));
}
@Test
public void multipleTest() {
assertEquals("*******, OMG ****!", YasRemover.remove("yaaaass, OMG yaas!"));
}
@Test
public void multipleYTest() {
assertEquals("all the yyyaass, none of the *****", YasRemover.remove("all the yyyaass, none of the yaaas"));
}
}replace seems like the perfect tool for the job in this case.
This version is in a one-liner format but could pretty easily be split on multiple lines for clarity.
There are also some potential very slight performance improvements as it does not need to create a temporary array in memory and the inner word/digit test only checks the first character (but this is likely irrelevant in most real-world use cases)
let transformText = s => s.replace(/\D+|[\d.]+/g, m => /^\D/.test(m) ? (m = m.trim()) && `<span>${m}</span>` : `<div>${m}</div>`);1 − function transformText(s) {2 − return s.split(/(\d+)/)
3 − .map(w => w.trim())
4 − .filter(w => w)
5 − .map(w => (
6 − /\d/.test(w) ? `<div>${w}</div>` : `<span>${w}</span>`7 − ))
8 − .join``;
9 − }
1 + let transformText = s => s.replace(/\D+|[\d.]+/g, m => /^\D/.test(m) ? (m = m.trim()) && `<span>${m}</span>` : `<div>${m}</div>`);
interface Calculator { static int calculate(int a, int b, char ops) { int[] calcs = {a * b, a + b, 0, a - b, 0, a / b}; return calcs[ops - 42]; } }1 1 interface Calculator {2 − static int calculate(int a, int b, char operation) {3 − int result = 0;
4 − switch(operation) {5 − case '+':
6 − result = a + b; break;
7 − case '-':
8 − result = a - b; break;
9 − case '*':
10 − result = a * b; break;
11 − default:
12 − System.exit(0); break;
13 − }
14 − return result;
2 + static int calculate(int a, int b, char ops) {3 + int[] calcs = {a * b, a + b, 0, a - b, 0, a / b};4 + return calcs[ops - 42];
15 15 }
16 16 }
Recent Moves:
interface Calculator { static int calculate(int a, int b, char operation) { int result = 0; switch(operation) { case '+': result = a + b; break; case '-': result = a - b; break; case '*': result = a * b; break; default: System.exit(0); break; } return result; } }1 − import javax.script.ScriptEngineManager;
2 − 3 3 interface Calculator {4 4 static int calculate(int a, int b, char operation) {5 − var engine = new ScriptEngineManager().getEngineByName("JavaScript");6 − try {7 − return Integer.parseInt(String.valueOf(engine.eval(a + " " + operation + " " + b)));
8 − } catch (Exception cause) {9 − return 0;
3 + int result = 0;
4 + switch(operation) {5 + case '+':
6 + result = a + b; break;
7 + case '-':
8 + result = a - b; break;
9 + case '*':
10 + result = a * b; break;
11 + default:
12 + System.exit(0); break;
10 10 }
14 + return result;
11 11 }
12 12 }
Recent Moves:
It is bad practice to have different return types. Maybe instead you could return 0 if the input is invalid.
You may also want to specify whether floats should be converted too.
def convert(number): return number*-1 if type(number) == int else 01 1 def convert(number):
2 − if isinstance(number, int):
3 − # Check if number is negitive
4 − if number < 0:
5 − # negitive -> positive
6 − return (abs(number))
7 − 8 − else:
9 − # positive -> negitive
10 − return (number * -1)
11 − 12 − else:
13 − return False
2 + return number*-1 if type(number) == int else 0
import codewars_test as test # TODO Write tests import solution # or from solution import example # test.assert_equals(actual, expected, [optional] message) @test.describe("These are your Test results") def test_group(): @test.it("test case") def test_case(): test.assert_equals(convert(-1), 1) test.assert_equals(convert(234), -234) test.assert_equals(convert(-3472398574349325748132), 3472398574349325748132) test.assert_equals(convert([2, 42, "3"]), 0) def converter(number): return number*-1 if type(number) == int else 0 @test.describe('Random Tests') def random(): import random for i in range(100): input = random.randint(-10000,10000) result = converter(input) test.assert_equals(convert(input),result)… Expand 1 1 import codewars_test as test
2 2 # TODO Write tests
3 3 import solution # or from solution import example
4 4 5 5 # test.assert_equals(actual, expected, [optional] message)
6 6 @test.describe("These are your Test results")7 7 def test_group():
8 8 @test.it("test case")9 9 def test_case():
10 10 test.assert_equals(convert(-1), 1)
11 11 test.assert_equals(convert(234), -234)
12 12 test.assert_equals(convert(-3472398574349325748132), 3472398574349325748132)
13 − test.assert_equals(convert([2, 42, "3"]), False)
13 + test.assert_equals(convert([2, 42, "3"]), 0)
14 + 15 + def converter(number):
16 + return number*-1 if type(number) == int else 0
17 + 18 + @test.describe('Random Tests')19 + def random():
20 + import random
21 + for i in range(100):
22 + input = random.randint(-10000,10000)
23 + result = converter(input)
24 + test.assert_equals(convert(input),result)
25 +
Recent Moves:
Summary
In this kata you have to make a function named converter.
What Does the converter Function do?
It converts a negitive number to a positive one and a positive number to a negetive one.
- Check the parameter
- If it is not integer just
return False
-
Check the word if it is negitive or positive
-
Convert the number
- if negitive convert to positive
- if positive convert to negitive
Now just return the final answer... Done!
Examples
-
# Negitive to Positive convert(-1) === 1 convert(-72) === 72 # Positive to Negitive convert(24) === -24 convert(32) === -32 # Invalid Sequences convert("23") === False convert("-94") === False convert(True) === False convert([123, 321]) == False convert({123, 1232, 34}) === False
def convert(number):
if isinstance(number, int):
# Check if number is negitive
if number < 0:
# negitive -> positive
return (abs(number))
else:
# positive -> negitive
return (number * -1)
else:
return Falseimport codewars_test as test
# TODO Write tests
import solution # or from solution import example
# test.assert_equals(actual, expected, [optional] message)
@test.describe("These are your Test results")
def test_group():
@test.it("test case")
def test_case():
test.assert_equals(convert(-1), 1)
test.assert_equals(convert(234), -234)
test.assert_equals(convert(-3472398574349325748132), 3472398574349325748132)
test.assert_equals(convert([2, 42, "3"]), False)I have undertaken a study of recursion. I find myself reaching for it fairly consistenly to solve different Kata but often find my understanding of certain concepts laking enough that I end up going with an iterative approach instead.
the goal of this was to produce in exponent notation the prime factors of a number.
The problem with this one is that because I created a new dictionary at the top of primeFactoring and because there is not an array or dictionary passed into it I ended up creating another function (factorPart) to fill the dictionary.
even ignoring all the messy formating code the solution seems convoluted.
What would be a better approach and what concepts should be understood to improve this answer?
def primeFactoring(n):
dict = {}
print(n)
factorPart(n,dict)
output = ""
for d, v in dict.items():
if v > 1:
output += str(d)+"^"+str(v)+" X "
else: output += str(d)+" X "
output = output.strip(" X ")
print(dict) #key being the factor and value being the number of occurrences
print(output) #formated in exponant form
return output
def factorPart(num, dict):
x = 2
while x <= num:
if num / x == num // x:
dict[x] = dict[x] + 1 if x in dict else 1
return factorPart(num // x, dict)
x+=1import codewars_test as test
# TODO Write tests
import solution # or from solution import example
# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
@test.it("test case")
def test_case():
test.assert_equals(1 + 1, 2)
test.assert_equals(primeFactoring(11223144), "2^3 X 3^3 X 223 X 233")