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.
create a program that takes an input and converts that input and removes all the spaces,numbers and capatal letters and then it counts how many charecters are left.
you will be given a string called s.
def remove(s):module Codewars.GetClosestPoint where
type Point = (Float, Float)
dist :: Point -> Point -> Float
dist (x1, x2) (y1, y2)
= sqrt (dx ^ 2 + dy ^ 2)
where (dx, dy) = (y1 - x1, y2 - x2)
closestPoint :: Point -> [Point] -> Point
closestPoint point [p] = p
closestPoint point (p : ps)
= closestBetweenTwo point p (dist point p) (closestPoint point ps)
where
closestBetweenTwo :: Point -> Point -> Float -> Point -> Point
closestBetweenTwo p0 p1 initialDist p2
| initialDist < dist point p2 = p1
| otherwise = p2
closestPoint' :: Point -> [Point] -> Point
closestPoint' point [] = point
closestPoint' point (p : ps)
= closestBetweenTwo point p (dist point p) ps
where
closestBetweenTwo :: Point -> Point -> Float -> [Point] -> Point
closestBetweenTwo p0 p1 initialDist [] = p1
closestBetweenTwo p0 p1 initialDist (p2 : ps)
| initialDist < dis = closestBetweenTwo p0 p1 initialDist ps
| otherwise = closestBetweenTwo p0 p2 dis ps
where dis = dist p0 p2module Codewars.GetClosestPointSpec where
import Codewars.GetClosestPoint (closestPoint, closestPoint')
import Test.Hspec
import Test.QuickCheck
spec :: Spec
spec = do
describe "Points" $ do
it "finds the closest Point" $ do
let points = [(38, 19), (833, 938), (83, 49), (83, 83), (72, 15)]
closestPoint (0, 0) points `shouldBe` (38, 19)
closestPoint' (0, 0) points `shouldBe` (38, 19)
-- the following line is optional for 8.2
-- main = hspec specThe given version
module Closest (closestPoint) where
type Point = (Float, Float)
-- calculates the ditance between two points
dist :: Point -> Point -> Float
dist (x1, x2) (y1, y2)
= sqrt (dx * dx + dy * dy)
where (dx, dy) = (y1 - x1, y2 - x2)
-- extracts from a list of points the closest to a given point
closestPoint :: Point -> [Point] -> Point
closestPoint point [p] = p
closestPoint point (p : ps)
= closest point p (closestPoint point ps)
where
closest :: Point -> Point -> Point -> Point
closest point p1 p2
| dist point p1 < dist point p2 = p1
| otherwise = p2module ClosestSpec (spec) where
import Closest (closestPoint)
import Test.Hspec
import Test.QuickCheck
spec :: Spec
spec = do
it "fixed tests" $ do
let points = [(38, 19), (833, 938), (83, 49), (83, 83), (72, 15)]
closestPoint (0, 0) points `shouldBe` (38, 19)
it "random tests" $ do
property $ \ point (NonEmpty points) -> do
closestPoint point points `shouldBe` refClosestPoint point points
type Point = (Float, Float)
-- calculates the ditance between two points
dist :: Point -> Point -> Float
dist (x1, x2) (y1, y2)
= sqrt (dx * dx + dy * dy)
where (dx, dy) = (y1 - x1, y2 - x2)
-- extracts from a list of points the closest to a given point
refClosestPoint :: Point -> [Point] -> Point
refClosestPoint point [p] = p
refClosestPoint point (p : ps)
= closest point p (closestPoint point ps)
where
closest :: Point -> Point -> Point -> Point
closest point p1 p2
| dist point p1 < dist point p2 = p1
| otherwise = p2The given version.
Helpers are in Preloaded and need never be changed.
Tests are in Tests and need never be changed.
Tests are performed against the original version, which is copied into Tests under a new name. This being the original version, it is tested against the fixed cases, and otherwise against itself. This starts making sense in forks, where closestPoint /= refClosestPoint.
module ClosestPoint (closestPoint) where
import Preloaded (Point,dist)
-- extracts from a list of points the closest to a given point
closestPoint :: Point -> [Point] -> Point
closestPoint point [p] = p
closestPoint point (p : ps)
= closest point p (closestPoint point ps)
where
closest :: Point -> Point -> Point -> Point
closest point p1 p2
| dist point p1 < dist point p2 = p1
| otherwise = p2module ClosestPointSpec (spec) where
import ClosestPoint (closestPoint)
import Preloaded (Point)
import Test.Hspec
import Test.QuickCheck
spec :: Spec
spec = do
it "fixed tests" $ do
let points = [(38, 19), (833, 938), (83, 49), (83, 83), (72, 15)]
closestPoint (0, 0) points `shouldBe` (38, 19)
it "random tests" $ do
property $ \ point (NonEmpty points) -> do
closestPoint point points `shouldBe` refClosestPoint point points
refClosestPoint :: Point -> [Point] -> Point
refClosestPoint point [p] = p
refClosestPoint point (p : ps)
= closest point p (closestPoint point ps)
where
closest :: Point -> Point -> Point -> Point
closest point p1 p2
| dist point p1 < dist point p2 = p1
| otherwise = p2
-- local copy, so we may change `Preloaded.dist` - maybe for a counting copy - without affecting `refClosestPoint`
-- calculates the ditance between two points
dist :: Point -> Point -> Float
dist (x1, x2) (y1, y2)
= sqrt (dx * dx + dy * dy)
where (dx, dy) = (y1 - x1, y2 - x2){-# OPTIONS_GHC -O1 #-}
module LongestPath (longestPath) where
{-
import Data.Vector.Unboxed as Vector (fromList,(!),(!?))
import Data.List (maximumBy,elemIndex)
import Data.Maybe (fromMaybe)
import Data.Monoid ((<>))
import Data.Function (on)
import Data.Ord (Down(Down))
memo :: (Enum a) => (a -> b) -> (a -> b)
memo fn = (map fn [ toEnum 0 .. ] !!) . fromEnum
longestPath :: String -> String
longestPath s = maximumBy order $ ("" :) $ zipWith ( \ i c -> if c == '\n' then "" else getLongestPath i ) [0..] s where
width = fromMaybe (length s) $ elemIndex '\n' s
order = (compare `on` length) <> (compare `on` Down)
v = fromList s
getLongestPath = memo $ \ i ->
v ! i : (maximumBy order $ ("" :)
$ map getLongestPath
$ filter ( \ j -> Just (v ! i) < v !? j )
$ [ i-width-2, i-width-1, i-width
, i-1 , i+1
, i+width , i+width+1, i+width+2
]
)
-}
import Control.Monad
import Data.Function ((&))
import Data.Ix (inRange)
import Data.List.Split (chunksOf)
import Data.Maybe
import Data.Vector (Vector)
import qualified Data.Vector as V
minimumOn :: (Ord b) => (a -> b) -> [a] -> a
minimumOn f [] = error "Data.List.Extra.minimumOn: empty list"
minimumOn f (x:xs) = g x (f x) xs
where
g v mv [] = v
g v mv (x:xs) | mx < mv = g x mx xs
| otherwise = g v mv xs
where mx = f x
longestPath :: String -> String
longestPath = solve . lines
maximumCell :: [(Int, [Char])] -> (Int, [Char])
maximumCell = minimumOn (\(n, s) -> (-n, s))
solve :: [[Char]] -> [Char]
solve input = knot & V.toList & V.concat & V.toList & maximumCell & snd
where
grid = V.fromList $ V.fromList <$> input
height = length input
width = length (head input)
knot = V.fromList $ do
row <- [0 .. height - 1]
pure $ V.fromList $ seqLenAt grid knot row <$> [0 .. width - 1]
around :: [(Int, Int)]
around = (,) <$> [-1 .. 1] <*> [-1 .. 1] & filter (/= (0, 0))
seqLenAt
:: Vector (Vector Char)
-> Vector (Vector (Int, [Char]))
-> Int
-> Int
-> (Int, [Char])
seqLenAt grid knot row col = maximumCell candidates
where
hereCh = (grid V.! row) V.! col
candidates = (1, [hereCh]) : do
(dx, dy) <- around
let (ty, tx) = (row + dy, col + dx)
thereCh <- maybeToList $ (V.!? ty) >=> (V.!? tx) $ grid
guard $ hereCh < thereCh
let (n, s) = (knot V.! ty) V.! tx
pure (n + 1, hereCh : s){-# OPTIONS_GHC -O1 #-}
module LongestPathSpec (spec) where
import LongestPath (longestPath)
import Test.Hspec
import Test.QuickCheck
import Data.Vector.Unboxed as Vector (fromList,(!),(!?))
import Data.List (maximumBy,elemIndex)
import Data.Maybe (fromMaybe)
import Data.Monoid ((<>))
import Data.Function (on)
import Data.Ord (Down(Down))
spec :: Spec
spec = do
it "example tests" $ do
longestPath "mda\n\
\xfc\n\
\gxx\n" `shouldBe` "acdfgx"
longestPath "bja\n\
\def\n\
\ghi\n" `shouldBe` "bdefhi"
longestPath "/o'xk4^%6N\n\
\xZ-(CKd:}N\n\
\#LoYiI.o(2\n\
\Qu+$oBE[oe\n\
\RSr&Y|O'*Q\n\
\ypmJ9th[&G\n\
\*XKq,{&/Q_\n\
\44>S6=6{jR\n\
\&)2KgPBlAF\n\
\39rG:2ixUV\n" `shouldBe` "$&+LQRSmpru"
it "fixed tests" $ do
longestPath "" `shouldBe` ""
longestPath "\n" `shouldBe` ""
longestPath "\n\
\\n" `shouldBe` ""
longestPath "a\n" `shouldBe` "a"
longestPath "ab\n" `shouldBe` "ab"
longestPath "a\n\
\b\n" `shouldBe` "ab"
longestPath "zzzz\n\
\zzzz\n" `shouldBe` "z"
it "random tests" $ do
withMaxSuccess 100 $ forAll (genGrid (10,20)) $ \ s -> do
-- print s
-- print $ ( length $ refLongestPath s, refLongestPath s )
longestPath s `shouldBe` refLongestPath s
it "random tests" $ do
withMaxSuccess 300 $ forAll (genGrid (50,80)) $ \ s -> do
-- print s
-- print $ ( length $ refLongestPath s, refLongestPath s )
longestPath s `shouldBe` refLongestPath s
genGrid :: (Int,Int) -> Gen String
genGrid range = do
width <- choose range
height <- choose range
fmap unlines $ vectorOf height $ vectorOf width $ elements [' '..'~']
memo :: (Enum a) => (a -> b) -> (a -> b)
memo fn = (map fn [ toEnum 0 .. ] !!) . fromEnum
refLongestPath :: String -> String
refLongestPath s = longestPath s
refLongestPath s = maximumBy order $ ("" :) $ zipWith ( \ i c -> if c == '\n' then "" else getLongestPath i ) [0..] s where
width = fromMaybe (length s) $ elemIndex '\n' s
order = (compare `on` length) <> (compare `on` Down)
v = fromList s
getLongestPath = memo $ \ i ->
v ! i : (maximumBy order $ ("" :)
$ map getLongestPath
$ filter ( \ j -> Just (v ! i) < v !? j )
$ [ i-width-2, i-width-1, i-width
, i-1 , i+1
, i+width , i+width+1, i+width+2
]
)You have to create an which abbreviation function. It will take string and return a string while taking the first and last char and replace the remaining with the number of chars.
For example:
internationalization => i18n
Localization => L10n
Deepak-Vishwa => D4k-V4a
function abbrev(str) {
// TODO
}const Test = require("@codewars/test-compat");
describe("Solution", function() {
it("should test for something", function() {
Test.assertEquals(abbrev("internationalization"), "i18n");
Test.assertEquals(abbrev("Localization"), "L10n");
Test.assertEquals(abbrev("Deepak-Vishwa"), "D4k-V4a");
});
});Write a function that returns the value of a number divided by 2
(Positive)(Truncated)
div2(7) = 3
div2(10) = 5
unsigned long long div2(unsigned long long a){
//Use binary operators...I-O
return a >> 1;
}// TODO: Replace examples and use TDD by writing your own tests
Describe(d2)
{
It(under10)
{
Assert::That(div2(10), Equals(5));
Assert::That(div2(0), Equals(0));
Assert::That(div2(3), Equals(1));
}
It(huge_numbers)
{
Assert::That(div2(65536), Equals(32768));
Assert::That(div2(6553665535), Equals(3276832767));
Assert::That(div2(1234567890), Equals(617283945));
}
};take a number as input say (n) and add all the digit of this numnber until result is not equal to a single digit no.
EX. 1245358,
output=1+2+4+5+3+5+8=28, 28=2+8=10, 10=1+0=1
so, output=1
n=int(input())
for i in range(n):
add=add+n[i]
if add>9:
while add<10:
for j in range(add):
add+=add[j]
print(add)
else:
print(add)import codewars_test as test
# TODO Write tests
import solution # or from solution import example
# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
@test.it("test case")
def test_case():
test.assert_equals(1 + 1, 2)A binary gap within a positive integer N is any maximal sequence of consecutive zeros that is surrounded by ones at both ends in the binary representation of N.
For example, number 9 has binary representation 1001 and contains a binary gap of length 2. The number 529 has binary representation 1000010001 and contains two binary gaps: one of length 4 and one of length 3. The number 20 has binary representation 10100 and contains one binary gap of length 1. The number 15 has binary representation 1111 and has no binary gaps. The number 32 has binary representation 100000 and has no binary gaps.
Write a function:
that, given a positive integer N, returns the length of its longest binary gap. The function should return 0 if N doesn't contain a binary gap.
For example, given N = 1041 the function should return 5, because N has binary representation 10000010001 and so its longest binary gap is of length 5. Given N = 32 the function should return 0, because N has binary representation '100000' and thus no binary gaps.
function binaryGap($n) {
}<?php
use PHPUnit\Framework\TestCase;
// PHPUnit Test Examples:
// TODO: Replace examples and use TDD by writing your own tests
class ExampleTest extends TestCase
{
// test function names should start with "test"
public function testThatSomethingShouldHappen() {
$this->assertEquals(5, binaryGap(1041));
$this->assertEquals(9, binaryGap(9));
$this->assertEquals(0, binaryGap(15));
}
}def abbrev(str):
return str[0] + str(len(str[1::-1])) + str[-1]import codewars_test as test
# TODO Write tests
import solution # or from solution import example
# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
@test.it("test case")
def test_case():
test.assert_equals(1 + 1, 2)