Start a new Kumite
AllAgda (Beta)BF (Beta)CCFML (Beta)ClojureCOBOL (Beta)CoffeeScriptCommonLisp (Beta)CoqC++CrystalC#D (Beta)DartElixirElm (Beta)Erlang (Beta)Factor (Beta)Forth (Beta)Fortran (Beta)F#GoGroovyHaskellHaxe (Beta)Idris (Beta)JavaJavaScriptJulia (Beta)Kotlinλ Calculus (Beta)LeanLuaNASMNim (Beta)Objective-C (Beta)OCaml (Beta)Pascal (Beta)Perl (Beta)PHPPowerShell (Beta)Prolog (Beta)PureScript (Beta)PythonR (Beta)RacketRaku (Beta)Reason (Beta)RISC-V (Beta)RubyRustScalaShellSolidity (Beta)SQLSwiftTypeScriptVB (Beta)
Show only mine

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.

Ad
Ad
RobsonMoonvs.MattZ306

Return 100

It works once every year :)

Code
Diff
  • var moment = require('moment')
function returnhundred() {
  return moment().dayOfYear()
}
    • var moment = require('moment')
    • function returnhundred() {
    • return new Date().getMinutes() + new Date().getMinutes() + new Date().getMinutes() + new Date().getMinutes();
    • return moment().dayOfYear()
    • }
RobsonMoonvs.dargonesti

Return ok

Code
Diff
  • function ok() {
  return ok.toString().substr(9, 2);
}
    • ok=_=>"ok"
    • wink=(v,o)=>"wink"
    • function ok() {
    • return ok.toString().substr(9, 2);
    • }
ᛚᚨᚱᛊ ᚺᛖᚾᚱᛁᚲvs.rtoliveira

Lost Pencils!

Algorithms
Logic
Code
Diff
  • lostPencils = lambda end: sum(range(end+1))
    • def lostPencils(end):
    • result = 0
    • for i in range(1,end+1):
    • result+=i
    • return result
    • lostPencils = lambda end: sum(range(end+1))
benricevs.rtoliveira

Big number

Code
Diff
  • public class BiggerNum{

  public static int compare(int a, int b) {
    return (a>b) ? a : b;
  }

}
    • public class BiggerNum{
    • public static int compare(int a, int b) {
    • if(a>b)
    • return a;
    • else
    • return b;
    • return (a>b) ? a : b;
    • }
    • }
MattZ306vs.saykou__

Help your family seat at a restaurant.

Your family members are a bit picky when it comes to choose who they want to seat next to in a family outing to the restaurant. Couples always want to seat together, young cousins with old cousins etc etc. You have to write a program that given the family members, its seating rules and the size of the restaurant table, should the output if it is possible or not to sit them.

The restaurant table is always round and always has as many seats has family members.

example
// family members seating rules
canTheySit(["Mark", "Marta", "Oliver"], ["Mark", "Marta"]) == true

Contributing my own, different solution. It passes the tests but it's possible that it would fail on a different edge case.

I could see this as a decent kata provided it's not a duplicate :) (then again if it's a duplicate, this kumite shouldn't be here)

Code
Diff
  • // there are three conditions that could cause the rules to fail:
// - a name in the rules doesn't exist in the family
// - a family member wants to sit next to three other people, or themself
// - a loop consisting of a smaller subset of the family exists
// this solution checks for these three

