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.

Return 100

function returnhundred() {
  return returnhundred.name.charCodeAt(9);
}

Test Cases

Diff

```
Test.assertEquals(returnhundred(),100)
```

Recent Moves:

ViManvs.Palkin_Fedor

Bioinformatics - The Reverse Compliment

Code

Diff

reverse_compliment = lambda dna: dna.upper()[::-1].translate(str.maketrans("ACGT", "TGCA"))

Gakkun89vs.pawptart

Compile-Time Tuple Utilities

Here we have introduced two new useful functions:

peel_front
print_tuple
tuple_split

These basic utilities allow us to perform compile time type manipulations and extend the stl.

peel_front will remove a single element from the front of a tuple and return it.
tuple_split takes either a type parameter to split on or a list of indexes to split on.
print_tuple takes an abitrary tuple and prints it.

template <typename... TYPES, typename INTTYPE, INTTYPE... Idxs>
constexpr auto peel_front(std::tuple<TYPES...> tuple, std::integer_sequence<INTTYPE, Idxs...>) {
  return std::make_tuple(std::get<Idxs + 1>(tuple)...);
}


template <typename FIRST, typename... TYPES>
constexpr std::tuple<TYPES...> peel_front(std::tuple<FIRST, TYPES...> val) {
  return peel_front(val, std::make_integer_sequence<int, sizeof...(TYPES)>());
}

namespace _detail {

    struct tag{};

  template <typename TYPE_TO_SPLIT_ON, typename... TYPES, typename... RESULT_TYPES>
  constexpr auto tuple_split(std::tuple<TYPES...> so_far, std::tuple<RESULT_TYPES...> result, std::tuple<>) {
    return std::tuple_cat(so_far, std::make_tuple(result));
  }
  
  template <typename TYPE_TO_SPLIT_ON, typename FIRST, typename... TYPES, typename... TYPES2, typename... RESULT_TYPES>
  constexpr auto tuple_split(std::tuple<TYPES...> so_far, std::tuple<RESULT_TYPES...> result, std::tuple<FIRST, TYPES2...> to_process) {
    if constexpr(std::is_same_v<FIRST, TYPE_TO_SPLIT_ON>) {
      return tuple_split<TYPE_TO_SPLIT_ON>(std::tuple_cat(so_far, std::make_tuple(result)), std::tuple<>{}, peel_front(to_process));
    }
    else {
      return tuple_split<TYPE_TO_SPLIT_ON>(so_far, std::tuple_cat(result, std::make_tuple(std::get<0>(to_process))), peel_front(to_process));
    }
  }
  
  template <typename INTTYPE, INTTYPE... IdxsLeft, INTTYPE... IdxsRight, typename... TYPES>
  constexpr auto tuple_split(std::tuple<TYPES...> tup, std::integer_sequence<INTTYPE, IdxsLeft...>, std::integer_sequence<INTTYPE, IdxsRight...>) {
    std::cout << (( std::to_string(IdxsRight) + " " ) + ...) << std::endl;
    return std::make_tuple(std::make_tuple(std::get<IdxsLeft>(tup)...), std::make_tuple(std::get<IdxsRight + sizeof...(IdxsLeft) + 1>(tup)...));
  }

  template <int FIRST, typename... TYPES>
  constexpr auto tuple_split(std::tuple<TYPES...> tup, tag) {
    const auto& [left, right] = tuple_split(tup, std::make_integer_sequence<int, FIRST - 1>(), std::make_integer_sequence<int, sizeof...(TYPES) - FIRST>());
    return std::tuple_cat(std::make_tuple(left), std::make_tuple(right));
  }
  
  template <int FIRST, int ...REST, typename... TYPES, typename = std::enable_if_t<(sizeof...(REST) > 0)>>
  constexpr auto tuple_split(std::tuple<TYPES...> tup, tag) {
    static_assert(sizeof...(REST) > 0, "Must have at least one element in the parameter pack!");
    const auto& [left, right] = tuple_split(tup, std::make_integer_sequence<int, FIRST - 1>(), std::make_integer_sequence<int, sizeof...(TYPES) - FIRST>());
    return std::tuple_cat(std::make_tuple(left), tuple_split<(REST - FIRST)...>(right, tag{}));
  }
}

