Begin a new Kumite
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.
We can use recursion because the size of long is limited
Also we could combine two methods like this:
f(x) => x == 0 ? 0 : x < 0 ? f(-x) : x % 10 + f(x / 10);
or even multiply by the signum of x on each iteration:
(x >> sizeof(long) * 8 - 1 << 1) + 1
but it is a bit slower.
using System; using System.Linq; using System.Collections.Generic; namespace Kumite { public class Problem { public static long SignedSumDigitsOf(long x) => x == 0 ? 0 : x % 10 + SignedSumDigitsOf(x / 10); public static long SumDigitsOf(long x) => SignedSumDigitsOf(x) * Math.Sign(x); } }1 1 using System; 2 2 using System.Linq; 3 3 using System.Collections.Generic; 4 4 5 5 namespace Kumite 6 6 { 7 − public class Problem 8 − { 9 − public static int SumDigitsOf(long integer) => 10 − Array.ConvertAll(integer.ToString().TrimStart('-').ToCharArray(), 11 − c => (int)Char.GetNumericValue(c)).Sum(); 12 − } 7 + public class Problem 8 + { 9 + public static long SignedSumDigitsOf(long x) => 10 + x == 0 ? 0 : x % 10 + SignedSumDigitsOf(x / 10); 11 + 12 + public static long SumDigitsOf(long x) => 13 + SignedSumDigitsOf(x) * Math.Sign(x); 14 + } 13 13 }
Given an array containing only 0s, 1s, and 2s;
sort the array in ascending order.
from __future__ import annotations from collections import Counter def sort_values(vals:list[int]) -> list[int]: #Given an array of size N containing only 0s, 1s, and 2s; #sort the array in ascending order. assert set(vals) <= {0,1,2} return counting_sort(vals) # O(n+k) instead of n log(n) def counting_sort(vals:list[T]) -> list[T]: res = [] c = Counter(vals) for k,amt in sorted(c.items()): res += [k]*amt return res1 − import java.util.Arrays; 2 − public class Kata { 3 − public static int[] sortValues(int[] my_array, int size) { 4 − // Given an array of size N containing only 0s, 1s, and 2s; 5 − // sort the array in ascending order. 6 − Arrays.sort(my_array); 7 − return my_array; 8 − } 9 − } 1 + from __future__ import annotations 2 + from collections import Counter 3 + 4 + def sort_values(vals:list[int]) -> list[int]: 5 + #Given an array of size N containing only 0s, 1s, and 2s; 6 + #sort the array in ascending order. 7 + assert set(vals) <= {0,1,2} 8 + return counting_sort(vals) 9 + # O(n+k) instead of n log(n) 10 + 11 + def counting_sort(vals:list[T]) -> list[T]: 12 + res = [] 13 + c = Counter(vals) 14 + for k,amt in sorted(c.items()): 15 + res += [k]*amt 16 + return res
test.assert_equals(sort_values( [0,0,2,0,1,1,2,0]), [0,0,0,0,1,1,2,2] ) test.assert_equals(sort_values([2, 0, 1, 2]), [0, 1, 2, 2])1 − import org.junit.jupiter.api.Test; 2 − import static org.junit.jupiter.api.Assertions.assertArrayEquals; 1 + test.assert_equals(sort_values( [0,0,2,0,1,1,2,0]), [0,0,0,0,1,1,2,2] ) 2 + test.assert_equals(sort_values([2, 0, 1, 2]), [0, 1, 2, 2]) 3 3 4 − // TODO: Replace examples and use TDD by writing your own tests 5 − 6 − class SolutionTest { 7 − @Test 8 − void testSomething() { 9 − int[] inputArray = {0,0,2,0,1,1,2,0}; 10 − int[] expectedArray = {0,0,0,0,1,1,2,2}; 11 − assertArrayEquals(expectedArray, Kata.sortValues(inputArray, 8)); 12 − } 13 − 14 − @Test 15 − void testSomethingElse() { 16 − int[] inputArray = {2, 0, 1, 2}; 17 − int[] expectedArray = {0, 1, 2, 2}; 18 − assertArrayEquals(expectedArray, Kata.sortValues(inputArray, 8)); 19 − } 20 − }
Recent Moves:
import java.util.Arrays; public class Kata { public static int[] sortValues(int[] my_array, int size) { // Given an array of size N containing only 0s, 1s, and 2s; // sort the array in ascending order. Arrays.sort(my_array); return my_array; } }1 + import java.util.Arrays; 1 1 public class Kata { 2 2 public static int[] sortValues(int[] my_array, int size) { 3 3 // Given an array of size N containing only 0s, 1s, and 2s; 4 4 // sort the array in ascending order. 5 − int[] returnArray = {0,0,0,0,1,1,2,2}; 6 − return returnArray; 6 + Arrays.sort(my_array); 7 + return my_array; 7 7 } 8 8 }
public class Kata { public static int findIndex (int[] my_array, int t) { for(int i=0; i< my_array.length; i++){ if(my_array[i]==t){ return i; } } return 4; } }1 1 public class Kata { 2 2 public static int findIndex (int[] my_array, int t) { 3 − // Find the index of t 4 − return 4; 3 + for(int i=0; i< my_array.length; i++){ 4 + if(my_array[i]==t){ 5 + return i; 6 + } 7 + 8 + } 9 + return 4; 5 5 } 11 + 6 6 }
import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; class SolutionTest { @Test void testSomething() { int[] randomArray = {1, 2, 5, 7,10 }; assertEquals(4, Kata.findIndex(randomArray, 10)); } }1 1 import org.junit.jupiter.api.Test; 2 2 import static org.junit.jupiter.api.Assertions.assertEquals; 3 3 4 − // TODO: Replace examples and use TDD by writing your own tests 5 5 6 6 class SolutionTest { 7 7 @Test 8 8 void testSomething() { 9 − int[] randomArray = {1, 2, 5, 7}; 10 − assertEquals(2, Kata.findIndex(randomArray, 5)); 8 + int[] randomArray = {1, 2, 5, 7,10 }; 9 + assertEquals(4, Kata.findIndex(randomArray, 10)); 11 11 } 12 12 }
import java.util.stream.IntStream; public class Adder { public static int AddAllContent(int[] numbersToAdd) { int sum = IntStream.of(numbersToAdd).sum(); return sum; } }1 − public class Adder { 2 − 3 − public static int AddAllContent(int[] numbersToAdd) { 4 − int sum = 0; 5 − 6 − for (int i : numbersToAdd) 7 − sum += i; 8 − 9 − return sum; 1 + import java.util.stream.IntStream; 2 + public class Adder 3 + { 4 + public static int AddAllContent(int[] numbersToAdd) 5 + { 6 + int sum = IntStream.of(numbersToAdd).sum(); 7 + 8 + return sum; 10 10 } 11 11 }
Removed redundant zeroing.
global double_multiplication section .text double_multiplication: mov rax,rdi mul rsi ret1 1 global double_multiplication 2 2 section .text 3 3 double_multiplication: 4 − xor rdx,rdx 5 5 mov rax,rdi 6 6 mul rsi 7 7 ret
#include <stdio.h> #include <criterion/criterion.h> int double_multiplication(int a, int b); Test(add_test, should_multiply_integers) { cr_assert_eq(double_multiplication(1, 1), 1); cr_assert_eq(double_multiplication(2, 1), 2); cr_assert_eq(double_multiplication(3, 1), 3); cr_assert_eq(double_multiplication(1, 2), 2); cr_assert_eq(double_multiplication(3, 3), 9); }1 1 #include <stdio.h> 2 2 #include <criterion/criterion.h> 3 3 4 4 int double_multiplication(int a, int b); 5 − Test(add_test, should_add_integers) { 5 + Test(add_test, should_multiply_integers) { 6 6 cr_assert_eq(double_multiplication(1, 1), 1); 7 + cr_assert_eq(double_multiplication(2, 1), 2); 8 + cr_assert_eq(double_multiplication(3, 1), 3); 9 + cr_assert_eq(double_multiplication(1, 2), 2); 10 + cr_assert_eq(double_multiplication(3, 3), 9); 7 7 }
Macro on conditional moves (only one here though).
It works in theory (probably will fail if %2 is rax).
; A macro with two parameters ; Implements actual int max(int a, int b) %macro _max 2 mov rax, %1 cmp %2, %1 ; compare a ?= b cmovg rax, %2 ret %endmacro section .text global max ; declaring int max(int a, int b) max: _max rdi, rsi ; using inner _max macro ret1 1 ; A macro with two parameters 2 2 ; Implements actual int max(int a, int b) 3 3 %macro _max 2 4 + mov rax, %1 4 4 cmp %2, %1 ; compare a ?= b 5 − jle _lower ; jump to lower if a <= b 6 − jmp _greater ; jump to greater if a > b 7 − 8 − _lower: 9 − mov rax, %1 ; assgine rax to b 10 − jmp _end ; end program 11 − _greater: 12 − mov rax, %2 ; assgine rax to a 13 − _end: 6 + cmovg rax, %2 14 14 ret 15 − 16 16 %endmacro 17 17 18 18 section .text 19 19 global max ; declaring int max(int a, int b) 20 20 21 21 max: 22 22 _max rdi, rsi ; using inner _max macro 23 23 ret
#include <criterion/criterion.h> int max(int, int); Test(max, should_return_max) { cr_assert_eq(max(3, 2), 3); cr_assert_eq(max(2, 3), 3); cr_assert_eq(max(3, 3), 3); }1 1 #include <criterion/criterion.h> 2 2 int max(int, int); 3 3 Test(max, should_return_max) { 4 4 cr_assert_eq(max(3, 2), 3); 5 + cr_assert_eq(max(2, 3), 3); 6 + cr_assert_eq(max(3, 3), 3); 5 5 } 6 −
Made a branchless variant (but now there is a data dependency).
Extended tests; added transformation outputs.
section .text global changeCase changeCase: mov ax, di ; load default answer (unmodified character) to ax mov cx, di xor cx, 32 ; load modified answer (with changed case) to cx and di, 95 ; normalize value (bring everything to upper case (destroys non alpha characters, but it is irrelevant)) sub di, 65 cmp di, 26 ; check if it is an alphabetical symbol (in range 65-90,97-122) cmovb ax, cx ; if it is - replace the answer by the modified one (with changed case) ret1 1 section .text 2 2 global changeCase 3 3 4 4 changeCase: 5 − mov ax,di 6 − sub di,0x41 ; di -= 'A' 7 − cmp di,0x7a-0x41 ; 'z' - 'A' 8 − ja _ 9 − sub di,0x5a-0x41 ; di -= 'Z' - 'A' 10 − cmp di,0x61-0x5a ; 'a' - 'Z' 11 − jb _ 12 − xor ax,0x20 13 − _: 5 + mov ax, di ; load default answer (unmodified character) to ax 6 + 7 + mov cx, di 8 + xor cx, 32 ; load modified answer (with changed case) to cx 9 + 10 + and di, 95 ; normalize value (bring everything to upper case (destroys non alpha characters, but it is irrelevant)) 11 + sub di, 65 12 + cmp di, 26 ; check if it is an alphabetical symbol (in range 65-90,97-122) 13 + 14 + cmovb ax, cx ; if it is - replace the answer by the modified one (with changed case) 14 14 ret
#include <criterion/criterion.h> char changeCase(char letter); void do_one_test(char input, char expected) { char actual = changeCase(input); printf("'%c' -> '%c' should be '%c'\n", input, actual, expected); cr_assert_eq(actual, expected); } Test(changeCase, should_change_the_char_case) { char *input = " !\"$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^-`abcdefghijklmnopqrstuvwxyz{|}~", *expect = " !\"$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\\]^-`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~"; while (*input) do_one_test(*input++, *expect++); }1 1 #include <criterion/criterion.h> 2 2 3 3 char changeCase(char letter); 4 4 5 + void do_one_test(char input, char expected) 6 + { 7 + char actual = changeCase(input); 8 + printf("'%c' -> '%c' should be '%c'\n", input, actual, expected); 9 + cr_assert_eq(actual, expected); 10 + } 11 + 5 5 Test(changeCase, should_change_the_char_case) { 6 − cr_expect(changeCase('a') == 'A'); 7 − cr_expect(changeCase('q') == 'Q'); 8 − cr_expect(changeCase('T') == 't'); 9 − cr_expect(changeCase('z') == 'Z'); 10 − cr_expect(changeCase('@') == '@'); 11 − cr_expect(changeCase('1') == '1'); 12 − cr_expect(changeCase('^') == '^'); 13 − 14 − cr_expect(changeCase('{') == '{'); 13 + char *input = " !\"$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^-`abcdefghijklmnopqrstuvwxyz{|}~", 14 + *expect = " !\"$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\\]^-`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~"; 15 + while (*input) 16 + do_one_test(*input++, *expect++); 15 15 }