Begin a new Kumite
Search
About
  • 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.

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;
    };

    Mat3.prototype.add = function(mat){
      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;

})();
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:

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();
		}
	}
}());

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
    33
    from math import sqrt
    
    44
    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:

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
    }
    
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
    
  • 11
    defmodule Piapprox do
    
    22
    33
      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)
    
    1212
      end
    
    1313
    1414
      defp leibniz_stream do
    
    1515
        Stream.unfold(1, fn
    
    1616
          n when rem(n,4) == 1 -> { 4/n, n+2 }
    
    1717
          n                    -> {-4/n, n+2 }
    
    18
        end) |> Stream.with_index
    
    19+
        end)
    
    1919
      end
    
    2020
    end
    

Recent Moves: