C# - recherche un tableau de chaînes utilisant des chaînes d'un autre tableau de chaînes

Question

Tout comme dans le titre. J'ai un tableau de chaînes et un deuxième tableau de chaînes. Je veux afficher le résultat dans ce type de motif: premier élément du premier tableau - puis tous les éléments du deuxième tableau qui se produit dans le premier élément du premier tableau. Après ce deuxième élément du premier tableau et tous les éléments du deuxième tableau qui se produit dans le deuxième élément du premier tableau. Etc. Par exemple:

string[] arrayA = {"Lorem ipsum dolor sit amet, justo", "notgin like good cold beer"}; 
string[] arrayB = {"justo","beer","lorem"} 
for (int i = 0; i < arrayA.Length; i++) 
    { 
     Console.WriteLine(arrayA[i]); 

     for (int j = 0; j < arrayB.Length; j++) 
     { 
      int controlIndex = arrayA[i].IndexOf(arrayB[j]); 
      if (controlIndex != -1) 
      { 
       Console.Write(" :--contains-->" + arrayB[j]); 
      } 

    } 

}

Ainsi, le résultat devrait ressembler à ceci:

• Lorem ipsum dolor sit amet, justo: - contient ->justo, lorem
• notgin comme bonne bière froide: - contient ->bière.

Mais le mien résultat est: - Lorem ipsum dolor sit amet, justo: - contient ->justo - notgin comme une bonne bière froide: - contient ->bière.

Comme vous pouvez le voir il n'y a pas lorem liste

Answer 1

Ce n'est pas difficile du tout si vous cassez votre problème. Tout d'abord, évitez de traiter avec des tableaux et des index en eux. Il suffit d'utiliser IEnumerable<T>, il va rendre votre vie plus facile.

Voilà comment je vois:

D'abord, vous voulez trouver toutes les chaînes d'un tableau needles, qui font partie d'une chaîne, haystack.

public static IEnumerable<string> MatchingStrings(string haystack, IEnumerable<string> needles) 
{ 
    return needles.Where(needle => haystack.Contains(needle)); 
} 

Cela renverra un IEnumerable de toutes les chaînes de needles qui font partie de haystack. Puis, vous voulez simplement parcourir toutes vos chaînes de recherche, j'appellerai ça haystacks.

static void Main(string[] args) 
    { 
     var haystacks = new[] { 
      "Lorem ipsum dolor sit amet, justo", 
      "notgin like good cold beer" 
     }; 

     var needles = new[] {"justo", "beer", "lorem"}; 

     foreach (var haystack in haystacks) { 
      Console.Write(haystack + " contains --> "); 
      var matches = MatchingStrings(haystack, needles); 

      Console.WriteLine(String.Join(",", matches)); 
     } 

     Console.ReadLine(); 
    } 

Notez que String.Contains() est sensible à la casse. Donc "Lorem" ne correspondra pas "lorem". Si vous voulez ce comportement, vous devrez d'abord les convertir en minuscules.

public static IEnumerable<string> MatchingStringsCaseInsensitive(string haystack, IEnumerable<string> needles) 
{ 
    var h = haystack.ToLower(); 
    return needles.Where(needle => h.Contains(needle.ToLower())); 
} 

Answer 2

string[] arrayA = {"Lorem ipsum dolor sit amet, justo", "notgin like good cold beer"}; 
string[] arrayB = {"justo","beer","lorem"}; 

foreach (var s in arrayA) 
{ 
    Console.Write(s + " contains: " + 
        string.Join(",", arrayB.Where(s.Contains))); 
} 

Et si vous voulez ignorer la casse:

foreach (var s in arrayA) 
{ 
    Console.Write(s + " contains: " + 
        string.Join(",", arrayB.Where(x => 
         s.IndexOf(x, StringComparison.OrdinalIgnoreCase) != -1))); 
} 

Answer 3

foreach(var a in arrayA) 
{ 
    Console.WriteLine("a: " + a); 
    Console.WriteLine("bs: " + 
     String.Join(", ", arrayB.Where(b => a.IndexOf(b) > -1))); 
} 

Aussi, si vous voulez dire de ne pas se soucier de cas , a.IndexOf(b) serait a.IndexOf(b, StringComparison.OrdinalIgnoreCase).

