c# - 检查字符串是否包含一个单词，然后检查它是否以该单词开头，如果不包含？

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)

我需要检查最后一个 else if 语句中所有出现的 foo 都是小写的最后一件事？

Answer 1

不想看我的书？答案如下:
作为奖励，这是性能最快的解决方案。

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

继续阅读编码逻辑类(class)(幽默这个老人)
这个问题可能很老了，但是 为了那些后来发现这个问题的人对如何从逻辑上提取单词问题感到好奇 ，这是我对这个极其简单的家庭作业的过度分析:
我运行了一组测试来查看哪些选项是最快的——这通常有助于我发现逻辑中的缺陷。我还将解释我的思考过程，因为，恕我直言，了解如何将问题提炼为其核心逻辑对于现实世界的使用来说是一件好事。
毕竟，这就是业务需求文档......需要提炼成功能规范(例如架构设计)的文字问题。
第1步
消除无关信息
根据给定的要求，小写 foo 可能重要也可能无关紧要:没有明确声明不包含 foo 且不包含 Foo 的字符串应该返回 false；也没有明确的声明说不包含 Foo 且不包含 foo 的字符串应该返回 true。
在一个完美的世界中，您会回去澄清要求，但在某些情况下，没有时间。假设有一个最后期限，我会继续假设我们只关心 Foo 只在句子的第一个位置时是大写的，其他时候都是小写的，所以我们将完全忽略 foo，如果“客户”提示，指出缺少的清晰度并解释您为什么做出判断(以保持项目按时并按预算进行，如果适用)。
第2步
将逻辑分解为 OR/AND 部分:
将 Foo 分解成组件让我们可以查看单个部分，这比查看整体更容易。因此，如果我们将字符串拆分为“Foo 之前的东西”(即使那是“什么都没有”)和“Foo 之后的东西”，或者如果 Foo 不在那里拆分字符串，我们只需要查看一个片段。 (我们的大脑一直都在这样做——这叫做模式识别)。
如果 无法拆分字符串，因为找不到 Foo
或者
在 Foo 上拆分给我们的结果不超过两部分:之前什么都没有，之后的所有内容
AND(前面的检查暗示只找到一个空的“before”，并且在“after”中只找到一个“section”)
在字符串 中的其他任何地方都找不到 Foo
听起来不错？嗯，它是 100% 准确的，但是我们可以减少一些细节并进一步提炼它 - 请记住，计算机不像人类那样思考，因此我们的心理处理对它们来说效率低下。
因为根本没有找到 Foo 被认为是有效的，并且开头的 Foo 是有效的，但字符串中其他任何地方的 Foo 都是无效的，我们可以说:
如果 找不到 Foo
或者
在字符串中第一个位置之后的任何位置都找不到 Foo
看起来很紧对吧？现在不要停下来。我们可以做得更好。
如果一开始就找到了 Foo ，那我们就没事了，对吧？因此，可以从更纯逻辑( bool 值、真/假、黑白)的角度来看“未找到 Foo”或“在开头找到 Foo 并且在其他任何地方都找不到 Foo”:

LET FNA = "在任何地方都找不到 Foo"

LET FN1 = "在位置 1 中找不到 Foo"

LET FN2 = "在位置 1 之后找不到 Foo"

LET FF1 = "Foo 位于位置 1"

LET FF2 = "在位置 1 之后找到 Foo"

因此，现在仅将那些保证无效的情况定义为无效，并将其余情况标记为有效。我们将使用 bool 数学来确定所有用例。

让 FNA = 有效

让 FN1 = 有效

让 FN2 = 有效

让 FF1 = 有效

让 FF2 = 无效

现在我们只标记了绝对强制返回 false 的情况，我们可以进行数学计算以查看我们获得无效/错误值的唯一情况。
FNA = FN1 和 FN2(所以如果 FNA & X = 真，则 F1 & X 必须为真，F2 & X 也必须为真)；
FNA 和/或 FF1 = 真，所以我们知道这 4 个变量的所有组合和/或所有组合 = 真；这样只剩下一个变量可以组合，我们可以很快看到 FF2 和任何东西总是假的。
所以转换回人类逻辑......看看这个任务有多简单？
只有在 时才为假 Foo 位于位置 1 之后
或者，翻转 bool 值(因为要求说在有效情况下返回 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%!)。
所以希望某个地方的某个学生已经读过这篇文章，并且灯泡继续亮着。你总是可以想出一些方法来制作“有效”的东西，但是理解 bool 逻辑以及如何将一个概念提炼到它的核心可以对你的工作质量产生重大影响。