sim_m2 - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

sim - C, Java, Pascal, Modula-2, Lisp, Miranda, അല്ലെങ്കിൽ ടെക്സ്റ്റ് ഫയലുകളിൽ സമാനതകൾ കണ്ടെത്തുക

സിനോപ്സിസ്

സിം_സി [ -[defFiMnpPRsSTv] -r N -t N -w N -o F ] ഫയൽ ... [ [ / | ] ഫയൽ ...]
സിം_സി ...
സിം_ജാവ ...
സിം_പാസ്ക് ...
sim_m2 ...
സിം_ലിസ്പ് ...
സിം_മീര ...
സിം_ടെക്സ്റ്റ് ...

വിവരണം

സിം_സി സി ഫയലുകൾ വായിക്കുന്നു ഫയല് ... ഒപ്പം സമാനമായ ടെക്‌സ്‌റ്റ് സെഗ്‌മെന്റുകൾക്കായി തിരയുന്നു; രണ്ട്
ലേഔട്ട്, കമന്റ്, ഐഡന്റിഫയറുകൾ എന്നിവയിൽ മാത്രം വ്യത്യാസമുണ്ടെങ്കിൽ പ്രോഗ്രാം ടെക്‌സ്‌റ്റിന്റെ സെഗ്‌മെന്റുകൾ സമാനമായിരിക്കും.
അക്കങ്ങൾ, സ്ട്രിങ്ങുകൾ, പ്രതീകങ്ങൾ എന്നിവയുടെ ഉള്ളടക്കവും. മതിയായ ദൈർഘ്യമുള്ള ഏതെങ്കിലും റണ്ണുകൾ ഉണ്ടെങ്കിൽ
കണ്ടെത്തി, അവ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിൽ റിപ്പോർട്ട് ചെയ്യപ്പെടുന്നു; ഓട്ടത്തിലെ പ്രധാനപ്പെട്ട ടോക്കണുകളുടെ എണ്ണം
ചതുര ബ്രാക്കറ്റുകൾക്കിടയിൽ നൽകിയിരിക്കുന്നു.

സിം_ജാവ ജാവയിലും ഇതുതന്നെ ചെയ്യുന്നു, സിം_പാസ്ക് പാസ്കലിനായി, sim_m2 മോഡുല-2-ന്, സിം_മീര വേണ്ടി
മിറാൻഡ, ഒപ്പം സിം_ലിസ്പ് ലിസ്പിന്. സിം_ടെക്സ്റ്റ് അനിയന്ത്രിതമായ വാചകത്തിൽ പ്രവർത്തിക്കുന്നു, അത് ഇടയ്ക്കിടെയാണ്
ഷെൽ സ്ക്രിപ്റ്റുകളിൽ ഉപയോഗപ്രദമാണ്.

കോപ്പി ചെയ്ത കോഡിന്റെ ഭാഗങ്ങൾ, ബന്ധമില്ലാത്തതെന്നു കരുതി കണ്ടെത്താൻ പ്രോഗ്രാം ഉപയോഗിക്കാം
പ്രോഗ്രാമുകൾ (കൂടെ -s or -S), അല്ലെങ്കിൽ വലിയ പ്രോജക്റ്റുകളിൽ ആകസ്മികമായി തനിപ്പകർപ്പ് കോഡ് കണ്ടെത്തുന്നതിന്
(കൂടെ -f or -F).

ഒരു വിഭജനം ആണെങ്കിൽ / or | ഇൻപുട്ട് ഫയലുകളുടെ പട്ടികയിൽ ഉണ്ട്, ഫയലുകളെ a ആയി തിരിച്ചിരിക്കുന്നു
"പുതിയ" ഫയലുകളുടെ ഗ്രൂപ്പ് (മുമ്പ് / or |) കൂടാതെ "പഴയ" ഫയലുകളുടെ ഒരു കൂട്ടം; ഇല്ലെങ്കിൽ / or
|, എല്ലാ ഫയലുകളും "പുതിയത്" ആണ്. പഴയ ഫയലുകൾ ഒരിക്കലും പരസ്പരം താരതമ്യം ചെയ്യാറില്ല. ഇതും കാണുക
യുടെ വിവരണം -s ഒപ്പം -S ചുവടെയുള്ള ഓപ്ഷനുകൾ.

