Kumite

Show My Kumite Only?
Filter by Language:
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.

Mongoid Example

require 'mongoid'
File.open('mongoid.yml', 'w') do |file|
  file.write <<-CONFIG
development:
  sessions:
    default:
      database: mongoid
      hosts:
        - localhost:27017
CONFIG
end
fork do
  exec 'mongod'
end

sleep 1 # need to find a better way to wait for mongo to startup

ENV['RACK_ENV'] = 'development'
Mongoid.load!('mongoid.yml')

class User
  include Mongoid::Document
  field :name
end
describe User do
  it 'should save' do
    Test.expect(User.new.save)
    Test.assert_equals(User.count, 1)
  end
end

xcthulhu

Pi in Your Eye

Mathematics

Algorithms

Numbers

Using Liebniz' formula... converges attrociously slowing...

(->> (iterate inc 0) 
     (map #(-> (Math/pow -1 %) (/ (inc (* 2 %))))) 
     (take 1200001) 
     (reduce +) 
     (* 4) 
     println)

noogavs.xcthulhu

Number to Word

Numbers

Interview Questions

Code

Diff

(ns number-to-words
  (:require [clojure.string :refer [join]]))

(def digit-to-word
  {1 "One"  2 "Two" 3 "Three" 4 "Four"
   5 "Five" 6 "Six" 7 "Seven" 8 "Eight"
   9 "Nine"})

(def tens-to-word
  {
   20 "Twenty" 30 "Thirty" 40 "Fourty"
   50 "Fifty"  60 "Sixty"  70 "Seventy"
   80 "Eighty" 90 "Ninety"})

(def teen-to-word
  {10 "Ten"      11 "Eleven"    12 "Twelve"
   13 "Thirteen" 14 "Fourteen"  15 "Fifteen"  
   16 "Sixteen"  17 "Seventeen" 18 "Eighteen"
   19 "Nineteen"})

(defn divmod [n d] [(quot n d) (mod n d)])

(defn tens [n & {:keys [zero] :or {zero ""}}] 
  (let [[tens ones] (divmod n 10)
        digit       (digit-to-word ones)]
        (condp = tens 
          0 (or digit zero)
          1 (teen-to-word n)
            (str (tens-to-word (* 10 tens)) (when digit (str "-" digit))))))
            
(defn order [d name f n]
  (let [[hs ts] (divmod n d)]
        (str ""
          (when (> hs 0) (str (f hs) " " name))
          (when (> ts 0) (str (when (> hs 0) " ") (f ts))))))

(def hundreds (partial order 100 "Hundred" tens))

(def orders ["" " Thousand" " Million" " Billion" " Trillion"])
          
(defn addp [lst n o]
  (if (> n 0) (conj lst (str (hundreds n) (orders o))) lst))
          
(defn convert- [x]
  (join ", "
    (loop [i 0, n x, out '()]
      (let [[a b] (divmod n 1000)]
        (cond
         (>= a 1000) (recur (inc i) a (addp out b i))
         (>  a 0)    (-> out (addp b i) (addp a (inc i)))
         :else       (addp out b i)
         )))))

(defn convert [x]
  (case (compare x 0)
    -1 (str "Negative " (convert- (- (int x))))
     0 "Zero"
     1 (convert- (int x))
     nil))

Test Cases

Diff

(ns number-to-word-test
  (:require [clojure.test :refer :all]
            [number-to-words]))

(deftest conversion-test
  (is (= "Zero" (number-to-words/convert 0)))
  (is (= "One" (number-to-words/convert 1)))
  (is (= "Seven" (number-to-words/convert 7)))
  (is (= "Eleven" (number-to-words/convert 11)))
  (is (= "Ninety" (number-to-words/convert 90)))
  (is (= "Twenty-Six" (number-to-words/convert 26)))
  (is (= "Three Hundred Eleven" (number-to-words/convert 311)))
  (is (= "Two Hundred Two" (number-to-words/convert 202)))
  (is (= "Seven Hundred" (number-to-words/convert 700)))
  (is (= "Five Hundred Ninety-Nine" (number-to-words/convert 599)))
  (is (= "One Million" (number-to-words/convert 1e6)))
  (is (= "Nine Hundred Ninety-Nine Thousand" (number-to-words/convert 999e3))
  (is (= "Six Hundred Twelve Thousand, Three Hundred Twenty-Three" (number-to-words/convert 612323)))))

phailyoor

Inline Assembly

int main()
{
  printf("%d\n", test());
}

int test()
{
  __asm__("movl $1337, %eax");
}

xcthulhu

Hello world racket!

(display "Hello, world!")

jhoffner

Ruby Redis example

Redis

NoSQL

Databases

A basic example of how to run a Redis in ruby on CW.

fork do
  exec "redis-server"
end

require 'redis'
r = Redis.new

r.set('a', 'b')

Test.assert_equals(r.get('a'), 'b')

xcthulhu

Thread UNSafe with-out-str

When you have a thread ouputting to stdout, and you want to catch its output in a test case...

(defmacro with-out-str-not-thread-safe
  "A version of clojure.core/with-out-str that is not thread-safe"
  [& body]
  `(let [s# (StringWriter.)]
     (with-redefs [*out* s#]
       ~@body
       (str s#))))

rmulliganvs.user578387

Array#flip method

Recursion

Algorithms

Computability Theory

Theoretical Computer Science

Arrays

Methods

Functions

Object-oriented Programming

Control Flow

Basic Language Features

Fundamentals

Classes

Code

Diff

class Array # Opens up the Array class for method creation
  def flip
    self.reverse.map{|e| e.is_a?(Array) ? e.flip : e}
  end
end

xcthulhu

xcthulhu's Kumite #20

class Solution {
    public static void main(String[] args) {
        System.out.println("Hello darkness, my old friend...");
    }
}

adamveld12vs.adamveld12

Tail Recursive Factorial

Recursion

Algorithms

Computability Theory

Theoretical Computer Science

A Tail recursive factorial function

Code

Diff

Factorial = fun(N) when N > 0 ->

  Tail = fun (Y, Acc, 0) ->  Acc;
             (Y, Acc, N) -> Y(Y, Acc * N, N - 1) 
         end,
         
  Tail(Tail, 1, N)
end,

io:format("~s~n", [Factorial(5)]),

 class Array # Opens up the Array class for method creation
   def flip
-−
+    result = []
-−
+    me = self.reverse # Don't fret, I'll sort the Arrays out!
-−
-−
+    me.each do |x|
-−
-−
+      if x.class == Array then result << x.flip # Here's the recursion.
-−
+      else result << x
-−
+      end
-−
-−
+    end
-−
-−
+    return result
     self.reverse.map{|e| e.is_a?(Array) ? e.flip : e}
   end
 end

Filter by Language:

Confirm