2

タイトル通りです。1 つの文字列配列と 2 番目の文字列配列を取得しました。この種のパターンで結果を表示したい: 最初の配列の最初の要素 - 次に、最初の配列の最初の要素にある 2 番目の配列のすべての要素。最初の配列の 2 番目の要素と、最初の配列の 2 番目の要素で発生する 2 番目の配列のすべての要素の後。等々。例えば：

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]);
          }

    }

}

したがって、結果は次のようになります。

  • Lorem ipsum dolor sit amet, justo :--contains--> justo,lorem
  • よく冷えたビールのようにノトジン :--含む-->ビール.

しかし、私の結果は次のとおり です。

ご覧のとおり、ローレムはリストされていません

4

8 に答える 8

2

問題をいくつか分解すれば、これはまったく難しいことではありません。まず第一に、配列とそれらへのインデックスの取り扱いから離れてください。使うだけIEnumerable<T>で、生活が楽になります。

これが私がそれを見る方法です：

needlesまず、文字列の一部である配列からすべての文字列を検索しますhaystack。

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

needlesこれにより、の一部であるすべての文字列のIEnumerableが返されhaystackます。

次に、すべての検索文字列を単純に反復処理する必要があります。これをと呼びます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();
    }

大文字と小文字String.Contains()が区別されることに注意してください。したがって、「Lorem」は「lorem」と一致しません。この動作が必要な場合は、最初に小文字に変換する必要があります。

public static IEnumerable<string> MatchingStringsCaseInsensitive(string haystack, IEnumerable<string> needles)
{
    var h = haystack.ToLower();
    return needles.Where(needle => h.Contains(needle.ToLower()));
}
于 2012-07-22T00:36:14.010 に答える
1 
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)));
}

大文字と小文字を区別しない場合：

foreach (var s in arrayA)
{
    Console.Write(s + " contains: " +
                  string.Join(",", arrayB.Where(x =>
                      s.IndexOf(x, StringComparison.OrdinalIgnoreCase) != -1)));
}
于 2012-07-22T00:30:20.417 に答える
1 
foreach(var a in arrayA)
{
    Console.WriteLine("a: " + a);
    Console.WriteLine("bs: " + 
        String.Join(", ", arrayB.Where(b => a.IndexOf(b) > -1)));
}

また、あなたがケースを気にしないつもりなら、a.IndexOf(b)でしょうa.IndexOf(b, StringComparison.OrdinalIgnoreCase)。

于 2012-07-22T00:33:11.320 に答える
1

これは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));
}

これがデモです：http：//ideone.com/wxl6I

于 2012-07-22T00:37:40.477 に答える
1

これが私の試みです

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);
}

注：Containsこれは大文字と小文字を区別する比較であり、カスタム比較機能を作成する必要があります（他の回答ではすでに行われているように）

于 2012-07-22T00:38:46.277 に答える
0

Loremは大文字です。大文字と小文字を区別しない検索を使用してみてください。 .indexOf(string, StringComparison.CurrentCultureIgnoreCase)

于 2012-07-22T00:39:29.210 に答える
0

可能な限りの回答をさせていただきましたが、下記のような場合にcontainsメソッドもtrueを返してしまうという問題が発生します。

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

を避けるようにしてください。containsメソッドは

「指定された System.String オブジェクトがこの文字列内にあるかどうかを示す値を返します」

注: 大文字と小文字を区別しないために StringComparer.OrdinalIgnoreCase が追加されています。

/// <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;
        }
于 2013-12-12T14:12:22.413 に答える