Answer 4

Ceci est la solution Linq:

var result = arrayA.Select(a => new{ 
    A = a, 
    bContains = arrayB.Where(b => a.IndexOf(b, 0, StringComparison.CurrentCultureIgnoreCase) > -1)    
}); 

foreach(var x in result) 
{ 
    Console.WriteLine("{0}:--contains-->{1}", x.A, string.Join(",", x.bContains)); 
} 

Voici une démo: http://ideone.com/wxl6I

Answer 5

Voici ma tentative

string[] arrayA = {"lorem ipsum dolor sit amet, justo", "notgin like good cold beer"}; 
string[] arrayB = {"justo", "beer", "lorem"}; 

foreach (var item in from a in arrayA from b in arrayB where a.Contains(b) select new {a, b}) 
{ 
    Console.WriteLine(item.a); 
    Console.WriteLine(item.b); 
} 

Note: Contains est un cas comparer et vous sensible » Il va falloir écrire un comparateur personnalisé (comme d'autres réponses l'ont déjà fait)

Answer 6

Lorem est en majuscule. Essayez d'utiliser une recherche insensible à la casse: .indexOf(string, StringComparison.CurrentCultureIgnoreCase)

Answer 7

Je vous ai donné toutes les réponses possibles, mais la méthode contains va créer un problème qui retournera vrai dans le cas mentionné ci-dessous.

reference_string = "Hello Stack Overflow" 
test_string = "Over" 

alors essayez d'éviter contient parce que contient la méthode sera

« Retourne une valeur indiquant si l'objet System.String spécifié se produit au sein de la cette chaîne »

Note: la StringComparer.OrdinalIgnoreCase est ajouté pour insensible à la casse.

/// <summary> 
     /// Compares using binary search 
     /// </summary> 
     /// <param name="input"> search input</param> 
     /// <param name="reference"> reference string</param> 
     /// <returns> returns true or false</returns> 
     public bool FatMan(string input, string reference) 
     { 
      string[] temp = reference.Split(); 
      Array.Sort(temp); 
      List<string> refe = new List<string> { }; 
      refe.AddRange(temp); 

      string[] subip = input.Split(); 
      foreach (string str in subip) 
      { 
       if (refe.BinarySearch(str, StringComparer.OrdinalIgnoreCase) < 0) 
       { 
        return false; 
       } 
      } 

      return true; 
     } 

     /// <summary> 
     /// compares using contains method 
     /// </summary> 
     /// <param name="input"> search input</param> 
     /// <param name="reference"> reference string</param> 
     /// <returns> returns true or false</returns> 
     public bool Hiroshima(string input, string reference) 
     { 
      string[] temp = reference.Split(); 
      Array.Sort(temp); 
      List<string> refe = new List<string> { }; 
      refe.AddRange(temp); 
      string[] subip = input.Split(); 

      foreach (string str in subip) 
      { 
       if (!refe.Contains(str, StringComparer.OrdinalIgnoreCase)) 
       { 
        return false; 
       } 
      } 

      return true; 
     } 


     public bool Nakashaki(string input, string reference) 
     { 
      string[] temp = reference.Split(); 
      Array.Sort(temp); 
      List<string> refe = new List<string> { }; 
      refe.AddRange(temp); 
      string[] subip = input.Split(); 

      int result = (from st in subip where temp.Contains(st, StringComparer.OrdinalIgnoreCase) select st).Count(); 

      if (result <= 0) 
      { 
       return false; 
      } 

      return true; 
     } 

     /// <summary> 
     /// compares using contains method 
     /// </summary> 
     /// <param name="input"> search input</param> 
     /// <param name="reference"> reference string</param> 
     /// <returns> returns true or false</returns> 
     public bool LittleBoy(string input, string reference) 
     { 
      string[] subip = input.Split(); 
      foreach (string str in subip) 
      { 
       if (!reference.Contains(str)) 
       { 
        return false; 
       } 
      } 

      return true; 
     } 

Answer 8

bool oupt ; 
string[] strarray1 = new string[3]{"abc","def","ghi" }; 
string[] strarray2 = new string[4] { "648", "888", "999", "654" }; 
if (strarray1.All(strarray.Contains)) 
    oupt = true; 
else 
    oupt = false;