檢查一個字符串是否包含一個Word，然后檢查它是否從所述Word開始，如果它不是？

Question

在這里有另一個艱難的人，基本上我想檢查一個字符串是否包含單詞“Foo”，如果它確實包含它，它是否從它開始？ 如果它確實以Foo開頭，它應該是唯一以首都開頭的Foo，其他所有都應該是小寫字母。

如果滿足上述條件，則應返回true。

如果字符串包含Foo但不以Foo開頭，則它應該立即返回false，因為您不能在字符串的中間有一個大寫Foo。

如果所述字符串包含foo，但不以Foo開頭，則foo的所有實例都應為小寫。 如果滿足此條件，則返回true。

我應該提到我正在尋找C＃代碼，我嘗試過但還沒有成功，但由於我只編程了2周，我認為這對你們這些季節專業人士來說不會有麻煩。

---

這是我按照要求嘗試的，我認為它的標准是關閉，但至少我嘗試過。

            if (Title.Contains("Foo") == true && Regex.IsMatch(Title, "^Foo") == true)
        {
            CheckAnd = true;
        }
        else if (Title.Contains("Foo") == true && Regex.IsMatch(Title, "^Foo") == false)
        {
            CheckAnd = false;
        }
        else if (Regex.IsMatch(Title, "^foo"))
        {
            CheckAnd = false;
        }
        else
        {
            CheckAnd = true;
        }

---

好的，幾乎在那里，這是我從你的所有答案得到的：

if (Title.IndexOf("Foo") == 0 && Title.LastIndexOf("Foo") == 0)
        {
            CheckAnd = true;
        }
        else if (Title.LastIndexOf("Foo") > 0)
        {
            CheckAnd = false;
        }
        else if(Title.Contains("foo") && Title.StartsWith("Foo") == false && PUT CHECK HERE)

我需要檢查的是，在最后一個if語句中，所有出現的foo都是小寫的嗎？

Answer 1

不想看我的書嗎？ 這是答案：

作為獎勵，這是性能最快的解決方案。

public void CheckValidFoo(String Title) {     
    return (Title.LastIndexOf("Foo") <= 0);
}

繼續閱讀編碼邏輯課程（幽默這位老人）

這個問題可能已經過時了，但是為了那些后來發現這個問題的人，他們對如何在邏輯上提煉出單詞問題感到好奇 （所以請不要對最終決定發布的潛伏者進行投票），這是我極為誇張的分析。簡單的家庭作業：

我運行了一系列測試來查看最快的選項 - 這通常可以幫助我看到邏輯上的缺陷。 我也將解釋我的思維過程，因為，恕我直言，了解如何將問題提煉到它的核心邏輯是一個好事，知道現實世界的使用。

畢竟，這就是業務需求文檔......需要將其提煉到功能規范中的單詞問題（例如，架構設計）。

第1步

消除無關信息
根據給定的要求，小寫foo可能或可能不重要：沒有明確聲明不包含foo且不包含Foo的字符串應該返回false; 也沒有明確的聲明說不包含Foo且不包含foo的字符串應該返回true。

在一個完美的世界中，你會回去澄清要求，但在某些情況下，沒有時間。 假設有一個截止日期，我會向前推進，假設我們所關心的只是在句子的第一個位置時Foo為大寫，在其他所有時間都是小寫，所以我們將完全忽略foo，如果“客戶“抱怨，指出缺失的清晰度，並解釋為什么你做出判斷電話（以保持項目准時，並按預算，如果適用）。

第2步

將邏輯分解為OR / AND部分：
將Foo分解為組件可以讓我們看看各個部分，這比查看整體更容易。 所以，如果我們將字符串分解為“Foo之前​​的東西”（即使那是“沒有”）和“Foo之后的東西”或者如果Foo不在那里打破字符串，我們只有一個要看的東西。 （我們的大腦一直這樣做 - 它被稱為模式識別）。

IF 無法拆分字符串，因為找不到Foo
要么
分裂在Foo上給我們不超過兩件：之前沒有任何東西，以及之后的一切
AND （由前一個檢查暗示只找到一個空的“之前”，而“after”中只有一個“section”） 字符串中的其他任何地方都找不到Foo

聽起來不錯？ 嗯，它是100％准確，但我們可以削減一些殘余並進一步提煉它 - 記住計算機不像人類那樣思考，所以我們的心理處理對他們來說是低效的。

因為根本沒有找到Foo被認為是有效的，並且開頭的Foo是有效的，但是字符串中的Foo后面的其他任何地方都是無效的，我們可以說：

如果沒有找到Foo
要么
在第一個位置之后的字符串中找不到Foo

看起來很緊，對嗎？ 別現在停下來。 我們可以做得更好。

如果在開頭找到Foo，我們就可以了，對吧？ 因此，“Foo未找到”或“Foo在開頭被發現並且在其他地方找不到Foo”可以從更純粹的邏輯（布爾，真/假，黑白）角度來看待：

• LET FNA =“Foo在任何地方都找不到”
• LET FN1 =“在位置1找不到Foo”
• LET FN2 =“在位置1后找不到Foo”
• LET FF1 =“Foo位於第1位”
• LET FF2 =“在位置1后找到Foo”

所以現在只將那些保證無效的情況定義為無效，並將其余部分標記為有效。 我們將使用布爾數學來確定所有用例。

• 讓FNA =有效
• LET FN1 =有效
• LET FN2 =有效
• 讓FF1 =有效
• LET FF2 =無效

現在我們只標記了絕對強制返回false的情況，我們可以進行數學計算，看看我們得到無效/假值的唯一情況。

FNA = FN1和FN2（所以如果FNA和X =真，則F1和X必須為真，F2和X也必須為真）;

