berechnen Slab Preise

Question

Ich möchte nach Brammen Stromkosten berechnen, wie in der nachstehenden Tabelle mit C#,

SlabFrom SlabTo  Rate 

    0   100   5.00 
    101   500   10.00 
    501   Null  15.00 

Anzahl der Platten ändern können, benötigen eine beste Lösung Gesamtkosten
nach Gesamtverbrauch zu berechnen. Wenn Gesamtverbrauch 1000 ist, sollte es berechnen:

(100 X 5) + (400 x 10) + (500 x 15) = 12.000

public class Cost 
{ 
    public decimal SlabFrom { get; set; } 

    public decimal SlabTo { get; set; } 

    public bool SlabHour { get; set; } 

    public decimal RatePerUnit { get; set; } 
} 

     var rates = new List<Cost> 
     { 
      new Cost() 
      { 
       SlabFrom = 0, 
       SlabTo = 100, 
       RatePerUnit = 5 
      }, 
      new Cost() 
      { 
       SlabFrom = 101, 
       SlabTo = 500, 
       RatePerUnit = 10 
      }, 
      new Cost() 
      { 
       SlabFrom = 501, 
       SlabTo = 1000, 
       RatePerUnit = 15 
      }, 
      new Cost() 
      { 
       SlabFrom = 1001, 
       SlabTo = 1500, 
       RatePerUnit = 20 
      } 
     }; 

Answer 1

Sie können dies tun:

rates.TakeWhile(item => item.SlabFrom totalUsage) 
    .Sum(item => (double)((item.SlabTo > totalUsage ? totalUsage : item.SlabTo) - item.SlabFrom) * item.RatePerUnit); 

Answer 2

Wenn Sie nur die ersten 3

int usage = 503; 
int total = usage < 100 ? usage * 5 : 500 + (usage < 500 ? (usage - 100) * 10 : 4000 + (usage - 500) * 15); 
//4545 

Wenn Sie eine allgemeinere Antwort wollen
von th e Art und Weise i Ihre Cost-Klasse verwendet diese

decimal used = 1000; 
decimal LastSlabto = 0; 
decimal total = 0; 

foreach (Cost rate in rates) 
{ 
    if (used > rate.SlabTo - LastSlabto) 
     total += (rate.SlabTo - LastSlabto) * rate.RatePerUnit; 
    else 
    { 
     total += used * rate.RatePerUnit; 
     used = 0; 
     break; 
    } 
    used -= rate.SlabTo - LastSlabto; 
    LastSlabto = rate.SlabTo;    
} 

Answer 3

dieser Bereich

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Data; 

namespace ConsoleApplication4 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      DataTable dt = new DataTable(); 
      dt.Columns.Add("SlabFrom", typeof(int)); 
      dt.Columns.Add("SlabTo", typeof(int)); 
      dt.Columns["SlabTo"].AllowDBNull = true; 
      dt.Columns.Add("Rate", typeof(double)); 

      dt.Rows.Add(new object[] {0,100,5.00}); 
      dt.Rows.Add(new object[] {100,500,10.00}); 
      dt.Rows.Add(new object[] {501,null,15.00}); 

      int usage = 1500; 

      double cost = 0; 
      foreach(DataRow row in dt.AsEnumerable()) 
      { 
       if(usage > 0) 
       { 
        if((row.Field<int?>("SlabTo") == null) || (usage < row.Field<int>("SlabTo"))) 
        { 
         cost += usage * row.Field<double>("Rate"); 
         usage = 0; 
        } 
        else 
        { 
         cost += (row.Field<int>("SlabTo") - row.Field<int>("SlabFrom")) * row.Field<double>("Rate"); 
         usage -= (row.Field<int>("SlabTo") - row.Field<int>("SlabFrom")); 
        } 
       } 
      } 
     } 
    } 

} 

Answer 4

101-500 Versuchen zu testen, wird wie folgt berechnet (500-101) * 10. Er kann jedoch geändert werden, um Ihr zu passen Anforderung durch geringfügige Änderungen.

private static double CalculateRate(int totalUsage) 
{ 
    var applicableSlabRates = sr.Where(r => r.SlabFrom <= totalUsage).OrderBy(r => r.SlabFrom); 

     double cost = 0; 
     foreach (var r in applicableSlabRates) 
     { 
      int range = 0; 
      if ((r.SlabFrom < totalUsage && totalUsage <= r.SlabTo) || r.SlabTo == null) 
      { 
       range = totalUsage; 
      } 
      else 
      { 
       range = Convert.ToInt32(r.SlabTo) - r.SlabFrom; 
      } 

      cost += range * r.Rate; 

      totalUsage = totalUsage - range; 
     } 

     return cost; 
} 


public class SlabRate 
{ 
     public int SlabFrom { get; set; } 
     public int? SlabTo { get; set; } 
     public double Rate { get; set; } 
} 

static List<SlabRate> sr = new List<SlabRate>(); 
    sr.Add(new SlabRate() { SlabFrom = 0, SlabTo = 100, Rate = 5.00 }); 
    sr.Add(new SlabRate() { SlabFrom = 101, SlabTo = 500, Rate = 10.00 }); 
    sr.Add(new SlabRate() { SlabFrom = 501, SlabTo = null, Rate = 15.00 }); 

Answer 5

Von der obigen Antwort habe ich es richtig gemacht, Danke. Bitte sehen

private static double GenericCostCalculation(double units) 
    { 
     var rates = new List<Cost> 
     { 
      new Cost { SlabFrom = 0, SlabTo = 100, RatePerUnit = 10 }, 

      new Cost { SlabFrom = 101, SlabTo = 500, RatePerUnit = 20 }, 

      new Cost { SlabFrom = 501, SlabTo = 1000,RatePerUnit = 30 }, 

      new Cost { SlabFrom = 1001, SlabTo = 2000, RatePerUnit = 40 } 
     }; 

     double cost = 0; 
     foreach (var rate in rates) 
     { 
      if (units > 0) 
      { 
       if ((rate.SlabTo == rates.Max(x => x.SlabTo)) || (units < rate.SlabTo)) 
       { 
        cost += units * rate.RatePerUnit; 
        units = 0; 
       } 
       else 
       { 
        cost += (rate.SlabTo - rate.SlabFrom) * rate.RatePerUnit; 
        units -= (rate.SlabTo - rate.SlabFrom); 
       } 
      } 
     } 
     return cost; 
    }