using System;

public class Program

{

    public static void Main()

    {

        string clearedText = "deneme yazisi go mongo";

        string searchTextAnd = "go&&mongo";

        string searchTextOr = "yazisi||sdfsdfsdf";

        string searchTextOther = "ali&&ata&&bak";

        if(ContainsAny(clearedText,searchTextAnd,100))//100 similarity

            Console.WriteLine("text search is found(AND)");

        else

            Console.WriteLine("text search is not found(AND)");

        if(ContainsAny(clearedText,searchTextOr,100))//100 similarity

            Console.WriteLine("text search is found(OR)");

        else

            Console.WriteLine("text search is not found(OR)");

        if(ContainsAny(clearedText,searchTextOther,100))//100 similarity

            Console.WriteLine("searchTextOther is found");

        else

            Console.WriteLine("searchTextOther is not found");

    }

    public static readonly double mWeightThreshold = 0.7;

    public static readonly int mNumChars = 4;

            /// <summary>

        /// &&  || ',' ile gruplanmış text araması yapar

        /// </summary>

        /// <param name="text"></param>

        /// <param name="formatedSearchText">&&  || ',' ile gruplanmış textler olabilir</param>

        /// <param name="similarity"></param>

        /// <returns></returns>

        public static bool ContainsAny(string text, string formatedSearchText, int similarity)

        {

            if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(formatedSearchText))

            {

                return false;

            }

​

            string[] formatedTextArr = formatedSearchText.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);

​

            foreach (string formatedTex in formatedTextArr)

            {

                bool? result = null;

​

                string[] searchMainArr = formatedTex.Split(new string[] { "&&" }, StringSplitOptions.RemoveEmptyEntries);

​

                foreach (string searchTextPart in searchMainArr)

                {

                    string[] searchArr = searchTextPart.Split(new string[] { "||" }, StringSplitOptions.RemoveEmptyEntries);

​

                    bool innerResult = false;

​

                    foreach (string searchItem in searchArr)

                    {

                        if (Contains(text,searchItem, similarity))

                        {

                            innerResult = true;

                            break;

                        }

                    }

​

                    if (result.HasValue == false)

                    {

                        result = innerResult;

                    }

                    else

                    {

                        result = result.Value && innerResult;

                    }

​

                    if (result.Value == false)

                    {

                        break;

                    }

                }

​

                if (result.Value == true)

                {

                    return true;

                }

            }

​

            return false;

        }

    public static bool Contains(string source, string search, int similarity)

        {

            if (string.IsNullOrEmpty(source) || string.IsNullOrEmpty(search))

            {

                return false;

            }

​

            bool result = false;

​

            if (source.IndexOf(search, StringComparison.InvariantCultureIgnoreCase) != -1)

            {

                result = true;

            }

            else

            {

                if (source.Length == search.Length)

                {

                    result = Similarity(source, search) >= similarity;

                }

                else

                {

                    for (int m = 0; result == false && m <= source.Length - search.Length; m++)

                    {

                        string subword = source.Substring(m, search.Length);

​

                        if (Similarity(subword, search) >= similarity)

                        {

                            result = true;

                        }

                    }

                }

            }

​

            return result;

        }

            public static double Similarity(string aString1, string aString2)

        {

            return (Proximity(aString1, aString2) * 100.0);

        }

    public static double Proximity(string aString1, string aString2)

        {

            int lLen1 = aString1.Length;

            int lLen2 = aString2.Length;

            if (lLen1 == 0)

                return lLen2 == 0 ? 1.0 : 0.0;

​

            int lSearchRange = Math.Max(0, Math.Max(lLen1, lLen2) / 2 - 1);

​

            // default initialized to false

            bool[] lMatched1 = new bool[lLen1];

            bool[] lMatched2 = new bool[lLen2];

​

            int lNumCommon = 0;

            for (int i = 0; i < lLen1; ++i)

            {

                int lStart = Math.Max(0, i - lSearchRange);

                int lEnd = Math.Min(i + lSearchRange + 1, lLen2);

                for (int j = lStart; j < lEnd; ++j)

                {

                    if (lMatched2[j]) continue;

                    if (aString1[i] != aString2[j])

                        continue;

                    lMatched1[i] = true;

                    lMatched2[j] = true;

                    ++lNumCommon;

                    break;

                }

            }

            if (lNumCommon == 0) return 0.0;

​

            int lNumHalfTransposed = 0;

            int k = 0;

            for (int i = 0; i < lLen1; ++i)

            {

                if (!lMatched1[i]) continue;

                while (!lMatched2[k]) ++k;

                if (aString1[i] != aString2[k])

                    ++lNumHalfTransposed;

                ++k;

            }

            // System.Diagnostics.Debug.WriteLine("numHalfTransposed=" + numHalfTransposed);

            int lNumTransposed = lNumHalfTransposed / 2;

​

            // System.Diagnostics.Debug.WriteLine("numCommon=" + numCommon + " numTransposed=" + numTransposed);

            double lNumCommonD = lNumCommon;

            double lWeight = (lNumCommonD / lLen1

                             + lNumCommonD / lLen2

                             + (lNumCommon - lNumTransposed) / lNumCommonD) / 3.0;

​

            if (lWeight <= mWeightThreshold) return lWeight;

            int lMax = Math.Min(mNumChars, Math.Min(aString1.Length, aString2.Length));

            int lPos = 0;

            while (lPos < lMax && aString1[lPos] == aString2[lPos])

                ++lPos;

            if (lPos == 0) return lWeight;

            return lWeight + 0.1 * lPos * (1.0 - lWeight);

​

        }

}