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.
basically refactored
def max_sequence(arr): # Code to find maximum sum of subarray sum_b = sum(arr) for i in range(len(arr)): for k in range(len(arr)-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)- sum_b = sum(arr)
for i in range(l_a):for k in range(l_a-i+1):- for i in range(len(arr)):
- for k in range(len(arr)-i+1):
- sum_c = sum(arr[k:k+i])
- if sum_c > sum_b: sum_b = sum_c
- return(sum_b)
.IsUpper() returns bools for you
public static class Kata { public static int SameCase(char a, char b) { if (char.IsLetter(a) && char.IsLetter(b)) { if (char.IsUpper(a) == char.IsUpper(b)) { return 1; } else { return 0; } } return -1; } }
- public static class Kata
- {
- public static int SameCase(char a, char b) {
bool areBothCharsLetter = char.IsLetter(a) && char.IsLetter(b);bool areSameLetters = char.IsUpper(a) == char.IsUpper(b);if (areBothCharsLetter)- if (char.IsLetter(a) && char.IsLetter(b))
- {
if (areSameLetters)- if (char.IsUpper(a) == char.IsUpper(b))
- {
- return 1;
- }
- else
{- {
- return 0;
- }
- }
- return -1;
- }
- }
Rewrote in Rust using match and enum language features. I find it more elegant, save that floating-point values can't be coerced from integer literals and must be explicitly written as a floating-point literal.
Sorting when there are two roots was not strictly necessary, but made test cases easier to grok.
use std::cmp::Ordering; #[derive(Debug, PartialEq)] enum Roots { None, One(f64), Two(f64, f64) } fn quadratic_formula(a: f64, b: f64, c: f64) -> Roots { let delta = b * b - 4.0 * a * c; match delta.partial_cmp(&0.0).unwrap() { Ordering::Less => Roots::None, Ordering::Equal => Roots::One(-b / (2.0 * a)), Ordering::Greater => { let s1 = (-b + delta.sqrt()) / (2.0 * a); let s2 = (-b - delta.sqrt()) / (2.0 * a); Roots::Two(s1.min(s2), s1.max(s2)) } } }
//IamQuan :3- use std::cmp::Ordering;
//Libraly#include<iostream>#include <math.h>using namespace std;//Code//Ham Phu de goi an cho a b cdouble GoiAn(){double ABC{};std::cin >> ABC;return ABC;- #[derive(Debug, PartialEq)]
- enum Roots {
- None,
- One(f64),
- Two(f64, f64)
- }
//Codeint main(){//Khai bao cho DKint A{};//Khai bao cho tinh toandouble x1, x2;//--------------------------------------------------// User nhap a b ccout << "Chuong trinh tinh phuong trinh bac 2 mot an\n";cout << "Vui long nhap cac he so a , b , c\n";cout << "---------------------------------------------" << endl;//Nhap he so acout << "Nhap he so a: " ;double a{GoiAn()};//Dieu kienwhile (a == 0 && A < 1000){cout << "Phuong trinh da chuyen ve \nphuong trinh bac nhat mot an" << endl;cout << "Ban co muon nhap lai ham so a ?\nNeu muon thi nhap lai.\na:" << endl;cin >> a;A++;}//Nhap he so bcout << "Nhap he so b: ";double b{ GoiAn() };//Nhap he so ccout << "Nhap he so c: ";double c{ GoiAn() };// Thong bao cho usercout << "Dang tinh delta va nghiem ......." << endl;//Khai bao Deltadouble delta{ (b * b) - 4 * a * c };//Tinh deltaif (delta < 0){cout << "Delta = " << delta << "\n";cout << " => Phuong trinh vo nghiem " << endl;}else if (delta == 0){cout << "Delta = " << delta << "\n";cout << " => Phuong trinh co nghiem kep " << endl;}else if (delta > 0){cout << "Delta = " << delta << "\n";cout << " => Phuong trinh co 2 nghiem phan biet " << endl;}cout << "\n\n";//Tinh nghiemif (delta > 0){x1 = (-b - sqrt(delta)) / (2 * a);x2 = (-b + sqrt(delta)) / (2 * a);cout << "Nghiem cua phuong trinh la: \n";cout << "x1 = " << x1 << endl;cout << "x2 = " << x2 << endl;}else if (delta == 0) {x1 = x2 = -b / (2 * a);cout << "Nghiem cua phuong trinh la: \n";cout << "x1 = x2 = " << x1 << endl;}else{cout << "Vi phuong trinh vo nghiem nen khong co nghiem" << endl;}system("pause");return 0;- fn quadratic_formula(a: f64, b: f64, c: f64) -> Roots {
- let delta = b * b - 4.0 * a * c;
- match delta.partial_cmp(&0.0).unwrap() {
- Ordering::Less => Roots::None,
- Ordering::Equal => Roots::One(-b / (2.0 * a)),
- Ordering::Greater => {
- let s1 = (-b + delta.sqrt()) / (2.0 * a);
- let s2 = (-b - delta.sqrt()) / (2.0 * a);
- Roots::Two(s1.min(s2), s1.max(s2))
- }
- }
- }
#[cfg(test)] mod tests { use super::*; #[test] fn test_no_roots() { assert_eq!(quadratic_formula(1.0, 0.0, 2.0), Roots::None); assert_eq!(quadratic_formula(-10.5, 3.0, -2.0), Roots::None); } #[test] fn test_one_root() { assert_eq!(quadratic_formula(2.5, 0.0, 0.0), Roots::One(0.0)); assert_eq!(quadratic_formula(-1.0, -2.0, -1.0), Roots::One(-1.0)); } #[test] fn test_two_roots() { assert_eq!(quadratic_formula(2.5, 0.0, -10.0), Roots::Two(-2.0, 2.0)); assert_eq!(quadratic_formula(-6.0, 4.0, 2.0), Roots::Two(-1.0/3.0, 1.0)); } }
- #[cfg(test)]
- mod tests {
- use super::*;
- #[test]
- fn test_no_roots() {
- assert_eq!(quadratic_formula(1.0, 0.0, 2.0), Roots::None);
- assert_eq!(quadratic_formula(-10.5, 3.0, -2.0), Roots::None);
- }
- #[test]
- fn test_one_root() {
- assert_eq!(quadratic_formula(2.5, 0.0, 0.0), Roots::One(0.0));
- assert_eq!(quadratic_formula(-1.0, -2.0, -1.0), Roots::One(-1.0));
- }
- #[test]
- fn test_two_roots() {
- assert_eq!(quadratic_formula(2.5, 0.0, -10.0), Roots::Two(-2.0, 2.0));
- assert_eq!(quadratic_formula(-6.0, 4.0, 2.0), Roots::Two(-1.0/3.0, 1.0));
- }
- }
Translation to Python??
def other_angle(a, b): req_angle = 180 - (a + b) return req_angle
fn other_angle(a: u32, b: u32) -> u32 {180 - (a + b)}- def other_angle(a, b):
- req_angle = 180 - (a + b)
- return req_angle
import codewars_test as test @test.describe("tests") def fixed_tests(): @test.it('test cases') def basic_test_cases(): test.assert_equals(other_angle(30, 60), 90) test.assert_equals(other_angle(60, 60), 60) test.assert_equals(other_angle(43, 78), 59) test.assert_equals(other_angle(10, 20), 150) test.assert_equals(other_angle(110, 30), 40) test.assert_equals(other_angle(100, 40), 40)
#[test]fn test() {assert_eq!(other_angle(30, 60), 90);assert_eq!(other_angle(60, 60), 60);assert_eq!(other_angle(43, 78), 59);assert_eq!(other_angle(10, 20), 150);}- import codewars_test as test
- @test.describe("tests")
- def fixed_tests():
- @test.it('test cases')
- def basic_test_cases():
- test.assert_equals(other_angle(30, 60), 90)
- test.assert_equals(other_angle(60, 60), 60)
- test.assert_equals(other_angle(43, 78), 59)
- test.assert_equals(other_angle(10, 20), 150)
- test.assert_equals(other_angle(110, 30), 40)
- test.assert_equals(other_angle(100, 40), 40)
fn parse_quaternion(quaternion: &str) -> [f64; 4] { let mut iter = quaternion.chars().filter(|&c| c != ' ').peekable(); let mut terms = Vec::new(); while let Some(first) = iter.next() { let mut term = first.to_string(); while iter.peek().map_or(false, |&c| !"+-".contains(c)) { term.push(iter.next().unwrap()); } terms.push(term); } let mut real = 0.0; let mut imaginary = 0.0; let mut jmaginary = 0.0; let mut kmaginary = 0.0; for term in terms { match term.chars().last().unwrap() { 'i' => imaginary += parse_term(&term), 'j' => jmaginary += parse_term(&term), 'k' => kmaginary += parse_term(&term), _ => real += parse_term(&term) } } [real, imaginary, jmaginary, kmaginary] } fn parse_term(mut term: &str) -> f64 { if term.chars().last().map_or(false, |c| c.is_ascii_alphabetic()) { term = &term[..term.len()-1]; if !term.chars().any(|c| c.is_ascii_digit()) { return format!("{term}1").parse().unwrap(); } } term.parse().unwrap() }
#include <array>#include <string>#include <regex>#include <algorithm>std::array<float, 4> ParseQuaternion(const std::string& t_quaternion){std::smatch matches;std::regex realCompPattern("(-?)([0-9.]+)*[^ijk]([+]|-|$)");std::regex_search(t_quaternion, matches, realCompPattern);float w = matches.empty() ? 0 : std::stof(matches[0]);auto g = [&](const std::string& t_letter) -> float {const std::regex pattern(R"((-?)([ (0-9).]+)?)" + t_letter);std::string result;if (std::regex_search(t_quaternion, matches, pattern)){if (matches[2].matched && matches[2] != " "){auto matchStr = matches[2].str();matchStr.erase(std::remove(matchStr.begin(), matchStr.end(), ' '), matchStr.end());result = matches[1].str() + matchStr;}else{result = matches[1].str() + "1";}- fn parse_quaternion(quaternion: &str) -> [f64; 4] {
- let mut iter = quaternion.chars().filter(|&c| c != ' ').peekable();
- let mut terms = Vec::new();
- while let Some(first) = iter.next() {
- let mut term = first.to_string();
- while iter.peek().map_or(false, |&c| !"+-".contains(c)) {
- term.push(iter.next().unwrap());
- }
else{result = "0";- terms.push(term);
- }
- let mut real = 0.0;
- let mut imaginary = 0.0;
- let mut jmaginary = 0.0;
- let mut kmaginary = 0.0;
- for term in terms {
- match term.chars().last().unwrap() {
- 'i' => imaginary += parse_term(&term),
- 'j' => jmaginary += parse_term(&term),
- 'k' => kmaginary += parse_term(&term),
- _ => real += parse_term(&term)
- }
return std::stof(result);};- }
- [real, imaginary, jmaginary, kmaginary]
- }
auto i = g("i");auto j = g("j");auto k = g("k");return { w, i, j, k };- fn parse_term(mut term: &str) -> f64 {
- if term.chars().last().map_or(false, |c| c.is_ascii_alphabetic()) {
- term = &term[..term.len()-1];
- if !term.chars().any(|c| c.is_ascii_digit()) {
- return format!("{term}1").parse().unwrap();
- }
- }
- term.parse().unwrap()
- }
#[test] fn test() { assert_eq!(parse_quaternion("1 + 2i + 3j + 4k"),[ 1.0, 2.0, 3.0, 4.0]); assert_eq!(parse_quaternion("-1 + 3i -3j+7k"), [ -1.0, 3.0, -3.0, 7.0]); assert_eq!(parse_quaternion("-1-4i-9j-2k"), [ -1.0, -4.0, -9.0, -2.0]); assert_eq!(parse_quaternion("17-16i-15j-14k"), [ 17.0, -16.0, -15.0, -14.0]); assert_eq!(parse_quaternion("7+2i"), [ 7.0, 2.0, 0.0, 0.0]); assert_eq!(parse_quaternion("2i-6k"), [ 0.0, 2.0, 0.0, -6.0]); assert_eq!(parse_quaternion("1-5j+2k"), [ 1.0, 0.0, -5.0, 2.0]); assert_eq!(parse_quaternion("3+4i-9k"), [ 3.0, 4.0, 0.0, -9.0]); assert_eq!(parse_quaternion("42i+j-k"), [ 0.0, 42.0, 1.0, -1.0]); assert_eq!(parse_quaternion("6-2i+j-3k"), [ 6.0, -2.0, 1.0, -3.0]); assert_eq!(parse_quaternion("1+i+j+k"), [ 1.0, 1.0, 1.0, 1.0]); assert_eq!(parse_quaternion("-1-i-j-k"), [ -1.0, -1.0, -1.0, -1.0]); assert_eq!(parse_quaternion("16k-20j+2i-7"), [ -7.0, 2.0, -20.0, 16.0]); assert_eq!(parse_quaternion("i+4k-3j+2"), [ 2.0, 1.0, -3.0, 4.0]); assert_eq!(parse_quaternion("5k-2i+9+3j"), [ 9.0, -2.0, 3.0, 5.0]); assert_eq!(parse_quaternion("5k-2j+3"), [ 3.0, 0.0, -2.0, 5.0]); assert_eq!(parse_quaternion("1.75-1.75i-1.75j-1.75k"), [1.75, -1.75, -1.75, -1.75]); assert_eq!(parse_quaternion("2.0j-3k+0.47i-13"),[-13.0, 0.47, 2.0, -3.0]); assert_eq!(parse_quaternion("5.6-3i"), [ 5.6, -3.0, 0.0, 0.0]); assert_eq!(parse_quaternion("k-7.6i"), [ 0.0, -7.6, 0.0, 1.0]); assert_eq!(parse_quaternion("0"), [ 0.0, 0.0, 0.0, 0.0]); assert_eq!(parse_quaternion("0j+0k"), [ 0.0, 0.0, 0.0, 0.0]); assert_eq!(parse_quaternion("-0j"), [ 0.0, 0.0, 0.0, 0.0]); assert_eq!(parse_quaternion("1-0k"), [ 1.0, 0.0, 0.0, 0.0]); }
// TODO: Replace examples and use TDD by writing your own testsDescribe(Quaternions){It(AllTests){Assert::That(ParseQuaternion("1 + 2i + 3j + 4k"), Equals(std::array<float, 4>{1, 2, 3, 4}));Assert::That(ParseQuaternion("-1 + 3i -3j+7k"), Equals(std::array<float, 4>{-1, 3, -3, 7}));Assert::That(ParseQuaternion("-1-4i-9j-2k"), Equals(std::array<float, 4>{-1, -4, -9, -2}));Assert::That(ParseQuaternion("17-16i-15j-14k"), Equals(std::array<float, 4>{17, -16, -15, -14}));Assert::That(ParseQuaternion("7+2i"), Equals(std::array<float, 4>{7, 2, 0, 0}));Assert::That(ParseQuaternion("2i-6k"), Equals(std::array<float, 4>{0, 2, 0, -6}));Assert::That(ParseQuaternion("1-5j+2k"), Equals(std::array<float, 4>{1, 0, -5, 2}));Assert::That(ParseQuaternion("3+4i-9k"), Equals(std::array<float, 4>{3, 4, 0, -9}));Assert::That(ParseQuaternion("42i+j-k"), Equals(std::array<float, 4>{0, 42, 1, -1}));Assert::That(ParseQuaternion("6-2i+j-3k"), Equals(std::array<float, 4>{6, -2, 1, -3}));Assert::That(ParseQuaternion("1+i+j+k"), Equals(std::array<float, 4>{1, 1, 1, 1}));Assert::That(ParseQuaternion("-1-i-j-k"), Equals(std::array<float, 4>{-1, -1, -1, -1}));Assert::That(ParseQuaternion("16k-20j+2i-7"), Equals(std::array<float, 4>{-7, 2, -20, 16}));Assert::That(ParseQuaternion("i+4k-3j+2"), Equals(std::array<float, 4>{2, 1, -3, 4}));Assert::That(ParseQuaternion("5k-2i+9+3j"), Equals(std::array<float, 4>{9, -2, 3, 5}));Assert::That(ParseQuaternion("5k-2j+3"), Equals(std::array<float, 4>{3, 0, -2, 5}));Assert::That(ParseQuaternion("1.75-1.75i-1.75j-1.75k"), Equals(std::array<float, 4>{1.75, -1.75, -1.75, -1.75}));Assert::That(ParseQuaternion("2.0j-3k+0.47i-13"), Equals(std::array<float, 4>{-13, 0.47, 2.0, -3}));Assert::That(ParseQuaternion("5.6-3i"), Equals(std::array<float, 4>{5.6, -3, 0, 0}));Assert::That(ParseQuaternion("k-7.6i"), Equals(std::array<float, 4>{0, -7.6, 0, 1}));Assert::That(ParseQuaternion("0"), Equals(std::array<float, 4>{0, 0, 0, 0}));Assert::That(ParseQuaternion("0j+0k"), Equals(std::array<float, 4>{0, 0, 0, 0}));Assert::That(ParseQuaternion("-0j"), Equals(std::array<float, 4>{0, 0, 0, 0}));Assert::That(ParseQuaternion("1-0k"), Equals(std::array<float, 4>{1, 0, 0, 0}));}};- #[test]
- fn test() {
- assert_eq!(parse_quaternion("1 + 2i + 3j + 4k"),[ 1.0, 2.0, 3.0, 4.0]);
- assert_eq!(parse_quaternion("-1 + 3i -3j+7k"), [ -1.0, 3.0, -3.0, 7.0]);
- assert_eq!(parse_quaternion("-1-4i-9j-2k"), [ -1.0, -4.0, -9.0, -2.0]);
- assert_eq!(parse_quaternion("17-16i-15j-14k"), [ 17.0, -16.0, -15.0, -14.0]);
- assert_eq!(parse_quaternion("7+2i"), [ 7.0, 2.0, 0.0, 0.0]);
- assert_eq!(parse_quaternion("2i-6k"), [ 0.0, 2.0, 0.0, -6.0]);
- assert_eq!(parse_quaternion("1-5j+2k"), [ 1.0, 0.0, -5.0, 2.0]);
- assert_eq!(parse_quaternion("3+4i-9k"), [ 3.0, 4.0, 0.0, -9.0]);
- assert_eq!(parse_quaternion("42i+j-k"), [ 0.0, 42.0, 1.0, -1.0]);
- assert_eq!(parse_quaternion("6-2i+j-3k"), [ 6.0, -2.0, 1.0, -3.0]);
- assert_eq!(parse_quaternion("1+i+j+k"), [ 1.0, 1.0, 1.0, 1.0]);
- assert_eq!(parse_quaternion("-1-i-j-k"), [ -1.0, -1.0, -1.0, -1.0]);
- assert_eq!(parse_quaternion("16k-20j+2i-7"), [ -7.0, 2.0, -20.0, 16.0]);
- assert_eq!(parse_quaternion("i+4k-3j+2"), [ 2.0, 1.0, -3.0, 4.0]);
- assert_eq!(parse_quaternion("5k-2i+9+3j"), [ 9.0, -2.0, 3.0, 5.0]);
- assert_eq!(parse_quaternion("5k-2j+3"), [ 3.0, 0.0, -2.0, 5.0]);
- assert_eq!(parse_quaternion("1.75-1.75i-1.75j-1.75k"), [1.75, -1.75, -1.75, -1.75]);
- assert_eq!(parse_quaternion("2.0j-3k+0.47i-13"),[-13.0, 0.47, 2.0, -3.0]);
- assert_eq!(parse_quaternion("5.6-3i"), [ 5.6, -3.0, 0.0, 0.0]);
- assert_eq!(parse_quaternion("k-7.6i"), [ 0.0, -7.6, 0.0, 1.0]);
- assert_eq!(parse_quaternion("0"), [ 0.0, 0.0, 0.0, 0.0]);
- assert_eq!(parse_quaternion("0j+0k"), [ 0.0, 0.0, 0.0, 0.0]);
- assert_eq!(parse_quaternion("-0j"), [ 0.0, 0.0, 0.0, 0.0]);
- assert_eq!(parse_quaternion("1-0k"), [ 1.0, 0.0, 0.0, 0.0]);
- }