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

平衡比率【难度:3级】:

答案1:

using System;
using System.Linq;

public class Kata {
  public static int NextProduct(int[] desiredRatio, int[] actualStock) 
  {
    var desired = desiredRatio.Select(i => ((double)i) / desiredRatio.Sum()).ToList();
    var actual = actualStock.Select(i => ((double)i) / actualStock.Sum()).ToList();

    if(desired.SequenceEqual(actual))
    {
      return -1;
    }
    
    double maxDiff = 0;
    int maxDiffIndex = -1;
    
    for(int i = 0;i <desiredRatio.Length;i++)
    {
      if(desired[i] > actual[i])
      {
        var diff = desired[i] - actual[i];
        if(maxDiff <= diff)
        {
          maxDiff = diff;
          maxDiffIndex = i;
        }
      }
    }
    return maxDiffIndex;
  }
}​

答案2:

using System;
using System.Linq;
     public class Kata
    {
        public static int NextProduct(int[] dr, int[] ast)
        {
          Console.WriteLine(string.Join(",", dr.Select(x => x)));
               Console.WriteLine(string.Join(",", ast.Select(x => x)));
            int maxD = dr.Sum();
            int maxS = ast.Sum();
            dr = dr.Select(x => x * 100 / maxD).ToArray();
            ast = ast.Select(x => x * 100 / maxS).ToArray();
            int r = dr[0] - ast[0];
            int ans = 0;
            int j = 0;
            if(dr[0] - ast[0] == 0) j++;
            for(int i = 1; i < dr.Length; i++)
            {           
                int temp = (dr[i] - ast[i]);
                if (temp == 0) j++;
                if (temp < r &amp;&amp; temp > 0) { r = temp; ans = i; }
                else if(temp > r) { r = temp; ans = i; }
                if (j == dr.Length) ans = -1;
            }
            return ans;
        }
    }​

答案3:

using System.Linq;
using System;

public class Kata {
  public static int NextProduct(int[] desiredRatio, int[] actualStock) {
    double sumDesired = (double)desiredRatio.Sum();
    int sumAcutual = actualStock.Sum();
       
    double[] desireDecimal = ConvertToDecimal(desiredRatio, sumDesired);
    double[] actualeDecimal = ConvertToDecimal(actualStock, sumAcutual);
    
    if(differentPossibility(desireDecimal, actualeDecimal) == 0){
      return -1;
    }
    
    double[] diffRatio = new double[actualStock.Length];
    for(int i = 0; i < actualStock.Length; i++){
      int[] copy = actualStock.Select(x => x).ToArray();
      copy[i] = copy[i] +1;
      actualeDecimal = ConvertToDecimal(copy,sumAcutual+1 );
      diffRatio[i] = differentPossibility(desireDecimal, actualeDecimal);
    }        
    
    int result = 0;
    double minD = diffRatio[0];
    
    for(int i = 0; i < diffRatio.Length; i++){
      if(diffRatio[i] < minD){
        minD = diffRatio[i];
        result = i;
      }
    }
    
    return result;
  }
  
  private static double[] ConvertToDecimal(int[] ratio, double sumRatio ){
    return ratio.Select(x => x / sumRatio).ToArray();    
  }
  
  private static double differentPossibility(double[] desireDecimal, double[] actualeDecimal){
    double diff = 0;
    for(int i = 0; i < desireDecimal.Length; i++){
      diff += Math.Abs(desireDecimal[i] - actualeDecimal[i]);
    }
    return diff;
  }
}​

答案4:

using System;