namespace std{

template <typename TYPE_TO_SPLIT_ON, typename... TYPES>
constexpr auto tuple_split(std::tuple<TYPES...> tuple) {
  return _detail::tuple_split<TYPE_TO_SPLIT_ON>(std::tuple<>{}, std::tuple<>{}, tuple);
} 
  
template <int ...Idxs, typename... TYPES>
constexpr auto tuple_split(std::tuple<TYPES...> tuple) {
  static_assert((( Idxs >= 0) && ...), "All indexes should be positive!");
  return _detail::tuple_split<Idxs...>(tuple, _detail::tag{});
} 
  
}


template <typename... TYPES, typename INTTYPE, INTTYPE ...Idxs>
inline std::ostream& print_tuple(std::ostream& os, std::tuple<TYPES...> tup, std::integer_sequence<INTTYPE, Idxs...>) {
    os << "std::tuple<";
    int dummy1[] = { ( (os << (Idxs == 0 ? "" : ", ") << typeid(std::get<Idxs>(tup)).name()) ,0)... }; 
    os << ">(";
    int dummy2[] = { ( (os << (Idxs == 0 ? "" : ", ") << std::get<Idxs>(tup)),0)... }; 
    os << ")";
    return os;
}

template <typename... TYPES>
inline std::ostream& operator<<(std::ostream& os, std::tuple<TYPES...> tup) {
    return print_tuple(os, tup, std::make_integer_sequence<int, sizeof...(TYPES)>());
}

// TODO: Replace examples and use TDD by writing your own tests

Describe(any_group_name_you_want)
{
    It(Can_Perform_split_on_type_params)
    {
        auto tup = std::make_tuple(1,2,3,4l,3,4,5,6l,7);
        const auto& [first, second, third] = std::tuple_split<long>(tup);
        Assert::That(std::get<0>(first), Equals(1));
        Assert::That(std::get<1>(first), Equals(2));
        Assert::That(std::get<2>(first), Equals(3));
        Assert::That(std::get<0>(second), Equals(3));
        Assert::That(std::get<1>(second), Equals(4));
        Assert::That(std::get<2>(second), Equals(5));
        Assert::That(std::get<0>(third), Equals(7));
        std::cout << first << std::endl;
        std::cout << second << std::endl;
        std::cout << third << std::endl;
    }
    It(Can_perform_split_on_single_int_param)
    {
        auto tup = std::make_tuple(1,2,3,4l,3,4,5,6l,7);
        const auto& [first, second, third] = std::tuple_split<2,4>(tup);
        std::cout << first << std::endl;
        std::cout << second << std::endl;
        std::cout << third << std::endl;
    }
};

rowcasedvs.opr

Slots Winner

Arrays

A gaming company has just built a slots game with 1 line.
Each line is made up of an array object displaying what landed in those slots.

In the code they pass this line into the function isWinner()
This will return an object which supplies a boolean to say if they have won and how many matches in the row there was.

The matches must start from the first entry and accumulate, a winner is only true when there is over 2 or more matches.

Code

Diff

function isWinner(lineInfo){
  let matches = 0, numbers = {}, others = {};
  for(let item of lineInfo){
    if(typeof(item) == 'number'){
      if(item in numbers) {
        matches += numbers[item] == 1 ? 2 : 1;
        numbers[item] += 1;
      }
      else
        numbers[item] = 1;
    }
    else{
      if(item in others) {
        matches += others[item] == 1 ? 2 : 1;
        others[item] += 1;
      }
      else
        others[item] = 1;
    }
  }
  return [matches != 0, matches];
}

Test Cases

Diff

