אגב בלי רגקס אפשר לעשות ככה

private bool containsAll(string[] words, string text)
{
    bool searchMatch = words.All(word => text.Contains(word));
    return searchMatch;
}

איבחנתי את המהירות על שעון פשוט ספרתי כמה זמן לקח לכל אחד לגמור.

אז בדקת ישר במצטבר, ולא על פעולה בודדת.
לא היית מציע לך רג'קס אם הייתי יודע שזה על פני מסמכים רבים (כמה, זה הגיוני להכין מאות תוצאות מראש כשהמשתמש לא יראה אותם בכלל?). אני לא יכול לעזור כי צריך לאפיין את כל הפעולה, יש המון שיפורים פוטציאליים.
הקוד של GPT גם לא טוב, הוא גם מבזבז המון זיכרון, וגם לו יש עלות לא קטנה אם מדובר בהמון מסמכים.

30 או 21 זה לא באמת משנה. רק זה קצת מקל על הקוד של הgpt לעשות גזירים קצת יותר ארוכים כי אז יש לו פחות פעולות לעשות.

אתה משווה שני שיטות, ואני מעיר לך על קולא שאתה עושה עם אחד ואתה אומר מה זה משנה, זה רק מקל קצת...

איבחנתי את המהירות על שעון פשוט ספרתי כמה זמן לקח לכל אחד לגמור.

אכן הקוד של הgpt הוא שיטה אחרת לגמרי לגבי אופן יצירת המקטעים אתה צודק שכחתי לטפל בזה. רק צריך לעשות שיהיה קצת חפיפה בין המקטעים.

30 או 21 זה לא באמת משנה. רק זה קצת מקל על הקוד של הgpt לעשות גזירים קצת יותר ארוכים כי אז יש לו פחות פעולות לעשות.

האם זה אומר שעדיף לעשות שורה של פקודות replace במקום regex replace אחד שכולל הרבה אפשרויות?

ממש לא. ראשית כל Replcae עושה עבודה שלמה מחדש, שנית הפונקציה Replace היא לא קוד מותאם אלא קוד גנרי שמישהו כתב עבורך בדיוק כמו רג'קס. קוד מותאם זה אומר קוד שכתוב ייעודית ובנוי ביעילות בדיוק עבור התוצאה המבוקשת (וכל שינוי בתוצאה מחייב הרבה שינוי בקוד).

הצטברות של פעולות כלומר הרצה של הקוד על כמה מסמכים אחד אחרי השני - ככל שכמות המסמכים גדלה כן גדל הפער בביצועים.
יצויין שהמסמכים המדוברים הם מסמכים קצרים מאוד של טקסט. (בערך באורך של פרק א במשניות ברכות)

כמות המופעים היה במאות או אם חיפשתי מילה כמו "כי" אז באלפים.

נראה לי שהעבודה שעשיתי על התוצאות איננה רלוונטית מכיוון שהיא בעצם זהה בשני השיטות רק צורת השליפה היא שונה.

בכל אופן מצו"ב הקודים של שני הבדיקות

1. קוד הרגקס

string pattern = "(\\b\\w+\\W+){0,10}" + Regex.Escape(searchTerm) + "(\\W+\\w+\\b){0,10}";
MatchCollection matches = Regex.Matches(textToSearch, pattern);

if (matches.Count > 0)
{
    foreach (Match match in matches)
    {
        string result = match.Value;
        result = Regex.Replace(result, @"<.*?>|[^א-ת\.""':, \(\)[]\{\}]", " ");
        result = result.Replace(searchTerm, "<span style=\"color: red;\">" + searchTerm + "</span>");
        fileIndexes[filePath].Add($"<li><a href='#{HttpUtility.HtmlEncode(fileName)}%{HttpUtility.HtmlEncode(chapterName)}' onclick='showMessage(this)'>{fileName} {chapterName}</a><br>{result}</li>");
        resultPagesSum++;
    }
}

2. הקוד של gpt

List<string> snippets = SplitStringIntoSnippets(textToSearch, 30);

foreach (string snippet in snippets)
{
    if (snippet.Contains(searchTerm))
    {
        string result = Regex.Replace(snippet, @"<.*?>|[^א-ת\.""':, \(\)[]\{\}]", " ");
        result = result.Replace(searchTerm, "<span style=\"color: red;\">" + searchTerm + "</span>");
        fileIndexes[filePath].Add($"<li><a href='#{HttpUtility.HtmlEncode(fileName)}%{HttpUtility.HtmlEncode(chapterName)}' onclick='showMessage(this)'>{fileName} {chapterName}</a><br>{result}</li>");
        resultPagesSum++;
    }
}

static List<string> SplitStringIntoSnippets(string input, int maxSnippetLength)
{
    List<string> snippets = new List<string>();

    string[] words = input.Split(new char[] { ' ', '\t', '\n' }, StringSplitOptions.RemoveEmptyEntries);
    int wordCount = 0;
    int currentIndex = 0;

    for (int i = 0; i < words.Length; i++)
    {
        wordCount++;
        if (wordCount >= maxSnippetLength)
        {
            snippets.Add(string.Join(" ", words, currentIndex, maxSnippetLength));
            currentIndex = i + 1;
            wordCount = 0;
        }
    }

    if (currentIndex < words.Length)
    {
        snippets.Add(string.Join(" ", words, currentIndex, words.Length - currentIndex));
    }

    return snippets;
}

ועוד שאלה:
@dovid כתב בשאלה בC#: מה הדרך הכי טובה להוציא גזירים מתוך קטע טקסט?:

קוד טוב יהיה טוב יותר מרגקס (נכון להיום בדוטנט)

