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
lyaguxafrogvs.Cilok

Reverse strings but python now

Fundamentals
Strings
Code
Diff
  • reverse_string = lambda s: s[::-1]
    • def reverse_string(s):
    • return s[::-1]
    • reverse_string = lambda s: s[::-1]
lyaguxafrogvs.Pinnacle

Identifiera Datatyp

Fundamentals
Logic
Code
Diff
  • def identify_data_type(n):
    return n.__class__.__name__
    • identify_data_type=lambda i:type(i).__name__
    • def identify_data_type(n):
    • return n.__class__.__name__
lyaguxafrogvs.0xKillswitch

Greetings!

Code
Diff
  • def Greeting(n, rank='', formal=False):
    determinant = f'{rank} {n}' if formal and rank else f'{n}'
    return f"Hello, {determinant}." if formal else f"Hey, {determinant}!"
    • def Greeting(n, rank='', formal=0):
    • determinant = f'{rank} {n}' if formal and rank else f'{n}'
    • return f"Hello, {determinant}." if formal else f"Hey, {determinant}!"
    • def Greeting(n, rank='', formal=False):
    • determinant = f'{rank} {n}' if formal and rank else f'{n}'
    • return f"Hello, {determinant}." if formal else f"Hey, {determinant}!"
lyaguxafrogvs.m.yudak

Word Game - Nth Longest Words

Arrays
Sorting
Code
Diff
  • import re

def longest_words(word_list, num_words):
    if not isinstance(word_list, list) or not isinstance(num_words, int) or num_words < 0:
        return 'Invalid Parameters'

    valid_words = [re.sub(r'[^A-Za-z]', '', word) for word in word_list if word and re.sub(r'[^A-Za-z]', '', word)]

    return sorted(valid_words, key=len, reverse=True)[:num_words] if num_words <= len(valid_words) else 'Invalid Parameters'
    • import re
    • def longest_words(array, num):
    • valid_words = [re.sub(r'[^A-Za-z]', '', word) for word in array if word and re.sub(r'[^A-Za-z]', '', word)]
    • return sorted(valid_words, key=len, reverse=True)[:num] if num <= len(valid_words) else 'Invalid Parameters'
    • def longest_words(word_list, num_words):
    • if not isinstance(word_list, list) or not isinstance(num_words, int) or num_words < 0:
    • return 'Invalid Parameters'
    • valid_words = [re.sub(r'[^A-Za-z]', '', word) for word in word_list if word and re.sub(r'[^A-Za-z]', '', word)]
    • return sorted(valid_words, key=len, reverse=True)[:num_words] if num_words <= len(valid_words) else 'Invalid Parameters'
gmottajrvs.gmottajr

Sum of the letters (ASCII)

You have received 2 names.

Verify if the sum of letters of the 1 name is the same as sum of the letters of the 2 name. If the name or surname is null output NULL.

For example:

"Anna" and "Nana"
"Anna" = 65+110+110+97 = 382
"Nana" = 78+97+110+97 = 382
Result: "Anna" and "Nana" => "TRUE"

"Sebastian" and "Patricia" => "FALSE"

"John" and null => "NULL"

Code
Diff
  • #include <string>
#include <numeric>
#include <algorithm>

class StringComparer {
public:
    static bool verifySum(const std::string& w1, const std::string& w2) {
        int sumW1 = sumOfCharacters(w1);
        int sumW2 = sumOfCharacters(w2);

        return sumW1 == sumW2;
    }
  
    static int sumOfCharacters(const std::string& word) {
        return std::accumulate(word.begin(), word.end(), 0, [](int sum, char ch) {
            return sum + static_cast<int>(ch);
        });
    }
};
    • #include <string>
    • #include <numeric>
    • #include <algorithm>
    • class StringComparer {
    • public:
    • static bool verifySum(const std::string& w1, const std::string& w2) {
    • int sumW1 = sumOfCharacters(w1);
    • int sumW2 = sumOfCharacters(w2);
    • std::cout << "String 1: " << w1 << " - Sum of Characters: " << sumW1 << std::endl;
    • std::cout << "String 2: " << w2 << " - Sum of Characters: " << sumW2 << std::endl;
    • return sumW1 == sumW2;
    • }
    • static int sumOfCharacters(const std::string& word) {
    • return std::accumulate(word.begin(), word.end(), 0, [](int sum, char ch) {
    • return sum + static_cast<int>(ch);
    • });
    • }
    • };