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
user354062vs.tungbelatung

Value Added Tax (VAT) and Luxury tax

Here is one in Python, rounding up to the nearest hundredth.

Code
Diff
  • def final_price(price):
    vat = 0.1
    lux = 0.3
    
    return round(price*(1+vat+lux),2) if price >= 1000 else round(price*(1+vat),2)
    • function finalPrice(price) {
    • var vat = 0.1
    • var lux = 0.3
    • if(price >= 1000) {
    • return Math.floor(price * (1+vat+lux))
    • } else {
    • return Math.floor(price * (1+vat))
    • }
    • }
    • def final_price(price):
    • vat = 0.1
    • lux = 0.3
    • return round(price*(1+vat+lux),2) if price >= 1000 else round(price*(1+vat),2)
Hardythvs.DemsZer

alpha "Rock Paper Scissor Lizard Spock"

Code
Diff
  • std::string rps(const std::string p1, const std::string p2) {
  enum shape {
    rock     = 1 << 0,
    paper    = 1 << 1,
    scissors = 1 << 2,
    lizard   = 1 << 3,
    spock    = 1 << 4,

    beaten_by_rock     = shape::scissors | shape::lizard,
    beaten_by_paper    = shape::spock | shape::rock,
    beaten_by_scissors = shape::paper | shape::lizard,
    beaten_by_lizard   = shape::spock | shape::paper,
    beaten_by_spock    = shape::scissors | shape::rock
  };

  typedef std::pair<shape, shape> shape_info;
  
  static std::map<std::string, shape_info> shapes;
  
  if (shapes.empty()) {
    shapes.insert(std::make_pair("rock", std::make_pair(shape::rock, shape::beaten_by_rock)));
    shapes.insert(std::make_pair("paper", std::make_pair(shape::paper, shape::beaten_by_paper)));
    shapes.insert(std::make_pair("scissors", std::make_pair(shape::scissors, shape::beaten_by_scissors)));
    shapes.insert(std::make_pair("lizard", std::make_pair(shape::lizard, shape::beaten_by_lizard)));
    shapes.insert(std::make_pair("spock", std::make_pair(shape::spock, shape::beaten_by_spock)));
  }
  
  assert(shapes.find(p1) != shapes.end());
  assert(shapes.find(p2) != shapes.end());
  
  shape_info shape_info_p1 = shapes.find(p1)->second;
  shape_info shape_info_p2 = shapes.find(p2)->second;
  
  if (p1 == p2) {
    return "Draw!";
  } else if (shape_info_p1.first & ~(shape_info_p2.second)) {
    return "Player 1 won!";
  } else if (shape_info_p2.first & ~(shape_info_p1.second)) {
    return "Player 2 won!";
  } else {
    assert(false);
  }
}
    • string rps(const std::string p1, const std::string p2)
    • {
    • std::map<std::string, int> dict;
    • std::string rps(const std::string p1, const std::string p2) {
    • enum shape {
    • rock = 1 << 0,
    • paper = 1 << 1,
    • scissors = 1 << 2,
    • lizard = 1 << 3,
    • spock = 1 << 4,
    • dict["rock"] = 0;
    • dict["paper"] = 1;
    • dict["scissors"] = 2;
    • dict["lizard"] = 3;
    • dict["spock"] = 4;
    • beaten_by_rock = shape::scissors | shape::lizard,
    • beaten_by_paper = shape::spock | shape::rock,
    • beaten_by_scissors = shape::paper | shape::lizard,
    • beaten_by_lizard = shape::spock | shape::paper,
    • beaten_by_spock = shape::scissors | shape::rock
    • };
    • if(p1 == p2) return "Draw!";
    • if(dict[p1] == 0){
    • if(dict[p2] == 1) return "Player 2 won!";
    • if(dict[p2] == 2) return "Player 1 won!";
    • if(dict[p2] == 3) return "Player 1 won!";
    • if(dict[p2] == 4) return "Player 2 won!";
    • }
    • if(dict[p1] == 1){
    • if(dict[p2] == 0) return "Player 1 won!";
    • if(dict[p2] == 2) return "Player 2 won!";
    • if(dict[p2] == 3) return "Player 2 won!";
    • if(dict[p2] == 4) return "Player 1 won!";
    • }
    • if(dict[p1] == 2){
    • if(dict[p2] == 0) return "Player 2 won!";
    • if(dict[p2] == 1) return "Player 1 won!";
    • if(dict[p2] == 3) return "Player 1 won!";
    • if(dict[p2] == 4) return "Player 2 won!";
    • }
    • if(dict[p1] == 3){
    • if(dict[p2] == 0) return "Player 2 won!";
    • if(dict[p2] == 1) return "Player 1 won!";
    • if(dict[p2] == 2) return "Player 2 won!";
    • if(dict[p2] == 4) return "Player 1 won!";
    • }
    • if(dict[p1] == 4){
    • if(dict[p2] == 0) return "Player 1 won!";
    • if(dict[p2] == 1) return "Player 2 won!";
    • if(dict[p2] == 2) return "Player 1 won!";
    • if(dict[p2] == 3) return "Player 2 won!";
    • }
    • typedef std::pair<shape, shape> shape_info;
    • static std::map<std::string, shape_info> shapes;
    • if (shapes.empty()) {
    • shapes.insert(std::make_pair("rock", std::make_pair(shape::rock, shape::beaten_by_rock)));
    • shapes.insert(std::make_pair("paper", std::make_pair(shape::paper, shape::beaten_by_paper)));
    • shapes.insert(std::make_pair("scissors", std::make_pair(shape::scissors, shape::beaten_by_scissors)));
    • shapes.insert(std::make_pair("lizard", std::make_pair(shape::lizard, shape::beaten_by_lizard)));
    • shapes.insert(std::make_pair("spock", std::make_pair(shape::spock, shape::beaten_by_spock)));
    • }
    • assert(shapes.find(p1) != shapes.end());
    • assert(shapes.find(p2) != shapes.end());
    • shape_info shape_info_p1 = shapes.find(p1)->second;
    • shape_info shape_info_p2 = shapes.find(p2)->second;
    • if (p1 == p2) {
    • return "Draw!";
    • } else if (shape_info_p1.first & ~(shape_info_p2.second)) {
    • return "Player 1 won!";
    • } else if (shape_info_p2.first & ~(shape_info_p1.second)) {
    • return "Player 2 won!";
    • } else {
    • assert(false);
    • }
    • }
vsanniervs.dan323

List of divisors of number

Code
Diff
  • module Divisors where

divisors :: Integer -> [Integer]
divisors n = filter ((0 ==) . mod n) [1..n]
    • module Divisors where
    • divisors :: Integer -> [Integer]
    • divisors n = 1:n:(divisorsAux 2)
    • where
    • divisorsAux k
    • | (fromIntegral k) > sqrt (fromIntegral n) = []
    • | otherwise = if n `mod` k == 0
    • then if n`div`k ==k
    • then k:(divisorsAux (k+1))
    • else k:(n`div`k):(divisorsAux (k+1))
    • else divisorsAux (k+1)
    • divisors n = filter ((0 ==) . mod n) [1..n]
jorelcbvs.jorelcbFailed Tests

Multiples of 3 or 5

Code
Diff
  • package kata

func Multiple3And5(number int) int {
    // Code goes here
}
    • package kata
    • func Multiple3And5(number int) int {
    • // Code goes here
    • }
SirSkylordvs.mariohernandezv

Basic Select (SQL)

Code
Diff
  • SELECT *
FROM greetings
WHERE id <= 10
    • SELECT name
    • SELECT *
    • FROM greetings
    • LIMIT 10;
    • WHERE id <= 10
Wrackervs.WestwardLand968

Return 100

Code
Diff
  • def returnhundred(s):
    k = sum([ord(x) for x in str(s)])
    return (((k * 2) + 200) // 2) - k
    • def returnhundred(s):
    • return (True + True + True + True + True + True + True + True + True + True) ** (True + True)
    • k = sum([ord(x) for x in str(s)])
    • return (((k * 2) + 200) // 2) - k
TimurIstemirovvs.csoyars

Bioinformatics - The Reverse Compliment

Code
Diff
  • def reverse_compliment(dna):
    DNA = dna.upper()
    rcom = []
    for i in dna:
        if i == 'A':
            rcom.append('T')
        elif i == 'T':
            rcom.append('A')
        elif i == 'G':
            rcom.append('C')
        elif i == 'C':
            rcom.append('G')
    r = rcom[::-1]
    reversedna = ''.join(r)
    return reversedna
    • def reverse_compliment(dna):
    • pass
    • DNA = dna.upper()
    • rcom = []
    • for i in dna:
    • if i == 'A':
    • rcom.append('T')
    • elif i == 'T':
    • rcom.append('A')
    • elif i == 'G':
    • rcom.append('C')
    • elif i == 'C':
    • rcom.append('G')
    • r = rcom[::-1]
    • reversedna = ''.join(r)
    • return reversedna
tonylicodingvs.bearfangxiong

Switchout

Code
Diff
  • switchout = lambda *_: " g F e D c B a "
    • def switchout(sentence,switchout,word):
    • return sentence.replace(switchout,word)
    • switchout = lambda *_: " g F e D c B a "
hecekielvs.jorelcb

First MPCS Kumite

Code
Diff
  • package orderedcount

// Use the preloaded Tuple struct as return type
// type Tuple struct {
//	Char  rune
//	Count int
// }

func OrderedCount(text string) []Tuple {
  tuples := make([]Tuple, 0)
 for _, c := range text {
     exists := false
     for _, t := range tuples {
       if(t.Char == rune(c)) {
         exists = true
       }
     }
     if (!exists) {
       tuples = append(tuples, Tuple{rune(c), 0})
     }
 }
 for _, c := range text {
     for i := range tuples {
       if(tuples[i].Char == rune(c)) {
         tuples[i].Count++
       }
     }
 }
 return tuples
}
    • package orderedcount
    • // Use the preloaded Tuple struct as return type
    • // type Tuple struct {
    • // Char rune
    • // Count int
    • // }
    • func OrderedCount(text string) []Tuple {
    • // to implement
    • tuples := make([]Tuple, 0)
    • for _, c := range text {
    • exists := false
    • for _, t := range tuples {
    • if(t.Char == rune(c)) {
    • exists = true
    • }
    • }
    • if (!exists) {
    • tuples = append(tuples, Tuple{rune(c), 0})
    • }
    • }
    • for _, c := range text {
    • for i := range tuples {
    • if(tuples[i].Char == rune(c)) {
    • tuples[i].Count++
    • }
    • }
    • }
    • return tuples
    • }
dominikdosoudilvs.Platonov Ivan

Platforms

Games
Arrays
Data Types
Algorithms
Logic
Code
Diff
  • fn required_energy(heights: Vec<i64>) -> i64 {
    heights
        .iter()
        .skip(1)
        .zip(heights.iter())
        .map(|(y2, y1)| (y2 - y1).abs())
        .sum::<i64>()
}
    • using System;
    • public static class Kata
    • {
    • public static int CalculatingTheAmountEnergy(int[] coordinates)
    • {
    • // here's your code
    • }
    • fn required_energy(heights: Vec<i64>) -> i64 {
    • heights
    • .iter()
    • .skip(1)
    • .zip(heights.iter())
    • .map(|(y2, y1)| (y2 - y1).abs())
    • .sum::<i64>()
    • }