sim_pasc - Online sa Cloud

PROGRAMA:

NAME

sim - maghanap ng mga pagkakatulad sa C, Java, Pascal, Modula-2, Lisp, Miranda, o mga text file

SINOPSIS

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

DESCRIPTION

Sim_c binabasa ang mga C file file ... at naghahanap ng mga segment ng teksto na magkatulad; dalawa
magkatulad ang mga segment ng text ng programa kung magkaiba lamang ang mga ito sa layout, komento, identifier,
at ang mga nilalaman ng mga numero, mga string at mga character. Kung ang anumang run ng sapat na haba ay
natagpuan, ang mga ito ay iniulat sa karaniwang output; ang bilang ng mga makabuluhang token sa pagtakbo
ay ibinibigay sa pagitan ng mga square bracket.

Sim_java ginagawa ang parehong para sa Java, sim_pasc para kay Pascal, sim_m2 para sa Modula-2, sim_mira para
Miranda, at sim_lisp para kay Lisp. Sim_text gumagana sa arbitrary na teksto at ito ay paminsan-minsan
kapaki-pakinabang sa mga script ng shell.

Maaaring gamitin ang program para sa paghahanap ng mga kinopyang piraso ng code sa diumano'y walang kaugnayan
mga programa (kasama ang -s or -S), o para sa paghahanap ng aksidenteng nadobleng code sa malalaking proyekto
(may -f or -F).

Kung isang separator / or | ay naroroon sa listahan ng mga input file, ang mga file ay nahahati sa a
pangkat ng mga "bagong" file (bago ang / or |) at isang pangkat ng mga "lumang" file; kung wala / or
|, ang lahat ng mga file ay "bago". Ang mga lumang file ay hindi kailanman inihambing sa isa't isa. Tingnan din ang
paglalarawan ng mga -s at -S mga pagpipilian sa ibaba.

Dahil ang tester ng pagkakatulad ay nangangailangan ng mga pangalan ng file upang matukoy ang mga pagkakatulad, hindi ito mabasa
mula sa karaniwang input.

Mayroong mga sumusunod na opsyon:

-d Ang output ay nasa a Diff(1)-like na format sa halip na ang default na 2-column na format.

