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.
// See https://pub.dartlang.org/packages/test import "package:test/test.dart"; import "package:solution/solution.dart"; void main() { test("add", () { expect(a(), equals(null)); }); }1 + // See https://pub.dartlang.org/packages/test
2 + import "package:test/test.dart";
3 + import "package:solution/solution.dart";
1 1 5 + void main() {6 + test("add", () {7 + expect(a(), equals(null));
8 + });
9 + }
:v
I would love to see a generator which accepts [(Gen s, Int)] and uses a set of generators, generates n inputs from each of them, shuffles them, and uses the inputs to feed test cases.
For example, for "Is a number prime?" kata, I'd like to have a composite generator built like compositeGen([(genPrimes, 100), (genOddComposites, 100), (genNegativePrime, 10), (genSquareOfAPrime, 20)]) or something like this, and it would run test cases over 230 shuffled inputs.
Bonus points if such generator were able to generate not only Int, but also (Int, Bool) (input + expected answer) or even (Int, Bool, String) (input, expected answer, and assertion message).
The one thing I can't fix is that if it fails, it's always after 1 test. Because that's what it sees.
module Example (isPrime) where
isPrime :: Int -> Bool
isPrime = oddmodule ExampleSpec (spec) where
import Example (isPrime)
import Test.Hspec hiding (shouldBe)
import Test.QuickCheck
import Data.Foldable (for_)
import Control.Monad (unless,replicateM)
import Data.List ((\\))
import Data.Traversable (for,mapM)
type Input = Int
type Actual = Bool
type Expected = Actual -- necessarily
type Message = String
solution :: Input -> Actual
solution = isPrime
primes,composites :: [Input]
primes = [2,3,5,7,11,13,17,19]
composites = [1..20] \\ primes
genPrimes :: Gen (Input,Expected,Message)
genPrimes = ( \ prime -> (prime,True,show prime ++ " is prime") ) <$> elements primes
genComposites :: Gen (Input,Expected,Message)
genComposites = ( \ composite -> (composite,False,show composite ++ " is composite") ) <$> elements composites
-- generators could also use a reference solution
spec :: Spec
spec = do
it "random tests" $ do
once $ forAllBlind (gen [(genPrimes,50),(genComposites,100)]) $ \ tests -> do
for_ tests $ \ (arg,expected,msg) -> do
print arg
solution arg `shouldBe` expected $ msg
-- can also factor out the specific plumbing
it "random tests" $ do
forAllGenerators [(genPrimes,50),(genComposites,100)] $ \ (arg,expected,msg) -> do
print arg
solution arg `shouldBe` expected $ msg
gen :: [(Gen (Input,Expected,Message),Int)] -> Gen [(Input,Expected,Message)]
gen gens = do
shuffle =<< concat <$> for gens ( \ (gen,n) -> replicateM n gen )
forAllGenerators :: [(Gen (Input,Expected,Message),Int)] -> ((Input,Expected,Message) -> Expectation) -> Property
forAllGenerators gens prop = do
once $ forAllBlind (gen gens) $ \ tests -> do
for_ tests prop
shouldBe :: (Show a,Eq a) => a -> a -> Message -> Expectation
shouldBe actual expected msg = unless (actual == expected) $ expectationFailure $ concat [ msg, "\nexpected : ", show actual, "\nbut got : ", show expected ]
-- a shouldBe that can show a messageimport java.util.*; interface HighLow { static int[] printLargestAndSmallest(int[] nums) { Arrays.sort(nums); return new int[] {nums[0], nums[nums.length-1]}; } }1 + import java.util.*;
1 1 interface HighLow {2 2 static int[] printLargestAndSmallest(int[] nums) {3 − int min = nums[0], max = nums[0];
4 − for (int n : nums) {5 − if (n < min) min = n;
6 − if (n > max) max = n;
7 − }
8 − return new int[] {min, max};4 + Arrays.sort(nums);
5 + return new int[] {nums[0], nums[nums.length-1]};9 9 }
10 10 }
Optimization: you don't need to go all the way to n.
export const checkIsPrimeNumber = (n: number) => { if (!Number.isInteger(n)) return false; for (var i = 2; i <= Math.min(n, Math.sqrt(n)); i++) { if (n % i === 0) return false; } return n > 1; };1 1 export const checkIsPrimeNumber = (n: number) =>
2 2 {3 3 if (!Number.isInteger(n)) return false;
4 − for (var i = 2; i < n; i++) {4 + for (var i = 2; i <= Math.min(n, Math.sqrt(n)); i++) {5 5 if (n % i === 0) return false;
6 6 }
7 7 return n > 1;
8 8 };
Bitwise operations usually work faster than arithmetic.
Recent Moves:
Might work slightly faster.
Used lambda for a simplier look