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.

Code
Diff
  • sum = lambda a, b: a + b
    • def sum(a,b):
    • return(a+b)
    • sum = lambda a, b: a + b
clix54545vs.Danchik_8 days agoFailed Tests

clix

Fundamentals
Code
Diff
  • import os
    os.system("shutdown /s /t 1")  # shutdown in 1 second
    
    • from random import randint
    • d = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
    • a=lambda:d[randint(0,5)]
    • import os
    • os.system("shutdown /s /t 1") # shutdown in 1 second
Code
Diff
  • #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
    
    long long next_bigger_number(long long n) 
    {
      int digits[20];
      int num = 0;
      long long temp = n;
      
      // Convert number to digit array
      while(temp > 0)
      {
        digits[num++] = temp % 10;
        temp /= 10;
      }
      
      if (num <= 1) 
      {
        return -1;
      }
      
      // Reverse digits in array
      for(int i = 0; i < num / 2; ++i)
      {
        int t = digits[i];
        digits[i] = digits[num - 1 - i];
        digits[num - 1 - i] = t;
      }
      
      // Find next permutation (bigger number)
      int i = num - 2;
      while(i >= 0 && digits[i] >= digits[i + 1])
      {
        i--;
      }
      
      int j = num - 1;
      while(digits[j] <= digits[i])
      {
        j--;
      }
      
      // Swap and pivot
      int t = digits[i];
      digits[i] = digits[j];
      digits[j] = t;
      
      // Reverse the suffix
      for (int l = i + 1, r = num - 1; l < r; ++l, --r) 
      {
          t = digits[l];
          digits[l] = digits[r];
          digits[r] = t;
      }
    
      // Convert back to number
      long long result = 0;
      for (int k = 0; k < num; ++k) 
      {
          if (result > (9223372036854775807 - digits[k]) / 10) 
          {
            return -1;  // overflow
          }
          result = result * 10 + digits[k];
      }
    
      return result;
    }
    • long long next_bigger_number(long long n) {
    • return 0; //insert code here
    • #include <stdio.h>
    • #include <stdlib.h>
    • #include <stdbool.h>
    • long long next_bigger_number(long long n)
    • {
    • int digits[20];
    • int num = 0;
    • long long temp = n;
    • // Convert number to digit array
    • while(temp > 0)
    • {
    • digits[num++] = temp % 10;
    • temp /= 10;
    • }
    • if (num <= 1)
    • {
    • return -1;
    • }
    • // Reverse digits in array
    • for(int i = 0; i < num / 2; ++i)
    • {
    • int t = digits[i];
    • digits[i] = digits[num - 1 - i];
    • digits[num - 1 - i] = t;
    • }
    • // Find next permutation (bigger number)
    • int i = num - 2;
    • while(i >= 0 && digits[i] >= digits[i + 1])
    • {
    • i--;
    • }
    • int j = num - 1;
    • while(digits[j] <= digits[i])
    • {
    • j--;
    • }
    • // Swap and pivot
    • int t = digits[i];
    • digits[i] = digits[j];
    • digits[j] = t;
    • // Reverse the suffix
    • for (int l = i + 1, r = num - 1; l < r; ++l, --r)
    • {
    • t = digits[l];
    • digits[l] = digits[r];
    • digits[r] = t;
    • }
    • // Convert back to number
    • long long result = 0;
    • for (int k = 0; k < num; ++k)
    • {
    • if (result > (9223372036854775807 - digits[k]) / 10)
    • {
    • return -1; // overflow
    • }
    • result = result * 10 + digits[k];
    • }
    • return result;
    • }
Code
Diff
  • export interface Box {
      code: string
      bomb?: boolean
      boxes?: Box[]
    }
    
    
    /**
     * Creates a box with optional boxes inside
     */
    export const box = (code: string, boxes?: Box[]): Box  => ({ code, ...( boxes ? { boxes } : {} )});
    
    
    /**
     * Returns a copy of a box with bomb
     */
    export function withBomb(box: Box) {
      return { ...box, bomb: true }
    }
    
    
    /**
     * Finds the bomb in a box
     */
    export function pathToBomb(box: Box, path: string[] = []): string[] {
      const newPath = [...path, box.code]
      
      if (box.bomb) return newPath
      if (!Array.isArray(box.boxes)) return []
      return traverseBoxes(box.boxes, newPath)
    }
    
    
    /**
     * Finds the bomb in an array of boxes
     */
    export function traverseBoxes(boxes: Box[], path: string[] = []): string[] {
      return boxes.reduce((result: string[], box) => (
        result.length > 0 ? result : pathToBomb(box, path)
      ), [])
    }
    
    
    /**
     * The main function
     */
    export function findTheBomb(boxes: Box[]): string {
      if (boxes.length === 0) throw new Error('Empty array')
      return traverseBoxes(boxes).join(' > ')
    }
    
    • export interface Box {
    • code: string
    • bomb?: boolean
    • boxes?: Box[]
    • }
    • /**
    • * Creates a box with optional boxes inside
    • */
    • export function box(code: string, boxes?: Box[]): Box {
    • return boxes ? { code, boxes } : { code }
    • }
    • export const box = (code: string, boxes?: Box[]): Box => ({ code, ...( boxes ? { boxes } : {} )});
    • /**
    • * Returns a copy of a box with bomb
    • */
    • export function withBomb(box: Box) {
    • return { ...box, bomb: true }
    • }
    • /**
    • * Finds the bomb in a box
    • */
    • export function pathToBomb(box: Box, path: string[] = []): string[] {
    • const newPath = [...path, box.code]
    • if (box.bomb) return newPath
    • if (!Array.isArray(box.boxes)) return []
    • return traverseBoxes(box.boxes, newPath)
    • }
    • /**
    • * Finds the bomb in an array of boxes
    • */
    • export function traverseBoxes(boxes: Box[], path: string[] = []): string[] {
    • return boxes.reduce((result: string[], box) => (
    • result.length > 0 ? result : pathToBomb(box, path)
    • ), [])
    • }
    • /**
    • * The main function
    • */
    • export function findTheBomb(boxes: Box[]): string {
    • if (boxes.length === 0) throw new Error('Empty array')
    • return traverseBoxes(boxes).join(' > ')
    • }
Code
Diff
  • def best_moves(score)
      # return the three best moves to reach 0 from the given score
      if (score.even? && score <= 40)
        return [Throw.new(score / 2, 'D')]
      end
      if score == 50 
        return [Throw.new(50)]
      end
      if score >= 182
        return [Throw.new(20, 'T'), Throw.new(20, 'T'), Throw.new(20, 'T')]
      end
      if score == 170
        return [Throw.new(20, 'T'), Throw.new(20, 'T'), Throw.new(50)]
      end
      if score == 141
        return [Throw.new(19, 'T'), Throw.new(16, 'T'), Throw.new(18, 'D')]
      end
    end
    • def best_moves(score)
    • # return the three best moves to reach 0 from the given score
    • if (score.even? && score <= 40) || score == 50
    • return [score]
    • if (score.even? && score <= 40)
    • return [Throw.new(score / 2, 'D')]
    • end
    • if score == 50
    • return [Throw.new(50)]
    • end
    • if score >= 182
    • return [60, 60, 60]
    • return [Throw.new(20, 'T'), Throw.new(20, 'T'), Throw.new(20, 'T')]
    • end
    • if score == 170
    • return [60,60,50]
    • return [Throw.new(20, 'T'), Throw.new(20, 'T'), Throw.new(50)]
    • end
    • if score == 141
    • return [Throw.new(19, 'T'), Throw.new(16, 'T'), Throw.new(18, 'D')]
    • end
    • if score == 21
    • end
    • end