import Data.List (group, sortBy, intercalate)

between :: (Ord a) => a -> a -> a -> Bool
between lo hi v = v >= lo && v <= hi

compareLetters :: Char -> Char -> Ordering
compareLetters a b
  | setA < setB = LT
  | setA > setB = GT
  | otherwise   = compare a b
  where setOf c = if between 'a' 'z' c then 0
                  else if between 'A' 'Z' c then 1
                  else 2
        setA    = setOf a
        setB    = setOf b

blocks :: [[a]] -> [[a]]
blocks [] = []
blocks xss = let ys  = map head xss
                 yss = filter (not . null) $ map tail xss
             in  ys : blocks yss

blockify :: (Eq a) => ([a] -> [a]) -> [a] -> [[a]]
blockify sort = blocks . group . sort

blockifyString :: String -> String
blockifyString = intercalate "-" . blockify (sortBy compareLetters)

def blocks(str):
  # const - reference for extracting blocks
  order = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

  # count occurences of characters in str
  mapping = {}
  # build mapping
  for s in str:
    if s not in mapping:
      mapping[s] = 0
    mapping[s] += 1

  # iterate through mapping to create each block, decrementing the counts
  # with each pass. when the count is 0, delete the key,value pair.
  # stop iterating when there are no more values to create blocks from
  blocks = []
  while mapping.values():
    block = []
    for o in order:
      if o in mapping:
        block.append(o)
        mapping[o] -= 1
        if mapping[o] == 0:
          del mapping[o]
    blocks.append(''.join(block))

  return '-'.join(blocks)

print(blocks("21AxBz"), "xzAB12")
print(blocks("abacad"), "abcd-a-a")
print(blocks(""), "")
print(blocks("21BxAzAasfdaXZas"), "adfsxzABXZ12-asA-a")

import re

def sorted_blocks(input_str):
    str_usage = {}
    arr_list = {}

    upper_case = re.findall('[A-Z]', input_str)
    lower_case = re.findall('[a-z]', input_str)
    numbers = re.findall('[0-9]', input_str)

    upper_case.sort()
    lower_case.sort()
    numbers.sort()

    for dataset in [lower_case, upper_case, numbers]:

        for item in dataset:
            if str_usage.get(item) is not None:
                str_usage[item] += 1
            else:
                str_usage[item] = 1

            index = str_usage[item]

            arr_list.setdefault(index, '')
            arr_list[index] += item

    print 'input    : "' + input_str + '"'
    print 'block(s) : "' + '-'.join(arr_list.values()) + '"'
    print ' '

# tests
sorted_blocks('21AxBz')
sorted_blocks('21BxAzAasfdaXZas')
sorted_blocks('abacad')
sorted_blocks('')

# output

# input    : "21AxBz"
# block(s) : "xzAB12"
# 
# input    : "21BxAzAasfdaXZas"
# block(s) : "adfsxzABXZ12-asA-a"
# 
# input    : "abacad"
# block(s) : "abcd-a-a"
# 
# input    : ""
# block(s) : ""