function canTheySit(familyMembers, rules) {
  var desiredSeating = {};
  familyMembers.forEach(member => desiredSeating[member] = []);
  
  if (rules.some(rule => {
    if (rule.some(member => !desiredSeating[member]) || rule[0] == rule[1])
      return true;
  
    desiredSeating[rule[0]].push(rule[1]);
    desiredSeating[rule[1]].push(rule[0]);
    
    return rule.some(member => desiredSeating[member].length > 2);
  }))
    return false;
  
  var visited = {};
  for (var m = 0; m < familyMembers.length; m++) {
    var member = familyMembers[m];
  
    if (visited[member]) continue;
    visited[member] = true;
    
    var loopLength = 0;
    var currMember = member;
    while (desiredSeating[currMember].length > 0) {
      var prevMember = currMember;
      currMember = desiredSeating[currMember][0];
      visited[currMember] = true;
      loopLength++;
      
      if (currMember == member)
        return loopLength == familyMembers.length;
      
      var currSeating = desiredSeating[currMember];
      currSeating.splice(currSeating.indexOf(prevMember), 1);
    }
  }
  
  return true;
}
    • function arrangeSeating(table, seating)
    • {
    • // first check if table is in any one of this solutions
    • // none is seated
    • // one is seated
    • // both are seated
    • var seated = {};
    • seated[seating[0]] = false;
    • seated[seating[1]] = false;
    • for(var i = 0; i < table.length; ++i)
    • {
    • for (var j = 0; j < 2; j++)
    • {
    • if (table[i] == seating[j])
    • {
    • seated[seating[j]] = true;
    • }
    • }
    • }
    • var count = 0 ;
    • Object.keys(seated).forEach((id) => {if (seated[id]) {count++;}});
    • // there are three conditions that could cause the rules to fail:
    • // - a name in the rules doesn't exist in the family
    • // - a family member wants to sit next to three other people, or themself
    • // - a loop consisting of a smaller subset of the family exists
    • // this solution checks for these three
    • function canTheySit(familyMembers, rules) {
    • var desiredSeating = {};
    • familyMembers.forEach(member => desiredSeating[member] = []);
    • if (rules.some(rule => {
    • if (rule.some(member => !desiredSeating[member]) || rule[0] == rule[1])
    • return true;
    • // find two empty seats
    • if (count == 0)
    • {
    • for(var i = 0; i < table.length; ++i)
    • {
    • if (table[i] === "Empty" && table[(i + 1) % table.length] == "Empty")
    • {
    • table[i] = seating[0];
    • table[(i + 1) % table.length] = seating[1];
    • return true;
    • }
    • }
    • }
    • else if (count == 1)
    • {
    • // one of them is seated let's see if any chair next to him is filled
    • desiredSeating[rule[0]].push(rule[1]);
    • desiredSeating[rule[1]].push(rule[0]);
    • var seatedOne = "";
    • var toSit = "";
    • if (seated[seating[0]] == true)
    • {
    • seatedOne = seating[0];
    • toSit = seating[1];
    • }
    • else
    • {
    • seatedOne = seating[1];
    • toSit = seating[0];
    • }
    • return rule.some(member => desiredSeating[member].length > 2);
    • }))
    • return false;
    • var visited = {};
    • for (var m = 0; m < familyMembers.length; m++) {
    • var member = familyMembers[m];
    • if (visited[member]) continue;
    • visited[member] = true;
    • for(var i = 0; i < table.length; ++i)
    • {
    • if (table[i] === seatedOne)
    • {
    • var rightSeat = (i + 1) % table.length;
    • var leftSeat = ((table.length + i) - 1) % table.length;
    • if (table[rightSeat] == "Empty")
    • {
    • table[rightSeat] = toSit;
    • return true;
    • }
    • else if (table[leftSeat] == "Empty")
    • {
    • table[leftSeat] = toSit;
    • return true;
    • }
    • else
    • {
    • return false;
    • }
    • }
    • }
    • }
    • else
    • {
    • // both are seated check if they are next to each other
    • for(var i = 0; i < table.length; ++i)
    • {
    • if (table[i] === seating[0])
    • {
    • var rightSeat = (i + 1) % table.length;
    • var leftSeat = ((table.length + i) - 1) % table.length;
    • if (table[rightSeat] === seating[1])
    • {
    • return true;
    • }
    • else if (table[leftSeat] === seating[1])
    • {
    • return true;
    • }
    • else
    • {
    • return false;
    • }
    • }
    • var loopLength = 0;
    • var currMember = member;
    • while (desiredSeating[currMember].length > 0) {
    • var prevMember = currMember;
    • currMember = desiredSeating[currMember][0];
    • visited[currMember] = true;
    • loopLength++;
    • if (currMember == member)
    • return loopLength == familyMembers.length;
    • var currSeating = desiredSeating[currMember];
    • currSeating.splice(currSeating.indexOf(prevMember), 1);
    • }
    • }
    • return false;
    • }
    • function canTheySit(familyMembers, rules)
    • {
    • var indices = {};
    • var indices_inv = {};
    • var pairs = Array(familyMembers.length).fill().map(()=>Array(familyMembers.length).fill(false));
    • for (var i = 0; i < familyMembers.length; ++i)
    • {
    • indices[familyMembers[i]] = i;
    • indices_inv[i] = familyMembers[i];
    • }
    • rules.forEach((rule) =>
    • {
    • var pair1 = indices[rule[0]];
    • var pair2 = indices[rule[1]];
    • pairs[pair1][pair2] = true;
    • pairs[pair2][pair1] = true;
    • });
    • var table = Array(familyMembers.length).fill("Empty");
    • var toReturn = true;
    • var i = 0;
    • pairs.forEach((list) =>
    • {
    • var total = 0;
    • for (var j = i + 1; j < list.length; ++j)
    • {
    • if (list[j])
    • {
    • // find if possible to sit
    • if (!arrangeSeating(table, [indices_inv[i], indices_inv[j]]))
    • {
    • toReturn = false;
    • }
    • }
    • }
    • i++;
    • });
    • return toReturn;
    • return true;
    • }
FANATlCvs.ᛚᚨᚱᛊ ᚺᛖᚾᚱᛁᚲ

Common Substring

Code
Diff
  • 
from operator import contains as common_substring
def common_substring(string, sub_str):
    # Write your code here
    if sub_str in string:
        return True
    else:
        return False
    • from operator import contains as common_substring
    • from operator import contains as common_substring
    • def common_substring(string, sub_str):
    • # Write your code here
    • if sub_str in string:
    • return True
    • else:
    • return False
lbvf50mobilevs.lbvf50mobile

Example by @hobovsky adding shuffling in tests

Adding shuffling in test.

Code
Diff
  • let minusOne = str => (BigInt(str) - 1n).toString();
    • let minusOne = str => {
    • // Make it green, then make it clean :-)
    • if('10' == str) return '9'
    • if('124' == str) return '123'
    • if('062462935174393901' == str) return '062462935174393900'
    • return '0'
    • };
    • let minusOne = str => (BigInt(str) - 1n).toString();
donaldsebleungvs.donaldsebleung

[Coq] TLC package on Codewars?

Code
Diff
  • From TLC Require Import LibTactics.
 
Inductive R : nat -> nat -> Prop :=
  | R_0_1 : R 0 1.

Example not_R_S_n_m : forall n m, ~ R (S n) m.
Proof.
  (* Duplicate current subgoal to demonstrate two ways to prove
     the same statement *)
  dup.

  (* Was ... *)
  intros n m H; inversion H.

  (* Is now ... *)
  introv H; inverts H.

Qed.
    • From TLC Require Import LibTactics.
    • Inductive R : nat -> nat -> Prop :=
    • | R_0_1 : R 0 1.
    • Example not_R_S_n_m : forall n m, ~ R (S n) m.
    • Proof.
    • (* Duplicate current subgoal to demonstrate two ways to prove
    • the same statement *)
    • dup.
    • (* Was ... *)
    • intros n m H; inversion H.
    • (* Is now ... *)
    • introv H; inverts H.
    • Qed.