Permutare e combinare i valori in base alla chiave

Question

Permutare e combinare i valori in base alla chiave

#1 da (1 voti)
#2 da (1 voti)

-1

Sto cercando di generare una tabella che mostri tutte le possibili combinazioni basate sulla chiave. Per renderlo più chiaro, diciamo che ho un tipo di chiave, set di coppie di valori (il suo tipo menzionato perché ci sono chiavi univoche e valori diversi). Devo riempire la tabella con tutte le possibili combinazioni dei valori con chiavi diverse.

Orahobisognodirenderelachiavecomel'intestazionedellatabellaeaggiungereivaloridiconseguenzainmodochenoncisianorigheduplicateechesianopresentituttelecombinazioni.LostofacendoinC#.Hopotutorecuperaresoloquestecoppiedivalorichiavedalmiodatabaseinbaseallecondizioni,manonhoideadicomepossaesserecostruitalatabella.

Cisonodegliesempichequalcunopotrebbefornire?Ounapprocciodibasechedovreiseguireperraggiungerlo?

Finoralemieidee:

Percreareunarraycondimensioniugualianumerodiparametridistintidichiave.Aggiungivaloriallamatriceepoipassaunelencodellamatriceallavista.

P.S:ilmiomodellodidatiècomplesso.Riferimentoa questa domanda darebbe un'idea di una parte del mio modello di dati. Il valore di cui sto parlando deriva dal SetValue descritto nel modello e dalla chiave di un'altra classe che non è descritta (ritengo che questa informazione sia irrilevante dato che ho già l'elenco delle mie coppie di valori chiave) . Penso di aver postato la domanda nel forum giusto, poiché non sto chiedendo alcun codice. In caso contrario, fammi sapere il forum giusto a cui questa domanda apparterrà.

c# algorithms asp.net-mvc

posta Vini 17.11.2015 - 09:52

fonte

2 risposte

Leggi altre domande sui tag c# algorithms asp.net-mvc

Se I # include un file, devo avere un percorso valido per qualsiasi intestazione # incluso nel file incluso [chiuso] È sempre meglio usare __construct () nei modelli e nelle viste di CodeIgniter, anche se non è necessario? [chiuso]

score 1 · Answer 1

Se hai un numero fisso di tipi come in questo caso (colore, frutta, verdura), puoi farlo facilmente con cicli annidati. Ad esempio:

foreach (var color in colors)
{
    foreach (var fruit in fruits)
    {
        foreach (var veg in vegetables)
        {
            rows.Add(new Row(color, fruit, vegetable));
        }
    }
}

Questo diventa ingombrante se il numero di cose diverse cresce comunque.

Puoi, tuttavia, generalizzarlo in una classe che genererà permutazioni per qualsiasi numero di cose diverse.

score 1 · Answer 2

Sono riuscito a fare una versione più versatile, che consente di permutare più proprietà con un elenco di valori. È piuttosto sciocco (non usa LINQ, dato che i dati di input sono OrderedDictionary) e può essere migliorato se i dati di input sono in un formato più amichevole.

// hold index data for permutations
class IndexData
{
    public int PropIndex { get; set; }
    public int MaxCount { get; set; }
}

// input data - OrderedDictionary helps with the key order, but has serious non-typed drawbacks
var propsValues = new OrderedDictionary()
{
    { "colour", new List<String>() { "red", "blue", "violet", "black", "yellow"}},
    { "fruit", new List<String>() { "apple", "mango", "banana", "banana"}},
    { "vegetable", new List<String>() { "onion", "potato", "tomato"}},
    { "shape", new List<String>() { "round", "oval" }}
};

// compute index containers to help with permutations
var propsIndexes = new Dictionary<String, IndexData>();
var propsKeys = new List<String>();
foreach (var key in propsValues.Keys)
{
    propsKeys.Add((String) key);
    propsIndexes.Add((String) key, new IndexData() { PropIndex = 0, MaxCount = (propsValues[key] as List<String>).Count});
}

int propCount = propsValues.Count;
String lastKey = propsKeys[propCount - 1];

// count the permutations until the "most significant" property (the one changing least often) has reached its count
for (int combinationIndex = 0; ; combinationIndex ++ )
{
    var sb = new StringBuilder();
    sb.AppendFormat("{0}: ", combinationIndex + 1);
    foreach (var key in propsValues.Keys)
    {
        int propIndex = propsIndexes[(String)key].PropIndex;
        sb.AppendFormat("{0} ", ((propsValues[(String)key] as List<String>)[propIndex]));
    }
    Console.WriteLine(sb.ToString());

    // incrementing indexes
    bool exit = false;
    propsIndexes[lastKey].PropIndex++;

    for (int i = propCount - 1; i >= 0; i--)
    {
        String propKey = (String)propsKeys[i];

        // current index has reached its count - incrementing previous one and resetting current one
        if (propsIndexes[propKey].PropIndex >= propsIndexes[propKey].MaxCount)
        {
            propsIndexes[propKey].PropIndex = 0;

            // "most significant" property has reached its count
            if (i == 0)
            {
                exit = true;
                break;
            }

            String prevPropKey = (String)propsKeys[i - 1];
            propsIndexes[prevPropKey].PropIndex++;
        }
    }

    if (exit)
        break;
}