C#练习题答案: 沃克【难度：2级】--景越C#经典编程题库,1000道C#基础练习题等你来挑战

沃克【难度:2级】:

答案1:

using System;

class Walker
{

    public static int[] Solve(int a, int b, int c, int alpha, int beta, int gamma)
    {
      double aa = alpha * Math.PI / 180;
      double bb = beta * Math.PI / 180;
      double cc = gamma * Math.PI / 180;
      double x = a * Math.Cos(aa) - b * Math.Sin(bb) - c * Math.Cos(cc);
      double y = a * Math.Sin(aa) + b * Math.Cos(bb) - c * Math.Sin(cc);
      double r = Math.Sqrt(x * x + y * y);
      int theta = (int)(Math.Acos(x / r) * 180 * 3600 / Math.PI);
      int d = theta / 3600;
      int mm = theta % 3600;
      int m = mm / 60;
      int s = mm % 60;
      return new int[]{(int)Math.Round(r), d, m, s};
    }

}
​

答案2:

using System;

class Walker
{
        public static int[] Solve(int a, int b, int c, int alpha, int beta, int gamma)
        {
            var h = Math.Sin(alpha * Math.PI / 180) * a + Math.Cos(beta * Math.PI / 180) * b - Math.Sin(gamma * Math.PI / 180) * c;
            var w = Math.Sin(beta * Math.PI / 180) * b + Math.Cos(gamma * Math.PI / 180) * c - Math.Cos(alpha * Math.PI / 180) * a;
            var oc = (int)Math.Round(Math.Sqrt(h * h + w * w));
            var angle = (180 - Math.Atan(h / w) * 180 / Math.PI) * 3600;
            var degree = angle / 3600;
            var minute = angle % 3600 / 60;
            var second = angle % 3600 % 60;
            return new[] { oc, (int)degree, (int)minute, (int)second };
        }
}​

答案3:

using System;
using System.Collections.Generic;
using System.Linq;

class Walker
{

     public static int[] Solve(int oa,int ab,int bc,int alpha,int beta,int gamma)
        {

            int boaAngle = 90 - alpha + beta;
            double vectorOB = VectorAddition(oa,ab,boaAngle);
            double tauAngle = Math.Round( beta - (boaAngle - AngleUnderVectors(ab, vectorOB, (180-boaAngle))),6);
            double vectorCO =VectorAddition(vectorOB, bc, (90-tauAngle+gamma));
            double tettaAngle = AngleUnderVectors(bc,vectorCO, (90+tauAngle-gamma));
            double resultAngle = 90 + tauAngle + tettaAngle;
            return (new int[] { (int)Math.Round(vectorCO) }).Concat(DegreeToMinAndSec(resultAngle)).ToArray();

        }

        private static double VectorAddition(double firstVector,double secondVector,double angle)
        {
            double result;
            result = Math.Sqrt(Math.Pow(firstVector, 2) + Math.Pow(secondVector, 2) + 2 *firstVector* secondVector * Math.Cos(angle * Math.PI / 180));
            return Math.Round(result, 6);
        }

        private static double AngleUnderVectors(double firstVector, double secondVector, double angle) =>
            Math.Round((Math.Asin((firstVector*Math.Sin(angle * Math.PI / 180))/secondVector)*180/Math.PI),6);
      
        private static int[] DegreeToMinAndSec(double degrees)
        {
            int resultDegree = (int)degrees;
            var minAsDouble = 60 * (degrees - resultDegree);
            var secAsDouble =60 * (minAsDouble - (int)minAsDouble);
            return  new int[]{resultDegree,(int)minAsDouble, (int)secAsDouble};
           
        }
}​

答案4:

using System;

