Writing Challenge - Day 9

I don't write only English.  And today I'm punting on my writing challenge because I spent a good deal of time writing this after dinner:

using System;
using System.Linq;

public class Program
{
public static void Main()
{
int[] A = {0,1,2,3,4,5,6,7,8,9,10};
//factorials(A);
int[] B = {0,1,10,11,12,100,101,111,112,123,1000,1001,1011,1230,1234,2147483647,120,12000};
double[] expected = {1,1,1,1,2,1,2,1,3,6,1,3,3,18,24,302400,4,8};
var actual = setSimilarCounts(B);
Console.WriteLine("Test entries: {0}", string.Join(",", B));
Console.WriteLine("'Similar' counts: {0}", string.Join(",", actual));
for(int i=0;i<B.Length; i++){
if(expected[i] != actual[i]){
Console.WriteLine("\t\t\t\t\t\t\t\t\t\t\t\tFAIL: Tested: {0} Expected: {1}, Actual: {2}", B[i], expected[i], actual[i]);
}
else{
Console.WriteLine("PASS : Tested: {0} Expected: {1}, Actual: {2}", B[i], expected[i], actual[i]);
}
}
}

public static double[] setSimilarCounts(int[] A){
var counts = new double[A.Length];
        for(int i=0;i<A.Length; i++){
counts[i] = similarCount(A[i]);
        }
return counts;
}

public static double similarCount(int a, bool useLeadingZeroExclusion = true){
const string strFormat = @"
value:                       {0},
stringValue.Length:          {1}
zeroCount:                   {2}
distinctCharCount:           {3}
distinctNonZeroCharCount:    {4}
permutationsWithoutZeroRule: {5}";
var value = a;
var stringValue = value.ToString();
var stringLength = stringValue.Length;
var enumerableValue = stringValue.Cast<char>();
var zeroCount = enumerableValue.Count(c => c == '0');
var distinctChars = enumerableValue.Distinct();
var distinctCharCount = distinctChars.ToArray().Length;
var distinctNonZeroChars = distinctChars.Where(c => c!='0');
var distinctNonZeroCharCount = zeroCount > 0 ? distinctCharCount -1 : distinctCharCount;
var maxPermutations = factorial(stringLength);

if(distinctCharCount < 2 || (stringLength - zeroCount) == 1){
return 1;
}


if(value == 0 || stringLength == distinctNonZeroCharCount){
return maxPermutations;
}

double product = 1;
foreach(var c in distinctChars){
product *= factorial(enumerableValue.Count(chr => chr == c));
}

if(zeroCount == 0 || useLeadingZeroExclusion == false){
return maxPermutations / product;
}

var permutationsWithoutLeadingZeroRule = maxPermutations / product;
var indexOfFirstZero = stringValue.IndexOf('0');
var segmentFollowingLeadingZero = string.Join("", enumerableValue.Where((chr,i) => i != indexOfFirstZero).ToArray());
var similarCountOfSegment = similarCount(Convert.ToInt32(segmentFollowingLeadingZero), false);
var permutations = permutationsWithoutLeadingZeroRule - similarCountOfSegment;
/* Console.WriteLine(
                string.Format(strFormat, 
 value, 
 stringValue.Length,
 zeroCount,
 distinctCharCount,
 distinctNonZeroCharCount,
 permutationsWithoutZeroRule
                )
            ); */
return permutations;
}

public static void factorials(int[] A){
        for(int i=0;i<A.Length; i++){
            Console.WriteLine(
                string.Format(
                    "value: {0}, value!: {1}", A[i], factorial(A[i])
                )
            );
        }
}
    
    public static double factorial(int a){
        return a<2 ? 1 : a * factorial(a-1);
    }
}