Pseudocode: calculer le total récursivement

Question

On m'a donné une exigence (au moins pour moi) d'écrire une logique dans une application. Je l'ai d'écrire une logique métier dans laquelle il doit effectuer les fonctionnalités suivantes

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

Maintenant, supposons que les batteries nécessaires pour alimenter le courant (A + B) être « X »

De plus, chaque X peut contribuer à la consommation totale de courant, donc j'ai besoin pour calculer la consommation totale de courant à nouveau comme première étape, y compris la consommation de courant de la batterie

-à-dire

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

Maintenant encore, je devrais calculer les piles nécessaires. Disons cela comme Y

-à-dire

pour fournir A + B + X » nous avons besoin Y nombre de batteries.

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 

Quelqu'un peut-il me aider ensemble initial de pseudocode? Tout type la suggestion est également apprécié

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 ... 

Answer 1

Il me semble que le pseudo-code est déjà là, mais pas très clair. Mais voir si cela est ce que vous voulez:

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: Vous pouvez utiliser System.Linq si vous avez besoin des fonctions pour travailler sur les listes, comme Sum().

Answer 2

La question n'est pas très claire (comme d'autres l'ont noté dans les commentaires), il serait donc utile si vous pouviez écrire un exemple plus concret ou spécifique du calcul. Quoi qu'il en soit, il me semble que vous avez un calcul avec un retour et vous devez atteindre un point où le calcul cesse de changer.

En mathématiques, ceci peut être décrit en utilisant un fixed-point. Pour une fonction donnée f (votre calcul) le point de fixation est une valeur telle que x = f (x) (ce qui signifie que si vous recalculez la valeur, il cessera de changer). Je ne suis pas sûr que cela puisse vous aider dans votre implémentation, mais c'est certainement un concept utile que vous pouvez utiliser lorsque vous réfléchissez au problème.

Voici un exemple de méthode qui calcule un point fixe d'une fonction donnée (en utilisant le délégué C# 3.0 Func<T, T>). La méthode est générique et doit être en mesure de comparer les valeurs:

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; 
} 

Wikipédia a un exemple de calcul de point fixe d'une fonction cos (voir le deuxième graphique à droite), que vous pouvez mettre en œuvre comme ceci:

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

Ceci est une façon très générale de décrire une boucle qui s'exécute jusqu'à ce qu'elle trouve un point stable de certains calculs. Cependant, votre question n'est pas très claire, donc ce n'est peut-être pas ce que vous cherchez ...

Answer 3

je ferais quelque chose le long des lignes de ce qui suit:

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; 
}