സമാനത പരിശോധിക്കാൻ സാമ്യത പരിശോധിക്കുന്നയാൾക്ക് ഫയൽ നാമങ്ങൾ ആവശ്യമുള്ളതിനാൽ, അത് വായിക്കാൻ കഴിയില്ല
സാധാരണ ഇൻപുട്ടിൽ നിന്ന്.

ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ ഉണ്ട്:

-d ഔട്ട്പുട്ട് a-യിലാണ് ഡിഫ്എഫ്(1) ഡിഫോൾട്ട് 2-കോളം ഫോർമാറ്റിന് പകരം-പോലുള്ള ഫോർമാറ്റ്.

-e ഓരോ ഫയലും ഒറ്റപ്പെട്ട ഓരോ ഫയലുമായി താരതമ്യം ചെയ്യുന്നു; ഇത് എല്ലാ സമാനതകളും കണ്ടെത്തും
ആവർത്തിച്ചുള്ള ടെക്‌സ്‌റ്റ് പരിഗണിക്കാതെ ഉൾപ്പെട്ടിരിക്കുന്ന എല്ലാ ടെക്‌സ്‌റ്റുകൾക്കിടയിലും (`കണക്കുകൂട്ടൽ കാണുക
ശതമാനം താഴെ).

-f പൊട്ടൻഷ്യൽ വേർതിരിക്കാൻ, ബാലൻസിങ് പരാൻതീസിസുകളുള്ള സെഗ്‌മെന്റുകളിലേക്ക് റണ്ണുകൾ പരിമിതപ്പെടുത്തിയിരിക്കുന്നു
സാധാരണ ശരീരങ്ങൾ (ഇല്ല സിം_ടെക്സ്റ്റ്).

-F കോളുകളിലെ ദിനചര്യകളുടെ പേരുകൾ കൃത്യമായി പൊരുത്തപ്പെടേണ്ടതുണ്ട് (ഇല്ല സിം_ടെക്സ്റ്റ്).

-i താരതമ്യം ചെയ്യേണ്ട ഫയലുകളുടെ പേരുകൾ സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിൽ നിന്ന് വായിക്കുന്നു, ഇതിൽ a
സാധ്യമായ വിഭജനം / or |; ഫയലിന്റെ പേരുകൾ ഒരു വരിയിൽ ഒന്നായിരിക്കണം. ഈ ഓപ്ഷൻ
വളരെയധികം ഫയൽ നാമങ്ങൾ വ്യക്തമാക്കാൻ അനുവദിക്കുന്നു; ഇത് @ എന്നതിൽ നിന്ന് വ്യത്യസ്തമാണ്
ചില കംപൈലറുകൾ നൽകുന്ന സൗകര്യം, അത് ഫയലുകളുടെ പേരുകൾ മാത്രം കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നു
ഓപ്‌ഷൻ ആർഗ്യുമെന്റുകൾ തിരിച്ചറിയുന്നില്ല.

-M സാധാരണ പിശക് ഔട്ട്പുട്ടിൽ മെമ്മറി ഉപയോഗ വിവരങ്ങൾ പ്രദർശിപ്പിക്കും.

-n കണ്ടെത്തിയ സമാനതകൾ ഫയലിന്റെ പേര്, സ്ഥാനം, വലുപ്പം എന്നിവയെ അടിസ്ഥാനമാക്കി സംഗ്രഹിച്ചിരിക്കുന്നു
പൂർണ്ണമായി പ്രദർശിപ്പിച്ചിരിക്കുന്നു.

-o F പേരിട്ടിരിക്കുന്ന ഫയലിലേക്ക് ഔട്ട്പുട്ട് എഴുതിയിരിക്കുന്നു F.

-p ഔട്ട്പുട്ട് സമാനത ശതമാനത്തിൽ നൽകിയിരിക്കുന്നു; താഴെയുള്ള `കണക്കുകൂട്ടൽ ശതമാനം' കാണുക;
ധ്വനിപ്പിക്കുന്നു -e ഒപ്പം -s.

-P As -p എന്നാൽ പ്രധാന സംഭാവകനെ മാത്രമേ കാണിച്ചിട്ടുള്ളൂ; ധ്വനിപ്പിക്കുന്നു -e ഒപ്പം -s.

-r N ഏറ്റവും കുറഞ്ഞ റൺ ദൈർഘ്യം സജ്ജീകരിച്ചിരിക്കുന്നു N യൂണിറ്റുകൾ; സ്ഥിരസ്ഥിതി 24 ടോക്കണുകളാണ്, ഒഴികെ
സിം_ടെക്സ്റ്റ്, അത് 8 വാക്കുകളാണ്.

-R ഇൻപുട്ട് ലിസ്‌റ്റിലെ ഡയറക്‌ടറികൾ ആവർത്തിച്ച് നൽകപ്പെടുന്നു, അവയിൽ അടങ്ങിയിരിക്കുന്ന എല്ലാ ഫയലുകളും
താരതമ്യത്തിൽ ഉൾപ്പെടുന്നു.

-s ഒരു ഫയലിന്റെ ഉള്ളടക്കം തന്നുമായി താരതമ്യം ചെയ്യപ്പെടുന്നില്ല (-s for "self" അല്ല).

-S പുതിയ ഫയലുകളുടെ ഉള്ളടക്കം പഴയ ഫയലുകളുമായി താരതമ്യപ്പെടുത്തുന്നു - അവയ്ക്കിടയിൽ അല്ല
തങ്ങളെത്തന്നെ.

-t N സംയോജിച്ച് -p or -P ഓപ്ഷനുകൾ, താഴെയുള്ള പരിധി (ശതമാനത്തിൽ) സജ്ജമാക്കുന്നു
ഏതൊക്കെ സമാനതകൾ റിപ്പോർട്ട് ചെയ്യപ്പെടില്ല; ഇൻ ഒഴികെയുള്ള ഡിഫോൾട്ട് 1 ആണ് സിം_ടെക്സ്റ്റ്,
എവിടെ അത് 20 ആണ്.

-T ഔട്ട്പുട്ടിന്റെ കൂടുതൽ വ്യക്തവും ഏകീകൃതവുമായ രൂപം നിർമ്മിക്കപ്പെടുന്നു, അത് കൂടുതൽ അനുയോജ്യമായേക്കാം
നടപടിക്കു ശേഷം.

-v സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിൽ പതിപ്പ് നമ്പറും സമാഹരണ തീയതിയും പ്രിന്റ് ചെയ്യുന്നു, തുടർന്ന് നിർത്തുന്നു.

-w N ഉപയോഗിച്ച പേജിന്റെ വീതി ഇതായി സജ്ജീകരിച്ചിരിക്കുന്നു N നിരകൾ; സ്ഥിരസ്ഥിതി 80 ആണ്.

-- (ഒരു രഹസ്യ ഓപ്‌ഷൻ, ഇൻപുട്ട് സാമ്യത പരിശോധിക്കുന്നയാൾ കാണുന്നതുപോലെ പ്രിന്റ് ചെയ്യുന്നു, ഒപ്പം
പിന്നെ നിർത്തുന്നു.)

ദി -p ഓപ്‌ഷൻ ഫോമിന്റെ വരികളിൽ കലാശിക്കുന്നു
G മെറ്റീരിയലിന്റെ x % ന് F അടങ്ങിയിരിക്കുന്നു
അതായത് F-ന്റെ വാചകത്തിന്റെ x % G-യിലും കാണാം. ഈ ബന്ധം അങ്ങനെയല്ല എന്നത് ശ്രദ്ധിക്കുക
സമമിതി; ഒരു ഫയലിൽ നിന്ന് 100% ടെക്‌സ്‌റ്റ് അടങ്ങിയിരിക്കുന്നത് വാസ്തവത്തിൽ തികച്ചും സാദ്ധ്യമാണ്
മറ്റൊരു ഫയൽ, മറ്റ് ഫയലിൽ ആദ്യ ഫയലിന്റെ ടെക്‌സ്‌റ്റിന്റെ 1% മാത്രമേ ഉള്ളൂ, എങ്കിൽ
അവയുടെ നീളം മതിയായ വ്യത്യാസമുണ്ട്. ദി -P (ക്യാപിറ്റൽ പി) ഓപ്ഷൻ പ്രധാന സംഭാവകനെ കാണിക്കുന്നു
ഓരോ ഫയലും മാത്രം. ഇത് A[1] ... A[n] എന്ന ഒരു കൂട്ടം ഫയലുകളുടെ തിരിച്ചറിയൽ ലളിതമാക്കുന്നു.
ഈ ഫയലുകളുടെ സംയോജനവും നിലവിലുണ്ട്. ഉപയോഗിച്ച് ഒരു പരിധി സജ്ജീകരിക്കാം -t
ഓപ്ഷൻ; അംഗീകൃത വാചകത്തിന്റെ ഗ്രാനുലാരിറ്റി ഇപ്പോഴും നിയന്ത്രിക്കുന്നത് ശ്രദ്ധിക്കുക -r
ഓപ്ഷൻ അല്ലെങ്കിൽ അതിന്റെ സ്ഥിരസ്ഥിതി.

ദി -r ഓപ്‌ഷൻ ഒരു റൺ ഉൾക്കൊള്ളുന്ന "യൂണിറ്റുകളുടെ" എണ്ണം നിയന്ത്രിക്കുന്നു. ആ പ്രോഗ്രാമുകൾക്കായി
പ്രോഗ്രാമിംഗ് ഭാഷാ കോഡ് താരതമ്യം ചെയ്യുക, ഒരു യൂണിറ്റ് പ്രസക്തമായ ഭാഷയിലെ ഒരു ലെക്സിക്കൽ ടോക്കൺ ആണ്;
അഭിപ്രായവും സ്റ്റാൻഡേർഡ് ആമുഖ സാമഗ്രികളും (ഫയൽ ഉൾപ്പെടുത്തൽ മുതലായവ) അവഗണിക്കപ്പെടുകയും എല്ലാ സ്ട്രിംഗുകളും
ഒരേ പോലെ കണക്കാക്കപ്പെടുന്നു. വേണ്ടി സിം_ടെക്സ്റ്റ് ഒരു യൂണിറ്റ് ഒരു "പദം" ആണ്, അത് ഏത് ക്രമമായും നിർവചിക്കപ്പെടുന്നു
ഒന്നോ അതിലധികമോ അക്ഷരങ്ങൾ, അക്കങ്ങൾ അല്ലെങ്കിൽ 127-ൽ കൂടുതലുള്ള പ്രതീകങ്ങൾ (177 ഒക്ടൽ), (ഉൾക്കൊള്ളാൻ)
ä, ø, തുടങ്ങിയ അക്ഷരങ്ങൾ).
സിം_ടെക്സ്റ്റ് സ്പേസ്ഡ്ടെക്സ്റ്റ് സാധാരണ ടെക്സ്റ്റായി സ്വീകരിക്കുന്നു.

