Skip to content
TheChatArchiveThe Chat Archive
o4-mini-2025-04-16· OpenAIHugging Face LMArena Human Preference 140K

C#. Tengo dos listas l1 y l2 de enteros. De qué manera puedo determinar si son iguales…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-235b-a22b-no-thinking’s answer.
  1. User

    C#. Tengo dos listas l1 y l2 de enteros. De qué manera puedo determinar si son iguales (mismos elementos en ambas listas) ?

  2. Assistant

    Aquí tienes varias formas de comparar dos listas de enteros en C#, según el criterio que necesites:

    1. Mismos elementos y mismo orden
    using System.Linq;
    
    List<int> l1 = …;
    List<int> l2 = …;
    
    bool igualesConOrden = l1.SequenceEqual(l2);
    
    1. Mismos elementos (incluyendo repeticiones) sin importar el orden
    using System.Linq;
    
    bool igualesSinOrden = l1
        .OrderBy(x => x)
        .SequenceEqual(l2.OrderBy(x => x));
    
    1. Mismos valores únicos (ignoras repeticiones y orden)
    var set1 = new HashSet<int>(l1);
    var set2 = new HashSet<int>(l2);
    
    bool mismosValoresUnicos = set1.SetEquals(set2);
    
    1. Mismos elementos y mismas repeticiones (multiconjunto), sin importar el orden
    using System.Linq;
    
    // Creamos diccionarios: clave = valor de la lista, valor = número de ocurrencias
    var dict1 = l1
        .GroupBy(x => x)
        .ToDictionary(g => g.Key, g => g.Count());
    
    var dict2 = l2
        .GroupBy(x => x)
        .ToDictionary(g => g.Key, g => g.Count());
    
    // Comparamos que tengan mismas claves y mismos conteos
    bool multiconjuntosIguais =
        dict1.Count == dict2.Count &&
        !dict1.Except(dict2).Any();  // ningún par (clave, conteo) difiere
    
    1. Otra opción “rápida” (pero no respeta repeticiones):
    // Se basa en conjuntos simples (no tiene en cuenta cuántas veces aparece cada elemento)
    bool mismoConjunto = !l1.Except(l2).Any() && !l2.Except(l1).Any();
    

    —
    Elige la que mejor se ajuste a tu definición de “iguales”. 🚀

  3. User

    En general cuál opción es mas rápida ?

  4. Assistant

    Aquí tienes un resumen de costes (tiempo y espacio) y una recomendación general para cada caso:

    MétodoComplejidad tiempoComplejidad espacioCuándo usarlo
    1) l1.SequenceEqual(l2)O(n)O(1)Mismo orden & mismas repeticiones
    2) OrderBy + SequenceEqualO(n·log n)O(n) (listas ordenadas)Ignoras orden, incluyendo repeticiones
    3) new HashSet(l1).SetEquals(new HashSet(l2))O(n) (hashing)O(n)Ignoras orden y repeticiones (únicos)
    4) GroupBy → Dictionary → comparación de pares (clave, cnt)O(n) (hashing + agrupado)O(n)Ignoras orden, pero respetas repeticiones
    5) !l1.Except(l2).Any() && !l2.Except(l1).Any()O(n) (dos pasadas + hashing)O(n)Ignoras orden, sin respetar repeticiones

    Recomendaciones por escenario:

    • Mismo orden + repeticiones ⇒ usa SequenceEqual (𝘖(n), nada de memoria extra).
    • Sin importar el orden:
      • Si las repeticiones no importan (sólo valores únicos) ⇒ HashSet + SetEquals (𝘖(n)).
      • Si sí importan ⇒ usa GroupBy+Dictionary o la variante con dos Except (𝘖(n)), ambos basados en hashing.
    • Orden no importa pero no te importa programar más ⇒ rápido de escribir es l1.OrderBy(...).SequenceEqual(l2.OrderBy(...)), aunque sube a 𝘖(n log n).

    En la mayoría de casos “ignorar orden” + “respeto repeticiones” la versión con GroupBy → Dictionary es la más eficiente (𝘖(n)), seguida de cerca por la doble Except. Solo si realmente necesitas simplicidad extrema y no te molestan las 𝘖(n log n), el OrderBy + SequenceEqual es válido. 👍

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.