Search
• ###### Filter by Language:
• 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.

### A small mat3 library

Need to do 2d affine transformations, or rotate stuff in 3d for your toy canvas library? look no further, the solution is here! Or at least it will be if you help improve this thing by forking it.

``````var mat3 = (function(){

function Mat3(a){
if(!a) return mat3.identity();
this.a = [];
for(var i = 0; i < 9; i++) this.a[i] = a[i] || 0;
};

return mat3([
this.a[0] + mat.a[0], this.a[1] + mat.a[1], this.arr[2] + mat.a[2],
this.a[3] + mat.a[3], this.a[4] + mat.a[4], this.arr[5] + mat.a[5],
this.a[6] + mat.a[6], this.a[7] + mat.a[7], this.arr[8] + mat.a[8]
]);
};

Mat3.prototype.applyToCanvasContext = function(ctx){
ctx.transform(this.a[0], this.a[3], this.a[1], this.a[4], this.a[2], this.a[5]);
};

Mat3.prototype.equals = function(mat){
return this.a[0] === mat.a[0] && this.a[1] === mat.a[1] && this.a[2] === mat.a[2]
&& this.a[3] === mat.a[3] && this.a[4] === mat.a[4] && this.a[5] === mat.a[5]
&& this.a[6] === mat.a[6] && this.a[7] === mat.a[7] && this.a[8] === mat.a[8];
};

Mat3.prototype.toString = function(){
return '[' + this.a.join(',') + ']';
};

// Matrix-Vector multiplication
Mat3.prototype.transform3d = function(v){
return [
v[0] * this.a[0] + v[1] * this.a[1] + v[2] * this.a[2],
v[0] * this.a[3] + v[1] * this.a[4] + v[2] * this.a[5],
v[0] * this.a[6] + v[1] * this.a[7] + v[2] * this.a[8]
];
};

// 2d affine transformation
Mat3.prototype.transform2d = function(v){
var v2 = this.transform3d([v[0],v[1],1]);
return [v2[0],v2[1]];
};

Mat3.prototype.inverse = function(){
var f = this.a[0] * (this.a[4]*this.a[8] - this.a[5]*this.a[7])
+ this.a[1] * (this.a[5]*this.a[6] - this.a[3]*this.a[8])
+ this.a[2] * (this.a[3]*this.a[7] - this.a[4]*this.a[6]);

return mat3([
this.a[4]*this.a[8] - this.a[5]*this.a[7],
this.a[2]*this.a[7] - this.a[1]*this.a[8],
this.a[1]*this.a[5] - this.a[2]*this.a[4],

this.a[5]*this.a[6] - this.a[3]*this.a[8],
this.a[0]*this.a[8] - this.a[2]*this.a[6],
this.a[2]*this.a[3] - this.a[0]*this.a[5],

this.a[3]*this.a[7] - this.a[4]*this.a[6],
this.a[1]*this.a[6] - this.a[0]*this.a[7],
this.a[0]*this.a[4] - this.a[1]*this.a[3]
]).multiplyScalar(1/f);
};

Mat3.prototype.multiply = function(mat){
return mat3([
this.a[0] * mat.a[0] + this.a[1] * mat.a[3] + this.a[2] * mat.a[6],
this.a[0] * mat.a[1] + this.a[1] * mat.a[4] + this.a[2] * mat.a[7],
this.a[0] * mat.a[2] + this.a[1] * mat.a[5] + this.a[2] * mat.a[8],

this.a[3] * mat.a[0] + this.a[4] * mat.a[3] + this.a[5] * mat.a[6],
this.a[3] * mat.a[1] + this.a[4] * mat.a[4] + this.a[5] * mat.a[7],
this.a[3] * mat.a[2] + this.a[4] * mat.a[5] + this.a[5] * mat.a[8],

this.a[6] * mat.a[0] + this.a[7] * mat.a[3] + this.a[8] * mat.a[6],
this.a[6] * mat.a[1] + this.a[7] * mat.a[4] + this.a[8] * mat.a[7],
this.a[6] * mat.a[2] + this.a[7] * mat.a[5] + this.a[8] * mat.a[8]
]);
};

Mat3.prototype.multiplyScalar = function(s){
return mat3([
this.a[0] * s, this.a[1] * s, this.arr[2] * s,
this.a[3] * s, this.a[4] * s, this.arr[5] * s,
this.a[6] * s, this.a[7] * s, this.arr[8] * s
]);
};

Mat3.prototype.transpose = function(){
return mat3([
this.a[0], this.a[3], this.a[6],
this.a[1], this.a[4], this.a[7],
this.a[2], this.a[5], this.a[8]
]);
};

function mat3(a){
return new Mat3(a);
};

mat3.identity = function(){
return mat3([1,0,0,0,1,0,0,0,1]);
};

// 2d rotation
mat3.rotate = function(phi){
var s = Math.sin(phi), c = Math.cos(phi);
return mat3([c,s,0,-s,c,0,0,0,1]);
};

// 3d rotations
mat3.rotate.z = mat3.rotate;

mat3.rotate.y = function(phi){
var s = Math.sin(phi), c = Math.cos(phi);
return mat3([c,0,s,0,1,0,-s,0,c]);
};

mat3.rotate.x = function(phi){
var s = Math.sin(phi), c = Math.cos(phi);
return mat3([1,0,0,0,c,-s,0,s,c]);
};

mat3.scale = function(x, y, z){
return mat3([x,0,0,0,y,0,0,0,z||1]);
};

mat3.translate = function(x, y){
return mat3([1,0,x,0,1,y,0,0,1]);
};

mat3.Mat3 = Mat3;

return mat3;

})();``````

### Dice Generator

