Question: I'm working on a system which allows imported files to be localized into other languages. 

This is mostly a private project to get the hang of MVC3, EntityFramework, LINQ, etcetera. Therefore I like doing some crazy things to spice up the end result, one of those things would be the recognition of similar strings.

Imagine you have the following list of strings - borrowed from a game I've worked with in the past:

* Megabeth: Holy Roller Uniform - Includes Head, Torso, and Legs
* Megabeth: Holy Roller Uniform Head
* Megabeth: Holy Roller Uniform Legs
* Megabeth: Holy Roller Uniform Torso
* Megabeth: PAX East 2012 Uniform - Includes Head, Torso, and Legs
* Megabeth: PAX East 2012 Uniform Head
* Megabeth: PAX East 2012 Uniform Legs
* Megabeth: PAX East 2012 Uniform Torso

As you can see, once users have translated the first 4 strings, the following 4 share a lot of similarities, in this case:

* Megabeth
* Uniform
* Includes Head, Torso, and Legs
* Head
* Legs
* Torso

Consider the first 4 strings are indeed already translated, when a user selects the 5th string from the list, what kind of algorithm or technique can I use to show the user the 1st string (and potentially others) under a sub-header of "Similar strings"?

Edit - A little comment on the Levenshtein Distance:
I'm currently targeting 10k strings in the database. Levenshtein Distance compares string per string, so in this case 10k x (10k -1) possible combinations. How would I approach this in a feasible way? Is there a better solution that this particular algorithm?

Answer: 
You could look into the [Levenshtein Distance](http://en.wikipedia.org/wiki/Levenshtein_distance). Those below a certain threshold will be considered similar. Two strings that are identical will have a distance of zero.

There's a C# implementation, amongst other languages, on [Rosetta Code](http://rosettacode.org/wiki/Levenshtein_distance#C.23).
This will depend on the size of the data and how rich the vocabulary is.
Here's the first thought:
build a map of words to strings
then another map of word pairs to strings
and perhaps if data is not huge map of string triplets to strings.
Remove mappings that point at a single string (this will dramatically reduce the number of triplet mappings).
Save resulting dictionary on disk or in a database if building it takes time.

Now given a string you should be able to quickly split it into words, word pairs and triplets and look up all strings related to it. You will need to play with giving weight to a triplet matching vs 4 words matching. I.e. is 
"I am an old man" closer to "an old man ate a carrot" or "man killed the old dog with an arrow" (sounds like triplet match is more important).

UPDATE: If this in a Microsoft SQL Server database you can play with full text search feature. I never tried it though.
You should also take a look at [Lucene](http://lucenenet.apache.org/).