similarity-tester - Online nel cloud

PROGRAMMA:

NOME

sim - trova somiglianze in C, Java, Pascal, Modula-2, Lisp, Miranda o file di testo

SINOSSI

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 ...
testo_sim ...

DESCRIZIONE

Sim_c legge i file C filetto ... e cerca segmenti di testo simili; Due
segmenti di testo del programma sono simili se differiscono solo per layout, commento, identificatori,
e il contenuto di numeri, stringhe e caratteri. Se le corse di lunghezza sufficiente sono
trovati, vengono riportati sullo standard output; il numero di token significativi nella corsa
è dato tra parentesi quadre.

Sim_java fa lo stesso per Java, sim_pasc per Pasquale, sim_m2 per Modula-2, sim_mira da
Miranda, e sim_lisp per Lisp. Sim_testo funziona su testo arbitrario ed è occasionalmente
utile sugli script di shell.

Il programma può essere utilizzato per trovare pezzi di codice copiati in presumibilmente non correlati
programmi (con -s or -S), o per trovare codice duplicato accidentalmente in progetti più grandi
(con -f or -F).

Se un separatore / or | è presente nell'elenco dei file di input, i file sono divisi in a
gruppo di file "nuovi" (prima del / or |) e un gruppo di file "vecchi"; se non c'è / or
|, tutti i file sono "nuovi". I vecchi file non vengono mai confrontati tra loro. Vedi anche il
descrizione del -s e -S opzioni di seguito.

Poiché il tester di somiglianza ha bisogno di nomi di file per individuare le somiglianze, non può leggere
dall'ingresso standard.

Ci sono le seguenti opzioni:

-d L'uscita è in a diffformato simile a (1) invece del formato a 2 colonne predefinito.

