Pseudocode: het berekenen van de totale recursief

Question

Pseudocode: het berekenen van de totale recursief

stemmen

1

Ik heb gekregen een vereiste (een uitdaging voor mij althans) om een logica in een toepassing te schrijven. Ik heb een business logica te schrijven, waarin hij de volgende functionaliteit moet uitvoeren

Total current consumption = current from A elements + current from B elements.
A and B are different types of devices

Laten we nu zeggen dat het nodig is om de stroom leveren batterijen (A + B) zijn 'X'

Ook elke X kan bijdragen aan het totale stroomverbruik, dus ik nodig om het totale stroomverbruik opnieuw berekenen net als de eerste stap inclusief de batterij stroomverbruik

d.w.z

`Total current consumed : A + B + X`  
where X is the current consumption of the battery

Nu weer moet ik de benodigde batterijen te berekenen. Laten we zeggen als Y

d.w.z

om het aanbod A + B + X we moeten Y aantal batterijen.

Now check whether X == Y ?
If same, then return Y and exit 
else add more X to the sum (A + B  + X) till X == Y

Kan iemand me helpen met de eerste reeks van pseudocode? Elke vorm van suggestie wordt ook gewaardeerd

Yes the end result this logic should return is number of batteries required. However it should return this result only after computing the total current consumption recursively till X == Y, where 
A : total current consumption of some active elements in a system.
B : total current consumption of some passive elements in a system

Total current consumption is A + B
to supply current of (A+B) amperes i require 'X' no. of batteries.
However each battery also adds some delta amount of current to the total value i.e 
A + B + X
if the batteries required to supply this delta is still 'X', then return X as the end result, else add more batteries --> calculate current --> no of batteries required ---> check again and so on ...

c#programming-languages functional-programming pseudocode

De vraag is gesteld op 04/03/2010 om 19:32
bron van user constant learner

In andere talen...

3 antwoorden

ANeves · Answer 1 · 2010-03-04 20:08

Het lijkt mij dat de pseudo-code is er al, alleen niet erg duidelijk. Maar zien of dit is wat je wilt:

private const decimal CurrentSuppliedPerBattery = 100;
private const decimal CurrentNeededPerBattery = 5;
private int BatteriesNeeded( List<A> As, List<B> Bs) {
    decimal currentToSupply = As.Sum( eachA => eachA.Current ) + Bs.Sum( eachB => eachB.Current );
    int batteries = 0;
    while(currentToSupply > 0)
    {
        int extraBatteries = Floor(1.0*currentToSupply/CurrentSuppliedPerBattery );
        batteries += extraBatteries;
        currentToSupply -= extraBatteries*CurrentSuppliedPerBattery;
        currentToSupply += extraBatteries*CurrentNeededPerBattery;
    }
    return batteries ;
}

ps: U kunt System.Linq gebruiken als u functies nodig hebt om te werken op lijsten, zoals Sum ().

Tomas Petricek · Answer 2 · 2010-03-04 20:10

De vraag is niet erg duidelijk (zoals anderen in reacties vermeld), dus het zou nuttig zijn als u wat meer beton of specifiek voorbeeld van de berekening kon schrijven. Hoe dan ook, het lijkt me dat je een aantal berekeningen met een feedback en je moet een punt waarin de berekening stopt veranderende bereiken.

In wiskunde, kan deze worden omschreven met een vast punt . Voor een gegeven functie f (uw berekening) de fixpoint is een waarde zodanig dat x = f (x) (wat betekent dat als u de waarde weer opnieuw te berekenen, zal het stoppen veranderende). Ik weet niet zeker of dit u kan helpen met de implementatie, maar het is zeker een nuttig concept dat u kunt gebruiken bij het denken over het probleem.

Hier is een voorbeeld van een werkwijze die een vast punt van een bepaalde functie (met C # 3.0 berekent Func<T, T>gemachtigde). De methode is generiek en moet in staat zijn om de waarden te vergelijken:

static T FixedPoint<T>(T initial, Func<T, T> calculateNext) 
    where T : IComparable<T> {
  T state = initial;
  T previous = default(T);
  do {
    previous = state;
    state = calculateNext(state);
  } while (previous.CompareTo(state) != 0);
  return state;
}

Wikipedia heeft een voorbeeld van de berekening van vaste-punt van een cos functie (zie tweede grafiek rechts), die u kunt uitvoeren als volgt:

double val = FixedPoint(-1.0, f => Math.Cos(f));
Console.WriteLine(val);

Dit is een zeer algemene manier om wat looping dat wil zeggen tot een stabiele punt van enkele berekening vindt beschrijven. Echter, uw vraag is niet erg duidelijk, dus dit is misschien niet wat je zoekt ...

TJMonk15 · Answer 3 · 2010-03-04 20:18

Ik zou iets in de trant van het volgende doen:

double CurrentFromEachBattery=100.0;
double CurrentNeededPerBattery=10.0;

int NumberOfBatteriesRequired(double activeCurrent, double passiveCurrent)
{
    int batteries=0;
    double currCurrent=0.0;
    double neededCurrent=activeCurrent+passiveCurrent;

    while( currCurrent < neededCurrent )
    {
        int newBatt = Math.Ceiling((neededCurrent - currCurrent) / CurrentFromEachBattery);
        neededCurrent += newBatt * CurrentNeededPerBattery;
        currCurrent += newBatt * CurrentFromEachBattery;
        batteries += newBatt;
    }

    return batteries;
}