<< problem 21 - Amicable numbers | Non-abundant sums - problem 23 >> |

# Problem 22: Names scores

(see projecteuler.net/problem=22)

Using names.txt, a 46K text file containing over five-thousand first names, begin by sorting it into alphabetical order.

Then working out the alphabetical value for each name, multiply this value by its alphabetical position in the list to obtain a name score.

For example, when the list is sorted into alphabetical order, COLIN, which is worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list.

So, COLIN would obtain a score of 938 x 53 = 49714.

What is the total of all the name scores in the file?

# Algorithm

When using an `std::set`

all its elements are automatically sorted.

A second container, my `std::map`

named `sorted`

contains each name as a key and its position in that set.

All names are written in uppercase - and my program doesn't verify it.

The value of a name is defined as the sum of its letters where A=1, B=2, ... which boils down to `value += c - 'A' + 1`

## Modifications by HackerRank

The modified Hackerrank differs significantly and is surprisingly easier than the original problem.

## Note

Project Euler's file can be easily parsed in C++.

Initially I included it in my source code (which works flawlessly) but then decided to read from STDIN.

# My code

… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, as well as the input data, too.

The code contains `#ifdef`

s to switch between the original problem and the Hackerrank version.

Enable `#ifdef ORIGINAL`

to produce the result for the original problem (default setting for most problems).

#include <iostream>
#include <string>
#include <map>
#include <set>
//#define ORIGINAL

// read a single name from STDIN, syntax: "abc","def","xyz"

std::string readName()
{
std::string result;
while (true)
{
// read one character
char c = std::cin.get();
// no more input ?
if (!std::cin)
break;
// ignore quotes
if (c == '"')
continue;
// finish when a comma appears
if (c == ',')
break;
// nope, just an ordinary letter (no further checks whether c in 'A'..'Z')
result += c;
}
return result;
}
int main()
{
// note: an std::set is always sorted
std::set<std::string> names;
#ifdef ORIGINAL
while (true)
{
// read a single name, abort when empty
auto name = readName();
if (name.empty())
break;
names.insert(name);
}
#else
unsigned int numNames;
std::cin >> numNames;
while (numNames--)
{
// Hackerrank's names are separated by a space
std::string name;
std::cin >> name;
// add to our set
names.insert(name);
}
#endif
// walk through all names in alphabetic order, keep track of their position
// store both information as [name] => [pos]
std::map<std::string, unsigned int> sorted;
unsigned int pos = 1;
for (auto name : names)
sorted[name] = pos++;
#ifdef ORIGINAL
// original problem
unsigned int sum = 0;
for (auto name : sorted)
{
unsigned int value = 0;
// 'A' = 1, 'B' = 2, ..., 'Z' = 26
for (auto c : name.first)
value += c - 'A' + 1;
// multiply by position
sum += value * name.second;
}
std::cout << sum << std::endl;
#else
unsigned int queries;
std::cin >> queries;
while (queries--)
{
std::string name;
std::cin >> name;
unsigned int value = 0;
// 'A' = 1, 'B' = 2, ..., 'Z' = 26
for (auto c : name)
value += c - 'A' + 1;
// multiply by position
value *= sorted[name];
std::cout << value << std::endl;
}
#endif
return 0;
}

This solution contains 16 empty lines, 18 comments and 10 preprocessor commands.

# Interactive test

*This feature is not available for the current problem.*

# Benchmark

The correct solution to the original Project Euler problem was found in 0.01 seconds on a Intel® Core™ i7-2600K CPU @ 3.40GHz.

Peak memory usage was about 3 MByte.

(compiled for x86_64 / Linux, GCC flags: `-O3 -march=native -fno-exceptions -fno-rtti -std=c++11 -DORIGINAL`

)

See here for a comparison of all solutions.

**Note:** interactive tests run on a weaker (=slower) computer. Some interactive tests are compiled without `-DORIGINAL`

.

# Changelog

February 23, 2017 submitted solution

April 4, 2017 added comments

May 9, 2017 read names from STDIN

# Hackerrank

see https://www.hackerrank.com/contests/projecteuler/challenges/euler022

My code solves **2** out of **2** test cases (score: **100%**)

# Difficulty

Project Euler ranks this problem at **5%** (out of 100%).

Hackerrank describes this problem as **easy**.

*Note:*

Hackerrank has strict execution time limits (typically 2 seconds for C++ code) and often a much wider input range than the original problem.

In my opinion, Hackerrank's modified problems are usually a lot harder to solve. As a rule thumb: brute-force is never an option.

# Links

projecteuler.net/thread=22 - **the** best forum on the subject (*note:* you have to submit the correct solution first)

Code in various languages:

Python: www.mathblog.dk/project-euler-22-what-is-the-total-of-all-the-name-scores-in-the-file-of-first-names/ (written by Kristian Edlund)

Haskell: github.com/nayuki/Project-Euler-solutions/blob/master/haskell/p022.hs (written by Nayuki)

Java: github.com/nayuki/Project-Euler-solutions/blob/master/java/p022.java (written by Nayuki)

Mathematica: github.com/nayuki/Project-Euler-solutions/blob/master/mathematica/p022.mathematica (written by Nayuki)

C: github.com/eagletmt/project-euler-c/blob/master/20-29/problem22.c (written by eagletmt)

Go: github.com/frrad/project-euler/blob/master/golang/Problem022.go (written by Frederick Robinson)

Javascript: github.com/dsernst/ProjectEuler/blob/master/22 Names scores.js (written by David Ernst)

Scala: github.com/samskivert/euler-scala/blob/master/Euler022.scala (written by Michael Bayne)

# Heatmap

green problems solve the original Project Euler problem and have a perfect score of 100% at Hackerrank, too.

yellow problems score less than 100% at Hackerrank (but still solve the original problem).

gray problems are already solved but I haven't published my solution yet.

blue problems are solved and there wasn't a Hackerrank version of it at the time I solved it or I didn't care about it because it differed too much.

*Please click on a problem's number to open my solution to that problem:*

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 |

26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 |

51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 |

76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 |

101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 |

126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 |

151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 |

176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 |

201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 |

226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 | 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 248 | 249 | 250 |

My username at Project Euler is

**stephanbrumme**while it's stbrumme at Hackerrank.

<< problem 21 - Amicable numbers | Non-abundant sums - problem 23 >> |