class Walker
        {

            public static int[] Solve(int a, int b, int c, int alpha, int beta, int gamma)
            {
                var alphaRadians = ConvertToRadians(alpha);
                var betaRadians = ConvertToRadians(beta);
                var gammaRadians = ConvertToRadians(gamma);

                var Ax = a * Math.Cos(alphaRadians);
                var Ay = a * Math.Sin(alphaRadians);

                var Bx = Ax - b * Math.Sin(betaRadians);
                var By = Ay + b * Math.Cos(betaRadians);

                var Cx = Bx - c * Math.Cos(gammaRadians);
                var Cy = By - c * Math.Sin(gammaRadians);

                var distance0C = Math.Sqrt(Cx * Cx + Cy * Cy);
                var anglet0CRadians = Math.Atan2(Cy, Cx);

                var angleT0CDegrees = ConvertToDegrees(anglet0CRadians);

                var totalSeconds = (int)(angleT0CDegrees * 3600);
                var degrees = totalSeconds / 3600;
                var minutes = (totalSeconds - degrees * 3600) / 60;
                var seconds = totalSeconds % 60;


                return new int[]
                    {
                        (int)Math.Round(distance0C),
                        degrees,
                        minutes,
                        seconds
                    };

            }

            public static double ConvertToRadians(double angleInDegrees)
            {
                return angleInDegrees * Math.PI / 180.0;
            }

            public static double ConvertToDegrees(double angleInRadians)
            {
                return angleInRadians * 180.0 / Math.PI;
            }
        }​

答案5:

using System;

class Walker
{
    public static int[] Solve(int a, int b, int c, int alpha, int beta, int gamma)
    {
        double ax = a * Math.Cos(alpha / 180.0 * Math.PI);
        double ay = a * Math.Sin(alpha / 180.0 * Math.PI);
        double bx = ax - b * Math.Sin(beta / 180.0 * Math.PI);
        double by = ay + b * Math.Cos(beta / 180.0 * Math.PI);
        double cx = bx - c * Math.Cos(gamma / 180.0 * Math.PI);
        double cy = by - c * Math.Sin(gamma / 180.0 * Math.PI);
        
        int co = (int)Math.Round(Math.Sqrt(cx * cx + cy * cy));
        
        double angle = Math.Atan2(cy, cx) / Math.PI * 180;
        int degrees = (int)angle;
        angle -= degrees;
        angle *= 60;
        int minutes = (int)angle;
        angle -= minutes;
        angle *= 60;
        int seconds = (int)angle;
        
        return new int[] { co, degrees, minutes, seconds };
    }
}​

答案6:

  using System;

class Walker
{

        public static int[] Solve(int a, int b, int c, int alpha, int beta, int gamma)
        {   
            Point A = new Point(Math.Cos(alpha * Math.PI / 180) * a, Math.Sin(alpha * Math.PI / 180) * a);
            Point B = new Point(A.X - Math.Sin((beta) * Math.PI / 180) * b, Math.Cos((beta) * Math.PI / 180) * b + A.Y);
            Point C = new Point(B.X - Math.Cos((gamma) * Math.PI / 180) * c, B.Y - Math.Sin((gamma) * Math.PI / 180) * c);
            var CO = Math.Sqrt(C.X * C.X + C.Y * C.Y);
            var degrees = 180 - Math.Atan2(Math.Abs(C.Y), Math.Abs(C.X)) * 180 / Math.PI;
            var minutes = (degrees - (int)degrees) * 60;
            var seconds = (minutes - (int)minutes) * 60;
            CO = CO-(int)CO >= 0.5 ? (int)CO+1 : (int)CO;
            return new [] {(int) CO, (int) degrees, (int) minutes, (int) seconds };
        }

        public struct Point
        {
            public Point(double x, double y)
            {
                X = x;
                Y = y;
            }
            public double X, Y;
        }
}​

答案7:

using System;

class Walker
{
public static int[] Solve(int a, int b, int c, int alpha, int beta, int gamma) {
            
            double xA = Math.Cos((double)alpha / 180 * Math.PI) * a;
            double yA = Math.Sin((double)alpha / 180 * Math.PI) * a;

            double xB = xA + (Math.Cos((double)beta / 180 * Math.PI + Math.PI / 2) * b);
            double yB = yA + (Math.Sin((double)beta / 180 * Math.PI + Math.PI / 2) * b);

            double xC = xB + (Math.Cos((double)gamma / 180 * Math.PI + Math.PI) * c);
            double yC = yB + (Math.Sin((double)gamma / 180 * Math.PI + Math.PI) * c);

            double distOC = Math.Sqrt(xC * xC + yC * yC);
            int OC = (int)Math.Round(distOC);
            double tOC = Math.Acos(xC / distOC) * 180 / Math.PI;
            if (tOC < 0) tOC += 180;

            int degrees = (int)tOC;
            double min = (tOC - degrees) * 60;
            int minutes = (int)min;
            double sek = (min - minutes) * 60;
            int seconds = (int)sek;

            return new int[4] { OC, degrees, minutes, seconds };

        }
}​