FNA和/或FF1 =真，所以我們知道這4個變量的所有組合和/或這些變量=真; 這只留下一個變量來組合，我們可以很快看到FF2和任何東西總是假的。

所以轉換回人類邏輯......看看這個任務有多簡單？

如果 在位置1之后找到Foo，則 僅為假

或者，翻轉布爾值（因為要求說有效情況下返回true）：

如果在位置1之后找不到Foo，則字符串有效。

或者，更像是計算機的想法：

如果從字符串末尾掃描到第2個字符到最后一個字符沒有找到Foo，則字符串有效

在那里，現在我們無法進一步提煉它。 因此，讓我們編寫這些不同的邏輯位，看看它們在實際代碼中的表現如何：

using System;

public static class Test
{
public static bool CheckFooTestA(String SearchMe, String[] FindMe)
{
    //split the string like the human eye does and check the count of Foos 
    //and the position of the Foo or Foos to determine our logic:
    string[] v = SearchMe.Split(FindMe, StringSplitOptions.None);

         //Foo not found, OR foo found once and was at the beginning of the string
    return (v.Length == 0 || v.Length == 1 && v[0] == String.Empty);
}
public static bool CheckFooTestB(String SearchMe, String[] FindMe)
{
    //scan the way computers or non-speed readers do, and look for the first instance of Foo
    int i = SearchMe.IndexOf(FindMe[0]);

    //Foo not found OR 
    //    foo found at the start of the string 
    //    AND the last Foo found is also at the start of the string
    return (i == -1 || i == 0 && SearchMe.LastIndexOf(FindMe[0]) == 0 );
}
public static bool CheckFooTestC(String SearchMe, String[] FindMe)
{
    //Use the logic we distilled from the word problem to make this single check:
    return (SearchMe.LastIndexOf(FindMe[0]) <= 0);
}
public static void Main()
{
    String[] x = new String[]{
        "Foo foo Foo bar",
        "Foo foo foo bar",
        "foo foo Foo bar",
        "foo foo foo bar",
        "asfda asdfa asf" };

    var s = new []{"Foo"};
    var i = 0;
    bool f=false;
    long End = DateTime.Now.Ticks;
    long Start = DateTime.Now.Ticks;
    for (; i < 1000; i++) {
        f = CheckFooTestA(x[i%5],s);
    }
    End = DateTime.Now.Ticks;
    Console.WriteLine((End - Start).ToString() + " ticks (Test A)");

    i = 0;
    f = false;
    End = DateTime.Now.Ticks;
    Start = DateTime.Now.Ticks;
    for (; i < 1000; i++) {
        f = CheckFooTestB(x[i%5],s);
    }
    End = DateTime.Now.Ticks;
    Console.WriteLine((End - Start).ToString() + " ticks (Test B)");

    i = 0;
    f = false;
    End = DateTime.Now.Ticks;
    Start = DateTime.Now.Ticks;
    for (; i < 1000; i++) {
        f = CheckFooTestC(x[i%5],s);
    }
    End = DateTime.Now.Ticks;
    Console.WriteLine((End - Start).ToString() + " ticks (Test C)");
}
}
Test.Main();

輸出：

260510 ticks (Test A)
117150 ticks (Test B)
76160 ticks (Test C)

結果和結論

測試A（視覺上分裂/計算發現的單詞的人類邏輯），與測試B（使用蒸餾邏輯的索引掃描）相比，測試A運行時間超過220％！

測試C是表現最好的 - 只需掃描一次所需的字符串。 進入所需的處理時間不到30％（測試A占用測試C完成相同工作所需時間的340％！）。

所以希望某個地方的某個學生已經讀過這個並且燈泡還在繼續。 您總是可以想出制作“有效”的方法，但了解布爾邏輯以及如何將概念提煉到其核心可以對您的工作質量產生重大影響。

大家快樂！

Answer 2

如果我正確地取消它應該這樣做！

    if (testString.IndexOf("Foo") == 0 && testString.LastIndexOf("Foo") == 0)
        // "Foo foo foo"
        return true;
    else if (testString.IndexOf("Foo") == 0 && testString.LastIndexOf("Foo") > 0)
        // "Foo foo Foo"
        return false;
    else if (testString.Contains("foo")  && testString.IndexOf("Foo") > 0)
        // "foo Foo foo" or "foo foo Foo"
        return false; 
    else if (testString.Contains("foo") && !testString.Contains("Foo"))
        // "foo foo foo"
        return true;  

Answer 3

這將返回true （因為它包含單詞Foo），然后返回false （因為Foo不在句子的開頭）。

        string word = "I am a string i contain Foo, aint that nice?";
        bool conts = word.Contains("Foo");
        int pos = word.IndexOf("Foo");                 
        if (conts)
        {
            if (pos != 0)
            {
                // do something
            }

        }

Answer 4

請參考String.IndexOf方法：

http://msdn.microsoft.com/en-us/library/k8b1470s.aspx

搜索區分大小寫，因此只需查找大寫單詞（例如：“Foo”）。 如果IndexOf返回0，則該單詞位於第一個位置。

編輯：我就是這樣做的（看到你的代碼后）

//changed to check for lowercase foo
if ((Title.StartsWith("Foo") && Title.LastIndexOf("Foo") == 0) 
|| (Title.Contains("foo") && !Title.StartsWith("foo")))
{
    CheckAnd = true;
}
else
    CheckAnd = false;

Answer 5

如果我正確理解了這個問題，這個方法應該可行。

    public bool ContainsFoo(string s)
    {
        bool result = true;

        if (s.IndexOf("Foo") > 0)
        {
            result = false;
        }
        else if (s.LastIndexOf("Foo") > 0)
        {
            result = false;
        }
        return result;
    }

如果我誤解了某些事情，請告訴我。