// Since Node 10, we're using Mocha.
// You can use `chai` for assertions.
const chai = require("chai");
// Uncomment the following line to disable truncating failure messages for deep equals, do:
// chai.config.truncateThreshold = 0;
// Since Node 12, we no longer include assertions from our deprecated custom test framework by default.
// Uncomment the following to use the old assertions:
const Test = require("@codewars/test-compat");

describe("Solution", function() {
  it("should return non winner", function() {
    var result = isWinner(["1", "2", "3", "4", "5"])
    Test.assertEquals(result[0], false);
  });
  
   it("should return winner with 2 match", function() {
    var result = isWinner(["1", "1", "3", "4", "5"])
    Test.assertEquals(result[0], true);
    Test.assertEquals(result[1], 2);
  });
  
  it("should return winner with 2 match", function() {
    var result = isWinner([1, 1, 3, 4, 5])
    Test.assertEquals(result[0], true);
    Test.assertEquals(result[1], 2);
  });
  
  it("should return winner with 3 match", function() {
    var result = isWinner(["1", "1", "1", "4", "5"])
    Test.assertEquals(result[0], true);
    Test.assertEquals(result[1], 3);
  });
  
  it("should return winner with 3 match", function() {
    var result = isWinner([1, 1, 1, 4, 5])
    Test.assertEquals(result[0], true);
    Test.assertEquals(result[1], 3);
  });
  
   it("should return winner with 4 match", function() {
    var result = isWinner(["1", "1", "1", "1", "5"])
    Test.assertEquals(result[0], true);
    Test.assertEquals(result[1], 4);
  });
  
  it("should return winner with 4 match", function() {
    var result = isWinner([1, 1, 1, 1, 5])
    Test.assertEquals(result[0], true);
    Test.assertEquals(result[1], 4);
  });
  
  it("should return winner with 5 match", function() {
    var result = isWinner(["1", "1", "1", "1", "1"])
    Test.assertEquals(result[0], true);
    Test.assertEquals(result[1], 5);
  });
  
  it("should return winner with 5 match", function() {
    var result = isWinner([1, 1, 1, 1, 1])
    Test.assertEquals(result[0], true);
    Test.assertEquals(result[1], 5);
  });
  
  it("should return winner with 5 match", function() {
    var result = isWinner([1, "1", 1, "1", "1"])
    Test.assertEquals(result[0], true);
    Test.assertEquals(result[1], 5);
  });

  it("should return winner with 3 match", function() {
    var result = isWinner([1, "1", "1", "1"])
    Test.assertEquals(result[0], true);
    Test.assertEquals(result[1], 3);
  });
});

-−
+class Kata{
-−
+  public static void Main(){
 class Kata
 {
   public static void Main()
   {
     string language = "C#";
-−
+    System.Console.WriteLine("Hello, {0}!",language);
     System.Console.WriteLine($"Hello, {language}!");
   }
 }

-−
+// TODO: Add your tests here
-−
+// Starting from Node 10.x, [Mocha](https://mochajs.org) is used instead of our custom test framework.
-−
+// [Codewars' assertion methods](https://github.com/Codewars/codewars.com/wiki/Codewars-JavaScript-Test-Framework)
-−
+// are still available for now.
-−
+//
-−
+// For new tests, using [Chai](https://chaijs.com/) is recommended.
-−
+// You can use it by requiring:
-−
+//     const assert = require("chai").assert;
-−
+// If the failure output for deep equality is truncated, `chai.config.truncateThreshold` can be adjusted.
 Test.assertEquals(returnhundred(),100)

 int returnHundred()
 {
-−
+  int i = 0;
-−
+  for (int r = 0; r <= 100; ++r) { i = r; }
-−
+  return i;
   static int i = 0;
   ++i;
   if (i != 100)
     return returnHundred();
   if (i == 100)
     return i;
 }

 int returnHundred()
 {
-−
+  int res = 0;
-−
+  while(++res < 100) {}
-−
+  return res;
   int i = 0;
   for (int r = 0; r <= 100; ++r) { i = r; }
   return i;
 }

 defmodule Solution do
   def sum(a, b) do
-−
+    a + b
     a + b - 0
   end
 end

Filter by Language:

Hello C#!

Return 100

Return 100

Return 100

Elixir Test

Bioinformatics - The Reverse Compliment

Average Grade

Number of digits

Compile-Time Tuple Utilities

Compile-Time Tuple Utilities

Slots Winner

	1	−	reverse_compliment = lambda dna: dna[::-1].translate(str.maketrans("ACGTacgt", "TGCATGCA"))
1		+	reverse_compliment = lambda dna: dna.upper()[::-1].translate(str.maketrans("ACGT", "TGCA"))

 def average(g)
-−
+  g==[] ? nil : g.sum.to_f/g.size
   g.empty? ? nil : g.sum.to_f/g.size
 end

 fn digits(n: u64, base: u64) -> usize {
-−
+    DigitIterator::new(n, base).count()
     digits_iter(n, base).count()
 }
-−
+enum DigitIterator {
-−
+    RemainingDigits { value: u64, base: u64 },
-−
+    Done,
-−
+}
-−
-−
+impl DigitIterator {
-−
+    pub fn new(value: u64, base: u64) -> Self {
-−
+        Self::RemainingDigits { value, base }
-−
+    }
-−
+}
 fn digits_iter(n: u64, base: u64) -> impl Iterator<Item = u64> {
     let mut n = Some(n);
     std::iter::from_fn(move || match n {
         Some(x) => {
             let digit = x % base;
             n = Some(x / base);
-−
+impl Iterator for DigitIterator {
-−
+    type Item = u64;
-−
-−
+    fn next(&mut self) -> Option<u64>{
-−
+        use DigitIterator::*;
-−
+        match self {
-−
+            Done => None,
-−
+            RemainingDigits { value, base } => {
-−
+                let digit = *value % *base;
-−
+                *value /= *base;
-−
+                if *value == 0 { *self = Done; }
-−
+                Some(digit)
             if let Some(0) = n {
                 n = None;
             }
             Some(digit)
         }
-−
+    }
         _ => None,
     })
 }

 function isWinner(lineInfo){
-−
+  let matchCount = 0;
-−
-−
+  //turn it into numbers so it's easier to deal with
-−
+  lineInfo = lineInfo.map(x => parseInt(x));
-−
-−
+  //for each number in the array, step through the rest of the array while
-−
+  //the numbers match.
-−
+  for(let i = 0; i<lineInfo.length; i++) {
-−
+    const number = lineInfo[i];
-−
+    let currentMatchCount = 1;
-−
+    let index = i;
-−
-−
+    //loop through the remaining items in the array while they match the current number.
-−
+    //If they don't match, or we reached the end of the array we can bail early.
-−
+    while(lineInfo[index+1] !== undefined && lineInfo[index+1] === number) {
-−
+      currentMatchCount++;
-−
+      index++;
   let matches = 0, numbers = {}, others = {};
   for(let item of lineInfo){
     if(typeof(item) == 'number'){
       if(item in numbers) {
         matches += numbers[item] == 1 ? 2 : 1;
         numbers[item] += 1;
       }
       else
         numbers[item] = 1;
     }
-−
-−
+    //we found more matches for this number, lineInfo[i], so update matchCount,
-−
+    //with the new count, and then fast forward the iterator
-−
+    //by the number of matches found (slight performance bonus)
-−
+    if(currentMatchCount > matchCount) {
-−
+      matchCount = currentMatchCount;
-−
+      i = i+currentMatchCount-1;
     else{
       if(item in others) {
         matches += others[item] == 1 ? 2 : 1;
         others[item] += 1;
       }
       else
         others[item] = 1;
     }
   }
-−
-−
+  return [matchCount > 1, matchCount];
   return [matches != 0, matches];
 }

Kumite

Filter by Language:

Compile-Time Tuple Utilities

Confirm