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.
TIL that
instance Foldable ((,) a) where
foldMap f (_, y) = f y
foldr f z (_, y) = f y z
module FoldableTuple2 where
-- see the testsmodule FoldableTuple2Spec where
import Test.Hspec
import Test.QuickCheck
spec :: Spec
spec = do
describe "(,) a" $ do
it "can be used with `length`" $
property $ \x -> length (x :: (Int, String)) `shouldBe` 1
it "can be used with `concat`" $
property $ \x -> concat (x :: (Int, String)) `shouldBe` snd xWhy when i try to run it i get the EOFError? I don't get it when i test in Python 3.6.5 Shell
from datetime import datetime
a = datetime.now()
c = str(a.hour) + str(a.minute)
b = input("Please, print the password here (without letters!): ")
if b.isdigit():
if(b == c):
print("ACCESS CONFIRMED")
else:
print("ACCESS DENIED")
else:
print("Please, don't print letters.")
print("Reset the program.")# TODO: Replace examples and use TDD development by writing your own tests
# These are some of the methods available:
# test.expect(boolean, [optional] message)
# test.assert_equals(actual, expected, [optional] message)
# test.assert_not_equals(actual, expected, [optional] message)
# You can use Test.describe and Test.it to write BDD style test groupings#include <stdlib.h>
typedef struct IntVector {
int *data;
} IntVector;
IntVector *IntVector_new(size_t size) {
IntVector *this = malloc(sizeof(IntVector));
this->data = calloc(sizeof(*this->data), size);
return this;
}
void IntVector_free(IntVector *this) {
free(this->data);
free(this);
}
int IntVector_get(const IntVector *this, size_t index) {
return this->data[index];
}
void IntVector_set(IntVector *this, size_t index, int value) {
return this->data[index] = value;
}#include <criterion/criterion.h>
typedef struct IntVector IntVector;
Test(type_IntVector, should_be_implemented) {
IntVector *v = IntVector_new(2);
cr_assert_eq(IntVector_get(v, 0), 0);
cr_assert_eq(IntVector_get(v, 1), 0);
IntVector_set(v, 0, 1);
IntVector_set(v, 1, 2);
cr_assert_eq(IntVector_get(v, 0), 1);
cr_assert_eq(IntVector_get(v, 1), 2);
IntVector_free(v);
}Yes and no. A queue can be implemented using one explicit stack by leveraging the technique of recursion in the "dequeue" operation but note that recursion is handled internally by a function call stack; hence, technically, there are still two stacks at work ;)
class Queue {
constructor() {
this._stack = []; // We will be using this array as a stack - only
// its push and pop operations will ever be called
}
enqueue(data) {
this._stack.push(data);
}
dequeue() {
if (this._stack.length === 1)
return this._stack.pop();
else {
var tmp = this._stack.pop(), result = this.dequeue();
this.enqueue(tmp);
return result;
}
}
}Test.describe("Queue", function () {
Test.it("should have working enqueue and dequeue operations", function () {
var queue = new Queue();
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);
Test.assertEquals(queue.dequeue(), 1);
queue.enqueue(4);
queue.enqueue(5);
queue.enqueue(6);
Test.assertEquals(queue.dequeue(), 2);
Test.assertEquals(queue.dequeue(), 3);
queue.enqueue(7);
queue.enqueue(8);
queue.enqueue(9);
queue.enqueue(10);
Test.assertEquals(queue.dequeue(), 4);
Test.assertEquals(queue.dequeue(), 5);
Test.assertEquals(queue.dequeue(), 6);
Test.assertEquals(queue.dequeue(), 7);
Test.assertEquals(queue.dequeue(), 8);
Test.assertEquals(queue.dequeue(), 9);
Test.assertEquals(queue.dequeue(), 10);
});
});def array_of_two(n)
raise 'n is not a number' unless n.is_a?(Numeric) # comment to fail test case
[n, n]
enddescribe "Test#expect_error" do
Test.expect_error("array_of_two should raise an exception if N is not a number") { array_of_two('hello world') }
endJust testing whether it is possible to "cheat" using the stack internally maintained by the computer to "implement" stack operations (between calls) in NASM.
Conclusion: It doesn't seem to be possible - at least with the way I did it, I got a segfault during the first call to stack_push() which just attempts to push its second argument to the internal stack and returns to the caller, let alone the pop and peek operations. There also doesn't seem to be a reliable way to check whether the internal stack is empty. Thus, it should be safe to translate my recent Stacks kata into NASM.
global stack_push, stack_pop, stack_peek ; , stack_is_empty
section .text
stack_push:
push rsi
ret
stack_pop:
pop rsi
ret
stack_peek:
pop rsi
push rsi
ret#include <criterion/criterion.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdio.h>
typedef struct node {
int data;
struct node *next;
} Node;
typedef struct {
Node *root;
} Stack;
void stack_push(Stack *stack, int data);
int stack_pop(Stack *stack);
int stack_peek(const Stack *stack);
// bool stack_is_empty(const Stack *stack);
Stack *new_stack() {
Stack *stack = malloc(sizeof(Stack));
stack->root = NULL;
return stack;
}
void delete_stack(Stack *stack) {
Node *nd = stack->root;
while (nd) {
Node *tmp = nd->next;
free(nd);
nd = tmp;
}
free(stack);
}
Test(Stack, should_work_for_some_examples) {
Stack *stack = new_stack();
printf("Stack initialized\n");
stack_push(stack, 1);
printf("First push operation successful!\n"); // This is never printed, suggesting that
// segfault occurs during first call to stack_push() attempting to cheat
stack_push(stack, 2);
stack_push(stack, 3);
cr_assert_eq(stack_peek(stack), 3);
cr_assert_eq(stack_pop(stack), 3);
cr_assert_eq(stack_peek(stack), 2);
cr_assert_eq(stack_pop(stack), 2);
cr_assert_eq(stack_peek(stack), 1);
cr_assert_eq(stack_pop(stack), 1);
delete_stack(stack);
}class Functionator
def initialize(s)
s.split(' ').each { | i | define_singleton_method :"#{i}" do Functionator.new(s.split(' ')[1..-1].join(' ')) end }
end
end
def functionator(string)
Functionator.new(string)
end# TODO: Replace examples and use TDD development by writing your own tests
# These are some of the methods available:
# Test.expect(boolean, [optional] message)
# Test.assert_equals(actual, expected, [optional] message)
# Test.assert_not_equals(actual, expected, [optional] message)
describe "t e s t s" do
it "t e s t s" do
obj = functionator('there are two kinds of people')
Test.expect(obj.there().are().two().kinds().of().people(),'Chain is incorrect');
obj = functionator('hello codewars world')
Test.expect(obj.hello().codewars().world(),'Chain is incorrect');
obj = functionator('theraretwokindsofpeople')
Test.expect(obj.theraretwokindsofpeople,'theraretwokindsofpeople is not defined');
end
endA mistake they don't want to fix...
function describePhp() {
return 2 * 2 == 4 ? 'php is good' : 2 * 2 == 5 ? 'php is weird' : 'php has features';
}class TestPhpQualities extends TestCase {
public function testPhpIsNice() {
$this->assertEquals('php is good', describePhp());
}
}Don't know how this "kumite" stuff works yet, so i may be doing sth wrong.
This is about finding better/more efficient ways to permutate a list starting with my sorry attempt. The result requires types of the typeclass Ord, to get a common result for the test cases. Havent thought about a way to solve that differently yet.
module Permutation where
import Data.List (sort)
permu :: [a] ->[[a]]
permu [] = [[]]
permu [x] = [[x]]
permu x = fuzz (length x) 0 x
where fuzz l n (x:xs) |n == l = []
|otherwise = map ((:) x) (permu xs) ++ fuzz l (n+1) (xs ++ [x])
permutation :: Ord a => [a] -> [[a]]
permutation x = permu xmodule PermuSpec where
import Test.Hspec
import Data.List (sort)
import Permutation
-- `spec` of type `Spec` must exist
spec :: Spec
spec = do
describe "Permutation" $ do
it "Basic Tests" $ do
shouldBe (sort $ permutation [1,2,3]) [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
shouldBe (sort $ permutation [1..4]) [[1,2,3,4],[1,2,4,3],[1,3,2,4],[1,3,4,2],[1,4,2,3],[1,4,3,2],[2,1,3,4],[2,1,4,3],[2,3,1,4],[2,3,4,1],[2,4,1,3],[2,4,3,1],[3,1,2,4],[3,1,4,2],[3,2,1,4],[3,2,4,1],[3,4,1,2],[3,4,2,1],[4,1,2,3],[4,1,3,2],[4,2,1,3],[4,2,3,1],[4,3,1,2],[4,3,2,1]]
shouldBe (sort $ permutation "wup") ["puw","pwu","upw","uwp","wpu","wup"]Lets go back to grade school!
Solve for the hypotenuse of a triangle.
Round a float to 4 decimal places.
def hypotenuse(a,b):
import math
h = round(math.sqrt(a**2 + b**2),4)
#print(h)
return htest.expect(hypotenuse(7,4) == 8.0623)
test.expect(hypotenuse(3,4) == 5)
test.expect(hypotenuse(56,87) == 103.465)
test.expect(hypotenuse(15,19) == 24.2074)
test.expect(hypotenuse(10,10) == 14.1421)