Mathematics
Algorithms
Numbers
Fundamentals
Code
Diff
• ``const dice=_=>~~(Math.random()*6)+1;``
•  1 − ```function Cube(){ ``` 2 − ``` return Math.floor(Math.random()*6)+1; ``` 3 − ``` } ``` 1 + ```const dice=_=>~~(Math.random()*6)+1; ```

Recent Moves:

### Singleton in js

Construct a singleton in js.

Tests:
let obj1 = new Singleton();
let obj2 = new Singleton();
obj1.test = 1;

obj1 === obj2 // true
obj2.test // 1

``````let Singleton = (function () {
let instance;

return function Construct_singletone () {
if (instance) {
return instance;
}
if (this && this.constructor === Construct_singletone) {
instance = this;
} else {
return new Construct_singletone();
}
}
}());``````

### Find the nth Fibonacci number

This implementation of fibonacci follows https://www.nayuki.io/page/fast-fibonacci-algorithms, with a base case that uses math.pow.

Code
Diff
• ``````from math import sqrt

def fib(x):
if x < 70:
a = 0.7236067977499789 # (sqrt(5) + 1) / (2 * sqrt(5))
b = 1.618033988749895 # (1 + sqrt(5)) / 2
return round(a * b**x)
elif x % 2 == 0:
a = fib(x / 2)
b = fib(x / 2 + 1)
return a * (2 * fib(b) - a)
else:
# x % 2 == 1, by elimination
a = fib((x - 1) / 2)
b = fib((x + 1) / 2)
return a * a + b * b
``````
•  1 − ```# Fibonacci # ``` 2 − 3 3 ```from math import sqrt ``` 4 4 5 − ```c1 = (sqrt(5) - 1) / (2 * sqrt(5)) ``` 6 − ```c2 = (sqrt(5) + 1) / (2 * sqrt(5)) ``` 7 − 8 − ```def f(x): ``` 9 − ``` fibo = c1 * ((1 - sqrt(5)) / 2)**x + c2 * ((1 + sqrt(5)) / 2)**x ``` 10 − ``` return int(round(fibo)) ``` 3 + ```def fib(x): ``` 4 + ``` if x < 70: ``` 5 + ``` a = 0.7236067977499789 # (sqrt(5) + 1) / (2 * sqrt(5)) ``` 6 + ``` b = 1.618033988749895 # (1 + sqrt(5)) / 2 ``` 7 + ``` return round(a * b**x) ``` 8 + ``` elif x % 2 == 0: ``` 9 + ``` a = fib(x / 2) ``` 10 + ``` b = fib(x / 2 + 1) ``` 11 + ``` return a * (2 * fib(b) - a) ``` 12 + ``` else: ``` 13 + ``` # x % 2 == 1, by elimination ``` 14 + ``` a = fib((x - 1) / 2) ``` 15 + ``` b = fib((x + 1) / 2) ``` 16 + ``` return a * a + b * b ```

Recent Moves:

### Powermod

Updated to test that it is working with new rust changes

Code
Diff
• ``````pub fn powermod(n: u64, p: u64, m: u64) -> u64 {
if p == 0 { return 1 % m }
if p == 1 { return n % m }

let mut r = powermod(n, p / 2, m);

r = r * r % m;
if p & 1 == 1 {
r = r * n % m;
}

r
}``````
• 88
```	if p & 1 == 1 {
```
99
```		r = r * n % m;
```
1010
```	}
```
1111
```
```
1212
```	r
```
1313
```}
```
14
15
```#[test]
```
16
```fn test_powermod() {
```
17
```	assert_eq!(powermod(2, 999999, 147), 50);
```
18
```}
```

### Pi Approximation using Leibniz sequence

Code
Diff
• ``````defmodule Piapprox do

def iter_pi(epsilon) do
pi = :math.pi
leibniz_stream
|> Stream.with_index
|> Enum.reduce_while(0, fn
({i, _}, acc) when abs(pi - acc) >= epsilon ->
{:cont, acc + i}
({_, n}, acc) ->
{:halt, [n, Float.round(acc, 10)]}
end)
end

defp leibniz_stream do
Stream.unfold(1, fn
n when rem(n,4) == 1 -> { 4/n, n+2 }
n                    -> {-4/n, n+2 }
end)
end
end
``````
•  1 1 ```defmodule Piapprox do ``` 2 2 3 3 ``` def iter_pi(epsilon) do ``` 4 − ``` leibniz_stream |> ``` 5 − ``` Enum.reduce_while(0, fn {i, n}, acc -> ``` 6 − ``` if abs(:math.pi - acc) >= epsilon do ``` 7 − ``` { :cont, acc + i } ``` 8 − ``` else ``` 9 − ``` { :halt, [n, Float.round(acc, 10)] } ``` 10 − ``` end ``` 11 − ``` end) ``` 4 + ``` pi = :math.pi ``` 5 + ``` leibniz_stream ``` 6 + ``` |> Stream.with_index ``` 7 + ``` |> Enum.reduce_while(0, fn ``` 8 + ``` ({i, _}, acc) when abs(pi - acc) >= epsilon -> ``` 9 + ``` {:cont, acc + i} ``` 10 + ``` ({_, n}, acc) -> ``` 11 + ``` {:halt, [n, Float.round(acc, 10)]} ``` 12 + ``` end) ``` 12 12 ``` end ``` 13 13 14 14 ``` defp leibniz_stream do ``` 15 15 ``` Stream.unfold(1, fn ``` 16 16 ``` n when rem(n,4) == 1 -> { 4/n, n+2 } ``` 17 17 ``` n -> {-4/n, n+2 } ``` 18 − ``` end) |> Stream.with_index ``` 19 + ``` end) ``` 19 19 ``` end ``` 20 20 ```end ```

Recent Moves: