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.

Meta strings - Check if two strings can become same after a swap in one string

Given two strings, the task is to check whether these strings are meta strings or not. Meta strings are the strings which can be made equal by exactly one swap in any of the strings. Equal string are considered here as Meta strings.

func areMetaStrings(_ str1: String, _ str2: String) -> Bool {
    return str1.lowercased().sorted() == str2.lowercased().sorted()
}

import XCTest
// XCTest Spec Example:
// TODO: replace with your own tests (TDD), these are just how-to examples to get you started

class SolutionTest: XCTestCase {
    static var allTests = [
        ("Test Example", testExample),
    ]

    func testExample() {
        XCTAssertTrue(areMetaStrings("geeks", "keegs"))
        XCTAssertTrue(areMetaStrings("rsting", "string"))
        XCTAssertFalse(areMetaStrings("geeks", "peegs"))
    }
}

XCTMain([
    testCase(SolutionTest.allTests)
])

ricbirvs. tolg

tolg's Kumite #3

Code

Diff

package solution

fun tribonacci(n: Int, signature: Triple<Int, Int, Int> = Triple(1, 1, 1)) =
    generateSequence(signature) { Triple(it.second, it.third, it.first + it.second + it.third) }
        .map { it.first }
        .take(n)
        .toList()

Test Cases

Diff

package solution

import kotlin.test.assertEquals
import org.junit.Test

class TestExample {
    @Test
    fun testTribonacci() {
        assertEquals(listOf(1), tribonacci(1))
        assertEquals(listOf(1, 1, 1, 3, 5, 9, 17, 31, 57, 105), tribonacci(10))
        assertEquals(listOf(2, 2, 2, 6, 10, 18, 34, 62, 114, 210), tribonacci(10, Triple(2, 2, 2)))
    }
}

ygorbunkovvs. Kutman-a

Code

Diff

const AbbreviateTwoWords = s => {
  const [first, middle, ...rest] = s.split(' ')
  return `${first.slice(0,1)}.${middle.slice(0,1)}. ${rest}`
}

Test Cases

Diff

Test.assertEquals(AbbreviateTwoWords('Jeffrey Jacob Abrams'), 'J.J. Abrams')

ygorbunkovvs. WestwardLand968

ROT13 - Find a better strategy

Code

Diff

const rot13 = s => s.replace(/[a-z]/g, m => String.fromCharCode(97+(m.charCodeAt(0)-97+13)%26))

1 - def rot13(s):
2 - return rot.encode(s,"rot_13")
1 + const rot13 = s => s.replace(/[a-z]/g, m => String.fromCharCode(97+(m.charCodeAt(0)-97+13)%26))

Test Cases

Diff

Test.assertEquals(rot13('abcdefghijklmnopqrstuvwxyz'), 'nopqrstuvwxyzabcdefghijklm')

Recent Moves:

rowcasedvs. theguy678

ROT13 - Find a better strategy

of course, this does assumes lowercase letters

Code

Diff

rot13 = lambda s: "".join(__import__('string').ascii_lowercase[(ord(c) - 84) % 26] for c in s)

theguy678vs. WestwardLand968

ROT13 - Find a better strategy

Code

Diff

def rot13(s):
    rot = "abcdefghijklmnopqrstuvwxyzabcdefghijklm"
    return "".join([rot[rot.index(x)+13] for x in s])

1 1 def rot13(s):
2 - return rot.encode(s,"rot_13")
2 + rot = "abcdefghijklmnopqrstuvwxyzabcdefghijklm"
3 + return "".join([rot[rot.index(x)+13] for x in s])

Test Cases

Diff

from random import randint
from string import ascii_lowercase

Test.describe("Basic Tests")
test.assert_equals(rot13("thisisastring"), "guvfvfnfgevat")
test.assert_equals(rot13("codewars"), "pbqrjnef")
test.assert_equals(rot13("westwardland"), "jrfgjneqynaq")