答案8:

using System;

class Walker
{

    public static int[] Solve(int a, int b, int c, int alpha, int beta, int gamma)
    {
            var XC = a * Math.Cos(alpha * Math.PI / 180) - b * Math.Sin(beta * Math.PI / 180) - c * Math.Cos(gamma * Math.PI / 180);
            var YC = a * Math.Sin(alpha * Math.PI / 180) + b * Math.Cos(beta * Math.PI / 180) - c * Math.Sin(gamma * Math.PI / 180);

            var distanceCO = Math.Sqrt(XC * XC + YC * YC);
            int CO = Convert.ToInt32(Math.Round(distanceCO));
            var tOC = 180 + Math.Atan(YC / XC) / Math.PI * 180;
            int degreesTOC = Convert.ToInt32(Math.Floor(tOC));
            var afterDegrees = tOC % 1;
            int minutesTOC = Convert.ToInt32(Math.Floor(afterDegrees * 60));
            var afterMinutes = afterDegrees * 60 - minutesTOC;
            int secondsTOC = Convert.ToInt32(Math.Floor(afterMinutes * 60));

            return new int[4] { CO, degreesTOC, minutesTOC, secondsTOC };
    }
}​

答案9:

using System;

class Walker
{

    public static int[] Solve(int a, int b, int c, int alpha, int beta, int gamma)
    {
            double rad = Math.PI / 180;
            double grad = 180 / Math.PI;

            double x = 0.0;
            double y = 0.0;
            double dres = 0.0;
            int quarter;
            double temp;
            int[] result = new int[4];

            x = a * Math.Cos(rad * alpha) - b * Math.Sin(rad * beta) - c * Math.Cos(rad * gamma);
            y = a * Math.Sin(rad * alpha) + b * Math.Cos(rad * beta) - c * Math.Sin(rad * gamma);
            result[0] = (int)Math.Round(Math.Sqrt(x * x + y * y));

            if (y > 0.0)
                if (x > 0.0) quarter = 0;
                else quarter = 1;
            else if (x < 0.0) quarter = 2;
            else quarter = 3;

            switch (quarter)
            {
                case 1:
                    temp = y;
                    y = -x;
                    x = temp;
                    break;
                case 2:
                    x = -x;
                    y = -y;
                    break;
                case 3:
                    temp = x;
                    x = -y;
                    y = temp;
                    break;
            }

            dres = grad * Math.Atan(y / x) + (quarter * 90);
            result[1] = (int)dres;
            dres = ((dres - result[1]) * 60) % 60;
            result[2] = (int)dres;
            result[3] = (int)((dres - result[2]) * 60  ) % 60;

            return result; 
    }
}​

答案10:

using System;

class Walker
{
    private const double PI_OVER_180 = Math.PI / 180;
    private const double PI_OVER_2 = Math.PI / 2;
    private const double PI_UNDER_180 = 180 / Math.PI;
    private const double TWO_PI = Math.PI * 2;

    public static int[] Solve(int a, int b, int c, int alpha, int beta, int gamma)
    {
        int[] results = new int[4];

        double theta = alpha * PI_OVER_180;
        double x = a * Math.Cos(theta);
        double y = a * Math.Sin(theta);

        theta = PI_OVER_2 + beta * PI_OVER_180;
        x += b * Math.Cos(theta);
        y += b * Math.Sin(theta);

        theta = Math.PI + gamma * PI_OVER_180;
        x += c * Math.Cos(theta);
        y += c * Math.Sin(theta);

        double distance = Math.Sqrt(x * x + y * y);
        double radians = Math.Atan2(y, x);

        while (radians < 0)
        {
            radians += TWO_PI;
        }

        double degrees = radians * PI_UNDER_180;
        double minutes = (degrees - Math.Truncate(degrees)) * 60;
        double seconds = (minutes - Math.Truncate(minutes)) * 60;

        results[0] = (int)Math.Round(distance);
        results[1] = (int)(radians * PI_UNDER_180);
        results[2] = (int)minutes;
        results[3] = (int)seconds;

        return results;
    }
}​