-e Ang bawat file ay inihambing sa bawat file sa paghihiwalay; makikita nito ang lahat ng pagkakatulad
sa pagitan ng lahat ng tekstong kasangkot, anuman ang paulit-ulit na teksto (tingnan ang `Pagkalkula
Mga porsyento sa ibaba).

-f Ang mga pagtakbo ay pinaghihigpitan sa mga segment na may balanseng panaklong, upang ihiwalay ang potensyal
nakagawiang katawan (hindi sa sim_text).

-F Ang mga pangalan ng mga gawain sa mga tawag ay kinakailangang tumugma nang eksakto (hindi sa sim_text).

-i Ang mga pangalan ng mga file na ihahambing ay binabasa mula sa karaniwang input, kabilang ang a
posibleng separator / or |; ang mga pangalan ng file ay dapat na isa sa isang linya. Ang pagpipiliang ito
nagbibigay-daan sa isang napakalaking bilang ng mga pangalan ng file na matukoy; ito ay naiiba sa @
pasilidad na ibinigay ng ilang mga compiler na pinangangasiwaan lamang nito ang mga pangalan ng file, at ginagawa nito
hindi nakikilala ang mga argumento ng opsyon.

-M Ang impormasyon sa paggamit ng memory ay ipinapakita sa karaniwang output ng error.

-n Ang mga nakitang pagkakatulad ay ibinubuod ng pangalan ng file, posisyon at laki, sa halip na
ipinapakita nang buo.

-o F Ang output ay nakasulat sa file na pinangalanan F.

-p Ang output ay ibinibigay sa mga porsyento ng pagkakatulad; tingnan ang `Pagkalkula ng mga Porsyento' sa ibaba;
nagpapahiwatig -e at -s.

-P As -p ngunit ang pangunahing kontribyutor lamang ang ipinapakita; nagpapahiwatig -e at -s.

-r N Ang minimum na haba ng pagtakbo ay nakatakda sa N mga yunit; ang default ay 24 na token, maliban sa
sim_text, kung saan ito ay 8 salita.

-R Ang mga direktoryo sa listahan ng pag-input ay ipinasok nang recursively, at lahat ng mga file na nilalaman nito
kasangkot sa paghahambing.

-s Ang mga nilalaman ng isang file ay hindi inihambing sa sarili nito (-s para sa "hindi sa sarili").

-S Ang mga nilalaman ng mga bagong file ay inihambing sa mga lumang file lamang - hindi sa pagitan
kanilang sarili.

-t N Kasabay ng -p or -P mga opsyon, nagtatakda ng threshold (sa porsyento) sa ibaba
kung aling mga pagkakatulad ang hindi iuulat; ang default ay 1, maliban sa sim_text,
kung saan ito ay 20.

-T Ang isang mas maikli at pare-parehong anyo ng output ay ginawa, na maaaring mas angkop para sa
post processing.

-v Ini-print ang numero ng bersyon at petsa ng compilation sa karaniwang output, pagkatapos ay hihinto.

-w N Ang lapad ng pahina na ginamit ay nakatakda sa N mga hanay; ang default ay 80.

-- (Isang lihim na opsyon, na nagpi-print ng input habang nakikita ito ng checker ng pagkakatulad, at
pagkatapos ay huminto.)

Ang -p resulta ng opsyon sa mga linya ng form
Ang F ay binubuo ng x % ng G materyal
ibig sabihin ay makikita rin ang x % ng teksto ni F sa G. Tandaan na ang kaugnayang ito ay hindi
simetriko; ito ay sa katunayan ay lubos na posible para sa isang file na binubuo para sa 100 % ng teksto mula sa
isa pang file, habang ang isa pang file ay binubuo lamang ng 1 % ng teksto ng unang file, kung
sapat na magkaiba ang kanilang mga haba. Ang -P (capital P) na opsyon ay nagpapakita ng pangunahing tagapag-ambag para sa
bawat file lamang. Pinapasimple nito ang pagkakakilanlan ng isang set ng mga file A[1] ... A[n], kung saan
ang pagsasama-sama ng mga file na ito ay naroroon din. Maaaring magtakda ng threshold gamit ang -t
opsyon; tandaan na ang granularity ng kinikilalang teksto ay pinamamahalaan pa rin ng -r
opsyon o ang default nito.

Ang -r kinokontrol ng opsyon ang bilang ng "mga yunit" na bumubuo ng isang run. Para sa mga programa na
ihambing ang programming language code, ang isang yunit ay isang lexical na token sa nauugnay na wika;
komento at karaniwang preamble na materyal (pagsasama ng file, atbp.) ay binabalewala at lahat ng mga string
ay itinuturing na pareho. Para sa sim_text ang yunit ay isang "salita" na binibigyang kahulugan bilang anumang pagkakasunod-sunod
ng isa o higit pang mga letra, digit, o character na higit sa 127 (177 octal), (upang matugunan
mga titik tulad ng ä, ø, atbp.).
Sim_text tumatanggap ng spacedtext bilang normal na text.

Ang -s at -S kinokontrol ng mga opsyon kung aling mga file ang ihahambing. Ang mga input file ay nahahati sa dalawa
grupo, bago at luma. Sa kawalan ng mga opsyon sa kontrol na ito, inihahambing ng mga programa ang
file kaya (para sa 4 na bagong file at 6 na luma):
bago / luma <- unang file
1 2 3 4 / 5 6 7 8 9 10
|------------/------------
n 1 | c /
e 2 | cc /
w 3 | ccc /
4 | cccc /
pangalawa // / / / / / / / / / /
file -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /
kung saan ang cs ay kumakatawan sa mga paghahambing ng file, at ang / ang demarcation sa pagitan ng bago at luma
file.
Paggamit ng -s binabawasan ito ng opsyon sa:
bago / luma <- unang file
1 2 3 4 / 5 6 7 8 9 10
|------------/------------
n 1 | /
e 2 | c /
w 3 | cc /
4 | ccc /
pangalawa // / / / / / / / / / /
file -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /
Ang -S Binabawasan ito ng opsyon sa:
bago / luma <- unang file
1 2 3 4 / 5 6 7 8 9 10
|------------/------------
n 1 | /
e 2 | /
w 3 | /
4 | /
pangalawa // / / / / / / / / / /
file -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /

Ang mga programa ay maaaring pangasiwaan ang mga pangalan ng file ng UNICODE sa ilalim ng Windows. Ito ay may kaugnayan lamang sa ilalim ng
-R opsyon, dahil walang paraan upang magbigay ng UNICODE file name mula sa command line.

LIMITASYON

Ang paulit-ulit na input ay ang bane ng pagsuri ng pagkakatulad. Kung mayroon kaming isang file na naglalaman ng 4
mga kopya ng magkatulad na teksto,
A1 A2 A3 A4
kung saan ang mga numero ay nagsisilbi lamang upang makilala ang magkatulad na mga kopya, mayroong 8 pagkakakilanlan:
A1=A2, A1=A3, A1=A4, A2=A3, A2=A4, A3=A4, A1A2=A3A4, at A1A2A3=A2A3A4. Sa mga ito, 3 lamang
ay makabuluhan: A1=A2, A2=A3, at A3=A4. At para sa isang talahanayan na may 20 linya na magkapareho sa bawat isa
iba pa, hindi pangkaraniwan sa isang programa, mayroong 715 na pagkakakilanlan, kung saan higit sa 19 ay
makabuluhan. Ang pag-uulat sa lahat ng 715 sa kanila ay malinaw na hindi katanggap-tanggap.

Upang malunasan ito, ang paghahanap ng mga pagkakakilanlan ay isinasagawa tulad ng sumusunod: Para sa bawat posisyon sa
text, ang pinakamalaking segment ay matatagpuan, kung saan ang isang hindi magkakapatong na kopya ay nangyayari sa teksto
sinusundan ito. Iniuulat ang segment na iyon at ang kopya nito at nagpapatuloy ang pag-scan sa posisyon
kakatapos lang ng segment. Para sa halimbawa sa itaas nagreresulta ito sa mga pagkakakilanlan A1A2=A3A4
at A3=A4, na medyo kasiya-siya, at para sa N halos magkaparehong mga segment 2 mag-log N
ibinibigay ang mga mensahe.

Mahusay din itong gagana kapag ang apat na magkaparehong segment ay nasa magkakaibang mga file:
File1: A1
File2: A2
File3: A3
File4: A4
Ngayon ang pinagsamang mga segment tulad ng A1A2 ay hindi nangyayari, at hinahanap ng algorithm ang mga run A1=A2,
A2=A3, at A3=A4, sa kabuuan na N-1 tumatakbo, lahat ay nagbibigay-kaalaman.

Tuso Porsyento
Ang diskarte sa itaas ay hindi angkop para sa pagkuha ng porsyento ng nilalaman ng file na iyon
ay matatagpuan sa ibang file. Nangangailangan ito ng paghahambing nang hiwalay sa bawat pares ng file
kinakatawan ng ac sa mga matrix sa itaas; ito ang -e ginagawa ng opsyon. Sa ilalim ng -e
opsyon na isang segment na File1:A1, na kinikilala sa File2, ay muling makikilala sa File3 at
File4. Sa halimbawa sa itaas ito ay gumagawa ng mga run
File1:A1=File2:A2
File1:A1=File3:A3
File1:A1=File4:A4
File2:A2=File3:A3
File2:A2=File4:A4
File3:A3=File4:A4
para sa isang kabuuang ng ½N(N-1) tumatakbo.

TIME AT Puwang MGA KINAKAILANGAN

Ang pangangalaga ay ginawa upang mapanatili ang mga kinakailangan sa oras ng lahat ng mga panloob na proseso (halos)
linear sa haba ng mga input file, sa pamamagitan ng paggamit ng iba't ibang mga talahanayan. Kung, gayunpaman, mayroon
hindi sapat na memorya para sa mga talahanayan, sila ay itinapon sa pagkakasunud-sunod ng hindi kahalagahan, kung saan
kundisyon na ang mga algorithm ay bumalik sa kanilang parisukat na katangian.

Ang mga kinakailangan sa oras ay parisukat sa bilang ng mga file. Ibig sabihin, halimbawa,
ang isang 64 MB na file ay nagpoproseso nang mas mabilis kaysa sa 8000 8 kB na mga file.

Ang programa ay nangangailangan ng 6 bytes ng memorya para sa bawat token sa input; 2 byte bawat bagong linya
(hindi kapag gumagawa ng mga porsyento); at mga 76 bytes para sa bawat run na natagpuan.

HALIMBAWA

Ang tawag
sim_c *.c
nagha-highlight ng duplicate na code sa direktoryo. (Kapaki-pakinabang na alisin ang mga nabuong file
una.) Isang tawag
sim_c -f -F *.c
maaaring matukoy ang mga ito nang higit pa.

Isang tawag
sim_text -e -p -s bago/* / luma/*
inihahambing ang bawat file sa bago/* sa bawat file sa bago/* at luma/*, at kung ang alinmang pares ay may higit na
20% sa karaniwan, ang katotohanang iyon ay iniulat. Karaniwan ang pagkakatulad ng 30% o higit pa ay makabuluhan;
mas mababa sa 20% ay malamang na nagkataon; at sa pagitan ay nagdududa.

Isang tawag
sim_text -e -n -s -r100 bago/* "|" matanda/*
inihahambing ang parehong mga file, at nag-uulat ng malalaking karaniwang mga segment. (Ang | ay maaaring magamit bilang isang
separator sa halip na / sa mga sistema kung saan ang / bilang isang command-line parameter ay makakakuha ng sira sa pamamagitan ng
ang command interpreter.)

Ang parehong mga diskarte ay mabuti para sa pagtuklas ng plagiarism.

Gumamit ng sim_pasc online gamit ang mga serbisyo ng onworks.net