Start a new Kumite
AllAgda (Beta)BF (Beta)CCFML (Beta)ClojureCOBOL (Beta)CoffeeScriptCommonLisp (Beta)CoqC++CrystalC#D (Beta)DartElixirElm (Beta)Erlang (Beta)Factor (Beta)Forth (Beta)Fortran (Beta)F#GoGroovyHaskellHaxe (Beta)Idris (Beta)JavaJavaScriptJulia (Beta)Kotlinλ Calculus (Beta)LeanLuaNASMNim (Beta)Objective-C (Beta)OCaml (Beta)Pascal (Beta)Perl (Beta)PHPPowerShell (Beta)Prolog (Beta)PureScript (Beta)PythonR (Beta)RacketRaku (Beta)Reason (Beta)RISC-V (Beta)RubyRustScalaShellSolidity (Beta)SQLSwiftTypeScriptVB (Beta)
Show only mine

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.

### Get Factors

Code
Diff
• ``````function getFactors (n) {
if (!Number.isInteger(n) || n < 1) return [];

var divisors = new Set();
for (let i = 1; i <= Math.sqrt(n); i++) {
}
return Array.from(divisors)
}``````
• function getFactors (n) {
• if (n < 1 || ! Number.isInteger(n)) return [];
• if (!Number.isInteger(n) || n < 1) return [];
• let divisors = [];
• for (let i = 1; i <= Math.sqrt(n); ++i) {
• if (n % i === 0) {
• divisors.push(i);
• if (n / i !== i) divisors.push(n / i);
• }
• var divisors = new Set();
• for (let i = 1; i <= Math.sqrt(n); i++) {
• }
• return divisors;
• return Array.from(divisors)
• }

### Find the nth Fibonacci number O(1)

math.sqrt(n) = n**.5

for python 3 replace long(...) with int(...)

Code
Diff
• ``fib = lambda n: long((((1+5**.5)/2)**(n+1) - ((1-5**.5)/2)**(n+1))/5**.5)``
• import math
• def fib(n):
• return long((((1+math.sqrt(5))/2)**(n+1) - ((1-math.sqrt(5))/2)**(n+1))/math.sqrt(5))
• fib = lambda n: long((((1+5**.5)/2)**(n+1) - ((1-5**.5)/2)**(n+1))/5**.5)

### Find Duplicates Using Reduce

Arrays
Data Types
Map/Reduce
Algorithms
Logic
Code
Diff
• ``const duplicates = a => a.reduce((r, v, i, l) => !r.includes(v) && l.indexOf(v) !== i ? [...r, v] : r, []);``
• function duplicates(arr) {
• var out = [];
• for(var x=0;x<arr.length-1;x++)
• {
• var ch = arr[x];
• for(var y=x+1;y<arr.length;y++)
• {
• var comp = arr[y];
• if (comp === ch && out.indexOf(comp) === -1)
• {
• out.push(comp);
• break;
• }
• }
• }
• out.sort();
• return out;
• }
• const duplicates = a => a.reduce((r, v, i, l) => !r.includes(v) && l.indexOf(v) !== i ? [...r, v] : r, []);

### Middle Character

Code
Diff
• ``const middleCharacter = s => s.slice(s.length/2 - !(s.length % 2), s.length/2+1);``
• var middleCharacter = (str) => str.slice(str.length/2 - !(str.length % 2), str.length/2+1);
• const middleCharacter = s => s.slice(s.length/2 - !(s.length % 2), s.length/2+1);
Failed Tests

### Convert to 2 point precision floating

Code
Diff
• ``const convert = n => Number(n.toFixed(2));``
• const convert = (num) => {
• return parseFloat(num.toFixed(2));
• };
• const convert = n => Number(n.toFixed(2));

### Hello JS!

Code
Diff
• ``const greetLanguage = (a = "Hello", b = "Javascript") => `\${a}, \${b}!```
• let greetLanguage = (a = "Hello", b = "Javascript") => `\${a}, \${b}!`
• const greetLanguage = (a = "Hello", b = "Javascript") => `\${a}, \${b}!`

### compose compare function with Monoid style

Comparing lists using the `length` function is problematical because it requires counting every item in both lists. However, we only need to count up until the length of the shortest list + 1 to know which one is shorter. This can make a big difference in performance if one list is much longer than the other -- and make the difference between termination and non-termination if one list is infinite.

My change fixes this problem by avoiding the use of the `length` function. I've also changed the tests to make sure the solution works when one list is infinite.

Code
Diff
• ``````module CmpStr where

import Data.Function
import Data.Monoid

cmpStr :: String -> String -> Ordering
cmpStr = (compare `on` map (const ())) `mappend` compare``````
• module CmpStr where
• import Data.Function
• import Data.Monoid
• cmpStr :: String -> String -> Ordering
• cmpStr = (compare `on` length) `mappend` compare
• cmpStr = (compare `on` map (const ())) `mappend` compare

### Say hello!

Code
Diff
• ``````def myMap(mine):
l = [i+1 for i in mine]
return l
``````
• def sayHello(say):
• say.append("bulbul")
• return say
• def myMap(mine):
• l = [i+1 for i in mine]
• return l