C#练习题答案: 伪装序列（II）【难度：2级】--景越C#经典编程题库,1000道C#基础练习题等你来挑战

伪装序列(II)【难度:2级】:

答案1:

using System;
using System.Numerics;

public class Disguised2
{
    private static  BigInteger Choose(int n, int p)
    {
        BigInteger ret = new BigInteger(1);
        for (int i = 0; i < p; i++)
        {
            ret = BigInteger.Multiply(ret, n - i);
            ret = BigInteger.Divide(ret, i + 1);
        }
        return ret;
    }
    public static BigInteger U1(int n, int p) 
    {
        BigInteger sm = new BigInteger(0);
        BigInteger b1 = new BigInteger(-1); 
        BigInteger b2 = new BigInteger(4); 
        int k = 0;
        while (k <= n) 
        {
            sm = BigInteger.Add(sm, 
                BigInteger.Multiply(BigInteger.Multiply(BigInteger.Pow(b1, k), BigInteger.Pow(b2, n-k)), Choose(2*n-k+1, k)));
            k += 1;
        }
        return BigInteger.Multiply(new BigInteger(p), sm);
    } 
    public static BigInteger V1(int n, int p) 
    {
        BigInteger sm = new BigInteger(0);
        BigInteger b1 = new BigInteger(-1); 
        BigInteger b2 = new BigInteger(4); 
        int k = 0;
        while (k <= n) 
        {
            sm = BigInteger.Add(sm, 
                BigInteger.Multiply(BigInteger.Multiply(BigInteger.Pow(b1, k), BigInteger.Pow(b2, n-k)), Choose(2*n-k, k)));
            k += 1;
        }
        return BigInteger.Multiply(new BigInteger(p), sm);
    } 
    public static BigInteger UEff(int n, int p) 
    {
        return BigInteger.Multiply(new BigInteger(p), new BigInteger(n+1));
    }
    public static BigInteger VEff(int n, int p) 
    {
        return BigInteger.Multiply(new BigInteger(p), new BigInteger(2*n+1));
    }
}​

答案2:

using System;
using System.Linq;
using System.Numerics;

public class Disguised2
{
    public static BigInteger U1(int n, int p) 
    {
        var result = BigInteger.Zero;
        for (var k = 0; k <= n; k++)
        {
            result += (int)Math.Pow(-1, k % 2) *p* BigInteger.Pow(4, n - k) * Choose(2 * n - k + 1, k);
        }
        return result;
    }
    
    public static BigInteger V1(int n, int p) 
    {
        var result = BigInteger.Zero;
        for (var k = 0; k <= n; k++)
        {
            result += (int)Math.Pow(-1, k % 2) *p* BigInteger.Pow(4, n - k) * Choose(2 * n - k, k);
        }
        return result;
    }
    
    private static BigInteger Choose(int n, int k)
    {
        k = Math.Min(k, n - k);
        
        var result = BigInteger.One;
        for (int i = 1, j = n; i <= k; i++, j--) result = result * j / i;
        return result;
    }
    
    public static BigInteger UEff(int n, int p) => (n + 1) * p;
    public static BigInteger VEff(int n, int p) => (2 * n + 1) * p;
}
​

答案3:

using System;
using System.Numerics;

public class Disguised2
{
    public static BigInteger U1(int n, int p) 
    {
        var sum = new BigInteger(0);
        for (int k=0;k<=n;k++)
        {
          int sign = k%2==1?-1:1;
          var m = Pow(4,n-k);
          m *= sign * BinomCoefficient(2*n-k+1,k);
          sum += m;
        }
        
        return p*sum;
    } 
    public static BigInteger V1(int n, int p) 
    {
        var sum = new BigInteger(0);
        for (int k=0;k<=n;k++)
        {
          int sign = k%2==1?-1:1;
          var m = Pow(4,n-k);
          m *= sign * BinomCoefficient(2*n-k,k);
          sum += m;
        }
        
        return p*sum;
    } 
    
    public static BigInteger Pow(int x, int y)
    {
      var p = new BigInteger(1);
      for (int i=0;i<y;i++)
        p *= x;
      return p;
    }
    
    public static BigInteger UEff(int n, int p) 
    {
        return p*(n+1);
    }
    public static BigInteger VEff(int n, int p) 
    {
        return p*(2*n+1);
    }
    
    
   public static BigInteger BinomCoefficient(long n, long k)
    {
        if (k > n) { return 0; }
        if (n == k) { return 1; } // only one way to chose when n == k
        if (k > n - k) { k = n - k; } // Everything is symmetric around n-k, so it is quicker to iterate over a smaller k than a larger one.
        BigInteger c = new BigInteger(1);
        for (long i = 1; i <= k; i++)
        {
            c *= n--;
            c /= i;
        }
        return c;
    }
    
}




​

答案4:

using System;

