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
pearcebasmanmvs.serhii_cho

Calculate even numbers in array

Code
Diff
  • fn calculate_even_numbers(array: &[i32]) -> usize {
    array.iter().filter(|&&n| n % 2 == 0).count()
}
    • function calculateEvenNumbers(array $numbers): int {
    • $result = [];
    • foreach ($numbers as $number) {
    • if ($number % 2 === 0) {
    • $result[] = $number;
    • }
    • }
    • return count($result);
    • fn calculate_even_numbers(array: &[i32]) -> usize {
    • array.iter().filter(|&&n| n % 2 == 0).count()
    • }
Gakkie4649vs.SergeGueaFailed Tests

Higher-Order Functions Series - Find the most senior developer

Code
Diff
  • const findSenior = (list) => {
  const maxAge = Math.max(...list.map(dev => dev.age));
  return list.filter(dev => dev.age === maxAge);
};
    • // Solution
    • function findSenior(list) {
    • let maxAge = 0;
    • list.forEach((dev) => { // ho usato forEach per trovare l'età massima tra gli sviluppatori
    • if (dev.age > maxAge) {
    • maxAge = dev.age;
    • }
    • });
    • return list.filter((dev) => dev.age === maxAge); // ho usato filter per filtrare gli sviluppatori con l'età massima
    • }
    • const findSenior = (list) => {
    • const maxAge = Math.max(...list.map(dev => dev.age));
    • return list.filter(dev => dev.age === maxAge);
    • };
alexguttleinvs.gaston-areco-tq

Find maximum number that can be formed using digits of a given number

Code
Diff
  • import java.util.Arrays;

public class MaxNumber {
    public static long print(long number) {
      
      //convierto el long en string para ingresarlo en un vector de enteros
        int longitud = String.valueOf(number).length();
        int[] digitos = new int[longitud];

        for (int i = 0; i < longitud; i++){
            digitos[i] = (int)(number % 10);
            number = number / 10;
        }
        
        //ordeno el array de numeros
        Arrays.sort(digitos);

        //recorro el array de enteros (empezando por el final) 
        //y los agrego a una nueva cadena
        String numComoString = "";
        for (int i = longitud-1; i >= 0; i--){
            numComoString += digitos[i];
        }

        //convierto la cadena en long y asigno a la variable inicial
        number = Long.parseLong(numComoString);  
      
        return number;
    }
}
    • import java.util.Arrays;
    • public class MaxNumber {
    • public static long print(long number) {
    • return number
    • //convierto el long en string para ingresarlo en un vector de enteros
    • int longitud = String.valueOf(number).length();
    • int[] digitos = new int[longitud];
    • for (int i = 0; i < longitud; i++){
    • digitos[i] = (int)(number % 10);
    • number = number / 10;
    • }
    • //ordeno el array de numeros
    • Arrays.sort(digitos);
    • //recorro el array de enteros (empezando por el final)
    • //y los agrego a una nueva cadena
    • String numComoString = "";
    • for (int i = longitud-1; i >= 0; i--){
    • numComoString += digitos[i];
    • }
    • //convierto la cadena en long y asigno a la variable inicial
    • number = Long.parseLong(numComoString);
    • return number;
    • }
    • }
MohammadSadeghAlimardanivs.rowcased

0 and 1 test case

Code
Diff
  • function helloWorld(_){
    if(_) return `Hello World baby`
    else return `No World`
}
    • helloWorld
    • =_=>
    • _?`Hello World baby`:`No World`
    • function helloWorld(_){
    • if(_) return `Hello World baby`
    • else return `No World`
    • }
MohammadSadeghAlimardanivs.Rishabh Trivedi

Сумма нечетных

Code
Diff
  • const sumNechet = (a, b) =>{
    let answer = 0;
    for (let index = a; index <= b; index++) {
        index % 2 == 1 ? answer += index : null;
    }
    return answer;
} 
console.log(sumNechet(5,15));
    • //Крюков Кирилл
    • function sumNechet(a, b) {
    • var answer = 0;
    • for (var i = a; i <= b; i++){
    • if (i % 2 != 0){
    • answer += i;
    • const sumNechet = (a, b) =>{
    • let answer = 0;
    • for (let index = a; index <= b; index++) {
    • index % 2 == 1 ? answer += index : null;
    • }
    • }
    • return answer;
    • }
    • return answer;
    • }
    • console.log(sumNechet(5,15));
pearcebasmanmvs.MrSmiters

Once upon a time in the huge array

Code
Diff
  • use itertools::Itertools;
use std::{hash::Hash, collections::VecDeque};

fn delete<T: Eq + Hash + Copy>(a: &[T]) -> Vec<T> {
    let mut v = VecDeque::new();
    a.iter().rev().unique().for_each(|&e| v.push_front(e));
    v.into()
}
    • import java.util.*;
    • use itertools::Itertools;
    • use std::{hash::Hash, collections::VecDeque};
    • class DeleteDuplicates {
    • public static double[] delete(double[] a) {
    • for(int i = 0; i < a.length / 2; i++) {
    • double temp = a[i];
    • a[i] = a[a.length - i - 1];
    • a[a.length - i - 1] = temp;
    • }
    • Set<Double> set = new LinkedHashSet<>();
    • for (double v : a) {
    • set.add(v);
    • if(v < 0.0)
    • return new double[]{-1.0};
    • }
    • List<Double> list = new ArrayList<>(set);
    • Collections.reverse(list);
    • double[] array_here = list.stream().mapToDouble(Double::doubleValue).toArray();
    • //incorrect (too long and witout accuracy)
    • return array_here;
    • }
    • }
    • fn delete<T: Eq + Hash + Copy>(a: &[T]) -> Vec<T> {
    • let mut v = VecDeque::new();
    • a.iter().rev().unique().for_each(|&e| v.push_front(e));
    • v.into()
    • }
playerO1vs.ShadowReW

C++ Simple Calculator

Code
Diff
  • #include <ostream>
using namespace std;

string calculator(char op, int a, int b) {
    stringstream s;
    switch (op) {
        case '+': {s<<a+b; break;}
        case '-': {s<<a-b; break;}
        case '*': {s<<a*b; break;}
        case '%': {s<<a%b; break;}
        case '/': {if (b != 0) {s<<a/b;break;}/*else default: Invalid Input!*/}
        default:  {s<<"Invalid Input!";}
    }
    return s.str();
}
    • #include <ostream>
    • using namespace std;
    • string calculator(char op, int a, int b) {
    • stringstream s;
    • switch (op) {
    • case '+': {s<<a+b; return s.str();}
    • case '-': {s<<a-b; return s.str();}
    • case '*': {s<<a*b; return s.str();}
    • case '/': {b != 0 ? s<<a/b : s<<"Invalid Input!"; return s.str();}
    • case '%': {s<<a%b; return s.str();}
    • default: return "Invalid Input!";
    • case '+': {s<<a+b; break;}
    • case '-': {s<<a-b; break;}
    • case '*': {s<<a*b; break;}
    • case '%': {s<<a%b; break;}
    • case '/': {if (b != 0) {s<<a/b;break;}/*else default: Invalid Input!*/}
    • default: {s<<"Invalid Input!";}
    • }
    • return s.str();
    • }
pearcebasmanmvs.Upsided

Integer to table

Code
Diff
  • fn int_to_table(num: u32) -> Vec<u32> {
    (0..=num).collect()
}
    • def int_to_table(num):
    • tab = []
    • for x in range(num + 1):
    • tab.append(x)
    • print(tab)
    • return tab
    • fn int_to_table(num: u32) -> Vec<u32> {
    • (0..=num).collect()
    • }
pearcebasmanmvs.user6161676

Find the odd one out!

Code
Diff
  • fn odd_one_out(s: &str) -> char {
    let arr: Vec<_> = s.chars().take(3).collect();
    let common = if arr[0] == arr[1] { arr[0] } else { arr[2] };
    s.chars().find(|&c| c != common).unwrap()
}
    • package oddoneout
    • fun oddOneOut(s: String): String {
    • var odd = 0
    • var same = 0
    • var keepTrack = s[0]
    • var sameTracker = ""
    • var oddTracker = ""
    • for (i in s.indices) {
    • if (s[i] == keepTrack) {
    • same += 1
    • sameTracker += s[i]
    • } else {
    • odd += 1
    • oddTracker += s[i]
    • }
    • }
    • if (odd < 2) {
    • return oddTracker
    • } else {
    • return sameTracker
    • }
    • fn odd_one_out(s: &str) -> char {
    • let arr: Vec<_> = s.chars().take(3).collect();
    • let common = if arr[0] == arr[1] { arr[0] } else { arr[2] };
    • s.chars().find(|&c| c != common).unwrap()
    • }
Tom H. Lautenbachervs.user8436785

Sum of the letters (ASCII)

Code
Diff
  • def verify_sum(w1, w2)
  w1.sum == w2.sum rescue false
end
    • def verifySum(w1, w2)
    • !!(w1 && w2 && w1.downcase.chars.sum(&:ord) == w2.downcase.chars.sum(&:ord))
    • def verify_sum(w1, w2)
    • w1.sum == w2.sum rescue false
    • end