ദി -s ഒപ്പം -S ഏത് ഫയലുകൾ താരതമ്യം ചെയ്യണമെന്ന് ഓപ്ഷനുകൾ നിയന്ത്രിക്കുന്നു. ഇൻപുട്ട് ഫയലുകൾ രണ്ടായി തിരിച്ചിരിക്കുന്നു
പുതിയതും പഴയതുമായ ഗ്രൂപ്പുകൾ. ഈ നിയന്ത്രണ ഓപ്ഷനുകളുടെ അഭാവത്തിൽ പ്രോഗ്രാമുകൾ താരതമ്യം ചെയ്യുന്നു
ഫയലുകൾ ഇങ്ങനെ (4 പുതിയ ഫയലുകൾക്കും 6 പഴയ ഫയലുകൾക്കും):
പുതിയ / പഴയ <- ആദ്യ ഫയൽ
1 2 3 4 / 5 6 7 8 9 10
|---------------------------
n 1 | c /
ഇ 2 | cc /
w 3 | ccc /
4 | cccc /
സെക്കന്റ് //////////////////
ഫയൽ -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 8 | cccc /
9 | cccc /
10 | cccc /
ഇവിടെ cs എന്നത് ഫയൽ താരതമ്യങ്ങളെ പ്രതിനിധീകരിക്കുന്നു, കൂടാതെ / പുതിയതും പഴയതും തമ്മിലുള്ള അതിർത്തി നിർണയവും
ഫയലുകൾ.
ഉപയോഗിച്ച് -s ഓപ്ഷൻ ഇത് കുറയ്ക്കുന്നു:
പുതിയ / പഴയ <- ആദ്യ ഫയൽ
1 2 3 4 / 5 6 7 8 9 10
|---------------------------
n 1 | /
ഇ 2 | c /
w 3 | cc /
4 | ccc /
സെക്കന്റ് //////////////////
ഫയൽ -> 5 | cccc /
o 6 | cccc /
l 7 | cccc /
d 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 /
d 8 | cccc /
9 | cccc /
10 | cccc /

