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.

Ad
Ad
theguy678vs.Sebscrm

adding 1 and -1 || invalid operation return 0 -

Code
Diff
  • def basicOp(operation, value1, value2):
    if operation == "+":
        return value1 + value2
    if operation == "-":
        return value1 - value2
    if operation == "*":
        return value1 * value2
    if operation == "/":
        return value1 / value2
    return "Invalid Operation"
    • function basicOp(operation, value1, value2) {
    • switch (operation) {
    • case '+':
    • return value1 + value2;
    • case '-':
    • return value1 - value2;
    • case '*':
    • return value1 * value2;
    • case '/':
    • return value1 / value2;
    • default:
    • return 0;
    • //Suppose we're adding 1 and -1.
    • }
    • }
    • def basicOp(operation, value1, value2):
    • if operation == "+":
    • return value1 + value2
    • if operation == "-":
    • return value1 - value2
    • if operation == "*":
    • return value1 * value2
    • if operation == "/":
    • return value1 / value2
    • return "Invalid Operation"
user8436785vs.sloppycee

Divide by 3 without division operation

Code
Diff
  • const dividedByThree = n => Math.floor(n * (1 / 3))
    • dividedByThree = (n) => (n - (n % 3)) * 0.3333333333333333;
    • const dividedByThree = n => Math.floor(n * (1 / 3))
pawptartvs.PinkDraconian

Sum of the letters (ASCII)

Code
Diff
  • def verifySum(w1, w2)
  return false if w1.nil? || w2.nil?
  w1.downcase().split('').map(&:ord).inject(:+) == w2.downcase().split('').map(&:ord).inject(:+)
end
    • class Kata{
    • public static String verifySum(String nameOne, String nameTwo) {
    • if (nameOne == null || nameTwo == null) return "NULL";
    • else return nameOne.chars().sum() == nameTwo.chars().sum() ? "TRUE" : "FALSE";
    • }
    • }
    • def verifySum(w1, w2)
    • return false if w1.nil? || w2.nil?
    • w1.downcase().split('').map(&:ord).inject(:+) == w2.downcase().split('').map(&:ord).inject(:+)
    • end
pawptartvs.user8436785

Given Two Lists, Find what's missing from list one, but is in list two

Bash
Regular Expressions
Declarative Programming
Advanced Language Features
Programming Paradigms
Fundamentals
Strings
Code
Diff
  • def missing(a, b)
  ( (a + b).to_set - a.to_set ).to_a.sort
end
    • def missing(a, b)
    • b.reject(&a.method(:include?)).uniq.sort
    • # syntactic sugar for b.reject do |x| a.include?(x) end.uniq.sort
    • # another approach: (b - a).uniq.sort
    • ( (a + b).to_set - a.to_set ).to_a.sort
    • end
dvextremevs.kappachino85Failed Tests

Doesn't work with this test :)

mathsisfunvs.jordanmcleod

Euler's Totient Function

Code
Diff
  • def factorise(a): # takes much less than O(a), unless a is prime
    prime_factors = {}
    p = 1
    while a > 1:
        p += 1
        while a % p == 0:
            if p in prime_factors: prime_factors[p] += 1
            else: prime_factors[p] = 1
            a = a//p
    return prime_factors

def totient(a):
    """python 3.6.0"""
    primes = factorise(a)
    totient = 1
    for i in primes: # formula for totient from prime factorisation
        totient *= i**(primes[i]-1) * (i-1)
    return totient
    • from math import gcd
    • def factorise(a): # takes much less than O(a), unless a is prime
    • prime_factors = {}
    • p = 1
    • while a > 1:
    • p += 1
    • while a % p == 0:
    • if p in prime_factors: prime_factors[p] += 1
    • else: prime_factors[p] = 1
    • a = a//p
    • return prime_factors
    • def totient(a):
    • """python 3.6.0"""
    • return len([b for b in range(a) if (gcd(a, b) == 1)])
    • primes = factorise(a)
    • totient = 1
    • for i in primes: # formula for totient from prime factorisation
    • totient *= i**(primes[i]-1) * (i-1)
    • return totient