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.
no need to assign strlen to a seperate variable, saved some cycles.
#include <stdlib.h> #include <string.h> #include <ctype.h> char *fun(const char *input) { char *result = malloc(strlen(input) + 1); char *p = result; while (*p++ = toupper(*input++)); return result; }- #include <stdlib.h>
- #include <string.h>
- #include <ctype.h>
char *fun(const char *input) {size_t len = strlen(input);char *result = malloc(len + 1);char *p = result;while ((*p++ = toupper(*input++)));return result;- char *fun(const char *input)
- {
- char *result = malloc(strlen(input) + 1);
- char *p = result;
- while (*p++ = toupper(*input++));
- return result;
- }
_Bool above_two(int *arg) { return *arg > 2 ? 1 : (*arg = 3, 0); }template<typename T>bool above_two(T& arg){static_assert(std::is_arithmetic<T>::value, "arg must be a arithmetic type");if(arg <= T(2)){arg = T(3);}return true;- _Bool above_two(int *arg)
- {
- return *arg > 2 ? 1 : (*arg = 3, 0);
- }
#include <criterion/criterion.h> _Bool above_two(int *arg); void tester(int arg) { cr_assert_eq(arg > 2, above_two(&arg)); cr_assert(arg > 2); } Test(example, test_case) { tester(0); tester(1); tester(2); tester(3); tester(4); tester(5); tester(6); tester(7); tester(8); tester(9); tester(10); }template<typename T>void tester(T arg){if(arg > 2){auto expected = arg;Assert::That(above_two(arg), Equals(true));Assert::That(arg, Equals(expected));}else{Assert::That(above_two(arg), Equals(true));Assert::That(arg, Is().GreaterThan(2));}- #include <criterion/criterion.h>
- _Bool above_two(int *arg);
- void tester(int arg)
- {
- cr_assert_eq(arg > 2, above_two(&arg));
- cr_assert(arg > 2);
- }
Describe(example)- Test(example, test_case)
- {
It(test_case_int){tester(0);tester(1);tester(2);tester(3);tester(4);tester(5);tester(6);tester(7);tester(8);tester(9);tester(10);}It(test_case_double){tester(0.0);tester(1.0);tester(2.0);tester(3.0);tester(4.0);tester(5.0);tester(6.0);tester(7.0);tester(8.0);tester(9.0);tester(10.0);}};- tester(0);
- tester(1);
- tester(2);
- tester(3);
- tester(4);
- tester(5);
- tester(6);
- tester(7);
- tester(8);
- tester(9);
- tester(10);
- }
Algorithms
Added memory ordering
Increment should just need relaxed, as it does not controll other states. It either keeps the potential object from being reclaimed, in which case there is no change, or the object is already reclaimed and you don't touch it anyway.
all else is more or less acq_rel to sync possible last access to an object, and it's destructor
#include <atomic> struct Counter { static constexpr uint64_t is_zero = 1ull << 63; static constexpr uint64_t helped = 1ull << 62; std::atomic<uint64_t> counter{1}; bool increment_if_not_zero(){ return (counter.fetch_add(1, std::memory_order_relaxed) & is_zero) == 0; } bool decrement(){ if(counter.fetch_sub(1, std::memory_order_acq_rel) == 1){ uint64_t e = 0; if(counter.compare_exchange_strong(e, is_zero, std::memory_order_acq_rel, std::memory_order_acquire)) return true; else if((e & helped) && (counter.exchange(is_zero, std::memory_order_acq_rel) & helped)) return true; } return false; } uint64_t read(){ auto val = counter.load(std::memory_order_acquire); if(val == 0 && counter.compare_exchange_strong(val, is_zero | helped, std::memory_order_acq_rel, std::memory_order_acquire)) return 0; return (val & is_zero) ? 0 : val; } };- #include <atomic>
- struct Counter {
- static constexpr uint64_t is_zero = 1ull << 63;
- static constexpr uint64_t helped = 1ull << 62;
- std::atomic<uint64_t> counter{1};
- bool increment_if_not_zero(){
return (counter.fetch_add(1) & is_zero) == 0;- return (counter.fetch_add(1, std::memory_order_relaxed) & is_zero) == 0;
- }
- bool decrement(){
if(counter.fetch_sub(1) == 1){- if(counter.fetch_sub(1, std::memory_order_acq_rel) == 1){
- uint64_t e = 0;
if(counter.compare_exchange_strong(e, is_zero)) return true;else if((e & helped) && (counter.exchange(is_zero) & helped)) return true;- if(counter.compare_exchange_strong(e, is_zero, std::memory_order_acq_rel, std::memory_order_acquire)) return true;
- else if((e & helped) && (counter.exchange(is_zero, std::memory_order_acq_rel) & helped)) return true;
- }
- return false;
- }
- uint64_t read(){
auto val = counter.load();if(val == 0 && counter.compare_exchange_strong(val, is_zero | helped)) return 0;- auto val = counter.load(std::memory_order_acquire);
- if(val == 0 && counter.compare_exchange_strong(val, is_zero | helped, std::memory_order_acq_rel, std::memory_order_acquire)) return 0;
- return (val & is_zero) ? 0 : val;
- }
- };
Arrays
#include <vector> #include <unordered_map> #include <numeric> int unique_sum(const std::vector<int>& n) { int sum{0}; std::unordered_map<int,int> frequencies; for (auto i : n) { auto &v=frequencies[i]; if (v==0) sum+=i; else if (v==1) sum-=i; v++; } return sum; }- #include <vector>
- #include <unordered_map>
- #include <numeric>
- int unique_sum(const std::vector<int>& n)
- {
- int sum{0};
- std::unordered_map<int,int> frequencies;
for (auto i : n)++frequencies[i];return std::accumulate(begin(n), end(n), 0, [&](auto sum, auto i){return frequencies[i] == 1 ? sum + i : sum;});- for (auto i : n) {
- auto &v=frequencies[i];
- if (v==0) sum+=i;
- else if (v==1) sum-=i;
- v++;
- }
- return sum;
- }
#include <stdlib.h> #include <string.h> char *reverse_string(const char *word) { if (!word) return NULL; size_t len = strlen(word); char *res = malloc(len + 1); if (!res) return NULL; for (size_t i = 0; i < len; i++) res[i] = word[len - i - 1]; res[len] = '\0'; return res; }- #include <stdlib.h>
- #include <string.h>
char *reverse_string(const char *word){size_t len = strlen(word);char *res = malloc(len + 1);for (size_t i = 0; i < len; i++)res[i] = word[len - i - 1];return res[len] = '\0', res;}- char *reverse_string(const char *word) {
- if (!word) return NULL;
- size_t len = strlen(word);
- char *res = malloc(len + 1);
- if (!res) return NULL;
- for (size_t i = 0; i < len; i++)
- res[i] = word[len - i - 1];
- res[len] = '\0';
- return res;
- }