sim_mira - אונליין בענן

תָכְנִית:

שֵׁם

sim - מצא קווי דמיון בקבצי C, Java, Pascal, Modula-2, Lisp, Miranda או טקסט

תַקצִיר

sim_c [ -[defFiMnpPRsSTv] -r N -t N -w N -o F ] קובץ ... [ [ / | ] קובץ ... ]
sim_c ...
sim_java ...
sim_pasc ...
sim_m2 ...
sim_lisp ...
sim_mira ...
sim_text ...

תיאור

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

Sim_java עושה את אותו הדבר עבור Java, sim_pasc עבור פסקל, sim_m2 עבור Modula-2, sim_mira ל
מירנדה, ו sim_lisp עבור ליספ. Sim_text עובד על טקסט שרירותי וזה קורה מדי פעם
שימושי על סקריפטים של מעטפת.

התוכנית יכולה לשמש למציאת פיסות קוד שהועתקו ללא קשר כביכול
תוכניות (עם -s or -S), או למציאת קוד משוכפל בטעות בפרויקטים גדולים יותר
(עם -f or -F).

אם מפריד / or | קיים ברשימת קבצי הקלט, הקבצים מחולקים ל-a
קבוצת קבצים "חדשים" (לפני ה / or |) וקבוצה של קבצים "ישנים"; אם אין / or
|, כל הקבצים הם "חדשים". אף פעם לא משווים קבצים ישנים זה לזה. ראה גם את
תיאור של ה -s ו -S אפשרויות להלן.

מכיוון שבודק הדמיון צריך שמות קבצים כדי לאתר את קווי הדמיון, הוא לא יכול לקרוא
מקלט רגיל.

יש את האפשרויות הבאות:

-d הפלט הוא ב-a הבדלפורמט דמוי (1) במקום פורמט ברירת המחדל של 2 עמודות.

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

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

-F שמות השגרה בשיחות נדרשים להתאים בדיוק (לא ב sim_text).

-i שמות הקבצים שיש להשוות נקראים מקלט סטנדרטי, כולל א
מפריד אפשרי / or |; שמות הקבצים חייבים להיות אחד עד שורה. אפשרות זו
מאפשר לציין מספר גדול מאוד של שמות קבצים; זה שונה מה-@
מתקן מסופק על ידי כמה מהדרים בכך שהוא מטפל בשמות קבצים בלבד, ועושה זאת
לא מזהה ארגומנטים של אופציה.

-M מידע על שימוש בזיכרון מוצג בפלט שגיאה סטנדרטי.

-n קווי דמיון שנמצאו מסוכמים לפי שם קובץ, מיקום וגודל, במקום
מוצג במלואו.

-o F הפלט נכתב לקובץ בשם F.

-p התפוקה ניתנת באחוזי דמיון; ראה 'חישוב אחוזים' להלן;
מרמז -e ו -s.

-P As -p אבל רק התורם הראשי מוצג; מרמז -e ו -s.

-r N אורך הריצה המינימלי מוגדר ל N יחידות; ברירת המחדל היא 24 אסימונים, למעט ב
sim_text, שבו זה 8 מילים.

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

-s התוכן של קובץ אינו מושווה לעצמו (-ים עבור "לא עצמי").

-S תוכן הקבצים החדשים מושווה לקבצים הישנים בלבד - לא ביניהם
עצמם.

-t N בשילוב עם -p or -P אפשרויות, מגדיר את הסף (באחוזים) למטה
אילו קווי דמיון לא ידווחו; ברירת המחדל היא 1, למעט ב sim_text,
איפה זה 20.

-T נוצרת צורת פלט מתומצתת ואחידה יותר, שאולי תתאים לה יותר
לאחר עיבוד.

-v מדפיס את מספר הגרסה ותאריך הקומפילציה על פלט רגיל, ואז מפסיק.

-w N רוחב העמוד בשימוש מוגדר ל N עמודים; ברירת המחדל היא 80.

