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
annanediakvs.Polymorbism

Basic python calculator

Code
Diff
  • Hinata = lambda Naruto, equals, cool: eval("{} {} {}".format(Naruto, equals, cool))
    • eval(compile((_ := __import__("ast")).fix_missing_locations(_.Module(body=[_.Expr(value=_.Call(func=_.Attribute(value=_.Call(func=_.Name(id='globals', ctx=_.Load()), args=[], keywords=[]), attr='update', ctx=_.Load()), args=[_.Dict(keys=[_.Constant(value='calc')], values=[_.Lambda(args=_.arguments(posonlyargs=[], args=[_.arg(arg='_')], kwonlyargs=[], kw_defaults=[], defaults=[]), body=_.Call(func=_.Name(id='eval', ctx=_.Load()), args=[_.Name(id='_', ctx=_.Load())], keywords=[]))])], keywords=[]))], type_ignores=[])), "your mom LOL!", "exec"))
    • Hinata = lambda Naruto, equals, cool: eval("{} {} {}".format(Naruto, equals, cool))
Ramotlakaulavs.Ramotlakaula

Permutations of Unique Numbers from 0 to 9 in a 12-Element Array

Permutations
Arrays
Mathematics
Charles-Mwanikivs.AlexRadch

Check same case

Code
Diff
  • public static class Kata 
{
  public static int SameCase(char a, char b) =>
    (!(char.IsLetter(a) && char.IsLetter(b)))
      ? -1
    
    : (char.IsLower(a) == char.IsLower(b))
      ? 1
      : 0;
}
    • public static class Kata
    • {
    • public static int SameCase(char a, char b) =>
    • (!char.IsLetter(a) || !char.IsLetter(b))
    • (!(char.IsLetter(a) && char.IsLetter(b)))
    • ? -1
    • : (char.IsLower(a) == char.IsLower(b))
    • ? 1
    • : 0;
    • }
pearcebasmanmvs.eignnx

AndriusV's Kumite #2

