Artix Linux Forum

sed 's/[^A]//g' INPUT | awk '{ print length }' > OUTPUT

sort -r -n FILE.txt

sort -r -g FILE.txt

iason:[nous]:~% cat t
AAAAA
AAAAB
AAABB
AAABC
AAABD
BAABE
iason:[nous]:~% perl -F'' -le '$c{$_}++ for @F; print %c; %c=();' t
A5
B1A4
A3B2
B1C1A3
A3D1B1
A2B2E1

#!/usr/bin/env python3
if __name__=='__main__':
	import sys
	with open(sys.argv[1],'r') as _:
		lines = _.readlines()

	for line in lines:
		#remove lead/trail whitespace; split on whitespace and rejoin without
		line = "".join(line.strip().split())
		counts = {}
		for c in line:
			counts.setdefault(c,0)
			counts[c] += 1
		print(' '.join((str(_) for _ in reversed(sorted(counts.values())))))

% perl -F'' -le '$c{$_}++ for @F; print %c; %c=();' t | sed 's/[^0-9]/ /g'
 5
 4 1
 3 2
 3 1 1
 1 3 1
 2 2 1

$ cat t && perl -F'' -le '$c{$_}++ for @F; print %c; %c=();' t | sed 's/[^0-9]/ /g'
AAAAAAAAAAAAAAAAAAAA
AAAAB
AABBBBBBBBBBBBBBBBBBABB
AAABAAAAAAAAAAAAAAC
AAABBBBBBBBBBBBBBBBBBBD
BAABE
 20
 4 1
 3 20
 1 17 1
 1 3 19
 2 2 1

$ python counter.py t
20
4 1
20 3
17 1 1
19 3 1
2 2 1

'''Permutations of n elements drawn from k values'''

from itertools import product


# replicateM :: Applicative m => Int -> m a -> m [a]
def replicateM(n):
    '''A functor collecting values accumulated by
       n repetitions of m. (List instance only here).
    '''
    def rep(m):
        def go(x):
            return [[]] if 1 > x else (
                liftA2List(lambda a, b: [a] + b)(m)(go(x - 1))
            )
        return go(n)
    return lambda m: rep(m)


# TEST ----------------------------------------------------
# main :: IO ()
def main():
    '''Permutations of two elements, drawn from three values'''
    print(
        fTable(main.__doc__ + ':\n')(repr)(showList)(

            replicateM(7)

        )(['abcdefg'])
    )


# GENERIC FUNCTIONS ---------------------------------------

# liftA2List :: (a -> b -> c) -> [a] -> [b] -> [c]
def liftA2List(f):
    '''The binary operator f lifted to a function over two
       lists. f applied to each pair of arguments in the
       cartesian product of xs and ys.
    '''
    return lambda xs: lambda ys: [
        f(*xy) for xy in product(xs, ys)
    ]


# DISPLAY -------------------------------------------------

# fTable :: String -> (a -> String) ->
#                     (b -> String) -> (a -> b) -> [a] -> String
def fTable(s):
    '''Heading -> x display function -> fx display function ->
                     f -> xs -> tabular string.
    '''
    def go(xShow, fxShow, f, xs):
        ys = [xShow(x) for x in xs]
        w = max(map(len, ys))
        return s + '\n' + '\n'.join(map(
            lambda x, y: y.rjust(w, ' ') + ' -> ' + fxShow(f(x)),
            xs, ys
        ))
    return lambda xShow: lambda fxShow: lambda f: lambda xs: go(
        xShow, fxShow, f, xs
    )


# showList :: [a] -> String
def showList(xs):
    '''Stringification of a list.'''
    return '[' + ','.join(
        showList(x) if isinstance(x, list) else repr(x) for x in xs
    ) + ']'


# MAIN ---
if __name__ == '__main__':
    main()

hyperion:[nous]:/tmp% cat t tt
AAAAA
AAAAB
AAABB
AAABC
AAABD
BAABE
AAAAAAAAAAAAAAAAAAAA
AAAAB
AABBBBBBBBBBBBBBBBBBABB
AAABAAAAAAAAAAAAAAC
AAABBBBBBBBBBBBBBBBBBBD
BAABE
hyperion:[nous]:/tmp% perl -F'' -le '$,=" "; $c{$_}++ for @F; print sort{$b<=>$a} values %c; %c=();' t tt
5
4 1
3 2
3 1 1
3 1 1
2 2 1
20
4 1
20 3
17 1 1
19 3 1
2 2 1