Test.describe("Complex Tests")
test.assert_equals(rot13("nopqrstuvwxyz"), "abcdefghijklm")
test.assert_equals(rot13('abcdefghijklmnopqrstuvwxyz'), 'nopqrstuvwxyzabcdefghijklm')

Test.describe("Random Tests")
for x in range(100):
    string = "".join([ascii_lowercase[randint(0, 25)] for x in range(randint(100, 150))])
    test.assert_equals(rot13(string), rot.encode(string,"rot_13"))

ygorbunkovvs. ksndrsn

Jerald the archaeologist.

Code

Diff

const decrypt = (s,d,a='ABCDEFGHIJKLMNOPQRSTUVWXYZ') => s.replace(/[A-Z]/g, m => a[(a.indexOf(m)+26-d)%26])

Test Cases

Diff

Test.assertEquals(decrypt("MJQQT YMJWJ",5),"HELLO THERE")
Test.assertEquals(decrypt("FVB NVA TL",7),"YOU GOT ME")

Recent Moves:

rowcasedvs. rowcased

Jerald the archaeologist.

Code

Diff

decrypt = lambda d,a: ''.join(chr((ord(c)-65-a)%26+65) if c.isalpha() else c for c in d)

Dimitris. Papadim

fqwefqwe

wrvcqwre

using System;


namespace Interpreter.Cata
{
    public static class FunctionalExtensions
    {

        public static Reader<Env, T1> App<Env, T, T1>(this Reader<Env, Func<T, T1>> @this, Reader<Env, T> fa)
            => new Reader<Env, T1>(env => { return @this.Map(f => fa.Map(f).Run(env)).Run(env); });



        public static T1 Eval<T, T1>(this Expr<T> @this,
            (Func<T1, T1, T1> add, Func<T1, T1, T1> sub, Func<T, T1> val) algebra)
            =>
            @this.MatchWith(pattern: (
                   add: (x, y) => algebra.add(x.Eval(algebra), y.Eval(algebra)),
                   sub: (x, y) => algebra.sub(x.Eval(algebra), y.Eval(algebra)),
                   val: v => algebra.val(v)
            ));

    }
    public abstract class Expr<T>
    {
        public abstract T1 MatchWith<T1>((Func<Expr<T>, Expr<T>, T1> add, Func<Expr<T>, Expr<T>, T1> sub, Func<T, T1> val) pattern);
    }
    public class ValExpr<T> : Expr<T>
    {
        public ValExpr(T x) { X = x; }
        public T X { get; }
        public override T1 MatchWith<T1>((Func<Expr<T>, Expr<T>, T1> add, Func<Expr<T>, Expr<T>, T1> sub, Func<T, T1> val) pattern)
                 => pattern.val(X);
    }
    public class AddExpr<T> : Expr<T>
    {
        public AddExpr(Expr<T> x, Expr<T> y) { X = x; Y = y; }

        public Expr<T> X { get; }
        public Expr<T> Y { get; }

        public override T1 MatchWith<T1>(
            (Func<Expr<T>, Expr<T>, T1> add,
            Func<Expr<T>, Expr<T>, T1> sub,
            Func<T, T1> val) pattern)
             => pattern.add(X, Y);
    }
    public class SubExpr<T> : Expr<T>
    {
        public SubExpr(Expr<T> x, Expr<T> y) { X = x; Y = y; }

        public Expr<T> X { get; }
        public Expr<T> Y { get; }

        public override T1 MatchWith<T1>((Func<Expr<T>, Expr<T>, T1> add,
             Func<Expr<T>, Expr<T>, T1> sub,
            Func<T, T1> val) pattern)
             => pattern.sub(X, Y);
    }
    public class Reader<Env, T>
    {
        public Func<Env, T> Fn { get; set; }
        public Reader(Func<Env, T> fn) => Fn = fn;
        public Reader<Env, T1> Map<T1>(Func<T, T1> f) => new Reader<Env, T1>((env) => f(Fn(env)));
        public T Run(Env env) => Fn(env);
    }
    public class Config
    {
        public string Name { get; set; }
    }

