Generare una tabella di decisioni in modo programmatico in C #?

Ho questa situazione che ho bisogno di lasciare che gli utenti definiscano le decisioni in base al numero di determinate condizioni. Ad esempio il mio programma ha bisogno di generare automaticamente una matrice come di seguito dato che ci sono due condizioni (IsMale e IsSmoker):

IsMale: YES YES NO NO IsSmoker: YES NO YES NO 

E la definizione è definita dall’utente, quindi una delle seguenti condizioni può essere valida:

 IsMale: YES YES NO NO IsSmoker: YES NO YES NO Decision: TFTF IsMale: YES YES NO NO IsSmoker: YES NO YES NO Decision: FFFF IsMale: YES YES NO NO IsSmoker: YES NO YES NO Decision: TTTT 

Per ogni condizione possono esserci solo due stati, Vero e Falso . Quindi il numero totale di combinazioni è calcolato come di seguito:

nessuno dei possibili stati (S) al potere di nessuna delle condizioni (C) S ^ C = numero totale di combinazioni

4 possibilità (2 ^ 2 = 4)

 Condition ATTFF Condition BTFTF 

8 possibilità (2 ^ 3 = 8)

 Condition ATTTTFFFF Condition BTTFFTFTF Condition CTFTFTTFF 

Spero di essermi spiegato un po ‘meglio della domanda originale.

Aggiornato: secondo la risposta data da Guffa . Di seguito è riportato il calcolo manuale del suo algoritmo per generare le diverse combinazioni.

 4 possibilities (2^2=4) 

indice = 0, (spostamento a destra 0)

 binary 8 4 2 1 Value original 0 0 0 1 1 & 1 0 0 0 1 1 T original 0 0 1 0 2 & 1 0 0 0 1 0 F original 0 0 1 1 3 & 1 0 0 0 1 1 T original 0 1 0 0 4 & 1 0 0 0 1 0 F 

indice = 1, (spostamento a destra 1)

 binary 8 4 2 1 Value original 0 0 0 1 1 shift 0 0 0 0 0 & 1 0 0 0 1 0 F original 0 0 1 0 2 shift 0 0 0 1 1 & 1 0 0 0 1 1 T original 0 0 1 1 3 shift 0 0 0 1 1 & 1 0 0 0 1 1 T original 0 1 0 0 4 shift 0 0 1 0 2 & 1 0 0 0 1 0 F 

combinazioni:

 Condition 1: TFTF Condition 2: FTTF 

L’output della matrice è piuttosto banale:

 int conditions = 3; for (int c = 0; c < conditions; c++) { Console.WriteLine( "Condition {0} : {1}", (char)('A' + c), new String( Enumerable.Range(0, (1 << conditions)) .Select(n => "TF"[(n >> c) & 1]) .ToArray() ) ); } 

Allora, cosa vuoi fare con esso?

Come djna ha menzionato nella sua / sua risposta, ti manca l’output per la decisione.

Ad esempio, se si dispone di un operatore che accetta due input (ad esempio: e, o operatori), è necessario provarlo per tutti i possibili input. Per un operatore semplice è abbastanza semplice poiché ci sono solo quattro possibili input, ma per operatori più complessi è necessario generare 2 ^ n ingressi possibili per calcolare tutti i possibili output.

Suggerisco di farlo in una serie di n variabili booleane, in cui si capovolgono i bit per ottenere 2 ^ n possibili input, quindi si verifica il proprio operatore con la matrice di input generata e si stampa il risultato.

Un modo semplice per generare la matrice è creare un ciclo in cui si incrementa una variabile da 0 a 2 ^ n – 1 e quindi si converte il numero in binario. Otterrai qualcosa del genere: (per n = 3):

 0: 0 0 0 1: 0 0 1 2: 0 1 0 3: 0 1 1 4: 1 0 0 5: 1 0 1 6: 1 1 0 7: 1 1 1 

Spero che questo ti aiuti!

Non sono sicuro di cosa intendi, ma forse questo è quello che stai cercando:

Ho apportato alcune piccole modifiche, perché il tuo secondo esempio non era coerente con il primo; e ha annullato i bit (ho sostituito F con 0 e T con 1), per mostrare il mio punto.

 Condition A 0 0 0 0 1 1 1 1 Condition B 0 0 1 1 0 0 1 1 Condition C 0 1 0 1 0 1 0 1 

Osserva ora lo schema di ogni colonna e pensa ai numeri binari;).

(Spero tu abbia l’idea.)

Penso di sapere cosa stai dicendo. Se le tue condizioni non sono così negative, puoi dire:

 se (A && B && C) {
      ritorno X;
 }
 se (! A && B && C) {
      ritorno Y;
 }

Oh aspetta! Penso che stai cercando di generare tutte le diverse combinazioni di condizioni! Vuoi permutazioni! E se hai solo un binario, beh, signore, ogni combinazione può essere trovata contando.

Non seguo abbastanza: sembra

 Stato 1 2 3 4
 Condizione ATTFF

?

A meno che mi manchi qualcosa ti manca qualcosa nella definizione del tuo problema. Hai definito la gamma di possibili input, che è sicuramente facile da generare?

 Condition ATTFF Condition BTFTF Decision TFFF 

L’output deve essere definito, non può essere dedotto. Ad esempio ho compilato un AND.

Sembra che il mio glib “facile da generare” sia il problema. Non funziona una soluzione ricorsiva?

 for (members of getListOfCombinedStates(n) ) print theMember getListOfCombinedStates(int howMany) { if ( n == 1 ) return list of possible States else { create empty resultlist for ( members of getListofCombinedStates(howMany -1) ) for ( members of listOfStates ) create new CombinedState by suffixing state, add to resultList return resultList } 

Quindi per n = 2 chiamiamo getListOfCombinedStates (2), che chiama getListOfCombinedStates (1), e restituisce {T, F}.

getListOfCombinedStates (2) poi itera {T, F} e aggiunge prima T e loro F a ciascun membro producendo {T, T} e {T, F} e poi {F, T} e {F, F}.

Spero sia chiaro come getListOfCombinedStates (3) a sua volta chiamerà getListOfCombinedStates (2) e genererà i valori richiesti.