היי חברים,

בניתי פונקציה קטנה שמאנדקסת מילים, הפונקציה מאנדקסת מילים שיש בהן יותר מ 2 תוים.

עכשיו יש מילים כמו you,are וכו׳ שאני לא רוצה שהיא תאנדקס

חשבתי לעשות בדיקה לעל כל מילה, האם היא לא נמצאת במערך A

עכשיו לשאלתי

מהו המקסימום מקומות שאני יכול להכניס למערך כזה?

תודה

סביר להניח שהמגבלה תלויה בעיקר בזיכרון (אני לא רואה סיבה שתהיה מגבלה אחרת, אלא אם כן היא מלאכותית). צריך להתחשב בזה שלא מדובר פה ב C, והמידע שלך צורך (הרבה?) יותר זיכרון ממה שאתה חושב: https://nikic.github.io/2011/12/12/...y-Hint-BIG.html

זכור ש PHP מגבילה את צריכת הזכרון של סקריפט בודד בהתאם לקונפיגורציה (ניתן, כמובן, לשנות). אם תגיע לצריכת המקסימום, תקבל שגיאה (אולי רק בלוג) על memory exhaustion ....

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

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

כמובן, שעצם הרעיון לבנות אינדקס בעצמך של דברים כשיש מוצרי מדף כמו Sphinx/ElasticSearch ודומיהם, ואולי אפילו MySQL Full-Index Search, שסביר להניח שעושים את זה בצורה מאוד אופטימאלית כיוון שזה ייעודם בחיים, הוא רעיון שכדאי לשקול כמה פעמים לפני שעושים אותו, בייחוד אם אתה מדבר על scale ולא על תרגיל מחשבתי שלא אמור לרוץ ב production.

נמאס לכם לזכור סיסמאות? לחצו כאן!

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

לא משהו מסובך
אני רק צריך לדלדג על ידי בדיקה על מילים כמו you,are וכו׳

הנקודה שלי היא שזה נשמע כאילו אתה מממש פונקציית חיפוש לפי relevance שכבר קיימת במנועי אחסון/חיפוש נתונים שעושים את זה לא רע בכלל... למשל: http://dev.mysql.com/doc/refman/5.1...l-language.html

נמאס לכם לזכור סיסמאות? לחצו כאן!

היי שימי,
אני לא מממש פונקציית חיפוש,
אני בונה אפליקציה שלומדת על המשתמש את התכנים שהוא אוהב לקרוא

אחת הטבלאות שיש לי זאת טבלה שמאדקסת את המילים של כל כתבה

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

נמאס לכם לזכור סיסמאות? לחצו כאן!

היי שימי
זה בדיוק מה שרשמתי למעלה,
לכל מילה אני מכניס ל DB יש שדה של כמות המופעים שלה בתוכן

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

ומתי שאני בונה את השאילתת אינדוקס המילים של הכתבה, אני רוצה לעשות על כל מילה בדיקה האם היא קיימת במערך של מילות הקישור ולא לאנדקס אותה.

עכשיו השאלה היא כמה גדול המערך יכול להיות, ועם איזו כמות הפונקציה in_array יכולה להתמודד

תודה

עניתי על זה - תלוי בהקצאת הזיכרון שאתה נותן ל PHP, ובזמן שאתה מוכן לחכות לביצוע.

זה לא שיש לך הרבה ברירות - אם אתה רוצה פונקציונליות מהסוג הזה, סביר להניח שלא תוכל לכתוב מימוש יותר יעיל מהמימוש שהם כבר עשו. מה שכן, כדאי לך לעשות benchmark על משהו דומה - ליצור מערך שבו המילים הן מפתחות של המערך, במקום ערכים שלו. ייתכן מאוד שה lookup של מפתח במערך (עם array_key_exists()) מהיר יותר - בייחוד אם שם משתמשים ב hash lookup (סביר להניח...?) ובחיפוש ערך באמצעות in_array הם לא.

נמאס לכם לזכור סיסמאות? לחצו כאן!

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

היי
חשבתי לעשות את זה.

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

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

האם מערך והפונקציה in_array התמודדו עם זה

תודה

