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.
You are building a calendar app. You have the following task assigned to you:
Build a function that receives a single parameter - a list of time intervals when the user is not available - and returns a list of the intervals when the user will be free in the same day. Consider that all times are restricted to 30 minutes increments, eg “12:00”, “00:30”, “17:30”. No input validation is necessary.
Both the parameter and the return value should be a list of tuples, for example, the following list:
[(“12:00”, “13:00”), (“14:00”, “17:00”)]
Means that the user is busy from 12:00 to 13:00 (let’s say it’s his lunch time) and from 14:00 to 17:00 (let’s say he’ll be in a long meeting). Calling the function with the arguments, like:
Should return the time intervals when the user is available, so, in this case, it would be:
[(“00:00”,“12:00”), (“13:00”, “14:00”), (“17:00”, “24:00”)]
def get_available_times(hours):
available_times = {}
i = 0
for i in range(0, len(hours)):
if hours[i][0] == '00:00':
continue
if i == 0:
available_times['00:00'] = hours[i][0]
else:
available_times[hours[i-1][1]] = hours[i][0]
if i == (len(hours) - 1) and hours[i][1] != '24:00':
available_times[hours[i][1]] = '24:00'
return list(available_times.items())import codewars_test as test
import solution # or from solution import example
# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
@test.it("One events")
def two_events():
test.assert_equals(get_available_times([('14:00', '17:00')]), [('00:00','14:00'), ('17:00', '24:00')])
@test.it("Two events")
def two_events():
test.assert_equals(get_available_times([('12:00', '13:00'), ('14:00', '17:00')]), [('00:00','12:00'), ('13:00', '14:00'), ('17:00', '24:00')])
@test.it("Three events")
def three_tuples():
test.assert_equals(get_available_times([('04:00', '05:00'), ('08:30', '10:30'), ('13:00', '21:00')]), [('00:00', '04:00'), ('05:00', '08:30'), ('10:30', '13:00'), ('21:00', '24:00')])
@test.it("Bussy at sunrise")
def bussy_surinse():
test.assert_equals(get_available_times([('00:00', '08:00'), ('10:30', '11:00'), ('14:00', '17:00')]), [('08:00', '10:30'), ('11:00', '14:00'), ('17:00', '24:00')])
@test.it("Working hours")
def working_hours():
test.assert_equals(get_available_times([('00:00', '08:00'), ('18:00', '24:00')]), [('08:00', '18:00')])The function must receive three parameters: array, order, and key. The key must determine the order of the array, as in the example:
let arr = [
{id: 5, name: 'Hugo'},
{id: 2, name: 'Julian'},
{id: 3, name: 'Anne'},
{id: 1, name: 'April'},
{id: 4, name: 'John'}
];
let order = [1, 2, 3, 4, 5];
mapOrder(arr, order, 'id');
must return:
0: {id: 1, name: "April"}
1: {id: 2, name: "Julian"}
2: {id: 3, name: "Anne"}
3: {id: 4, name: "John"}
4: {id: 5, name: "Hugo"}
function mapOrder(array, order, key) {
if (typeof array !== 'object' || typeof order !== 'object' || typeof key !== 'string') return [];
array.sort((a, b) => {
let A = a[key], B = b[key];
if (order.indexOf(A) > order.indexOf(B)) {
return 1;
} else return -1;
});
return array;
}const chai = require("chai");
const assert = chai.assert;
const Test = require("@codewars/test-compat");
describe("Solution", function() {
it("Must return the ordered array of objects", function() {
const arr = [
{id: 5, name: 'Hugo'},
{id: 2, name: 'Julian'},
{id: 3, name: 'Anne'},
{id: 1, name: 'April'},
{id: 4, name: 'John'}
];
const orderedArray = [
{id: 1, name: "April"},
{id: 2, name: "Julian"},
{id: 3, name: "Anne"},
{id: 4, name: "John"},
{id: 5, name: "Hugo"}
];
assert.strictEqual(JSON.stringify(mapOrder(arr, [
1, 2, 3, 4, 5
], 'id')), JSON.stringify(orderedArray));
});
it("Must return an empty array in case of any wrong parameter", function() {
assert.strictEqual(String(mapOrder('randomString', 'foo', 3)), '');
});
});Whether you're a kata solver or a kata author, Codewars allows you to embed client-side
HTML, CSS, and JavaScript in your outputs.
This goes well beyond ASCII art. The door is open to more sophisticated debugging and visualization techniques. For a contrived and sloppily coded example, run this kata; in the output panel there should be a snake which, if luck will have it, you can control via the arrow keys on your keyboard.
Some JavaScript methods are disabled in this environment, but even so, for kata authors with JavaScript+CSS experience and full DOM control, the sky's the limit.
// The client-side stuff that this demo is made of is
// in the preloaded section, but it's not pretty or necessary
// to look at so I'm leaving it out of the main code view.
// The purpose of this kumite isn't to demonstrate *how* to embed HTML.
// That's as trivial as console.log(). The point, rather, is
// to make a public service anouncement to remind everyone
// that HTML, CSS, and JavaScript are available, and when
// deployed appropriately they can improve your katas.const Test = require("@codewars/test-compat");
describe("Kumite", function() {
it("should exist in a sane universe", function() {
Test.assertEquals(1 + 1, 2);
});
});Split Each Alphabet in a String
You can use this method to split words.
def split(word):
# if word is "hello" returns ["h", "e", "l", "l", "o"]
return [x for x in word]import 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():
passAscii 'A' is single byte. = {65}
Unicode 'A' is double byte 'A' = {0,65}
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
unsigned short *AsciiToUnicode( unsigned char *ascii);
unsigned short *AsciiToUnicode( unsigned char *ascii){
int len = strlen((const char *)ascii);
unsigned short *ptr = NULL;
ptr = (unsigned short *)malloc(len);
memset(ptr, 0, len);
for (int i = 0; i < len; i++){
*(ptr + i) = *(ascii + i);
}
return ptr;
}
int main(){
unsigned short *unicode = AsciiToUnicode((unsigned char *)"ABC");
for (unsigned short i=0; *(unicode+i); i++){
printf("%c ", (unsigned char) *(unicode+i));
}
free(unicode);
return 0;
}export function validateString(input: string, index: number, stack: number = 0): boolean {
// TODO: your code
if(index === 0 && (input[index] === ')' | input[index] === '}' | input[index] === ']')) {
return false;
}
if(input[index] === '(' | input[index] === '{' | input[index] === '[') {
stack++;
}
validateString(input, index + 1, )
}// See https://www.chaijs.com for how to use Chai.
import { assert } from "chai";
import { validateString } from "./solution";
describe('validateString', function() {
it('test', function() {
assert.strictEqual(validateString('{([])}', 0), true);
assert.strictEqual(validateString('(A[B{C}D]E)', 0), true);
assert.strictEqual(validateString('a(b[d{a+b]/2]/4)/1', 0), false);
assert.strictEqual(validateString('[}{})()', 0), false);
});
});A company wants to put a cell tower to the north of a city but is unsure of where buildings will cause interference.
You will be given a 2D array comprised of numbers representing the interference of a building. This value will be a decimal number less than 1 that represents the percentage impact it has on the signal strength.
You may assume that the signal is uniform across the entire northern front of the city.
The first row will have the strength of the initial signal strength.
You are tasked with producing a 2D array that shows where the cell signal reaches comprised of numbers that represent the strength of the cell signal at each location.
With each unobstructed row the signal passes through, it will lose a constant 1 strength.
Should the signal drop below 1, it will be considered 0.
Each calculation should be rounded to 2 decimal points.
As an example, you may be given an input resembling the following (formatted to ease of reading):
building_map = [
[0.20, 0.00, 0.00, 0.00, 0.00],
[0.00, 0.00, 0.25, 0.00, 0.00],
[0.00, 0.50, 0.00, 0.00, 0.00],
[0.00, 0.00, 0.50, 0.00, 0.00],
[0.15, 0.00, 0.00, 0.10, 0.00]
],
signal_strength = 4
You should return the following array:
signal_map = [
[3.20, 4.00, 4.00, 4.00, 4.00],
[2.20, 3.00, 3.00, 3.00, 3.00],
[1.20, 1.50, 2.00, 2.00, 2.00],
[0.00, 0.00, 1.00, 1.00, 1.00],
[0.00, 0.00, 0.00, 0.00, 0.00]
]
# Enter solution here
def get_signal_pattern(building_map, signal_strength):
return []import 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():
building_map_1 = [
[0.05, 0.10, 0.00],
[0.00, 0.20, 0.00],
[0.00, 0.00, 0.30]
]
signal_strength_1 = 5
signal_map_1 = [
[4.75, 4.50, 5.00],
[3.75, 3.60, 4.00],
[2.75, 2.60, 2.80]
]
building_map_2 = [
[0.50, 0.50, 0.50],
[0.50, 0.50, 0.50],
[0.50, 0.50, 0.50]
]
signal_strength_2 = 5
signal_map_2 = [
[2.50, 2.50, 2.50],
[1.25, 1.25, 1.25],
[0.00, 0.00, 0.00]
]
building_map_3 = [
[0.00, 0.00, 0.00],
[0.00, 0.00, 0.00],
[0.00, 0.00, 0.00]
]
signal_strength_3 = 10
signal_map_3 = [
[10.00, 10.00, 10.00],
[9.00, 9.00, 9.00],
[8.00, 8.00, 8.00]
]
building_map_4 = [
[0.20, 0.00, 0.00, 0.00, 0.00],
[0.00, 0.00, 0.25, 0.00, 0.00],
[0.00, 0.50, 0.00, 0.00, 0.00],
[0.00, 0.00, 0.50, 0.00, 0.00],
[0.15, 0.00, 0.00, 0.10, 0.00]
]
signal_strength_4 = 4
signal_map_4 = [
[3.20, 4.00, 4.00, 4.00, 4.00],
[2.20, 3.00, 3.00, 3.00, 3.00],
[1.20, 1.50, 2.00, 2.00, 2.00],
[0.00, 0.00, 1.00, 1.00, 1.00],
[0.00, 0.00, 0.00, 0.00, 0.00]
]
building_map_5 = [
[0.10, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.10],
[0.00, 0.20, 0.00, 0.00, 0.00, 0.00, 0.00, 0.20, 0.00],
[0.00, 0.00, 0.30, 0.00, 0.00, 0.00, 0.30, 0.00, 0.00],
[0.00, 0.00, 0.00, 0.40, 0.00, 0.40, 0.00, 0.00, 0.00],
[0.00, 0.00, 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.00],
[0.00, 0.00, 0.00, 0.60, 0.00, 0.60, 0.00, 0.00, 0.00],
[0.00, 0.00, 0.70, 0.00, 0.00, 0.00, 0.70, 0.00, 0.00],
[0.00, 0.80, 0.00, 0.00, 0.00, 0.00, 0.00, 0.80, 0.00],
[0.90, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.90]
]
signal_strength_5 = 50
signal_map_5 = [
[45.00, 50.00, 50.00, 50.00, 50.00, 50.00, 50.00, 50.00, 45.00],
[44.00, 40.00, 49.00, 49.00, 49.00, 49.00, 49.00, 40.00, 44.00],
[43.00, 39.00, 34.30, 48.00, 48.00, 48.00, 34.30, 39.00, 43.00],
[42.00, 38.00, 33.30, 28.80, 47.00, 28.80, 33.30, 38.00, 42.00],
[41.00, 37.00, 32.30, 27.80, 23.50, 27.80, 32.30, 37.00, 41.00],
[40.00, 36.00, 31.30, 11.12, 22.50, 11.12, 31.3, 36.00, 40.00],
[39.00, 35.00, 9.39, 10.12, 21.50, 10.12, 9.39, 35.00, 39.00],
[38.00, 7.00, 8.39, 9.12, 20.50, 9.12, 8.39, 7.00, 38.00],
[3.80, 6.00, 7.39, 8.12, 19.50, 8.12, 7.39, 6.00, 3.80]
]
@test.it("Map #1")
def test_case():
test.assert_equals(solution.get_signal_pattern(building_map_1, signal_strength_1), signal_map_1, "Test #1 Failed")
@test.it("Map #2")
def test_case():
test.assert_equals(solution.get_signal_pattern(building_map_2, signal_strength_2), signal_map_2, "Test #2 Failed")
@test.it("Map #3")
def test_case():
test.assert_equals(solution.get_signal_pattern(building_map_3, signal_strength_3), signal_map_3, "Test #3 Failed")
@test.it("Map #4")
def test_case():
test.assert_equals(solution.get_signal_pattern(building_map_4, signal_strength_4), signal_map_4, "Test #4 Failed")
@test.it("Map #5")
def test_case():
test.assert_equals(solution.get_signal_pattern(building_map_5, signal_strength_5), signal_map_5, "Test #5 Failed")A company wants to put a cell tower to the north of a city but is unsure of where buildings will cause interference.
You will be given a 2D array comprised of 0s and 1s representing no buildings and buildings respectively.
You may assume that the signal is uniform across the entire northern front of the city.
You are tasked with producing a 2D array that shows where the cell signal reaches comprised of 0s and 1s where 0 is no signal and 1 has signal.
For this first iteration, assume that one building stops a signal and the locations of builds also do not have signal.
You may also assume that the signal is otherwise strong enough to reach the southern edge of the city.
As an example, you may be given an input resembling the following:
building_map = [
[1, 0, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0],
[1, 0, 0, 1, 0]
]
You should return the following array:
signal_map = [
[0, 1, 1, 1, 1],
[0, 1, 0, 1, 1],
[0, 0, 0, 1, 1],
[0, 0, 0, 1, 1],
[0, 0, 0, 0, 1]
]
# Enter solution here
def get_signal_pattern(building_map):
return []import 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():
building_map_1 = [
[1, 1, 0],
[0, 1, 0],
[0, 0, 1]
]
signal_map_1 = [
[0, 0, 1],
[0, 0, 1],
[0, 0, 0]
]
building_map_2 = [
[1, 1, 1],
[1, 1, 1],
[1, 1, 1]
]
signal_map_2 = [
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]
]
building_map_3 = [
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]
]
signal_map_3 = [
[1, 1, 1],
[1, 1, 1],
[1, 1, 1]
]
building_map_4 = [
[1, 0, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0],
[1, 0, 0, 1, 0]
]
signal_map_4 = [
[0, 1, 1, 1, 1],
[0, 1, 0, 1, 1],
[0, 0, 0, 1, 1],
[0, 0, 0, 1, 1],
[0, 0, 0, 0, 1]
]
building_map_5 = [
[1, 0, 0, 0, 0, 0, 0, 0, 1],
[0, 1, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 1, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 1, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 1, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 1, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 1, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 1]
]
signal_map_5 = [
[0, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 1, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0]
]
@test.it("Map #1")
def test_case():
test.assert_equals(solution.get_signal_pattern(building_map_1), signal_map_1, "Test #1 Failed")
@test.it("Map #2")
def test_case():
test.assert_equals(solution.get_signal_pattern(building_map_2), signal_map_2, "Test #2 Failed")
@test.it("Map #3")
def test_case():
test.assert_equals(solution.get_signal_pattern(building_map_3), signal_map_3, "Test #3 Failed")
@test.it("Map #4")
def test_case():
test.assert_equals(solution.get_signal_pattern(building_map_4), signal_map_4, "Test #4 Failed")
@test.it("Map #5")
def test_case():
test.assert_equals(solution.get_signal_pattern(building_map_5), signal_map_5, "Test #5 Failed")You are working to an accounting company and your boss ask to make a program to get the most worked years.
Him already have the data in the database and will response with a matrix data.
For example: [[2001,2005],[1920,1960],[2001,1999],...] what you
will receive from the database.
The program only should return only an integer value corresponding to the most worked year.
const mostWorkedYears = (matrix) =>
matrix
.map((item) => item[0])
.reduce(
(accum, curr, index, array) =>
curr === array[index + 1] ? accum + curr : curr,
0
);const Test = require("@codewars/test-compat");
const matrixYearsInput1 = [
[1960, 2005],
[1945, 2008],
[1938, 1999],
[1960, 2008],
[1999, 2005],
[1945, 1980],
[1960, 2001],
]
describe("Solution", function() {
it("Should return the most worked year: 1960", () => {
Test.assertEquals(mostWorkedYears(matrixYearsInput1), 1960);
});
});Write a program to check is the number simple.
It can receive either negative or positive numbers, integer and not integer, simple and not simple.
It should return true if the given number is actually simple (2, 3, 5, 7...)
export const checkIsNumberSimple = (number: number) => {
// Check if the number is integer
if (number % 1 != 0) return false;
if (number < 2) return false;
if (number != 2 && number % 2 == 0) return false;
if (number != 3 && number % 3 == 0) return false;
return true;
};// See https://www.chaijs.com for how to use Chai.
import { assert } from "chai";
import { checkIsNumberSimple } from "./solution";
// TODO Add your tests here
describe("Simple numbers", function() {
it("should not be negative numbers", function() {
assert.strictEqual(checkIsNumberSimple(-1), false);
});
it("should be integer numbers", function() {
assert.strictEqual(checkIsNumberSimple(3.1), false);
});
it("should be simple numbers", function() {
assert.strictEqual(checkIsNumberSimple(2), true);
assert.strictEqual(checkIsNumberSimple(3), true);
assert.strictEqual(checkIsNumberSimple(5), true);
assert.strictEqual(checkIsNumberSimple(3571), true);
assert.strictEqual(checkIsNumberSimple(0), false);
assert.strictEqual(checkIsNumberSimple(1), false);
assert.strictEqual(checkIsNumberSimple(4), false);
assert.strictEqual(checkIsNumberSimple(3572), false);
});
});