How to write more concise algorithms?

Question

I'm a beginner coding on a site called CodeFights and I noticed that many of the higher rated coders would have much more concise answers than me.

Take this problem for instance:

Given a sentence, check whether it is a pangram or not.
Example:
For sentence = "The quick brown fox jumps over the lazy dog.", the output should be isPangram(sentence) = true;
For sentence = "abcdefghijklmnopqrstuvwxya", the output should be isPangram(sentence) = false.

Input/Output

• [time limit] 3000ms (cs)
• [input] string sentence

A string containing characters with their ASCII-codes in the range [32, 126].

Guaranteed constraints:

1 ≤ sentence.length ≤ 100.

• [output] boolean
  true if sentence is a pangram, false otherwise.

[C#] Syntax Tips

// Prints help message to the console  
// Returns a string  
string helloWorld(string name) {  
  Console.Write("This prints to the console when you Run Tests");  
  return "Hello, " + name;  
}

My code is:

bool isPangramMine(string sentence)  
    {  
        char[] stringToCharArray = sentence.ToLower().Distinct().ToArray();  
        Array.Sort(stringToCharArray);  
        string joinedkArrayToCheck = String.Join("", stringToCharArray);  
        MatchCollection matches = Regex.Matches(joinedkArrayToCheck, "[a-z]");  
        string[] stringMatchArray = new string[matches.Count];  
        for (int i = 0; i < matches.Count; i++)  
            stringMatchArray [i] = matches[i].Groups[0].Value;  
        string joinedArrayToString = String.Join("", stringMatchArray );  
        Console.WriteLine(joinedArrayToString );  
        if (joinedArrayToString .Length == 26)  
            return true;  
        else  
            return false;  
    }  

The highest rated C# answer was written by someone named Slomo. That answer is:

int isPangram(string s) => s.ToUpper().Distinct().Count(_ => _ > 64 && _ < 91) / 26;

How is Slomo's code returning a value without using the return keyword?

I've seen answers similar to this here and here, but they only have the concise code without explaining how it works.

I'm looking for an answer that points me to a resource that I can use break down Slomo's code on my own, but someone taking the time to explain it themselves would be greatly appreciated as well.

Answer 1

Concise code isn't always something to strive for. Realistically, the sample you provided, the highly rated one, isn't what I would call concise. I would call it terse, and I might even call it incorrect.

Being pedantic, a more correct version of the provided sample would be:

bool isPangram(string s) => s.ToUpper().Distinct().Count(_ => _ >= 'A' && _ <= 'Z') == 26;

As to what the sample does, there are a few steps:

1. .ToUpper() converts the input string to upper case.
2. .Distinct() converts the string into a discrete list of characters (each character value that appears in the string will appear in the list once).
3. .Count(_ => _ > 64 && _ < 91) returns the number of elements in the list that are greater than 64 (the ASCII code for the letter A is 65) and less than 91 (the ASCII code for the letter Z is 90).
4. / 26 will return 1 if there are 26 elements in the final list (there are 26 letters in the (English) alphabet), and 0 if there are less than 26.
5. The values 0 and 1 will automatically cast to boolean false and true respectively.

As to how to write code more concisely, it will come with time and practice. Knowing the path of least resistance to your goal is the first step, then knowing all the ins and outs of your chosen language will help you find the easiest way to implement the easiest solution.

Hope that helps.

Answer 2

"How is Slomo's code returning a value without using the return keyword?"

It uses C#. It declares an expression-bodied function. Here is an old article on that C# 6.0 Gets More Concise…

And, from the specification for methods:

An expression body consists of => followed by an expression and a semicolon, and denotes a single expression to perform when the method is invoked.