Kumite

Show My Kumite Only?
Filter by Language:
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.

Kumite 1

not sure what this is...
function compute() {
  return 1;
}
describe("Solution", function() {
  it("should test for something", function() {
    let result = compute()
    Test.assertEquals(result, 1);
  });
});

Den4egvs. RobsonMoon

Intertwine

It's easier ;-)

Code

Diff

intertwine=a=> a.split('').sort().join('')

1 - intertwine=a=>[...a.slice(-a.length/2)].map((e,i)=>a[i]+e).join``
1 + intertwine=a=> a.split('').sort().join('')

Recent Moves:

RobsonMoonvs. ygorbunkov

Intertwine

Code

Diff

intertwine=a=>[...a.slice(-a.length/2)].map((e,i)=>a[i]+e).join``

Test Cases

Diff

Test.assertEquals(intertwine('13572468'), '12345678');
Test.assertEquals(intertwine('acegbdfh'), 'abcdefgh');
Test.assertEquals(intertwine('ab'), 'ab');
Test.assertEquals(intertwine(''), '');

ygorbunkov

Intertwine

const interwine = str => 
   [...str]
      .reduce((r,_,i,s) => 
         i%2 ? 
         [...r,s[(s.length+i-1)/2]] :
         [...r,s[i/2]], [])
      .join('')
Test.assertEquals(interwine('13572468'), '12345678');
Test.assertEquals(interwine('acegbdfh'), 'abcdefgh');

Battlesquidvs. ygorbunkov

Sum of the digits of years

Code

Diff

const ageSumDigits = (age1, age2, age3) => {
  return (age1+'').split('').map(n => parseInt(n)).reduce((n, m) => n + m) < age2 + age3;
}

Recent Moves:

hakr14vs. ygorbunkov

Sum of the digits of years

Code

Diff

d,a=lambda n:sum(int(c) for c in str(n)),lambda m,s,p:d(m)<d(s)+d(p)

Test Cases

Diff

Test.expect(not a(27,3,1));
Test.expect(a(33,9,7));
Test.expect(a(50,26,24));

ygorbunkovvs. burlacu.valeri

Sum of the digits of years

Code

Diff

const ageSumDigits = (age1, age2, age3) => {
  const sumOfDigits = num => [...`${num}`].reduce((sum,digit) => sum+Number(digit),0);
  return sumOfDigits(age2)+sumOfDigits(age3) > sumOfDigits(age1);
}

Test Cases

Diff

Test.assertEquals(ageSumDigits(27,3,1), false);
Test.assertEquals(ageSumDigits(33,9,7), true);
Test.assertEquals(ageSumDigits(50,26,24), true);

Unnamedvs. UnnamedFailed Tests

Errors caught

https://www.gnu.org/software/libc/manual/html_node/Heap-Consistency-Checking.html#Heap-Consistency-Checking

Test Cases

Diff

#include <criterion/criterion.h>
#include <stdlib.h>
#include <mcheck.h>

char *my_strdup_1(const char *str);
char *my_strdup_2(const char *str);

Test(my_strdup_1, should_work_correctly) {
  static const char str[] = "Qwerty";
  char *const res = my_strdup_1(str);
  cr_assert_str_eq(res, str);
  free(res);
}

Test(my_strdup_2, should_work_correctly) {
  static const char str[] = "Qwerty";
  char *const res = my_strdup_2(str);
  cr_assert_str_eq(res, str);
  free(res);
}

__attribute__((constructor(101))) static void init() {
  mcheck(NULL);
}

Recent Moves:

Unnamed

Errors not caught

#include <stdlib.h>
#include <string.h>

char *my_strdup_1(const char *str) {
  const size_t len = strlen(str);
  char *const res = malloc(len); // <- BUG
  memcpy(res, str, len);
  return res;
}

char *my_strdup_2(const char *str) {
  const size_t len = strlen(str);
  char *const res = malloc(len); // <- BUG
  memcpy(res, str, len + 1);
  return res;
}
#include <criterion/criterion.h>
#include <stdlib.h>

