Begin a new Kumite
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.
Strings
module Format where import Data.Bits ((.|.)) import Data.Char (chr) f :: Integer -> [Char] f n = f' [chr $ (.|.) 48 $ fromIntegral $ mod n 10] (div n 10) where f' :: [Char] -> Integer -> [Char] f' sol 0 = sol f' acc n = f'' ((:) (chr $ (.|.) 48 $ fromIntegral $ mod n 10) acc) (div n 10) where f'' :: [Char] -> Integer -> [Char] f'' sol 0 = sol f'' acc n = f''' ((:) (chr $ (.|.) 48 $ fromIntegral $ mod n 10) acc) (div n 10) where f''' :: [Char] -> Integer -> [Char] f''' sol 0 = sol f''' acc n = f' ((:) (chr $ (.|.) 48 $ fromIntegral $ mod n 10) $ (:) ',' acc) (div n 10)1 − def f(n):
2 − G = 3
3 − s = str(n)
4 − r = len(s) % G
5 − def make(s):
6 − if r:
7 − yield s[:r]
8 − for i in range(r, len(s), G):
9 − yield s[i:i+G]
10 − return ','.join(make(s))
1 + module Format where
2 + 3 + import Data.Bits ((.|.))
4 + import Data.Char (chr)
5 + 6 + f :: Integer -> [Char]
7 + f n = f' [chr $ (.|.) 48 $ fromIntegral $ mod n 10] (div n 10) where
8 + f' :: [Char] -> Integer -> [Char]
9 + f' sol 0 = sol
10 + f' acc n = f'' ((:) (chr $ (.|.) 48 $ fromIntegral $ mod n 10) acc) (div n 10) where
11 + f'' :: [Char] -> Integer -> [Char]
12 + f'' sol 0 = sol
13 + f'' acc n = f''' ((:) (chr $ (.|.) 48 $ fromIntegral $ mod n 10) acc) (div n 10) where
14 + f''' :: [Char] -> Integer -> [Char]
15 + f''' sol 0 = sol
16 + f''' acc n = f' ((:) (chr $ (.|.) 48 $ fromIntegral $ mod n 10) $ (:) ',' acc) (div n 10)
module FormatSpec where -- Tests can be written using Hspec http://hspec.github.io/ -- Replace this with your own tests. import Test.Hspec import Format -- `spec` of type `Spec` must exist spec :: Spec spec = do describe "Tests" $ do it "basic testing" $ do (f 100) `shouldBe` ("100" :: String) (f 1000) `shouldBe` ("1,000" :: String) (f 12345) `shouldBe` ("12,345" :: String) (f 123456789) `shouldBe` ("123,456,789" :: String) (f 10000000000) `shouldBe` ("10,000,000,000" :: String) -- the following line is optional for 8.2 main = hspec spec1 − import codewars_test as test
2 − # TODO Write tests
3 − import solution # or from solution import example
1 + module FormatSpec where
2 + -- Tests can be written using Hspec http://hspec.github.io/
3 + -- Replace this with your own tests.
4 4 5 − test.assert_equals(f(100), '100')
6 − test.assert_equals(f(1000), '1,000')
7 − test.assert_equals(f(12345), '12,345')
8 − test.assert_equals(f(123456789), '123,456,789')
9 − test.assert_equals(f(10000000000), '10,000,000,000')
5 + import Test.Hspec
6 + import Format
10 10 11 − @test.describe("Example")12 − def test_group():
13 − @test.it("test case")14 − def test_case():
15 − test.assert_equals(1 + 1, 2)
8 + -- `spec` of type `Spec` must exist
9 + spec :: Spec
10 + spec = do
11 + describe "Tests" $ do
12 + it "basic testing" $ do
13 + (f 100) `shouldBe` ("100" :: String)14 + (f 1000) `shouldBe` ("1,000" :: String)15 + (f 12345) `shouldBe` ("12,345" :: String)16 + (f 123456789) `shouldBe` ("123,456,789" :: String)17 + (f 10000000000) `shouldBe` ("10,000,000,000" :: String)18 + 19 + -- the following line is optional for 8.2
20 + main = hspec spec
Recent Moves:
Strings
def f(n): l = [digit for digit in str(n)] count_to_three = 1 for i in range(len(l) - 1, 0, -1): if count_to_three != 3: count_to_three += 1 else: l.insert(i, ',') count_to_three = 1 return ''.join(l) if count_to_three<=1: fotmat(len(l))… Expand 1 1 def f(n):
2 2 l = [digit for digit in str(n)]
3 3 4 4 count_to_three = 1
5 5 for i in range(len(l) - 1, 0, -1):
6 6 if count_to_three != 3:
7 7 count_to_three += 1
8 8 else:
9 9 l.insert(i, ',')
10 10 count_to_three = 1
11 11 12 − return ''.join(l)
12 + return ''.join(l)
13 + 14 + if count_to_three<=1:
15 + fotmat(len(l))
16 +
Strings
Use the way we handle this problem with our brain.
We count and put a comma every three digits.
def f(n): l = [digit for digit in str(n)] count_to_three = 1 for i in range(len(l) - 1, 0, -1): if count_to_three != 3: count_to_three += 1 else: l.insert(i, ',') count_to_three = 1 return ''.join(l)1 1 def f(n):
2 − G = 3
3 − s = str(n)
4 − r = len(s) % G
5 − def make(s):
6 − if r:
7 − yield s[:r]
8 − for i in range(r, len(s), G):
9 − yield s[i:i+G]
10 − return ','.join(make(s))
2 + l = [digit for digit in str(n)]
3 + 4 + count_to_three = 1
5 + for i in range(len(l) - 1, 0, -1):
6 + if count_to_three != 3:
7 + count_to_three += 1
8 + else:
9 + l.insert(i, ',')
10 + count_to_three = 1
11 + 12 + return ''.join(l)
Strings
Your boss give you a task to format some integer numbers like this:
123456789 -> 123,456,789
So, you should write a function f which recieves a integer number and returns a string which every 3 consecutive digits are splitted with , symbol from left to right.
Strings
def f(n, G=3): s = str(n) r = len(s) % G return ','.join([x for x in [s[:r]] + [s[i:i+G] for i in range(r, len(s), G)] if x])1 − def f(n):
2 − G = 3
1 + def f(n, G=3):
3 3 s = str(n)
4 4 r = len(s) % G
5 − def make(s):
6 − if r:
7 − yield s[:r]
8 − for i in range(r, len(s), G):
9 − yield s[i:i+G]
10 − return ','.join(make(s))
4 + return ','.join([x for x in [s[:r]] + [s[i:i+G] for i in range(r, len(s), G)] if x])
Recent Moves:
Not going to replace the // with a / in this fork.
""" d=lambda x:d(x//10)+x%10 if x>9 else x """ d=lambda x:(x>9and d(x//10))+x%10 a=lambda m,s,p:d(m)<d(s)+d(p)1 + """
1 1 d=lambda x:d(x//10)+x%10 if x>9 else x
3 + """
4 + d=lambda x:(x>9and d(x//10))+x%10
2 2 a=lambda m,s,p:d(m)<d(s)+d(p)
Test = test # writing this line makes me feel nostalgiac for an era of codewards i wasn't a part of Test.expect(not a(27,3,1)); Test.expect(a(33,9,7)); Test.expect(a(50,26,24)); Test.expect(not a(47,25,4)); Test.expect(a(47,25,5)); Test.expect(not a(107,4,22)); Test.expect(a(106,4,22));1 + Test = test # writing this line makes me feel nostalgiac for an era of codewards i wasn't a part of
2 + 1 1 Test.expect(not a(27,3,1));
2 2 Test.expect(a(33,9,7));
3 3 Test.expect(a(50,26,24));
4 4 Test.expect(not a(47,25,4));
5 5 Test.expect(a(47,25,5));
6 6 Test.expect(not a(107,4,22));
7 7 Test.expect(a(106,4,22));