אני די בטוח שאתה עושה משהו לא נכון...
אבל נגיע לזה לאט לאט.
1. המקסימום ID שאתה יכול להשתמש בו הוא קצת פחות מ-2.5 מיליארד אם אתה משתמש ב int כמפתח הראשי שלך (בsql, אני מניח שoracle זהה)
http://stackoverflow.com/questions/...ey-in-sqlserver

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

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

קוד PHP:

 select * from tWords where tWords.word not in (select word from tExceptions) 


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

היי קובי,
כנראה שלא הבנו אחד את השני כמו שצריך.

אני אחדד קצת...
אני סורק המון מאמרים, על כל מאמר אני מאנדקס את המילים שלו.
זתומרת שאם אני סורק עכשיו 3 מאמרים חדשים
ובשלושתם מופיעה המילה apple זה יוסיף 3 שורות חדשות ל db

הבנתי, למרות שלדעתי אתה צריך לשמור אותם לפי סוג אתר ולא לפי אתר (כי בצורה כזו 2 כתבות בynet ייצור לך כפילות של המון מילים שאין סיבה, עדיף לבצע grouping של אתרים לפי סוגים, לדוגמה טכנולוגיה, בריאות וכו')
אם ככה אתה מתכנן את הקוד שלך אז עדיף לעשות את המחיקה לפני ההכנסה לבסיס הנתונים, הקוד שלך ייראה בערך כך (c#, כנראה יש דרכים יעילות יותר - אני רק מסביר רעיון):

קוד:

class wordsData{
	public int Id;
	public String Word;
	public int orginiatingSiteId;
}

List<wordsData> siteWords;
List<String> exceptionWords;

siteWord = readWebsiteStats(website);
exceptionWords = readExceptionWordsTable();

foreach(var word in exceptionWords){
	siteWord.RemoveAll(x => x.Word == word);
}
 
  

בסופו של דבר תוסיף את כל ה siteWords לטבלה הרצוייה, כאשר תעשה את זה לכול דף/קבוצת דפים שאתה קורא בנפרד, כאשר בממוצע כתבות הן באיזור ה 300-700 מילה לא אמורה להיות לך בעיית ביצועים'
שים לב שכמו שאמרו מעלי - כדי להגיע להמלצות טובות יותר - אתה רוצה לחשוב על הוספת של מנגוננים של מילים דומות (אם אתה נתקל במילים Apple או Mac, ו iPhone חבל לספור את זה כ-3 מילים נפרדות - די ברור מה הכוונה, בנוסף אתה רוצה להבין אם הכתבה בדרך בשבח או בגנות הנושא כדי לדעת מה דעתו של הקורא, בדומה ל like בפייסבוק, רק אוטומטי)

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

שאלה נוספת:
האם מילים שהן בתוך גרשיים או עם קו אמצעי ביניהן לאנדקס כצירוף או להפריד אותן?

1. למה "חייב"? אתה לא מפתח את המערכת בעצמך לשימוש שלך? הלקוח דרש שתעשה דברים בצורה כזו? הייתי חושב על זה שוב, אבל כאמור - תכנון שלך ואני מניח שבדקת סטטיסטית וראית שזו הדרך המתאימה לך.
2. פשוט תחליף site ב article או address.
3. בשלוף - הייתי הופך כל תו מיוחד (נקודות, פסיקים, מקף, סלאשים) לרווח ואז חותך רווחים כפולים לפני האינדוקס עם 2 יוצאי דופן - מרכאות וגרשים, אם הם מקיפים עד 4 מילים הייתי שומר אותם כמילה אחת, אחרת הופך אותם גם-כן לרווחים. 4 נשמע כמו מספר מתאים של מילים שעדיין לא יכללו פתגמים/ציטוטים אבל כן ייכללו מילים שאמורים לבוא ביחד.

כמו-כן, שים לב שכשאתה "קורא" מאמר, תקרא רק מה שכתוב בעמוד אליו אתה מגיע ולא מקורות חיצוניים, לא full proof אבל לפחות ממרבית הפרסומות תתעלם.

היי קובי מצורפת הפונקציה הסופית אני חושב (:

הפונקציה מחפשת דפוס חוזר של צמדים של מילים (מוגבל עד 5 מילים)
וספרת כמה פעמים הם הופיעו
בנוסף היא סופרת מילים בודדות ובודקת כמה פעמים הם הופיעו

מה אומר?

קוד PHP:

 private function save_words_in_db($post_id, $content, $lang)
    {
    if(is_null($this->exceptionWords))
        {
            $this->exceptionWords = $this->getExceptionWords($lang);
        }
        
        $content = preg_replace("/[\#\,\.;&:?\[\]]+/", " ", $content);
        $content = preg_replace("/\s+/", " ", $content);
        //$content = preg_replace("/[^\w\-\s]/", "", $content);
        $content = trim($content);
        
        echo $content;
        
        $insert = array();
        $pattern_cache = array();
        $words = explode(" ", $content);
        
        foreach ($words as $key => $word)
        {
            $max_words = 0;
            
            for ($i = 5; $i > 0; $i--)
            {
                if(isset($words[$key + $i]))
                {
                    $max_words = $i;
                    break;
                }    
            }
            
            $pattern = array();
            
            for ($i = 0; $i <= $max_words; $i++)
            {
                $string = '';
                
                $j_counter = 0;
                
                for ($j = 0; $j <= $i; $j++)
                {
                    if(mb_strlen($words[$key + $j]) > 1)
                    {
                        if($j_counter++ > 0)
                        {
                            $string .= ' ';                                            
                        }
                        
                        $string .= $words[$key + $j];                                                                    
                    }
                }
                
                $string = trim($string);
                
                $string_md5 = md5($string);
                
                if(!array_key_exists($string_md5, $pattern_cache))
                {
                    $pattern[] = $string;
                    $pattern_cache[$string_md5] = 1;
                }
                
            }
            
            if(!empty($pattern))
            {
                preg_match_all('#'.implode('|', $pattern).'#i', $content, $matchs);
                
                foreach ($matchs as $val)
                {
                    if(!empty($val))
                    {
                        $md5 = md5($val[0]);
                        if(mb_strlen($val[0]) > 2 && !array_key_exists($md5, $this->exceptionWords))
                        {
                            $insert[$md5]['blog_id'] = $post_id;
                            $insert[$md5]['word'] = $val[0];
                            $insert[$md5]['show'] = count($val);                            
                        }
                        
                    }
                }
            }
            
        }
        
        echo '<pre>';print_r($insert);'<pre>';
        
        if(!empty($insert))
        {
            //$this->db->insert_batch('words', $insert);
        }
    } 


האמת היא שזו הפעם הראשונה שאני רואה קוד PHP אז ייקח לי קצת זמן לעבור על זה... זמן שלצערי אין לי (עבודה אמיתית וזה )
אבל יש כמה דברים שמציקים לי, למעשה דבר אחד מאוד מציק לי - אתה עושה כן לולאה של n^3, כלומר - אם יש לך 10 מילים במאמר אתה עושה תיאורתית 1000 מעברים, למה? זה לא יעיל במיוחד וכשתעבור על 10,000 מאמרים בני 1000 מילים כל אחד... אתה מבין לאיזה ברוך אתה נכנס?

אני גם לא מבין למה אתה בודק לגבי כל מילה עד 5 מילים קדימה ומחפש אם הם חוזרות על עצמן, זה לא מה שרצית, אם אתה התכוונת למהש הצעתי למעלה התכוונתי להתייחס למילים שמוקפות במרכאות בלבד, דוגמה זריזה ל-3 מעברים בלבד על המאמר תהייה:
1. תהפוך את כל התווים המיוחדים מלבד " ו ' לרווחים
2. כאשר אתה מגיע ל " או ל ' חפש בטווח של 5 מילים קדימה (4 רווחים) אם אתה נתקל שוב באותו התו, אם כן - תחליף את הרווחים ביניהם בנקודות, בכול מקרה תחליף את המרכאות/גרשים ברווח (שים לב שיש התנהגות שונה בין אם אתה מוצא "/' סוגרים או לא).
3. ספור את המילים שחוזרות על עצמן.

ככה על מאמר בן 10 מילים תעבור רק 30 פעם ולא 1000 (שוב, אלא אם לא קראתי את הקוד נכון, לא מתיימר להכיר PHP כשמעולם לא ראיתי קוד בשפה הזו, שלא לדבר על לכתוב בה)

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

יכולים להיות לך בקלות שני מאמרים על אותו נושא, בלי מילה אחת משותפת (שקשורה לנושא), ולהפך שני מאמרים לא קשורים עם המון מילים משותפות...

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

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