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.
from hex to 1 dec
'a:2:35:af:1' -> 10 + 2 + 53 + 175 + 1 -> 241
'b:356:3af:cba24:100' -> 11 + 854 + 943 + 834084 + 256 -> 836148
decr = lambda a: sum([int(h,16) for h in a.split(':')])test.assert_equals(decr('a:2:35:af:1'),241)
test.assert_equals(decr('b:356:3af:cba24:100'),836148)
test.assert_equals(decr('a:bbbcefff:134fdea:100'),3169971955)
test.assert_equals(decr('effbc4:edfc31:aedfc2506'),46973721851)
test.assert_equals(decr('ef23fae:123a'),250761704)Recent Moves:
import string import random def rubegoldberg(): alpha = string.ascii_lowercase find, total = "codewars", 1 for x, y in enumerate(find): if x % 2 == 0: total += alpha.index(y) else: total -= alpha.index(y) total -= len(find) nums = [] for i in range(0, 10): nums.append(i) random.shuffle(nums) try: for n in nums: a = 1 / n except ZeroDivisionError: return total1 1 import string
2 + import random
2 2 3 3 def rubegoldberg():
4 4 alpha = string.ascii_lowercase
5 5 find, total = "codewars", 1
6 6 for x, y in enumerate(find):
7 7 if x % 2 == 0:
8 8 total += alpha.index(y)
9 9 else:
10 10 total -= alpha.index(y)
11 11 total -= len(find)
12 − return total
13 + nums = []
14 + for i in range(0, 10):
15 + nums.append(i)
16 + random.shuffle(nums)
17 + try:
18 + for n in nums:
19 + a = 1 / n
20 + except ZeroDivisionError:
21 + return total
import string def rubegoldberg(): alpha = string.ascii_lowercase find, total = "codewars", 1 for x, y in enumerate(find): if x % 2 == 0: total += alpha.index(y) else: total -= alpha.index(y) total -= len(find) return total1 + import string
2 + 1 1 def rubegoldberg():
2 − return 2-1
4 + alpha = string.ascii_lowercase
5 + find, total = "codewars", 1
6 + for x, y in enumerate(find):
7 + if x % 2 == 0:
8 + total += alpha.index(y)
9 + else:
10 + total -= alpha.index(y)
11 + total -= len(find)
12 + return total
Add something to the function's logic so that it still returns 1!
def rubegoldberg():
return 1test.assert_equals(rubegoldberg(), 1)Find your way to discover an "a1", the inverse of the key(a1: a^(-1)), without using the brute-force loop like the example code
Then return the secret text
Note: a x a1 = 1 (modulo 26)
Example: 7 x -11 = 1 (modulo 26) >> a1 = -11
In order to find the secret text:
secret_text = ""
for c in ciphertext:
e = (a1 * (char2num(c) - b)) % m
secret_text = secret_text + num2char(e)
def char2num(c):
return ord(c) - 65
def num2char(n):
return chr(n + 65)
def a_little_decryption(a, b, m, ciphertext):
secret_text = ""
a1 = None
for i in range(0, m):
if (a*i)%m == 1:
a1 = i
break
for c in ciphertext:
e = (a1 * (char2num(c) - b)) % m
secret_text = secret_text + num2char(e)
return secret_texttest.assert_equals(a_little_decryption(7, 5, 26, "VZZAQZM"), "GOODJOB")
test.assert_equals(a_little_decryption(17, 2 , 26, "HCPBIPA"), "LANDING")
test.assert_equals(a_little_decryption(359, 499 , 26, "TWNYOHLP"), "SHORTKEY")How did I miss this?
def get_primes(n): bpr = [0,1] * ((n+1)//2) + [0] * (1 - (1 * 1&n)) bpr[:3] = [0, 0, 1] for i in range(3, 1+ int(n**0.5), 2): if bpr[i]: ipi, isq = i*2, i*i bpr[isq::ipi] = [0] * (( n - isq)//ipi + 1) return [2] + [i for i in range(3,n,2) if bpr[i]]1 1 def get_primes(n):
2 2 bpr = [0,1] * ((n+1)//2) + [0] * (1 - (1 * 1&n))
3 3 bpr[:3] = [0, 0, 1]
4 4 for i in range(3, 1+ int(n**0.5), 2):
5 5 if bpr[i]:
6 6 ipi, isq = i*2, i*i
7 7 bpr[isq::ipi] = [0] * (( n - isq)//ipi + 1)
8 − return [i for i, x in enumerate(bpr) if x]
9 − 8 + return [2] + [i for i in range(3,n,2) if bpr[i]]
Don't reinitialize static property, instead, reference it.
During first execution, it'll be created with a null value. Right after creation, since it's null the Null Coalescing Assignment Operator will give us a new anonymous class and return a new instance of itself.
On following executions, the static property will be referenced, and since it already exists, it will not be reset to null. Since it's not null, the class assignment will be skipped, and will jump right to return a new instance.
function a() { static $poi; $poi ??= new class { public function create() { return new static(); } }; return $poi->create(); }1 − function a(){2 − // We shall remove the following solution when publish as KATA
3 − static $poi = null;
4 − if ($poi) return $poi->create();
5 − $poi = new class {1 + function a() {2 + static $poi;
3 + $poi ??= new class {6 6 public function create() {7 7 return new static();
8 8 }
9 9 };
10 10 return $poi->create();
11 11 }
class AnonymousClassTest extends TestCase { public function testSameClassName() { $this->assertSame(get_class(a()), get_class(a())); } public function testAnonymous() { $this->assertSame(0, strpos(get_class(a()), "class@anonymous")); } public function testDifferentIns() { $this->assertSame(a() !== a(), true); } }1 − // PHPUnit Test Examples:
2 − // TODO: Replace examples and use TDD development by writing your own tests
3 − class MyTestCases extends TestCase
1 + class AnonymousClassTest extends TestCase
4 4 {5 − // test function names should start with "test"
6 6 public function testSameClassName() {7 7 $this->assertSame(get_class(a()), get_class(a()));
8 8 }
6 + 9 9 public function testAnonymous() {10 10 $this->assertSame(0, strpos(get_class(a()), "class@anonymous"));
11 11 }
10 + 12 12 public function testDifferentIns() {13 13 $this->assertSame(a() !== a(), true);
14 14 }
15 15 }
There is an array of numbers.
Let's assume that we delete every M-th element of the array, starting from the first element.
After the first loop, the process is repeated until the last element is left (the function must return the remaining element).
For example, if the length of the array is N=9 and if every M=5 is deleted, the last element will be element 8 (#8).
Input: N-length of the array, M-delete each M-th element!
public class Kata
{
public static int ReturnsTheLastElement(int n, int m)
{
// Here's your code))
}
}