Begin a new Kumite
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.
Recent Moves:
You will be given numbers and the task is to return odd numbers as they are, but subtract 1 from even numbers.
So if you get 3 you return 3. If you get 24 you return 23.
Your solution should be 27 or less characters long.
def o(n): return n-(n%2==0)import codewars_test as test
import random
# 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(o(1), 1)
test.assert_equals(o(2), 1)
test.assert_equals(o(5), 5)
test.assert_equals(o(8), 7)
@test.describe("Random tests")
def tests():
for i in range(10):
n = random.randint(1, 100)
expected = n-(n%2==0)
test.assert_equals(o(n), expected)Recent Moves:
import codewars_test as test import random # 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(e(1), 0) test.assert_equals(e(2), 2) test.assert_equals(e(6), 6) test.assert_equals(e(9), 8) @test.describe("Random tests") def tests(): for i in range(10): n = random.randint(1, 100) expected = n - n % 2 test.assert_equals(e(n), expected)1 1 import codewars_test as test
2 + import random
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("Example")7 7 def test_group():
8 8 @test.it("test case")9 9 def test_case():
10 10 test.assert_equals(e(1), 0)
11 11 test.assert_equals(e(2), 2)
12 12 test.assert_equals(e(6), 6)
13 13 test.assert_equals(e(9), 8)
15 + 16 + @test.describe("Random tests")17 + def tests():
18 + for i in range(10):
19 + n = random.randint(1, 100)
20 + expected = n - n % 2
21 + test.assert_equals(e(n), expected)
You will be given numbers and the task is to return even numbers as they are, but subtract 1 from odd numbers.
So if you get 4 you return 4. If you get 23 you return 22.
Your solution should be 22 or less characters long.
def e(n): return n-n%2import 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(e(1), 0)
test.assert_equals(e(2), 2)
test.assert_equals(e(6), 6)
test.assert_equals(e(9), 8)using System; class Kata { private static string LANGUAGE = "C#"; public static void Main() { string[] hello = {"H","e","l","l","o"}; Array.ForEach(hello, s => Console.Write(s)); Console.WriteLine(", " + LANGUAGE + "!" ); } }1 1 using System;
2 2 3 3 class Kata
4 4 {5 5 private static string LANGUAGE = "C#";
6 6 7 7 public static void Main()
8 8 {9 9 string[] hello = {"H","e","l","l","o"};10 − string result = "";
11 11 12 − foreach(string s in hello){13 − result = result + s;
14 − }
11 + Array.ForEach(hello, s => Console.Write(s));
15 15 16 − Console.WriteLine(result + ", " + LANGUAGE + "!" );
13 + Console.WriteLine(", " + LANGUAGE + "!" );17 17 18 18 }
19 19 20 20 21 21 }
Recent Moves:
using System; class Kata { private static string LANGUAGE = "C#"; public static void Main() { string[] hello = {"H","e","l","l","o"}; string result = ""; foreach(string s in hello){ result = result + s; } Console.WriteLine(result + ", " + LANGUAGE + "!" ); } }… Expand 1 1 using System;
2 2 3 3 class Kata
4 4 {5 5 private static string LANGUAGE = "C#";
6 6 7 7 public static void Main()
8 8 {9 9 string[] hello = {"H","e","l","l","o"};10 10 string result = "";
11 11 12 − for(int i = 0 ; i < hello.Length; i ++)
13 − {14 − result = result + hello[i];
15 − 16 − }
12 + foreach(string s in hello){13 + result = result + s;
14 + }
17 17 18 18 Console.WriteLine(result + ", " + LANGUAGE + "!" );
19 19 20 20 }
21 21 22 22 23 23 }
You need to resolve the famous game of Big Bang Theory.
for resume :
Scissors cut paper and decapited lizard.
Paper disproves Spock and covers rocks.
Lizard poison Spock and eats paper.
Spock smashes scissors and vaporizes rock.
rock crushes scissors and crushes lizard.
and return draw if draw.
I'm a student please be kind to my mistakes :)
string rps(const std::string p1, const std::string p2)
{
std::map<std::string, int> dict;
dict["rock"] = 0;
dict["paper"] = 1;
dict["scissors"] = 2;
dict["lizard"] = 3;
dict["spock"] = 4;
if(p1 == p2) return "Draw!";
if(dict[p1] == 0){
if(dict[p2] == 1) return "Player 2 won!";
if(dict[p2] == 2) return "Player 1 won!";
if(dict[p2] == 3) return "Player 1 won!";
if(dict[p2] == 4) return "Player 2 won!";
}
if(dict[p1] == 1){
if(dict[p2] == 0) return "Player 1 won!";
if(dict[p2] == 2) return "Player 2 won!";
if(dict[p2] == 3) return "Player 2 won!";
if(dict[p2] == 4) return "Player 1 won!";
}
if(dict[p1] == 2){
if(dict[p2] == 0) return "Player 2 won!";
if(dict[p2] == 1) return "Player 1 won!";
if(dict[p2] == 3) return "Player 1 won!";
if(dict[p2] == 4) return "Player 2 won!";
}
if(dict[p1] == 3){
if(dict[p2] == 0) return "Player 2 won!";
if(dict[p2] == 1) return "Player 1 won!";
if(dict[p2] == 2) return "Player 2 won!";
if(dict[p2] == 4) return "Player 1 won!";
}
if(dict[p1] == 4){
if(dict[p2] == 0) return "Player 1 won!";
if(dict[p2] == 1) return "Player 2 won!";
if(dict[p2] == 2) return "Player 1 won!";
if(dict[p2] == 3) return "Player 2 won!";
}
}{
It(should_pass_some_example_tests)
{
Assert::That(rps("rock", "lizard"), Equals("Player 1 won!"));
Assert::That(rps("rock", "paper"), Equals("Player 2 won!"));
Assert::That(rps("spock", "spock"), Equals("Draw!"));
}
}no need for len()
Recent Moves:
prod function is added as of 3.8, but it does not work on an empty list.
from math import prod def prod_(l): return prod(l) if len(l)>0 else 01 − from functools import reduce
2 − from operator import __mul__
3 − def prod(numbers):
4 − return reduce(__mul__, numbers) if numbers else 0
1 + from math import prod
2 + def prod_(l):
3 + return prod(l) if len(l)>0 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("Simple tests") def test_group(): @test.it("Short lists") def test_case(): test.assert_equals(prod_([1,1]), 1) test.assert_equals(prod_([]), 0) test.assert_equals(prod_([7, 2, -3, 8]), -336) test.assert_equals(prod_([239, 210, 100, 0, 67, -321, 1]), 0) test.assert_equals(prod_(range(1,10)), 362880)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("Simple tests")7 7 def test_group():
8 8 @test.it("Short lists")9 9 def test_case():
10 − test.assert_equals(prod([1,1]), 1)
11 − test.assert_equals(prod([]), 0)
12 − test.assert_equals(prod([7, 2, -3, 8]), -336)
13 − test.assert_equals(prod([239, 210, 100, 0, 67, -321, 1]), 0)
14 − test.assert_equals(prod(range(1,10)), 362880)
10 + test.assert_equals(prod_([1,1]), 1)
11 + test.assert_equals(prod_([]), 0)
12 + test.assert_equals(prod_([7, 2, -3, 8]), -336)
13 + test.assert_equals(prod_([239, 210, 100, 0, 67, -321, 1]), 0)
14 + test.assert_equals(prod_(range(1,10)), 362880)