-- (אפשרות סודית, שמדפיסה את הקלט כפי שבודק הדמיון רואה אותו, ו
ואז מפסיק.)

השמיים -p האפשרות גורמת לשורות של הטופס
F מורכב עבור x% מחומר G
כלומר, x % מהטקסט של F ניתן למצוא גם ב-G. שימו לב שיחס זה אינו
סימטרי; למעשה זה בהחלט אפשרי שקובץ אחד יכלול 100% מהטקסט ממנו
קובץ אחר, בעוד הקובץ השני מורכב רק 1% מהטקסט של הקובץ הראשון, if
האורכים שלהם שונים מספיק. ה -P אפשרות (P בירה) מציגה את התורם העיקרי עבור
כל קובץ בלבד. זה מפשט את הזיהוי של קבוצה של קבצים A[1] ... A[n], שבו
השרשור של קבצים אלה קיים גם כן. ניתן להגדיר סף באמצעות -t
אוֹפְּצִיָה; שים לב שהפירוט של הטקסט המוכר עדיין כפוף ל- -r
אפשרות או ברירת המחדל שלה.

השמיים -r אפשרות שולטת במספר ה"יחידות" המהוות ריצה. עבור התוכניות ש
השוו קוד שפת תכנות, יחידה היא אסימון מילוני בשפה הרלוונטית;
הערות וחומר ההקדמה הסטנדרטי (הכללת קבצים וכו') מתעלמים וכל המחרוזות
נחשבים זהים. ל sim_text יחידה היא "מילה" המוגדרת ככל רצף
של אות אחת או יותר, ספרה או תווים מעל 127 (177 אוקטליים), (כדי להכיל
אותיות כגון ä, ø וכו').
Sim_text מקבל טקסט מרווח כטקסט רגיל.

השמיים -s ו -S אפשרויות שולטות באילו קבצים להשוות. קבצי קלט מחולקים לשניים
קבוצות, חדשות וישנות. בהיעדר אפשרויות בקרה אלה התוכניות משווים את
קבצים לפיכך (עבור 4 קבצים חדשים ו-6 ישנים):
חדש / ישן <- קובץ ראשון
1 2 3 4 / 5 6 7 8 9 10
|------------/-------------
n 1 | ג /
ה 2 | סמ"ק /
w 3 | עותק /
4 | cccc /
שנייה / / / / / / / / / / / /
קובץ -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
ד 8 | cccc /
9 | cccc /
10 | cccc /
כאשר ה-cs מייצגים השוואות קבצים, וה-/ התיחום בין חדש לישן
קבצים.
משתמש ב -s האפשרות מצמצמת את זה ל:
חדש / ישן <- קובץ ראשון
1 2 3 4 / 5 6 7 8 9 10
|------------/-------------
n 1 | /
ה 2 | ג /
w 3 | סמ"ק /
4 | עותק /
שנייה / / / / / / / / / / / /
קובץ -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
ד 8 | cccc /
9 | cccc /
10 | cccc /
השמיים -S האפשרות מצמצמת זאת עוד יותר ל:
חדש / ישן <- קובץ ראשון
1 2 3 4 / 5 6 7 8 9 10
|------------/-------------
n 1 | /
ה 2 | /
w 3 | /
4 | /
שנייה / / / / / / / / / / / /
קובץ -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
ד 8 | cccc /
9 | cccc /
10 | cccc /

התוכניות יכולות להתמודד עם שמות קבצי UNICODE תחת Windows. זה רלוונטי רק תחת ה
-R אפשרות, מכיוון שאין דרך לתת שמות קבצים של UNICODE משורת הפקודה.

מגבלות

קלט חוזר הוא החמצה של בדיקת דמיון. אם יש לנו קובץ המכיל 4
עותקים של טקסט זהה,
A1 A2 A3 A4
כאשר המספרים משמשים רק להבחין בין העותקים הזהים, יש 8 זהויות:
A1=A2, A1=A3, A1=A4, A2=A3, A2=A4, A3=A4, A1A2=A3A4, ו-A1A2A3=A2A3A4. מתוכם, רק 3
הם בעלי משמעות: A1=A2, A2=A3 ו-A3=A4. ולשולחן עם 20 שורות זהות לכל אחד
אחר, לא יוצא דופן בתוכנית, יש 715 זהויות, מתוכן לכל היותר 19
בעל משמעות. דיווח על כל 715 מהם אינו מקובל בעליל.

כדי לתקן זאת, מציאת הזהויות מתבצעת באופן הבא: עבור כל תפקיד ב
טקסט, נמצא הקטע הגדול ביותר, שמתוכו מופיע עותק שאינו חופף בטקסט
בעקבותיו. קטע זה והעותק שלו מדווחים והסריקה מתחדשת בעמדה
רק אחרי הקטע. עבור הדוגמה שלמעלה, זה גורם לזהויות A1A2=A3A4
ו-A3=A4, שזה די מספק, ועבור N קטעים זהים בערך 2 היכנס N
ניתנות הודעות.

זה גם עובד היטב כאשר ארבעת המקטעים הזהים נמצאים בקבצים שונים:
קובץ 1: A1
קובץ 2: A2
קובץ 3: A3
קובץ 4: A4
כעת לא מתרחשים מקטעים משולבים כמו A1A2, והאלגוריתם מוצא את הריצות A1=A2,
A2=A3, ו-A3=A4, בסך הכל N-1 ריצות, הכל אינפורמטיבי.

חישוב אחוזים
הגישה שלעיל אינה מתאימה להשגת אחוז התוכן של קובץ זה
ניתן למצוא בקובץ אחר. זה מצריך השוואה בנפרד של כל זוג קבצים
מיוצג על ידי ac במטריצות למעלה; זה מה שה -e אפשרות כן. תחת -e
אפשרות קטע File1:A1, המוכר ב-File2, יזוהה שוב ב-File3 ו
קובץ 4. בדוגמה למעלה הוא מייצר את הריצות
File1:A1=File2:A2
File1:A1=File3:A3
File1:A1=File4:A4
File2:A2=File3:A3
File2:A2=File4:A4
File3:A3=File4:A4
בסך הכל ½N(N-1) רץ.

זמן ו SPACE דרישות

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

דרישות הזמן הן ריבועיות במספר הקבצים. זה אומר שלמשל,
קובץ אחד של 64 מגה-בייט מעבד הרבה יותר מהר מ-8000 קבצים של 8 קילו-בייט.

התוכנית דורשת 6 בתים של זיכרון עבור כל אסימון בקלט; 2 בתים לשורה חדשה
(לא כשעושים אחוזים); וכ-76 בתים עבור כל ריצה שנמצאה.

דוגמאות

השיחה
sim_c *.c
מדגיש קוד כפול בספרייה. (מועיל להסיר קבצים שנוצרו
ראשית.) שיחה
sim_c -f -F *.c
יכול להצביע עליהם יותר.

שיחה
sim_text -e -p -s new/* / old/*
משווה כל קובץ ב-new/* לכל קובץ ב-new/* ובישן/*, ואם לזוג כלשהו יש יותר מזה
20% במשותף, עובדה זו מדווחת. בדרך כלל דמיון של 30% או יותר הוא משמעותי;
נמוך מ-20% הוא כנראה צירוף מקרים; ובין לבין מוטל בספק.

שיחה
sim_text -e -n -s -r100 new/* "|" ישן/*
משווה את אותם קבצים, ומדווח על פלחים נפוצים גדולים. (ה | יכול לשמש כ
מפריד במקום / על מערכות שבהן / כפרמטר שורת פקודה מתנודד על ידי
מתורגמן הפיקוד.)

שתי הגישות טובות לזיהוי פלגיאט.

השתמש ב-sim_mira באינטרנט באמצעות שירותי onworks.net