പ്രോഗ്രാമുകൾക്ക് വിൻഡോസിന് കീഴിൽ UNICODE ഫയൽ നാമങ്ങൾ കൈകാര്യം ചെയ്യാൻ കഴിയും. ഇത് പ്രകാരം മാത്രമേ പ്രസക്തമാകൂ
-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
ഫയൽ1-ൽ തിരിച്ചറിഞ്ഞ സെഗ്‌മെന്റ് File1:A2 എന്ന ഓപ്ഷൻ വീണ്ടും File3-ലും തിരിച്ചറിയും
ഫയൽ 4. മുകളിലുള്ള ഉദാഹരണത്തിൽ അത് റണ്ണുകൾ നിർമ്മിക്കുന്നു
ഫയൽ1:എ1=ഫയൽ2:എ2
ഫയൽ1:എ1=ഫയൽ3:എ3
ഫയൽ1:എ1=ഫയൽ4:എ4
ഫയൽ2:എ2=ഫയൽ3:എ3
ഫയൽ2:എ2=ഫയൽ4:എ4
ഫയൽ3:എ3=ഫയൽ4:എ4
ആകെ ½N(N-1) റൺസ്.

TIME, ഒപ്പം SPACE ആവശ്യകതകൾ

എല്ലാ ആന്തരിക പ്രക്രിയകളുടെയും (ഏതാണ്ട്) സമയ ആവശ്യകതകൾ നിലനിർത്താൻ ശ്രദ്ധിച്ചിട്ടുണ്ട്.
വിവിധ പട്ടികകൾ ഉപയോഗിച്ച് ഇൻപുട്ട് ഫയലുകളുടെ നീളത്തിൽ രേഖീയമായി. എന്നിരുന്നാലും, ഉണ്ടെങ്കിൽ
ടേബിളുകൾക്ക് മതിയായ മെമ്മറി ഇല്ല, അവ അപ്രധാനമായ ക്രമത്തിൽ നിരസിച്ചു, അതിനടിയിൽ
വ്യവസ്ഥകൾ അൽഗോരിതങ്ങൾ അവയുടെ ചതുരാകൃതിയിലുള്ള സ്വഭാവത്തിലേക്ക് മടങ്ങുന്നു.

