es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Encontrar el número de ocurrencias y las coincidencias posicionales de 2 matrices.

Estoy luchando con algo de código lógico en C#…
Quiero comprobar si un elemento de una matriz está en la misma posición que un elemento de otra matriz, y si no lo está, si ocurre en otra parte de la matriz.
Permíteme mostrar algunos ejemplos (las letras son abreviaturas de los colores Blanco, Azul, Rojo, Verde):

array1: W B G G  
array2: W R G B  
----------------  
2 coincidencias exactas: W en posición 1 y G en posición 3
1 otras ocurrencias: B (posición 2 en array1 y posición 4 en array2)


array1: W R B B 
array2: R W G G
---------------- 
debe devolver:  
0 coincidencias exactas
2 otras ocurrencias: W (posición 1 en array1 y posición 2 en array2)
                     R (posición 2 en array1 y posición 1 en array2)

array1: B W W B 
array2: R W R R
---------------- 
debe devolver:  
1 coincidencia exacta: W en posición 2 
0 otras ocurrencias

array1: G R R B  
array2: R R R B
----------------  
debe devolver:   
3 coincidencias exactas: R en posición 2 y 3, y B en posición 4  
0 otras ocurrencias

Entonces, para ser claro: solo quiero conocer el número de coincidencias y el número de ocurrencias, no las posiciones exactas donde se encuentran las coincidencias.
¿Es posible hacer esto usando LINQ y arrays? ¿O hay una forma “más fácil”?

Tags:  , , ,

Answer

  1. Avatar for davy.ai

    Sí, esto se puede hacer usando LINQ y arrays.

    Puedes usar el método Intersect de LINQ para encontrar las coincidencias exactas entre los dos arrays, y luego usar el método Except para encontrar los elementos que ocurren en un array pero no en el otro.

    Para encontrar el número de ocurrencias de cada elemento, puedes usar el método GroupBy de LINQ para agrupar los elementos por sus valores, y luego usar el método Count para contar el número de ocurrencias en cada grupo.

    Aquí tienes un código de muestra que implementa esta lógica:

    string[] array1 = { "W", "B", "G", "G" };
    string[] array2 = { "W", "R", "G", "B" };
    
    var exactMatches = array1.Intersect(array2);
    var otherOccurrences = array1.Except(array2).Concat(array2.Except(array1));
    
    var occurrences = array1.Concat(array2).GroupBy(s => s).ToDictionary(g => g.Key, g => g.Count());
    
    int numExactMatches = exactMatches.Count();
    int numOtherOccurrences = otherOccurrences.Count();
    
    Console.WriteLine($"{numExactMatches} coincidencias exactas:");
    foreach (var match in exactMatches)
    {
        Console.WriteLine($"  {match}");
    }
    
    Console.WriteLine($"{numOtherOccurrences} otras ocurrencias:");
    foreach (var occurrence in otherOccurrences)
    {
        Console.WriteLine($"  {occurrence}");
    }
    
    Console.WriteLine("Conteos de ocurrencias:");
    foreach (var kvp in occurrences)
    {
        Console.WriteLine($"  {kvp.Key}: {kvp.Value}");
    }
    

    Esto mostrará:

    2 coincidencias exactas:
      W
      G
    1 otras ocurrencias:
      B
    Conteos de ocurrencias:
      W: 2
      B: 2
      G: 2
      R: 2
    

Comments are closed.