Comments on: Beautiful Code

By: Lautaro Pecile

Lautaro Pecile — Sat, 19 May 2012 01:34:47 +0000

[sourcecode lang="python"] from operator import truth as not_empty is_empty = lambda s: not not_empty(s) def iterate(f, string): s = string while not_empty(s): yield f(s) s = s[1:] def match (re, text): if re.startswith('^'): return matchhere(re[1:], text) return any(iterate(lambda t: matchhere(re, t), text)) def matchhere(re, text): if is_empty(re): return True if re.startswith('*', 1): return matchstar(re[0], re[2:], text) if re.startswith('$'): return is_empty(text) if (not_empty(text) and (re.startswith('.') or re[0] == text[0])): return matchhere(re[1:], text[1:]) return False def matchstar(c, re, text): while True: if matchhere(re, text): return True text = text[1:] if is_empty(text) or not (text.startswith(c) or c == '.'): break return False [/sourcecode]

By: Michel

Michel — Sun, 25 Oct 2009 06:04:58 +0000

My Clojure solution. Clojure uses Java strings, which are immutable, so taking substring would be too expensive. Instead, I made match-here and match-* internal functions, and give them indices rather than strings to work with. Solution, on GitHub

By: Luis Sergio Oliveira

Luis Sergio Oliveira — Thu, 22 Oct 2009 06:50:49 +0000

My Common Lisp solution: [sourcecode lang="css"] (defun empty (seq) (declare (inline)) (= 0 (length seq))) (defun match (re text) "search for re anywhere in text" (if (and (not (empty re)) (char= #\^ (elt re 0))) (matchhere (subseq re 1) text) ;; must look at empty string (cond ((matchhere re text)) ((empty text) nil) ((match re (subseq text 1)))))) (defun matchhere (re text) "search for re at beginning of text" (cond ((empty re)) ((and (< 1 (length re)) (char= #\* (elt re 1))) (matchstar (elt re 0) (subseq re 2) text)) ((and (char= #\$ (elt re 0)) (= 1 (length re))) (empty text)) ((and (not (empty text)) (or (char= #\. (elt re 0)) (char= (elt re 0) (elt text 0)))) (matchhere (subseq re 1) (subseq text 1))))) (defun matchstar (c re text) "search for c*re at beginning of text" (cond ((matchhere re text)) ((and (not (empty text)) (or (char= c (elt text 0)) (char= #\. c))) (matchstar c re (subseq text 1))))) [/sourcecode]

By: Beautiful Code « Programming Praxis | what a beautiful day..

Beautiful Code « Programming Praxis | what a beautiful day.. — Mon, 14 Sep 2009 03:06:17 +0000

[...] Beautiful Code « Programming Praxis. [...]

By: Tordek

Tordek — Sat, 12 Sep 2009 06:10:49 +0000

Assuming strings as lists of characters (They're usually atoms, so they should be transformed): Prolog solution.

match(['^'|Rs], T)          :- matchHere(Rs, T).
match(R, T)                 :- matchHere(R, T).
match(R, [_|Ts])            :- matchHere(R, Ts).

matchHere([], _).
matchHere(['$'], []).
matchHere([R,'*'|Rs], T)    :- matchStar(R, Rs, T).
matchHere([R|Rs], [R|Ts])   :- matchHere(Rs, Ts).
matchHere(['.'|Rs], [_|Ts]) :- matchHere(Rs, Ts).

matchStar(_, Rs, Ts)        :- matchHere(Rs, Ts).
matchStar(R, Rs, [R|Ts])    :- matchHere(Rs, Ts).
matchStar('.', Rs, [_|Ts])  :- matchHere(Rs, Ts).
matchStar(R, Rs, [R|Ts])    :- matchStar(R, Rs, Ts).
matchStar('.', Rs, [_|Ts])  :- matchStar('.', Rs, Ts).

By: Remco Niemeijer

Remco Niemeijer — Fri, 11 Sep 2009 17:12:31 +0000

My Haskell solution (see http://bonsaicode.wordpress.com/2009/09/11/programming-praxis-beautiful-code/ for a version with comments):

import Data.List

match :: String -> String -> Bool
match ('^':r) = matchHere r
match r       = or . map (matchHere r) . tails

matchHere :: String -> String -> Bool
matchHere (c:'*':r) xs  = matchStar c r xs
matchHere "$"       xs  = null xs
matchHere (r:rs) (x:xs) = (r == '.' || r == x) && matchHere rs xs
matchHere r      _      = null r

matchStar :: Char -> String -> String -> Bool
matchStar _ r xs     | matchHere r xs = True
matchStar c r (x:xs) = (c == '.' || c == x) && matchStar c r xs
matchStar _ _ _      = False

By: Programming Praxis – Beautiful Code « Bonsai Code

Programming Praxis – Beautiful Code « Bonsai Code — Fri, 11 Sep 2009 17:12:16 +0000

[...] Praxis – Beautiful Code By Remco Niemeijer Today’s Programming Praxis is about beautiful code. Specifically, it concerns a bit of C code that can [...]