Comments on: Digest Tag Population in Ruby

By: Scott Moonen

Scott Moonen — Mon, 10 Aug 2009 11:25:32 +0000

I’ve posted two alternate Clojure solutions here: http://scott.andstuff.org/ClojureSpikes. They take a slightly different approach from Raffael’s above. The high-level structure of my second solution is inspired by Raffael’s second solution — this is a helpful LISP idiom that I was glad to learn.

By: Brian Adkins

Brian Adkins — Sat, 21 Mar 2009 15:07:11 +0000

A Haskell version by Florian Kreidler (modifying a version by Greg Bacon) on comp.lang.haskell:

 import Data.List (sortBy, elemIndex)
 import Data.Ord(comparing)

 type Tag       = String
 type Pet       = (String, Int)
 type PetTag    = (Tag, [Pet])
 type TaggedPet = (Tag, Pet)

 pets :: PetTags
 pets =
   [ ("dog",   [ ("blab",    12)
               , ("glab",    17)
               , ("cbret",   82)
               , ("dober",   42)
               , ("gshep",   25)
               ])
   , ("cat",   [ ("pers",    22)
               , ("siam",    7)
               , ("tibet",   52)
               , ("russ",    92)
               , ("meow",    35)
               ])
   , ("snake", [ ("garter",  10)
               , ("cobra",   37)
               , ("python",  77)
               , ("adder",   24)
               , ("rattle",  40)
               ])
   , ("cow",   [ ("jersey",  200)
               , ("heiffer", 300)
               , ("moo",     400)
               ])
   ]

 digestTagPopulation :: [PetTag] -> [Tag] -> Int -> [TaggedPet]
 digestTagPopulation tp tags c
     = sortBy (comparing $ flip elemIndex tags . fst) $
       take c $ sortBy (flip $ comparing $ snd . snd)
       [ (t, p) | (t, ps) <- tp, t `elem` tags, p <- ps ]

By: Brian Adkins

Brian Adkins — Tue, 03 Mar 2009 06:06:06 +0000

Second version by Paul Rubin on comp.lang.haskell:

import Data.List
import Data.Ord

pets = [("dog", [("blab", 12),("glab", 17),("cbret", 82),
                 ("dober", 42),("gshep", 25)]),
        ("cat", [("pers", 22),("siam", 7),("tibet", 52),
                 ("russ", 92),("meow", 35)]),
        ("snake", [("garter", 10),("cobra", 37),("python", 77),
                   ("adder", 24),("rattle", 40)]),
        ("cow", [("jersey", 200),("heiffer", 300),("moo", 400)])]

digest_tag tag_pop pick_tags count =
    sortBy (comparing (\(a,_)->findIndex (==a) (map fst tag_pop)))
               (take count $ sortBy (flip (comparing (snd . snd)))
                         [(a,(b,c)) | (a,bs) <- tag_pop, a `elem` pick_tags,
                          (b,c) <- bs])

main = print $ digest_tag pets ["dog","cat","snake"] 5

By: Brian Adkins

Brian Adkins — Sun, 01 Mar 2009 19:50:22 +0000

Two Clojure versions by Raffael Cavallaro on comp.lang.lisp: Version 1:

(defn digest-tag-population [tag-population pick-tags count]
  (sort-by #(first (for [[idx elt]
			 (map vector (iterate inc 0) pick-tags)
			 :when (= elt (first%))] idx))
	   < (take count (sort-by #(nth % 2) >
				  (mapcat (fn [a-lst] (map #(cons (first a-lst) %)
							   (first (rest a-lst))))
					  (filter #(contains? (set pick-tags) (first %)) tag-population))))))

Version 2:

(defn digest-tag-population [tag-population pick-tags count]
  (let [selected (filter #(contains? (set pick-tags) (first %)) tag-population)
	union (mapcat (fn [a-lst]
			(map (fn [lst]
			       (cons (first a-lst) lst))
			     (first (rest a-lst))))
		      selected)
	pet-position (fn [petsym]
		       (first (for [[idx elt] (map vector (iterate inc 0) pick-tags) :when (= elt petsym)] idx)))
	pop-sorted (sort-by #(nth % 2) > union)
	top-n (take count pop-sorted)
	pet-sorted (sort-by #(pet-position (first %)) < top-n)]
    pet-sorted))

By: Brian Adkins

Brian Adkins — Sun, 01 Mar 2009 19:47:03 +0000

A Python version by Ron Garret from comp.lang.lisp:

pets = {'dog' : 'blab 12, glab 17, cbret 82, dober 42, gshep 25',
        'cat' :   'pers 22, siam 7, tibet 52, russ 92, meow 35',
        'snake' : 'garter 10, cobra 37, python 77, adder 24, rattle 40',
        'cow' : 'jersey 200, heiffer 300, moo 400'}

for k in pets: pets[k] = [(k,tag,int(n)) for (tag,n) in  
                          [s.split() for s in pets[k].split(',')]]

def keycmp(f): return lambda x,y: cmp(f(x), f(y))

def dtp(tags, types, cnt):
  l = []
  for t in types: l.extend(pets[t])
  l.sort(keycmp(lambda x:-x[2]))
  l=l[:cnt]
  l.sort(keycmp(lambda x: types.index(x[0]))
  return l


>>> dtp(pets, ['dog','cat','snake'], 5)
[('dog', 'cbret', 82), ('dog', 'dober', 42), ('cat', 'russ', 92), 
('cat', 'tibet', 52), ('snake', 'python', 77)]

By: Brian Adkins

Brian Adkins — Sun, 01 Mar 2009 19:30:44 +0000

A Haskell version by Paul Rubin from comp.lang.haskell:

import Data.List
import Data.Ord
import Control.Monad

pets =
   [("dog", [("blab", 12),("glab", 17),("cbret", 82),
             ("dober", 42),("gshep", 25)]),
     ("cat", [("pers", 22),("siam", 7),("tibet", 52),
              ("russ", 92),("meow", 35)]),
     ("snake", [("garter", 10),("cobra", 37),("python", 77),
                ("adder", 24),("rattle", 40)]),
     ("cow", [("jersey", 200),("heiffer", 300),("moo", 400)])]

digest_tag tag_pop pick_tags count =
  let selected_pops = 
        [(i,(-c,b)) | (i,(a,bs)) <- zip [0..] tag_pop, a `elem` pick_tags,
                                    (b,c) <- bs]
      top_pops = sort $ take count (sortBy (comparing snd) selected_pops)
  in [(fst (tag_pop !! i), b, -c) | (i, (c,b)) <- top_pops]

main = print $ digest_tag pets ["dog","cat","snake"] 5