Single line FizzBuzz solution in LINQ Now FizzBuzz itself isn't a big challenge but I agree that it can be a good tool to see if someone can code or not.  I wanted to practice my LINQ a little bit so here's my single line FizzBuzz solution.

Enumerable.Range(1,100).Select(
                        n =&gt; 
                        (n % 15 == 0) ? "FizzBuzz" : 
                        (n % 3 == 0) ? "Fizz" : 
                        (n % 5 == 0) ? "Buzz" : 
                        n.ToString())
                        .ToList()
                        .ForEach(Console.WriteLine);
Overall, I like this. It is concise, and neat, and all. My only beef is the nested ternaries.
In general, ternary operator precedence is complicated by the lack of blocks.... The need for the parenthesis on the modulo precedence makes the conditions clear ( (n % 15 == 0) ) and the actual indenting you have, makes the logic a little clearer, but precedence is not that simple, and I have seen bugs where subtle precedence problems have caused the wrong execution-path through the nested ternaries....
.... bottom line, is for simple statements, ternaries are great, but the readability is compromised when there are multi-levels of ternaries. Nice for small things, ugly for big.
I would have preferred if you made the coditionals more obvious ... by extracting to a function maybe... but that would ruin your 1-liner.....
How about ... (Shown in this ideone here):
Enumerable.Range(1,100).Select(
                    n =&gt; 
                    (n % 15 == 0) ? &quot;FizzBuzz&quot; : 
                    (
                        (n % 3 == 0) ? &quot;Fizz&quot; :
                        (
                            (n % 5 == 0) ? &quot;Buzz&quot; :  n.ToString())
                        )
                    )
                    .ToList()
                    .ForEach(Console.WriteLine);


EDIT: The above answer is not as good as I wanted it to be.....
The exact problem with ternary precedence is that it is right-associative. This makes the logic potentially buggy, and hard to understand.....
Consider the ternaries:
expa = boola ? expc : expd;
expb = boolb ? expe : expf;

result = boolc ? expa : expb;

You can modify this to be:
expa = boola ? expc : expd;

result = boolc ? expa : boolb ? expe : expf;

Or, rewriting it in 'your' style, as:
expa = boola ? expc : expd;

result = boolc ? expa :
         boolb ? expe :
         expf;

But, you cannot 'inline' expa in the above as easily:
expb = boolb ? expe : expf;

result = boolc ? (boola ? expc : expd) : expb;

You need the parenthesis.
Inlining ternaries is just plain ugly.

Better solution
I regret suggesting to use the parenthesis to block the code in a more readable format. There is no more readable format, other than to extract the function, which is the 'right' thing to do:
    static private string FizzBuzz(int value)
    {
        if (value % 15 == 0)
        {
            return &quot;FizzBuzz&quot;;
        }
        if (value % 3 == 0)
        {
            return &quot;Fizz&quot;;
        }
        if (value % 5 == 0)
        {
            return &quot;Buzz&quot;;
        }
        return value.ToString();
    }



    public static void Main()
    {
        foreach(var val in Enumerable.Range(1, 100).Select(n =&gt; FizzBuzz(n)))
            Console.WriteLine(val);
    }

Note, I have also undone the slow, and unnecessary conversion of the Enumerable to the ToList().ForEach() operation. Converting it to the list before re-converting it to an Enumeration is a waste of effort.
Bottom line, is that the 1-liner is not the best, or most readable format.
I have put this in an ideone, to show it working.