SNOWMAN's Dictionary !

First, we need to find the no. of words starting with A and there are $\frac{6!}{2}$ (Since,there are 2 N's )

Then,no. of words starting with M of which there are $\frac{6!}{2}$

Then,no. of words starting with N of which there are $6!$

Then,no. of words starting with O of which there are $\frac{6!}{2}$

Then,no. of words starting with SA of which there are $\frac{5!}{2}$

Then,no. of words starting with SM of which there are $\frac{5!}{2}$

Then,no. of words starting with SNA of which there are ${4!}$

Then,no. of words starting with SNM of which there are $4!$

Then,no. of words starting with SNN of which there are $4!$

Then,no. of words starting with SNOA of which there are $3!$

Then,no. of words starting with SNOM of which there are $3!$

Then,no. of words starting with SNON of which there are $3!$

We get a total of $2010$ words so far.

Now,we have to count words starting with SNOW till we get our desired word SNOWMAN .

We see first word starting with SNOW is SNOWAMN ,then SNOWANM and then SNOWMAN or that our desired word is the $2013th$ word in the dictionary. Hence, our answer is $2+0+1+3=\boxed{6}$ .

Can be done rather easily in python

from itertools import permutations as perm
print sorted(set(perm([i for i in 'SNOWMAN']))).index(tuple((i for i in 'SNOWMAN')))+1

JAVA CODE:

public class Permutations {

static int count = 0;
static List list = new ArrayList();
static LinkedHashSet lhs = new LinkedHashSet();

public static void perm(String s) {
    perm("", s);

}

private static void perm(String prefix, String s) {
    int N = s.length();
    if (N == 0) {
        lhs.add(prefix);

    } else {
        for (int i = 0; i < N; i++) {
            perm(prefix + s.charAt(i), s.substring(0, i) + s.substring(i + 1, N));

        }
    }


}

private static void swap(char[] a, int i, int j) {
    char c;
    c = a[i];
    a[i] = a[j];
    a[j] = c;
}

public static void main(String[] args) {

    String str = "snowman";
    char[] ca = str.toCharArray();
    Arrays.sort(ca);
    str = new String(ca);

    perm(str);

    list = Arrays.asList(lhs.toArray());

    int count = list.indexOf("snowman");
    System.out.println(count);

    Integer pr = (Integer) count+1;
    String string = pr.toString();
    char[] arr = string.toCharArray();


    int sum = 0;
    for (int i = 0; i < arr.length; i++) {
        sum += (arr[i] - 48);
    }
    System.out.println(sum);

}

}

In Mathematica:

Position[Sort[Permutations[{s, n, o, w, m, a, n}]], {s, n, o, w, m, a, n}]

2013

Probably the best way to do this is combinatorially, but I was too lazy to go over all the options and sum them up, so I wrote the following piece of code.

def generateWords(letters):
    if len(letters) == 1:
        return [letters]

    result = []
    for i, letter in enumerate(letters):
        result += [letter + subword for subword in generateWords(letters[:i] + letters[i + 1:])]
    return result

words = sorted(set(generateWords('SNOWMAN')))
print words.index('SNOWMAN') + 1

generateWords(letters) is a recursive function that generate all the possible permutations of the given string. I call it with the string 'SNOWMAN', and as there are to 'N's, there could be duplicates, so I wrap the result with set() to remove duplicates.

Finally, I sort the dictionary of words, and find the index of 'SNOWMAN', which is 2012 zero-based, so 2013 1-based. $2+0+1+3 = \boxed{6}$ .

Python Solution:

import itertools
a = list(itertools.permutations('SNOWMAN'))
b = [''.join(i) for i in a]
b.sort()
c = []
for i in b:
    if i not in c:
        c.append(i)
print c.index('SNOWMAN') + 1

This can be solved more cleverly, but since our alphabet size is small enough, we can simply generate all the permutations and find the position of the word "SNOWMAN" there. Here's a fairly short C++ implementation:

string start = "AMNNOSW";
vector<string> words;

int main()
{
    do
    {
        words.push_back(start);
    } while (next_permutation(start.begin(), start.end()));
    int ret = 1;
    for (;words[ret-1] != "SNOWMAN";ret++);
    printf("%d\n",ret);
}

Calling this code returns 2013, and hence the sum of digits is 6.

Naive Haskell

import Data.List
import Data.Char
import Data.Maybe
main = print $ sum $ map digitToInt $ show $ (1+) $ fromJust $ elemIndex "snowman" $ nub $ sort $ permutations "snowman"

Motivation : I first find the total number of ways to arrange the word, which is $2520$ . Because the words are written in alphabetical order, and next to $\mathbb{W}$ , the second last alphabet is $\mathbb{S}$ . So by working backwards, I counted the number of words that begins with $\mathbb{W}$ , call it $x$ . Now we know that somewhere between $2520 - x$ . Now, we have correctly placed the letter $\mathbb{S}$ in the first position. And because we're working backwards, we consider the letter $\mathbb{W}$ as the second letter and apply the same logic, and so on til we get the word $\mathbb{SNOWMAN}$

We note the total number of ways total arrange $\mathbb{SNOWMAN}$ is $\frac {7!}{2!} = 2520$

We know that $\mathbb{W}$ is the last in the alphabets (in the list). So if the position starts with $\mathbb{W}$ , then the last $\frac {(7-1)!}{2!} = 360$ words begins with $\mathbb{W}$ .

"Counting backwards", for words starting with $\mathbb{SW}$ there is a total $\frac {5!}{2!} = 60$ words.

And for words starting with $\mathbb{SO}$ there is a total $\frac {5!}{2!} = 60$ words.

Again, for words starting with $\mathbb{SNWO}$ , there is a total of $3! = 6$ words.

$2520 - 360 - 60 - 60 - 6 = 2034$

Thus

The word $\mathbb{SNOWNMA}$ is the $2034^{\text{th}}$ position

The word $\mathbb{SNOWNAM}$ is the $2033^{\text{rd}}$ position

The word $\mathbb{SNOWMNA}$ is the $2032^{\text{nd}}$ position

The word $\mathbb{SNOWMAN}$ is the $2031^{\text{st}}$ position

Hence, the answer is $2 + 0 + 3 + 1 = \boxed{6}$