സമയ ആവശ്യകതകൾ ഫയലുകളുടെ എണ്ണത്തിൽ ക്വാഡ്രാറ്റിക് ആണ്. ഇതിനർത്ഥം, ഉദാഹരണത്തിന്,
ഒരു 64 MB ഫയൽ 8000 8 kB ഫയലുകളേക്കാൾ വളരെ വേഗത്തിൽ പ്രോസസ്സ് ചെയ്യുന്നു.

ഇൻപുട്ടിലെ ഓരോ ടോക്കണിനും പ്രോഗ്രാമിന് 6 ബൈറ്റുകൾ മെമ്മറി ആവശ്യമാണ്; ഓരോ പുതിയ ലൈനിലും 2 ബൈറ്റുകൾ
(ശതമാനം ചെയ്യുമ്പോൾ അല്ല); കണ്ടെത്തിയ ഓരോ റണ്ണിനും ഏകദേശം 76 ബൈറ്റുകൾ.

ഉദാഹരണങ്ങൾ

വിളി
sim_c *.c
ഡയറക്ടറിയിൽ തനിപ്പകർപ്പ് കോഡ് ഹൈലൈറ്റ് ചെയ്യുന്നു. (ജനറേറ്റ് ചെയ്ത ഫയലുകൾ നീക്കംചെയ്യുന്നത് ഉപയോഗപ്രദമാണ്
ആദ്യം.) ഒരു കോൾ
sim_c -f -F *.c
അവരെ കൂടുതൽ കൃത്യമായി സൂചിപ്പിക്കാൻ കഴിയും.

