Pseudocode: calculer le total récursivement

Question

Pseudocode: calculer le total récursivement

voix

1

J'ai donné une exigence (difficile pour moi au moins) 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 fournir le courant (A + B) soit « X »

De plus, chaque X peut contribuer à la consommation totale de courant, donc je dois calculer la consommation totale de courant à nouveau comme première étape, y compris la consommation de courant batterie

c'est à dire

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

Maintenant, encore une fois je dois calculer les batteries nécessaires. Disons cela comme Y

c'est à dire

à l'alimentation A + B + X » nous avons besoin nombre Y 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 pseudo-code? Tout type de 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 ...

c#programming-languages functional-programming pseudocode

Créé 04/03/2010 à 19:32
source utilisateur constant learner

Dans d'autres langues...

3 réponses

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

Il me semble que le pseudo-code est déjà là, mais pas très clair. Mais si c'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 ().

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

La question est très claire (comme d'autres ont noté dans les commentaires), il serait utile que vous pourriez écrire quelques exemples plus concrets ou spécifiques du calcul. Quoi qu'il en soit, il me semble que vous avez un calcul avec une rétroaction et vous devez atteindre un point où le calcul cesse de changer.

En mathématiques, cela peut être décrit au moyen d' un point fixe . Pour une fonction donnée f (le calcul) est le point fixe une valeur telle que x = f (x) ( ce qui signifie que si vous recalculez à nouveau la valeur, il arrête de changer). Je ne sais pas si cela peut vous aider avec votre mise en œuvre, mais il est certainement un concept utile que vous pouvez utiliser en pensant à ce problème.

Voici un exemple d'un procédé qui permet de calculer un point fixe d'une fonction donnée ( en utilisant C # 3.0 Func<T, T>délégué). 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;
}

Wikipedia a un exemple de calcul de point fixe d'un cos fonction (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 pour décrire une boucle qui va jusqu'à ce qu'il trouve un point stable d'un calcul. Toutefois, votre question est pas très claire, donc ce ne peut pas être ce que vous cherchez ...

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

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