char *my_strdup_1(const char *str);
char *my_strdup_2(const char *str);

Test(my_strdup_1, should_work_correctly) {
  static const char str[] = "Qwerty";
  char *const res = my_strdup_1(str);
  cr_assert_str_eq(res, str);
  free(res);
}

Test(my_strdup_2, should_work_correctly) {
  static const char str[] = "Qwerty";
  char *const res = my_strdup_2(str);
  cr_assert_str_eq(res, str);
  free(res);
}

ygorbunkovvs. Etoneja

Swing list sorting

Code

Diff

const specialSort = arr =>
  arr.reduce((r,_,i,s) => i%2 ? [...r, s[s.length-1-(i-1)/2]] : [...r,s[i/2]], [])

Test Cases

Diff

Test.assertDeepEquals(specialSort([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), [0, 9, 1, 8, 2, 7, 3, 6, 4, 5])
Test.assertDeepEquals(specialSort([0, 1, 2, 3, 4, 5, 6, 7, 8]), [0, 8, 1, 7, 2, 6, 3, 5, 4])

 public class AgeSumDigits
 {
  public static boolean SumOfDigits(int[] ages) {
  int m = ages[0];
  int s = ages[1];
  int p = ages[2];
  // Coding with passion ;)
  return (calcSum(m) < calcSum(s)+calcSum(p)) ? true : false;
  }
  static int calcSum(int age){
  int sum = 0;
  while(age>0){
  sum += age % 10;
  age /= 10;
  }
  return sum;
  }
 const ageSumDigits = (age1, age2, age3) => {
  const sumOfDigits = num => [...`${num}`].reduce((sum,digit) => sum+Number(digit),0);
  return sumOfDigits(age2)+sumOfDigits(age3) > sumOfDigits(age1);
 }

 import org.junit.Test;
 import static org.junit.Assert.assertEquals;
 import org.junit.runners.JUnit4;
 public class SolutionTest {
  AgeSumDigits asd = new AgeSumDigits();
  @Test
  public void testSumDigits() {
  assertEquals(false, asd.SumOfDigits(new int[]{27,3,1}));
  assertEquals(true, asd.SumOfDigits(new int[]{33,9,7}));
  assertEquals(true, asd.SumOfDigits(new int[]{50,26,24}));
  }
 }
 Test.assertEquals(ageSumDigits(27,3,1), false);
 Test.assertEquals(ageSumDigits(33,9,7), true);
 Test.assertEquals(ageSumDigits(50,26,24), true);

 def special_sort(list):
  r = []
  l = len(list)
  for i in range(l // 2 + 1):
  if i == 0 or (i == l // 2 and not l % 2):
  r.append(list[i])
  else: r.extend([list[-i], list[i]])
  return r
 const specialSort = arr =>
  arr.reduce((r,_,i,s) => i%2 ? [...r, s[s.length-1-(i-1)/2]] : [...r,s[i/2]], [])

 # TODO: Replace examples and use TDD development by writing your own tests
 # These are some of the methods available:
 # test.expect(boolean, [optional] message)
 test.assert_equals(special_sort([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), [0, 9, 1, 8, 2, 7, 3, 6, 4, 5])
 test.assert_equals(special_sort([0, 1, 2, 3, 4, 5, 6, 7, 8]), [0, 8, 1, 7, 2, 6, 3, 5, 4])
 # test.assert_not_equals(actual, expected, [optional] message)
 # You can use Test.describe and Test.it to write BDD style test groupings
 Test.assertDeepEquals(specialSort([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), [0, 9, 1, 8, 2, 7, 3, 6, 4, 5])
 Test.assertDeepEquals(specialSort([0, 1, 2, 3, 4, 5, 6, 7, 8]), [0, 8, 1, 7, 2, 6, 3, 5, 4])

	1	-	intertwine=a=>[...a.slice(-a.length/2)].map((e,i)=>a[i]+e).join``
1		+	intertwine=a=> a.split('').sort().join('')

Filter by Language:

not sure what this is...

Confirm