Code
Diff
  • fn increment_string(string: &str) -> String {
    let split_point = string
        .rfind(|ch: char| !ch.is_ascii_digit())
        .map(|i| i + 1)
        .unwrap_or(0);
    
    let (text, numeric) = string.split_at(split_point);
    
    let next = numeric.parse().unwrap_or(0) + 1;
    
    format!("{text}{next:>0width$}", width=numeric.len())
}
    • fn incrementString(string: &str) -> String {
    • if string.is_empty() {
    • return "1".to_string();
    • }
    • fn increment_string(string: &str) -> String {
    • let split_point = string
    • .rfind(|ch: char| !ch.is_ascii_digit())
    • .map(|i| i + 1)
    • .unwrap_or(0);
    • let (text, numeric) = string.split_at(split_point);
    • let next = numeric
    • .parse()
    • .map(|n: u128| n + 1)
    • .unwrap_or(1);
    • let next = numeric.parse().unwrap_or(0) + 1;
    • format!("{text}{next:>0width$}", width=numeric.len())
    • }
pearcebasmanmvs.Jeddi212

Is n divisible by x and y?

Code
Diff
  • pub fn is_divisible(n: i32, x: i32, y: i32) -> bool {
    n % x == 0 && n % y == 0
}
    • pub fn is_divisible(n: i32, x: i32, y:i32) -> bool {
    • match (n % x == 0, n % y == 0) {
    • (true, true) => true,
    • _ => false
    • }
    • pub fn is_divisible(n: i32, x: i32, y: i32) -> bool {
    • n % x == 0 && n % y == 0
    • }
pearcebasmanmvs.ojeriejire

String to math operation

Strings
Mathematics
Parsing
Code
Diff
  • fn math(expression: &str) -> Result<i32, MathError> {
    // remove whitespace
    let expression: String = expression.chars().filter(|ch| !ch.is_whitespace()).collect();
    
    // get operator
    let mut operators = expression.chars().filter(|ch| ['+', '-', '*', '/', '='].contains(&ch));
    let operator = operators.next().ok_or(MathError::MissingOperator)?;
    if operators.next().is_some() {
        return Err(MathError::SurplusOperator);
    }
    
    // get operands
    let (num1, num2) = expression.split_once(operator).unwrap(); // a single operator guarantees two split sections
    let (Ok(num1), Ok(num2)) = (num1.parse::<i32>(), num2.parse::<i32>()) else {
        return Err(MathError::InvalidOperand);
    };
    
    // Cleaner but currently unstable
    // let [num1, num2] = [num1, num2].try_map(str::parse::<i32>).map_err(|_| MathError::InvalidOperand)?;
    
    // perform operation
    Ok(match operator {
        '+' => num1.checked_add(num2).ok_or(MathError::Overflow)?,
        '-' => num1 - num2, // underflow impossible without negative numbers
        '*' => num1.checked_mul(num2).ok_or(MathError::Overflow)?,
        '/' => num1.checked_div(num2).ok_or(MathError::DivideByZero)?,
        '=' => (num1 == num2).into(),
        _ => unreachable!()
    })
}

#[derive(Debug, PartialEq, Eq)]
enum MathError {
    MissingOperator,
    SurplusOperator,
    InvalidOperand,
    DivideByZero,
    Overflow,
}
    • fn math(expression: &str) -> Result<i32, MathError> {
    • // remove whitespace
    • let expression: String = expression.chars().filter(|ch| !ch.is_whitespace()).collect();
    • let operator: char = expression.chars().find(|ch| ['+', '-', '*', '/', '='].contains(&ch)).ok_or(MathError::MissingOperator)?;
    • // converting each string slice to an integer
    • let mut operands = expression.split(operator).filter_map(|n| n.parse::<i32>().ok());
    • let num1 = operands.next().ok_or(MathError::InvalidOperand)?;
    • let num2 = operands.next().ok_or(MathError::InvalidOperand)?;
    • // divide by zero check
    • if operator == '/' && num2 == 0 {
    • return Err(MathError::DivideByZero);
    • // get operator
    • let mut operators = expression.chars().filter(|ch| ['+', '-', '*', '/', '='].contains(&ch));
    • let operator = operators.next().ok_or(MathError::MissingOperator)?;
    • if operators.next().is_some() {
    • return Err(MathError::SurplusOperator);
    • }
    • let res: Option<i32> = match operator {
    • '+' => num1.checked_add(num2),
    • '-' => num1.checked_sub(num2),
    • '*' => num1.checked_mul(num2),
    • '/' => num1.checked_div(num2),
    • '=' => Some((num1 == num2).into()),
    • _ => unreachable!()
    • // get operands
    • let (num1, num2) = expression.split_once(operator).unwrap(); // a single operator guarantees two split sections
    • let (Ok(num1), Ok(num2)) = (num1.parse::<i32>(), num2.parse::<i32>()) else {
    • return Err(MathError::InvalidOperand);
    • };
    • return res.ok_or(MathError::Overflow);
    • // Cleaner but currently unstable
    • // let [num1, num2] = [num1, num2].try_map(str::parse::<i32>).map_err(|_| MathError::InvalidOperand)?;
    • // perform operation
    • Ok(match operator {
    • '+' => num1.checked_add(num2).ok_or(MathError::Overflow)?,
    • '-' => num1 - num2, // underflow impossible without negative numbers
    • '*' => num1.checked_mul(num2).ok_or(MathError::Overflow)?,
    • '/' => num1.checked_div(num2).ok_or(MathError::DivideByZero)?,
    • '=' => (num1 == num2).into(),
    • _ => unreachable!()
    • })
    • }
    • use MathError::*;
    • #[derive(Debug, PartialEq, Eq)]
    • enum MathError {
    • MissingOperator,
    • SurplusOperator,
    • InvalidOperand,
    • DivideByZero,
    • Overflow,
    • }
vldnvskvs.elendil7

JavaScript Foundations: Variables: Values of Data in Everyday Life

Code
Diff
  • yearlyElectricCosts=(...c)=>(r=>+`${r[0]}.${r[1].slice(0,2)}`)((''+c.reduce((a,b)=>a+b)).split`.`)
    • yearlyElectricCosts=(...c)=>(r=>+`${r[0]}.${r[1].slice(0,2)}`)((``+c.reduce((a,b)=>a+b)).split`.`)
    • yearlyElectricCosts=(...c)=>(r=>+`${r[0]}.${r[1].slice(0,2)}`)((''+c.reduce((a,b)=>a+b)).split`.`)