public class Disguised2
{
    public static Int64 V1(int n, int p) 
    {
        return (Int64)p * (2 * (Int64)n + 1);
    } 
    public static Int64 U1(int n, int p) 
    {
        return (Int64)p * ((Int64)n + 1);
    } 
    public static Int64 UEff(int n, int p) 
    {
        return (Int64)p * ((Int64)n + 1);
    }
    public static Int64 VEff(int n, int p) 
    {
        return (Int64)p * (2 * (Int64)n + 1);
    }
}
​

答案5:

using System.Numerics;

public class Disguised2 {

    public static BigInteger U1( int n, int p ) {
        BigInteger sum = 0;
        for ( int i = 0; i <= n; i++ ) {
            var s = BigInteger.Pow( -1, i );
            sum += s*p*BigInteger.Pow( 4, n - i )*C( 2*n - i + 1, i );
        }
        return sum;
    }

    public static BigInteger V1( int n, int p ) {
        BigInteger sum = 0;
        for ( int i = 0; i <= n; i++ ) {
            var s = BigInteger.Pow( -1, i );
            sum += s*p*BigInteger.Pow( 4, n - i )*C( 2*n - i, i );
        }
        return sum;
    }

    public static BigInteger UEff( int n, int p ) {
        return n*p + p;
    }

    public static BigInteger VEff( int n, int p ) {
        return 2*( n*p ) + p;
    }

    private static BigInteger C( BigInteger n, BigInteger k ) {
        if ( k > n ) {
            return 0;
        }
        BigInteger r = 1;
        for ( BigInteger d = 1; d <= k; d++ ) {
            r *= n--;
            r /= d;
        }
        return r;
    }
}
​

答案6:

using System.Numerics;

public class Disguised2
{
  public static BigInteger U1(int n, int p) => p * (n + new BigInteger(1));
  public static BigInteger V1(int n, int p) => p * (new BigInteger(2) * n + new BigInteger(1));
  public static BigInteger UEff(int n, int p) => p * (n + new BigInteger(1));
  public static BigInteger VEff(int n, int p) => p * (new BigInteger(2) * n + new BigInteger(1));
}​

答案7:

using System.Numerics;
public class Disguised2
{
        public static BigInteger U1(int n, int p) => new BigInteger(p) * (n + 1);
        public static BigInteger V1(int n, int p) => new BigInteger(p) * (2 * n + 1);
        public static BigInteger UEff(int n, int p) => U1(n, p);
        public static BigInteger VEff(int n, int p) => V1(n, p);
}
​

答案8:

using static System.Math;

using System.Numerics;
using System.Linq;

public class Disguised2
{
  public static BigInteger U1(int n, int p)
  {  
    return UEff(n, p);
  }
  
  public static BigInteger V1(int n, int p)
  {
    return VEff(n, p);
  }
  
  public static BigInteger UEff(int n, int p)
  {
    return n * p + p;
  }
  
  public static BigInteger VEff(int n, int p)
  {
    return (n * 2 + 1) * p;
  }
}
​

答案9:

using System;
using System.Collections.Generic;
using System.Numerics;

public class Disguised2
{
    private static bool _factorialTableBuilt = false;
    private static BigInteger[] _factorialTable = new BigInteger[2500];
    
    public static BigInteger U1(int n, int p) 
    {
      return CalcSummation(n, p, true);
    }

    public static BigInteger V1(int n, int p) 
    {
      return CalcSummation(n, p, false);
    }

    private static BigInteger CalcSummation(int n, int p, bool isU1) 
    {
      var sum = new BigInteger(0);
      int sign = n % 2 == 0 ? 1 : -1;
      var powerOf4 = new BigInteger(1);
      
      for (int k = n; k >= 0; k--)
      {
        int addOneIfU1 = isU1 ? 1 : 0;
        sum += sign * powerOf4 * CalculateCombinations(2 * n - k + addOneIfU1, k);
        sign *= -1;
        powerOf4 *= 4;
      }
      
      return p * sum;
    }
    
    private static BigInteger CalculateCombinations(int n, int r)
    {
      return CalculateFactorial(n) / CalculateFactorial(r) / CalculateFactorial(n - r);
    }

    public static BigInteger CalculateFactorial(int n)
    {
      if (n >= _factorialTable.Length)
        throw new ArgumentOutOfRangeException("Cannot compute factorial for values greater than or equal " + n);

      if (!_factorialTableBuilt)
      {
        InitFactorialTable();
        _factorialTableBuilt = true;
      }
      
      return _factorialTable[n];
    } 

    private static void InitFactorialTable()
    {
      _factorialTable[0] = new BigInteger(1);
      
      for (int i = 1; i < _factorialTable.Length; i++)
      {
        _factorialTable[i] = _factorialTable[i - 1] * i;
      }
    }
    
    public static BigInteger UEff(int n, int p) 
    {
      return new BigInteger(p * (n + 1));
    }
    
    public static BigInteger VEff(int n, int p) 
    {
      return new BigInteger(p * (2 * n + 1));
    }
}
​