http://www.code-story.net/

foobarqix.clj

(def rules {7 "Qix" 5 "Bar" 3 "Foo"})

(defn div [[n s]]
    (fn [[x accu]]
        [x (str accu (when (= 0 (rem x n)) s))]))        
        
(defn to-ints [x]
    (map #(- (int %) 48) (seq (str x))))

(defn has [[x accu]]
    [x (apply str accu (mapcat rules (to-ints x)))])

(def all (cons has (map div (seq rules))))

(defn fbq [n]
    (let [[n s] ((apply comp all) [n nil])]
            (if (seq s) s n)))
(doseq
    [i (range 1 101)]
    (println (fbq i)))

Solution to http://www.code-story.net/2011/11/16/foobarqix.html

C'est concis mais j'ai un peu mal à la tête :)

D'où sort le 48?

C'est tout simple en fait. Je fabrique des fonctions (avec make) qui exécutent une règle.
Chaque règle (sorte de prédicat amélioré) est décrite par une fonction de comptage et une chaîne en cas de succés.
Le 48 c'est le code entier du caractère 0.
Mais ça ne marche pas tout à fait ! Il faut appliquer les fonctions (de type has) dans l'ordre de lecture du nombre en entrée :-(

j'ai l'impression que ça pourrait être plus clair avec un
for [c (str x) :when (= c n)] ....
ou
(re-seq (re-pattern n) (str x))

j'ai pas testé :)

Je suis arrivé à ça : https://gist.github.com/1507832

Salut Stef, j'étais parti un peu comme toi au début, dans l'idée de faire générique générique, mais quand je me suis heurté au meme problème que toi (à savoir on n'applique pas dans le meme ordre les règles), je suis revenu à de l'application manuelle, et à vrai dire, pour 2 fonctions connues à l'avance, c'est moins overkill ;-)