Kumite

Begin a new Kumite

About

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.

jistjoalalvs. Myles2

Descending Order of numbers.

num -> string -> array -> [sort(), reverse()] -> string -> num

JS is fun!

Code

Diff

const descendingOrder = n =>
  +[...''+n].sort().reverse().join``;

1 - function descendingOrder(n){
2 - return Number(String(n).split('').sort(function(a, b){return b-a}).join(''));
3 - }
1 + const descendingOrder = n =>
2 + +[...''+n].sort().reverse().join``;

Recent Moves:

Myles2vs. omar199523

Descending Order of numbers.

Your code is good and possibly faster but I think this is a lot shorter and somewhat easier to understand.

Code

Diff

function descendingOrder(n){
  return Number(String(n).split('').sort(function(a, b){return b-a}).join(''));
}

omar199523vs. VladislavkaSmith

VladislavkaSmith's Kumite #2

Code

Diff

function descendingOrder(n){
  let x= n.toString();
  let arr = x.split('');
  let N = arr.length;
  
  if (n.length === 1) {
    return parseInt(n, 10);
  }
  
  for (let i = 0; i < N; i++) {
    
    for (let j = 0; j < N-i-1; j++) {
       if (arr[j] < arr[j+1]) {
        let k = arr[j];
        arr[j] = arr[j+1];
        arr[j+1] = k;
      }
    }
  }
 
 	n = arr.join('');
  n = parseInt(n, 10);
  return n;
}

cafreadvs. moragaFailed Tests

Remover itens duplicados

Code

Diff

const main = () =>  {
  let = ['https://www.uol','https://www.bol.com.br','https://www.uol','https://noticias.uol.com.br','https://www.bol.com.br'];
  return [...new Set(links)].length;
};

// Functions should be passed arguments, not have the data already inside them.
// Test case:
// Test.assertEquals(['https://www.uol','https://www.bol.com.br','https://www.uol','https://noticias.uol.com.br','https://www.bol.com.br'], 3);

Test Cases

Diff

// 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.

describe("Solution", function() {
  it("should test for something", function() {
    // Test.assertEquals(1 + 1, 2);
    // assert.strictEqual(1 + 1, 2);
  });
});

Recent Moves:

omar199523vs. Marcos AdrianoFailed Tests

Remover itens duplicados

Code

Diff

const main = () => {
  const links = [
    'https://www.uol',
    'https://www.bol.com.br',
    'https://www.uol',
    'https://noticias.uol.com.br',
    'https://www.bol.com.br',
  ];
  
  // converter para ES6
  function uniqueLinks (links){
    return uniqueLinks.length;
  }
};

felipedmzvs. JonesDalgaardCoderFailed Tests

Get iterated digit sum

With parameter int 011, the tests fail.

Test Cases

Diff

class MyTestCases extends TestCase
{
    public function testOutput() {
      $this->assertEquals(getIDS(1345), 13);
      $this->assertEquals(getIDS(12), 3);
      $this->assertEquals(getIDS(110), 2);
      $this->assertEquals(getIDS(011), 2);
    }
}

zendorvs. VladislavkaSmith

VladislavkaSmith's Kumite #3

Code

Diff

const alphabetPosition = s => s.toLowerCase().replace(/[a-z]|(.)/g, (m, c) => c ? '' : ` ${m.charCodeAt(0) - 96}`).trim();

danielhenrymantillavs. henninglive

Number of digits

Numbers

Integers

Algorithms

match point

Code

Diff

// Removed loop
fn digits (n: u64) -> usize
{
  match n {
    0 ..= 9 => 1,
    10 ..= 99 => 2,
    100 ..= 999 => 3,
    1000 ..= 9999 => 4,
    10000 ..= 99999 => 5,
    100000 ..= 999999 => 6,
    1000000 ..= 9999999 => 7,
    10000000 ..= 99999999 => 8,
    100000000 ..= 999999999 => 9,
    1000000000 ..= 9999999999 => 10,
    10000000000 ..= 99999999999 => 11,
    100000000000 ..= 999999999999 => 12,
    1000000000000 ..= 9999999999999 => 13,
    10000000000000 ..= 99999999999999 => 14,
    100000000000000 ..= 999999999999999 => 15,
    1000000000000000 ..= 9999999999999999 => 16,
    10000000000000000 ..= 99999999999999999 => 17,
    100000000000000000 ..= 999999999999999999 => 18,
    1000000000000000000 ..= 9999999999999999999 => 19,
    _ => 20,
  }
}

pcarmovs. Foobywalla

Return Hello World

Code

Diff

char* Hi (void)
{
  char* ans;
  asprintf(&ans, "Hello World.");
  return ans;
}

1 1 char* Hi (void)
2 2 {
3 - char* ans=malloc(13);
4 - strcpy(ans,"Hello World.");
3 + char* ans;
4 + asprintf(&ans, "Hello World.");
5 5 return ans;
6 6 }

w348917281Failed Tests

ShellSort

def ShellSort(ary):
    length = len(ary)
    gap = round(length)
    step = length//2
    while step:
        for i in range(step,length,step):
            tmp = ary[i]
            for j in range(i,0,-step):
                if ary[j-step] > tmp:
                    ary[j] = ary[j-step]
                else:
                    break
            ary[j] = tmp
        if step == 1:
            break
        step = step//2
      
        
ary = [1,23,4,53,55,34,3,99,14]
ShellSort(ary)
print(ary)

 function alphabetPosition(text) {
  let obj = {
  "a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7,
  "h": 8, "i": 9, "j": 10, "k": 11, "l":12, "m": 13, "n": 14, "o": 15, "p": 16, "q": 17, "r": 18, "s": 19, "t": 20,
  "u": 21, "v": 22, "w": 23, "x": 24, "y": 25, "z": 26
  }
  let arr = [];
  let str = '';
  text = text.replace(/[^a-zA-Z]+/g, '');
  for (let key in obj) {
  for (let i = 0; i < text.length; i++) {
  if(text[i].toLowerCase() == key.toLowerCase() && text[i] !== '') {
  arr[i] = obj[key];
  }
  }
  }
  str = arr.join(' ');
  return str;
 }
 const alphabetPosition = s => s.toLowerCase().replace(/[a-z]|(.)/g, (m, c) => c ? '' : ` ${m.charCodeAt(0) - 96}`).trim();

Filter by Language:

Confirm