-e Ogni file viene confrontato con ciascun file in isolamento; questo troverà tutte le somiglianze
tra tutti i testi coinvolti, indipendentemente dal testo ripetitivo (vedi `Calcolo
Percentuali' sotto).

-f Le esecuzioni sono limitate ai segmenti con parentesi di bilanciamento, per isolare il potenziale
organi di routine (non in testo_sim).

-F I nomi delle routine nelle chiamate devono corrispondere esattamente (non in testo_sim).

-i I nomi dei file da confrontare vengono letti dallo standard input, incluso a
possibile separatore / or |; i nomi dei file devono essere uno per riga. Questa opzione
consente di specificare un numero molto elevato di nomi di file; è diverso da @
funzione fornita da alcuni compilatori in quanto gestisce solo i nomi dei file e lo fa
non riconosce gli argomenti dell'opzione.

-M Le informazioni sull'utilizzo della memoria vengono visualizzate sull'output dell'errore standard.

-n Le somiglianze trovate sono riassunte per nome del file, posizione e dimensione, piuttosto che per
visualizzato per intero.

-o F L'output viene scritto nel file denominato F.

-p L'output è dato in percentuali di similarità; vedere "Calcolo delle percentuali" di seguito;
implica -e e -s.

-P As -p ma viene mostrato solo il contributore principale; implica -e e -s.

-r N La lunghezza minima della corsa è impostata su N unità; il valore predefinito è 24 token, tranne in
testo_sim, dove sono 8 parole.

-R Le directory nell'elenco di input vengono immesse in modo ricorsivo e tutti i file che contengono
sono coinvolti nel confronto.

-s Il contenuto di un file non viene confrontato con se stesso (-s per "not self").

-S Il contenuto dei nuovi file viene confrontato solo con i vecchi file, non tra
loro stessi.

-t N In combinazione con il programma -p or -P opzioni, imposta la soglia (in percentuale) sotto
quali somiglianze non verranno riportate; il valore predefinito è 1, tranne in testo_sim,
dove sono 20.

-T Viene prodotta una forma di output più concisa e uniforme, che può essere più adatta per
post produzione.

-v Stampa il numero di versione e la data di compilazione sullo standard output, quindi si interrompe.

-w N La larghezza della pagina utilizzata è impostata su N colonne; il valore predefinito è 80.

-- (Un'opzione segreta, che stampa l'input come lo vede il controllore di somiglianza, e
poi si ferma.)

. -p opzione risultati in righe del modulo
F consiste per x % di G materiale
il che significa che x% del testo di F può essere trovato anche in G. Nota che questa relazione non è
simmetrico; è infatti possibile che un file contenga il 100% di testo da
un altro file, mentre l'altro file consiste solo per l'1% del testo del primo file, se
le loro lunghezze differiscono abbastanza. Il -P L'opzione (P maiuscola) mostra il contributore principale per
solo ogni file. Ciò semplifica l'identificazione di un insieme di file A[1] ... A[n], dove
è presente anche la concatenazione di questi file. È possibile impostare una soglia utilizzando il -t
opzione; si noti che la granularità del testo riconosciuto è ancora disciplinata dal -r
opzione o il suo valore predefinito.

. -r L'opzione controlla il numero di "unità" che costituiscono una corsa. Per i programmi che
confrontare il codice del linguaggio di programmazione, un'unità è un token lessicale nel linguaggio pertinente;
il materiale di commento e preambolo standard (inclusione di file, ecc.) viene ignorato e tutte le stringhe
sono considerati uguali. Per testo_sim un'unità è una "parola" definita come qualsiasi sequenza
di una o più lettere, cifre o caratteri oltre 127 (177 ottali), (per adattarsi
lettere come ä, ø, ecc.).
Sim_testo accetta il testo spaziato come testo normale.

. -s e -S le opzioni controllano quali file confrontare. I file di input sono divisi in due
gruppi, vecchi e nuovi. In assenza di queste opzioni di controllo i programmi confrontano le
file così (per 4 nuovi file e 6 vecchi):
nuovo / vecchio <- primo file
1 2 3 4/5 6 7 8 9 10
|------------/------------
n 1 | C /
e 2 | cc /
w 3 | ccc /
4 | cccc /
secondo / / / / / / / / / / / /
file -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /
dove il cs rappresenta i confronti di file e il / la demarcazione tra nuovo e vecchio
File.
Usando il -s opzione riduce questo a:
nuovo / vecchio <- primo file
1 2 3 4/5 6 7 8 9 10
|------------/------------
n1 | /
e 2 | C /
w 3 | cc /
4 | ccc /
secondo / / / / / / / / / / / /
file -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /
. -S opzione riduce ulteriormente questo a:
nuovo / vecchio <- primo file
1 2 3 4/5 6 7 8 9 10
|------------/------------
n1 | /
e2| /
w3 | /
4| /
secondo / / / / / / / / / / / /
file -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /

I programmi possono gestire nomi di file UNICODE in Windows. Questo è rilevante solo sotto il
-R opzione, poiché non è possibile fornire nomi di file UNICODE dalla riga di comando.

LIMITAZIONI

L'input ripetitivo è la rovina del controllo della somiglianza. Se abbiamo un file contenente 4
copie di testo identico,
A1 A2 A3 A4
dove i numeri servono solo a distinguere le copie identiche, ci sono 8 identità:
A1=A2, A1=A3, A1=A4, A2=A3, A2=A4, A3=A4, A1A2=A3A4 e A1A2A3=A2A3A4. Di questi, solo 3
sono significativi: A1=A2, A2=A3 e A3=A4. E per una tabella con 20 righe identiche l'una all'altra
altro, non insolito in un programma, ci sono 715 identità, di cui al massimo 19 sono
significativo. Denunciarli tutti e 715 è chiaramente inaccettabile.

Per rimediare a ciò, la ricerca delle identità viene eseguita come segue: Per ogni posizione nel
testo, viene trovato il segmento più grande, di cui una copia non sovrapposta si verifica nel testo
seguendolo. Quel segmento e la sua copia vengono riportati e la scansione riprende nella posizione
subito dopo il segmento. Per l'esempio sopra questo risulta nelle identità A1A2=A3A4
e A3=A4, che è abbastanza soddisfacente, e per N segmenti identici all'incirca 2 ceppo N
i messaggi sono dati.

Funziona bene anche quando i quattro segmenti identici si trovano in file diversi:
Fascicolo 1: A1
Fascicolo 2: A2
Fascicolo 3: A3
Fascicolo 4: A4
Ora i segmenti combinati come A1A2 non si verificano e l'algoritmo trova le corse A1=A2,
A2=A3 e A3=A4, per un totale di N-1 corre, tutto informativo.

Calcolo Percentuali
L'approccio di cui sopra non è adatto per ottenere la percentuale del contenuto di un file che
può essere trovato in un altro file. Ciò richiede il confronto isolato di ciascuna coppia di file
rappresentato da ac nelle matrici precedenti; questo è quello che -e l'opzione fa. Sotto il -e
opzione un segmento File1:A1, riconosciuto in File2, sarà nuovamente riconosciuto in File3 e
File4. Nell'esempio sopra produce i 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
per un totale di ½N(N-1) piste.

ORARIO E SPACE REQUISITI

È stata prestata attenzione per mantenere i requisiti di tempo di tutti i processi interni (quasi)
lineare nelle lunghezze dei file di input, utilizzando varie tabelle. Se invece c'è
memoria insufficiente per le tabelle, vengono scartate in ordine di non importanza, in base alla quale
condizioni gli algoritmi tornano alla loro natura quadratica.

I requisiti di tempo sono quadratici nel numero di file. Ciò significa che, ad esempio,
un file da 64 MB elabora molto più velocemente di 8000 file da 8 kB.

Il programma richiede 6 byte di memoria per ogni token in ingresso; 2 byte per nuova riga
(non quando si fanno le percentuali); e circa 76 byte per ogni esecuzione trovata.

ESEMPI

La chiamata
sim_c *.c
evidenzia il codice duplicato nella directory. (È utile rimuovere i file generati
prima.) Una chiamata
sim_c -f -F *.c
può individuarli ulteriormente.

Una chiamata
sim_text -e -p -s nuovo/* / vecchio/*
confronta ogni file in new/* con ogni file in new/* e old/*, e se una coppia ne ha di più
20% in comune, questo fatto è riportato. Di solito è significativa una somiglianza del 30% o più;
inferiore al 20% è probabilmente una coincidenza; e in mezzo è dubbio.

Una chiamata
sim_text -e -n -s -r100 nuovo/* "|" vecchio/*
confronta gli stessi file e riporta ampi segmenti comuni. (Il | può essere usato come un
separatore invece di / su sistemi in cui il / come un parametro della riga di comando viene mutilato da
l'interprete dei comandi.)

Entrambi gli approcci sono utili per il rilevamento del plagio.

Utilizza il tester di somiglianza online utilizzando i servizi onworks.net