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
NikolaiSchvs.NikolaiSch

suryavel's Kumite #2

Code
Diff
  • def max_sequence(arr):
    # Code to find maximum sum of subarray
	l_a = len(arr)
	sum_b = sum(arr)
	
	for i in range(l_a):
		for k in range(l_a-i+1):
			sum_c = sum(arr[k:k+i])
			if sum_c > sum_b: sum_b = sum_c
                
	return(sum_b)
    • def max_sequence(arr):
    • # Code to find maximum sum of subarray
    • l_a = len(arr)
    • counter = 0
    • for m in arr:
    • if m < 0:
    • counter = counter
    • else:
    • counter += 1
    • if counter == 0:
    • return(0)
    • sum_b = sum(arr)
    • for i in range(l_a):
    • if i == 0:
    • sum_b = sum(arr)
    • else:
    • for k in range(l_a-i+1):
    • sum_c = sum(arr[k:k+i])
    • if sum_c > sum_b: sum_b = sum_c
    • for k in range(l_a-i+1):
    • sum_c = sum(arr[k:k+i])
    • if sum_c > sum_b: sum_b = sum_c
    • return(sum_b)
Martk4346568vs.quanghuy2701

Reverse strings but python now

Fundamentals
Strings
Code
Diff
  • reverse_string = lambda string: string[::-1]
    • def reverse_string(string): return string[::-1]
    • reverse_string = lambda string: string[::-1]
doufless23vs.gabrielhom

Sum of the letters (ASCII)

Code
Diff
  • #include <string>
#include <numeric>
#include <algorithm>
#include <string_view>

class StringComparer {
public:
    static inline auto verifySum(std::string_view w1, std::string_view w2) -> bool {
        return sumOfCharacters(w1) == sumOfCharacters(w2);
    }
  