    public class Demo
    {
        public static void Run()
        {
            var expression = new SubExpr<int>(new AddExpr<int>(new ValExpr<int>(2), new ValExpr<int>(2)), new ValExpr<int>(2));

            var result = expression.Eval(algebra: (
                    add: (x, y) => x + y,
                    sub: (x, y) => x + y,
                    val: v => v)
                );

        }
    }



}

namespace Solution {
  using NUnit.Framework;
  using System;

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

  [TestFixture]
  public class SolutionTest
  {
    [Test]
    public void MyTest()
    {
      Assert.AreEqual("actual", "actual");
    }
  }
}

WestwardLand968

Convert to Base 2

Write a function that converts a base 10 number and returns binary (base 2).

Binary is consisted of zeros and ones only, and those make up the binary number.

Suppose that place value works the same.

func binaryConverter(_ input: Int) -> Int {
  //Your Code Here
  return input
}

import XCTest
// XCTest Spec Example:
// TODO: replace with your own tests (TDD), these are just how-to examples to get you started

class SolutionTest: XCTestCase {
    static var allTests = [
        ("Test Example", testExample),
    ]

    func testExample() {
        let actual = 1
        XCTAssertEqual(actual, 1)
    }
}

XCTMain([
    testCase(SolutionTest.allTests)
])

 public class AbbreviateTwoWords {
  public static String abbrevName(String name) {
  String[] names = name.split(" ");
  return (names[0].charAt(0) + "." + names[1].charAt(0)).toUpperCase();
  }
 const AbbreviateTwoWords = s => {
  const [first, middle, ...rest] = s.split(' ')
  return `${first.slice(0,1)}.${middle.slice(0,1)}. ${rest}`
 }

 # 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(actual, expected, [optional] message)
 # test.assert_not_equals(actual, expected, [optional] message)
 # You can use Test.describe and Test.it to write BDD style test groupings
 test.assert_equals(rot13('abcdefghijklmnopqrstuvwxyz'), 'nopqrstuvwxyzabcdefghijklm')
 Test.assertEquals(rot13('abcdefghijklmnopqrstuvwxyz'), 'nopqrstuvwxyzabcdefghijklm')

 def decrypt(code,amount):
  #place code here
  let="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  word = ""
  x=0
  for c in range(0,len(code)):
  for i in range (0,len(let)):
  if code[c] == " ":
  word+=" "
  break
  elif code[c] == let[i]:
  x=i
  x-=amount
  if x < 0:
  x+=26
  word+=let[x]
  break
  return word
 const decrypt = (s,d,a='ABCDEFGHIJKLMNOPQRSTUVWXYZ') => s.replace(/[A-Z]/g, m => a[(a.indexOf(m)+26-d)%26])

	1	-	import org.junit.Test; import static org.junit.Assert.assertEquals; import org.junit.runners.JUnit4; public class SolutionTest { @Test public void testFixed() { assertEquals("S.H", AbbreviateTwoWords.abbrevName("Sam Harris")); assertEquals("P.F", AbbreviateTwoWords.abbrevName("Patrick Feenan")); assertEquals("E.C", AbbreviateTwoWords.abbrevName("Evan Cole")); assertEquals("P.F", AbbreviateTwoWords.abbrevName("P Favuzzi")); assertEquals("D.M", AbbreviateTwoWords.abbrevName("David Mendieta")); } }
1		+	Test.assertEquals(AbbreviateTwoWords('Jeffrey Jacob Abrams'), 'J.J. Abrams')

 def decrypt(code, amount):
  return ''.join([chr((ord(c)-amount+65)%26+65) if c.isalpha() else c for c in code])
 decrypt = lambda d,a: ''.join(chr((ord(c)-65-a)%26+65) if c.isalpha() else c for c in d)

Kumite

Filter by Language:

Confirm