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.
const firstNonRepeatingCharacter = (str) => { const charCount = {}; for (const char of str) { charCount[char] = (charCount[char] || 0) + 1; } for (const char of str) { if (charCount[char] === 1) { return char; } } return null; };- const firstNonRepeatingCharacter = (str) => {
for (let i = 0; i < str.length; i++) {let seenDuplicate = false;for (let j = 0; j < str.length; j++) {if (str[i] === str[j] && i !== j) {seenDuplicate = true;break;}}if (!seenDuplicate) {return str[i];- const charCount = {};
- for (const char of str) {
- charCount[char] = (charCount[char] || 0) + 1;
- }
- for (const char of str) {
- if (charCount[char] === 1) {
- return char;
- }
- }
return null; // return null if no unique character is found- return null;
- };
const nums = [ {0 : "zero"}, {1 : "one"}, {2 : "two"}, {3 : "three"}, {4 : "four"}, {5 : "five"}, {6 : "six"}, {7 : "seven"}, {8 : "eight"}, {9 : "nine"} ] function digitToText(digit) { if(digit > 9 || digit < 0){ return undefined }else{ return nums[digit][digit] } }const nums = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']- const nums = [
- {0 : "zero"},
- {1 : "one"},
- {2 : "two"},
- {3 : "three"},
- {4 : "four"},
- {5 : "five"},
- {6 : "six"},
- {7 : "seven"},
- {8 : "eight"},
- {9 : "nine"}
- ]
- function digitToText(digit) {
return nums[digit]- if(digit > 9 || digit < 0){
- return undefined
- }else{
- return nums[digit][digit]
- }
- }
fn reverse(mut n: u32) -> u32 { let mut reversed = 0; while n > 0 { reversed *= 10; reversed += n % 10; n /= 10; } reversed }public class Algorithms {public static int reverseInt(int n) {int reversed = 0;while(n != 0){reversed = reversed * 10 + (n % 10);n /= 10;- fn reverse(mut n: u32) -> u32 {
- let mut reversed = 0;
- while n > 0 {
- reversed *= 10;
- reversed += n % 10;
- n /= 10;
- }
return reversed;}}- reversed
- }
#[test] fn test() { assert_eq!(reverse(12345), 54321); }import org.junit.Test;import static org.junit.Assert.assertEquals;import org.junit.runners.JUnit4;// TODO: Replace examples and use TDD development by writing your own testspublic class SolutionTest {@Testpublic void reverseIntTest() {assertEquals(54321, Algorithms.reverseInt(12345));}- #[test]
- fn test() {
- assert_eq!(reverse(12345), 54321);
- }
#include <vector> using namespace std; int result ( vector <int> sum ) { if ( sum.size() == 0 ) return 0; int somma_totale = 0; for ( int i = 0; i < sum.size(); i++ ) { somma_totale = somma_totale + sum[i]; } return somma_totale; }def sum(arr):result = 0for i in arr:result += ireturn result- #include <vector>
- using namespace std;
- int result ( vector <int> sum ) {
- if ( sum.size() == 0 )
- return 0;
- int somma_totale = 0;
- for ( int i = 0; i < sum.size(); i++ ) {
- somma_totale = somma_totale + sum[i];
- } return somma_totale;
- }
Fundamentals
fn is_odd(input: i32) -> bool { input % 2 == 1 }public static class Kata{public static bool IsOdd(int input){return ((input % 10 == 1) || (input % 10 == 3) || (input % 10 == 5) || (input % 10 == 7) || (input % 10 == 9));}- fn is_odd(input: i32) -> bool {
- input % 2 == 1
- }
#[test] fn test() { assert!(is_odd(1)); assert!(is_odd(3)); assert!(!is_odd(2)); assert!(!is_odd(18284)); }namespace Solution {using NUnit.Framework;using System;// TODO: Replace examples and use TDD by writing your own tests[TestFixture]public class SolutionTest{[Test]public void MyTest(){Assert.AreEqual(true, Kata.IsOdd(1));Assert.AreEqual(false, Kata.IsOdd(2));Assert.AreEqual(true, Kata.IsOdd(13));Assert.AreEqual(false, Kata.IsOdd(18284));}}}- #[test]
- fn test() {
- assert!(is_odd(1));
- assert!(is_odd(3));
- assert!(!is_odd(2));
- assert!(!is_odd(18284));
- }
function нечетное(число) { if (число%2!=0){ return true } else { return false } } function sumNechet(a, b) { let sum=0 for(slag=a;slag<=b;slag++){ if (нечетное(slag)){ sum+=slag } } return (sum) }function sumNechet(a, b) {}- function нечетное(число) {
- if (число%2!=0){
- return true
- }
- else {
- return false
- }
- }
- function sumNechet(a, b) {
- let sum=0
- for(slag=a;slag<=b;slag++){
- if (нечетное(slag)){
- sum+=slag
- }
- }
}- return (sum)
- }
why not
function rps(player1, player2) { const rules = { 'rock': { killer: 'paper' }, 'paper': { killer: 'scissors' }, 'scissors': { killer: 'rock' }, }; if (rules[player1].killer === player2) { return 'Player 2 won!'; } if (rules[player2].killer === player1) { return 'Player 1 won!'; } return 'Draw!'; }- function rps(player1, player2) {
return player1 == player2 ? 'Draw!' :player1 == 'rock' && player2 == 'scissors' ||player1 == 'scissors' && player2 == 'paper' ||player1 == 'paper' && player2 == 'rock' ? 'Player 1 won!' : 'Player 2 won!';- const rules = {
- 'rock': {
- killer: 'paper'
- },
- 'paper': {
- killer: 'scissors'
- },
- 'scissors': {
- killer: 'rock'
- },
- };
- if (rules[player1].killer === player2) {
- return 'Player 2 won!';
- }
- if (rules[player2].killer === player1) {
- return 'Player 1 won!';
- }
- return 'Draw!';
- }