אם אני צריך לעבד טקסט על ידי שורה של החלפות.
האם זה אומר שעדיף לעשות שורה של פקודות replace במקום regex replace אחד שכולל הרבה אפשרויות?

בבדיקה שלי הקוד רגקס לקח כמעט פי שניים מהזמן של הקוד של gpt,

אני מאוד מתפלא, איך בדקת? מאוד מאוד מעניין אותי אם זה יותר לאט, אשמח לקבל מושג על גודל המסמך, וכמות המופעים, ואופן הבדיקה.
יכול להיות גם שהעבודה שעשית על התוצאות לקחה זמן, לכן נסה לבודד את הבדיקה רק על השליפה.

כלומר בהצטברות של הרבה פעולות ההפרש לא זניח בכלל.

מה שייך הצטברות של פעולות, וכי אתה מחלץ תוצאות חיפוש בבת אחת למאה משתמשים או למאה מונחים? בדרך כלל הצגת תוצאות חיפוש זו פעולה חד פעמית בזמן נתון, ובדיוק לכן רגקס היה ההמלצה החזקה שלי.

ההפרש זניח פר פעולה

בבדיקה שלי הקוד רגקס לקח כמעט פי שניים מהזמן של הקוד של gpt, כלומר בהצטברות של הרבה פעולות ההפרש לא זניח בכלל.

@dovid כתב בשאלה בC#: מה הדרך הכי טובה להוציא גזירים מתוך קטע טקסט?:

אם אתה נתקל באיטיות אפילו קטנה מאוד, רק אז יש מה לפתוח לדיון קוד מותאם אישית.

זה תלוי בך אם זה מעניין אותך אם לא אז לא אטריח אותך יתר על המידה. (לי אין מושג מאיפה להתחיל ואם מדובר בדברים מורכבים מאוד אז לא אוכל להשתתף די הצורך בפיתוח הרעיון).

השאלה היא האם יש דרך שלישית לקבל ביצועים יותר טובים.

קוד טוב יהיה טוב יותר מרגקס (נכון להיום בדוטנט), אבל: א. ההפרש זניח פר פעולה ב. כל כזאת החלטה של "מותאם אישית" יש לה מחירים של עוד קוד, תחזוקה, ובאגים. אם אתה נתקל באיטיות אפילו קטנה מאוד, רק אז יש מה לפתוח לדיון קוד מותאם אישית.

[\w"?]+

אתה רוצה לכלול סימני שאלה בתוך הרג'קס שלך? כי שמת את הסימן שאלה בתוך הסוגריים המרובעים.

הקוד של הGPT לא ראוי בעיני ליחס.

לבינתיים הקוד של gpt מבצע יותר מהיר מהקוד רגקס גם אחרי התיקון. (אולי הסיבה כך כי אני מתעסק עם מסמכי טקסט קצרים יחסית).
השאלה היא האם יש דרך שלישית לקבל ביצועים יותר טובים.

סליחה אבל עד עכשיו לא הבנתי בדיוק מה הבעיה, הצלחתי קצת להבין מההודעות של @dovid בהנחה והוא הבין אותך נכון.

החכמתני הרעיון שלך נכון גם לגבי וורד

השליפה נועדה ליצור גזירים לצורך הצגת תוצאות חיפוש במסמכי טקסט בודדים.
הוי אומר בטקסט ארוך שמופיעה מילת חיפוש כמה פעמים אני רוצה לשלוף גזירים רלוונטיים מתוך הטקסט בהם מופיעה המילה. ייתכן מאוד שיהיו גם עשרות גזירים תלוי באורך הטקסט ובכמות המופעים של מילת החיפוש.

השיטה השניה שהבאתי מgpt הוא רעיון אחר במקום לשלוף גזירים פשוט לחלק את הטקסט לגזירים ולמיין אח"כ את הגזירים הרלוונטיים.

string pattern = $@"(\b\w+\W+){0,10}{Regex.Escape(searchTerm)}(\W+\w+\b){0,10}";

הביטוי שהיה כלל כל תו (.), אין סוף פעמים (*), שאחריהם רווח, כפול עשר. זה ביטוי שגם לא בהכרח יביא תוצאה רצויה כי נקודה זה כולל רווח, ולכן זה ייקח את כל הטקסט שלפני הביטוי יהיה אורכו שיהיה, ומאידך הוא בעייתי כי יש המון דרכים לפרש אותו - בכל רווח צריך לחשב את נכונותו של כלל הביטוי.

הביטוי שהצעתי הוא כזה:

\b - גבול מילה, זה כולל רווח אבל לא רק, למשל תחילת הטקסט זה גבול מילה ללא רווח.
\w+ - רצף של כל תו שהינו חלק ממילה, למשל כל האלף בית.
\W* - תו או יותר בסיום המילה שאיננו חלק ממילה, כמו רווח נקודה וכולי.

private void getSnippets()
{

 List<string> snippets = SplitStringIntoSnippets(longText, 30);

 foreach (string snippet in snippets)
 {
 //do something
 }
}


 static List<string> SplitStringIntoSnippets(string input, int maxSnippetLength)
 {
     List<string> snippets = new List<string>();

     string[] words = input.Split(new char[] { ' ', '\t', '\n' }, StringSplitOptions.RemoveEmptyEntries);
     int wordCount = 0;
     int currentIndex = 0;

     for (int i = 0; i < words.Length; i++)
     {
         wordCount++;
         if (wordCount >= maxSnippetLength)
         {
             snippets.Add(string.Join(" ", words, currentIndex, maxSnippetLength));
             currentIndex = i + 1;
             wordCount = 0;
         }
     }

     if (currentIndex < words.Length)
     {
         snippets.Add(string.Join(" ", words, currentIndex, words.Length - currentIndex));
     }

     return snippets;
 }