ഒരു വിളി
sim_text -e -p -s പുതിയത്/* / പഴയത്/*
ഓരോ ഫയലും പുതിയ/* എന്നതിലെ ഓരോ ഫയലും പുതിയ/* പഴയ/* എന്നതിലെ ഓരോ ഫയലുമായി താരതമ്യം ചെയ്യുന്നു, കൂടാതെ ഏതെങ്കിലും ജോഡിയിൽ കൂടുതൽ ഉണ്ടെങ്കിൽ അത്
20% പൊതുവായി, ആ വസ്തുത റിപ്പോർട്ട് ചെയ്യുന്നു. സാധാരണയായി 30% അല്ലെങ്കിൽ അതിൽ കൂടുതലുള്ള സാമ്യം പ്രധാനമാണ്;
20% ൽ താഴെ എന്നത് ഒരുപക്ഷേ യാദൃശ്ചികമായിരിക്കാം; ഇടയ്ക്ക് സംശയാസ്പദവുമാണ്.

ഒരു വിളി
sim_text -e -n -s -r100 new/* "|" പഴയ/*
ഒരേ ഫയലുകൾ താരതമ്യം ചെയ്യുന്നു, വലിയ പൊതുവായ സെഗ്‌മെന്റുകൾ റിപ്പോർട്ടുചെയ്യുന്നു. (ദി | ഒരു ആയി ഉപയോഗിക്കാം
പകരം സെപ്പറേറ്റർ / സിസ്റ്റങ്ങളിൽ / ഒരു കമാൻഡ്-ലൈൻ പാരാമീറ്റർ മന്ഗിൾ ചെയ്യപ്പെടുന്നതിനാൽ
കമാൻഡ് ഇന്റർപ്രെറ്റർ.)

മോഷണം കണ്ടെത്തുന്നതിന് രണ്ട് സമീപനങ്ങളും നല്ലതാണ്.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് sim_m2 ഓൺലൈനായി ഉപയോഗിക്കുക