La sélection d'éléments de la matrice selon les indices spécifiés dans un autre tableau c#

Supposons que nous avons un tableau avec des données:

double[] x = new double[N] {x_1, ..., x_N};

Et tableau de taille N contenant les étiquettes correspondant aux éléments de x:

int[] ind = new int[N] {i_1, ..., i_N};

Quel est le moyen le plus rapide pour sélectionner tous les éléments de x qui ont certaines étiquette I selon ind?

Par exemple,

x = {3, 2, 6, 2, 5}
ind = {1, 2, 1, 1, 2}
I = ind[0] = 1

Résultat:

y = {3, 6, 2}

Clairement, il peut être facilement (mais pas de manière efficace et propre) fait avec des boucles, mais je pense qu'il devrait être la façon de le faire à l'aide .Where et les lambdas..Merci

EDIT:

La réponse fournie par MarcinJuraszek est tout à fait correct, merci. Cependant, j'ai simplifié la question dans l'espoir qu'il serait de travailler dans ma situation d'origine. Pourriez vous s'il vous plaît prendre un coup d'oeil quel est le problème si nous avons des types génériques:

T1[] xn = new T1[N] {x_1, ..., x_N};
T2[] ind = new T2[N] {i_1, ..., i_N};
T2 I = ind[0]

À l'aide de la solution fournie, j'obtiens une erreur "Délégué" du Système.Func "ne prenez pas 2 arguments":

T1[] y = xn.Where((x, idx) => ind[idx] == I).ToArray();

Merci beaucoup

OriginalL'auteur Oleg Shirokikh | 2013-04-03

  1. 17

    Comment à ce sujet:

    var xs = new[] { 3, 2, 6, 2, 5 };
var ind = new[] { 1, 2, 1, 1, 2 };
var I = 1;

var results = xs.Where((x, idx) => ind[idx] == I).ToArray();

    Il utilise la deuxième, moins populaire, Where surcharge:

    Énumérable.Où<TSource > (IEnumerable < TSource>, Func < TSource, Int32, Boolean>)

    qui a index de l'élément disponible en tant que prédicat paramètre (appelé idx dans ma solution).

    Version générique

    public static T1[] WhereCorresponding<T1, T2>(T1[] xs, T2[] ind) where T2 : IEquatable<T2>
{
    T2 I = ind[0];
    return xs.Where((x, idx) => ind[idx].Equals(I)).ToArray();
}

    Utilisation

    static void Main(string[] args)
{
    var xs = new[] { 3, 2, 6, 2, 5 };
    var ind = new[] { 1, 2, 1, 1, 2 };

    var results = WhereCorresponding(xs, ind);
}

    Générique + double version

    public static T[] Test<T>(T[] xs, double[] ind)
{
    double I = ind[0];

    return xs.Where((x, idx) => ind[idx] == I).ToArray();
}
    A été de penser à l'aide de Zip, mais diable: plus Court que ce qu'il ne va pas obtenir..
    Il est très gentil, merci. Pourriez-vous s'il vous plaît regardez la version éditée de la question?
    Pour les génériques, vous devez vous assurer T2 == T2 (ou T2.Equals(T2)) est défini - ajouter contrainte générique where T2 : IEquatable
    Pouvez-vous conseils comment dois-je intégrer cette contrainte?
    Voir mon jour de réponse, monsieur.

    OriginalL'auteur MarcinJuraszek

  2. 5

    C'est un classique de l'utiliser pour Enumerable.Zip, qui s'exécute par le biais de deux enumerables parallèle à l'eachother. À l'aide de Zip, vous pouvez obtenir vos résultats avec un seul passage. La suite est complètement de type agnostique, bien que j'utilise ints et strings pour l'illustration:

    int[] values = { 3, 2, 6, 2, 5 };
string[] labels = { "A", "B", "A", "A", "B" };
var searchLabel = "A";

var results = labels.Zip(values, (label, value) => new { label, value })
                    .Where(x => x.label == searchLabel)
                    .Select(x => x.value);

    OriginalL'auteur Joshua Honig