    static inline auto sumOfCharacters(std::string_view word) -> int {
        return std::accumulate(std::begin(word), std::end(word), 0, [](int sum,  char ch) {
            return sum + ch;
        });
    }
};
    • #include <string>
    • #include <numeric>
    • #include <algorithm>
    • #include <string_view>
    • class StringComparer {
    • public:
    • static inline auto verifySum(std::string_view w1, std::string_view w2) -> bool {
    • return sumOfCharacters(w1) == sumOfCharacters(w2);
    • }
    • static inline auto sumOfCharacters(std::string_view word) -> int {
    • return std::accumulate(std::begin(word), std::end(word), 0, [](int sum, const char ch) {
    • return sum + static_cast<int>(ch);
    • return std::accumulate(std::begin(word), std::end(word), 0, [](int sum, char ch) {
    • return sum + ch;
    • });
    • }
    • };
Pale-Vesselvs.Pale-Vessel

cool code

Code
Diff
  • def you_are_cool(n="Taki"):
    if not isinstance(n, str):
        return "Wait, so your name ISN'T a string of text?! That's wild!"
    n = n.strip()
    if not n:
        return "There is no name, so I'm not complimenting you. LOL"
    if len(n) > 100:
        return "Man, you have an insanely long name! Do people call you by your full name or just a nickname?"
    if n.isdigit():
        return "Are you sure? That looks like a number. Unless you're secretly a robot with a numerical name!"
    return f"Hello {n}, you are very cool!"
    
# edge case go BRRR
    • def you_are_cool(n="Taki"):
    • if not isinstance(n, str):
    • return "Wait, so your name ISN'T a string of text?! That's wild!"
    • n = n.strip()
    • if not n:
    • return "There is no name, so I'm not complimenting you. LOL"
    • elif len(n) > 100:
    • if len(n) > 100:
    • return "Man, you have an insanely long name! Do people call you by your full name or just a nickname?"
    • elif n.isdigit():
    • if n.isdigit():
    • return "Are you sure? That looks like a number. Unless you're secretly a robot with a numerical name!"
    • else:
    • return f"Hello {n}, you are very cool!"
    • return f"Hello {n}, you are very cool!"
    • # edge case go BRRR
pearcebasmanmvs.pearcebasmanm

Get determinant of matrix

Implement as trait

Code
Diff
  • pub trait Matrix {
    fn determinant(&self) -> i32;
    fn rows(&self) -> usize;
    fn cols(&self) -> usize;
    fn cofactor_matrix(&self, row: usize, col: usize) -> Self;
}

impl Matrix for Vec<Vec<i32>> {
   fn determinant(&self) -> i32 {
        if self.rows() == 2 && self.cols() == 2 {
            self[0][0] * self[1][1] - self[0][1] * self[1][0]
        } else {
            (0..self.cols()).map(|col| 
                (-1i32).pow(col as u32) * self[0][col] * self.cofactor_matrix(0, col).determinant()
            ).sum()
        }
    }
    
    fn rows(&self) -> usize {
        self.len()
    }
    
    fn cols(&self) -> usize {
        self[0].len()
    }
    
    fn cofactor_matrix(&self, row: usize, col: usize) -> Self {
        let mut cofactor = vec![vec![0;self.cols()-1];self.rows()-1];
        
        for (target_row, source_row) in (0..self.rows()).filter(|&n| n != row).enumerate() {
            for (target_col, source_col) in (0..self.cols()).filter(|&n| n != col).enumerate() {
                cofactor[target_row][target_col] = self[source_row][source_col];
            }
        }
        
        cofactor
    }
}
    • pub struct Matrix(Vec<Vec<i32>>);
    • pub trait Matrix {
    • fn determinant(&self) -> i32;
    • fn rows(&self) -> usize;
    • fn cols(&self) -> usize;
    • fn cofactor_matrix(&self, row: usize, col: usize) -> Self;
    • }
    • impl Matrix {
    • pub fn new(elements: Vec<Vec<i32>>) -> Self {
    • Self(elements)
    • }
    • pub fn determinant(&self) -> i32 {
    • impl Matrix for Vec<Vec<i32>> {
    • fn determinant(&self) -> i32 {
    • if self.rows() == 2 && self.cols() == 2 {
    • self.0[0][0] * self.0[1][1] - self.0[0][1] * self.0[1][0]
    • self[0][0] * self[1][1] - self[0][1] * self[1][0]
    • } else {
    • (0..self.cols())
    • .map(|col| (-1i32).pow(col as u32) * self.0[0][col] * self.cofactor_matrix(0, col).determinant())
    • .sum()
    • (0..self.cols()).map(|col|
    • (-1i32).pow(col as u32) * self[0][col] * self.cofactor_matrix(0, col).determinant()
    • ).sum()
    • }
    • }
    • fn rows(&self) -> usize {
    • self.0.len()
    • self.len()
    • }
    • fn cols(&self) -> usize {
    • self.0[0].len()
    • self[0].len()
    • }
    • fn cofactor_matrix(&self, row: usize, col: usize) -> Self {
    • let mut cofactor_inner = vec![vec![0;self.cols()-1];self.rows()-1];
    • let mut cofactor = vec![vec![0;self.cols()-1];self.rows()-1];
    • for (target_row, source_row) in (0..self.rows()).filter(|&n| n != row).enumerate() {
    • for (target_col, source_col) in (0..self.cols()).filter(|&n| n != col).enumerate() {
    • cofactor_inner[target_row][target_col] = self.0[source_row][source_col];
    • cofactor[target_row][target_col] = self[source_row][source_col];
    • }
    • }
    • Matrix::new(cofactor_inner)
    • cofactor
    • }
    • }
pearcebasmanmvs.GabyUnalaq

Numerical gradient of vector

Code
Diff
  • fn gradient(v: &[i32]) -> Vec<i32> {
    v.windows(2).map(|w| w[1] - w[0]).collect()
}
    • std::vector<int> gradient(const std::vector<int> &v) {
    • std::vector<int> dv;
    • for (int i = 1; i < int(v.size()); i++)
    • dv.push_back(v[i]-v[i-1]);
    • return dv;
    • fn gradient(v: &[i32]) -> Vec<i32> {
    • v.windows(2).map(|w| w[1] - w[0]).collect()
    • }
pearcebasmanmvs.ndorgu

Dead or Alive

Code
Diff
  • mod preloaded;
use preloaded::State;
use std::cmp::max;

fn dead_or_alive(human: (u32, u32), monster: (u32, u32), span: u32) -> State {
    if chebyshev_distance(human, monster) <= span {
        State::Dead
    } else {
        State::Alive
    }
}

fn chebyshev_distance(a: (u32, u32), b: (u32, u32)) -> u32 {
    max(a.0.abs_diff(b.0), a.1.abs_diff(b.1))
}
    • String DeadOrAlive(List<int> human, List<int> monster, int span) {
    • return ((monster[0] - human[0]).abs() <= span && (monster[1] - human[1]).abs() <= span) ? 'Dead!' : 'Alive!';
    • mod preloaded;
    • use preloaded::State;
    • use std::cmp::max;
    • fn dead_or_alive(human: (u32, u32), monster: (u32, u32), span: u32) -> State {
    • if chebyshev_distance(human, monster) <= span {
    • State::Dead
    • } else {
    • State::Alive
    • }
    • }
    • fn chebyshev_distance(a: (u32, u32), b: (u32, u32)) -> u32 {
    • max(a.0.abs_diff(b.0), a.1.abs_diff(b.1))
    • }
pearcebasmanmvs.lessonteacher

Codewars Array Run

Code
Diff
  • const ARRAY: [&str; 1] = ["codewars"];
    • var array = ['codewars'];
    • const ARRAY: [&str; 1] = ["codewars"];