public class Kata {
  public static int NextProduct(int[] desiredRatio, int[] actualStock) {
    double[] desiredPercentage = new double[desiredRatio.Length];
    int sum = 0;
    foreach (int i in desiredRatio) sum += i;
    for (int i = 0; i < desiredRatio.Length; i++)
      desiredPercentage[i] = 100.0 * desiredRatio[i] / sum;
      
    double[] possibleDiffs = new double[actualStock.Length];
    sum = 0;
    foreach (int i in actualStock) sum += i;
    
    double diff = 0;
    for (int i = 0; i < actualStock.Length; i++)
      diff += Math.Abs(100.0 * actualStock[i] / sum - desiredPercentage[i]);
    if (diff == 0) return -1;
    
    for (int i = 0; i < actualStock.Length; i++) {
      diff = 0;
      for (int j = 0; j < actualStock.Length; j++) {
        int stock = actualStock[j];
        if (i == j) stock++;
        double offset = (100.0 * stock) / (sum + 1) - desiredPercentage[j];
        if (offset < 0) diff -= offset; else diff += offset;
      }
      possibleDiffs[i] = diff;
    }

    double min = 100.0;
    int index = -1;
    for (int i = 0; i < possibleDiffs.Length; i++) {
      if (possibleDiffs[i] < min) {
        min = possibleDiffs[i];
        index = i;
      }
    }
    return index;
  }
}​

答案5:

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

public class Kata {
    public static int NextProduct(int[] desiredRatio, int[] actualStock)
    {
        var desiredPercentages = desiredRatio.Select(element => element * 100 / (double)desiredRatio.Sum());
        var actualPercentages = actualStock.Select(element => element * 100 / (double)actualStock.Sum());

        if (desiredPercentages.SequenceEqual(actualPercentages))
        {
            return -1;
        }

        var differences = new List<double>();

        for (var i = 0; i < actualStock.Length; i++)
        {
            actualStock[i] += 1;
            var producedPercentages = actualStock.Select(element => element * 100 / actualStock.Sum()).ToArray();
            differences.Add(producedPercentages.Zip(desiredPercentages, (i1, i2) => Math.Abs(i2 - i1)).Sum());
            actualStock[i] -= 1;
        }

        return differences.LastIndexOf(differences.Min());
    }
}​

答案6:

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

public class Kata {
  public static int NextProduct(int[] desiredRatio, int[] actualStock) {
    
  List<List<double>> tempList = new List<List<double>>();
            List<double> myDesiredRatio = desiredRatio.ToList().Select(p =>
            {
                    double sum = desiredRatio.Sum();
                    return p*100/sum;
            }).ToList();
            List<double> myActualStock = actualStock.ToList().Select(p =>
            {
                    double sum = actualStock.Sum();
                    return p*100/sum;
            }).ToList();
            var differenceList = myDesiredRatio.Zip(myActualStock, (x, y) => Math.Abs(x - y)).ToList();
            double sumOfDifference = differenceList.Sum();
            if (Math.Abs(sumOfDifference) ==0)
            {
                return -1;
            }
            for (int i = 0; i < actualStock.Length; i++)
            {
                actualStock[i] = actualStock[i] + 1;
                myActualStock = actualStock.ToList().Select(p =>
                {
                    {
                        double sum = actualStock.Sum();
                        return p*100/sum;
                    }
                }).ToList();
                differenceList = myDesiredRatio.Zip(myActualStock, (x, y) => Math.Abs(x - y)).ToList();
                sumOfDifference = differenceList.Sum();
                tempList.Add(new List<double>() {i, sumOfDifference});
                actualStock[i] = actualStock[i] - 1;
            }
            return  (int)tempList.Last(q => q[1] == tempList.Select(p => p[1]).ToList().Min())[0];
  }
}​

答案7:

using System;
using System.Linq;

public class Kata {
  public static int NextProduct(int[] desiredRatio, int[] actualStock) {
    float desiredTotal = desiredRatio.Sum();
    float[] desiredProportions = desiredRatio.Select(i => (float)(i) / desiredTotal).ToArray();
    float actualTotal = actualStock.Sum();
    float[] actualProportions = actualStock.Select(i => (float)(i) / actualTotal).ToArray();
    
    int maxDiffIndex = -1;
    float maxDiff = 0;
    for(int i = 0; i < desiredProportions.Length; ++i) {
      float diff = desiredProportions[i] - actualProportions[i];
      if(diff > maxDiff) {
        maxDiff = diff;
        maxDiffIndex = i;
      }
    }
    
    return maxDiffIndex;
  }
}​