16GB സൗജന്യ ഇടമുള്ള ഒരു ടാബ്‌ലെറ്റ് വഴി 4GB ടോറന്റ് ഡൗൺലോഡ് ചെയ്യുന്നു

ചുമതല:

ഇന്റർനെറ്റ് ഇല്ലാതെ ഒരു പിസി ഉണ്ട്, എന്നാൽ യുഎസ്ബി വഴി ഫയൽ കൈമാറാൻ സാധിക്കും. ഈ ഫയൽ ട്രാൻസ്ഫർ ചെയ്യാൻ കഴിയുന്ന ഇന്റർനെറ്റ് ഉള്ള ഒരു ടാബ്‌ലെറ്റ് ഉണ്ട്. നിങ്ങളുടെ ടാബ്‌ലെറ്റിൽ ആവശ്യമായ ടോറന്റ് ഡൗൺലോഡ് ചെയ്യാം, എന്നാൽ മതിയായ ഇടമില്ല. ടോറന്റിലെ ഫയൽ ഒന്ന് വലുതാണ്.

പരിഹാരത്തിലേക്കുള്ള വഴി:

ഞാൻ ഡൗൺലോഡ് ചെയ്യാൻ ടോറന്റ് ആരംഭിച്ചു. ശൂന്യമായ ഇടം ഏതാണ്ട് ഇല്ലാതായപ്പോൾ, ഞാൻ ഡൗൺലോഡ് താൽക്കാലികമായി നിർത്തി. ഞാൻ ടാബ്‌ലെറ്റ് പിസിയിലേക്ക് കണക്റ്റുചെയ്‌ത് ഫയൽ ടാബ്‌ലെറ്റിൽ നിന്ന് പിസിയിലേക്ക് നീക്കി. ഞാൻ താൽക്കാലികമായി നിർത്തി, എന്നെ അത്ഭുതപ്പെടുത്തിക്കൊണ്ട് ഫയൽ വീണ്ടും സൃഷ്ടിക്കപ്പെട്ടു, ഒന്നും സംഭവിക്കാത്തതുപോലെ ടോറന്റ് ഡൗൺലോഡ് തുടർന്നു.

ടോറന്റ് ക്ലയന്റ് അത് സ്വീകരിച്ച ഡാറ്റ എഴുതുന്ന ഫയലിലേക്ക് വിരളമായ ഫ്ലാഗ് സജ്ജീകരിക്കുന്നു എന്ന വസ്തുത കാരണം, സിസ്റ്റം ഒരേസമയം 16 ജിബി റിസർവ് ചെയ്യാൻ ശ്രമിക്കുന്നില്ല, കൂടാതെ 4 ജിബിക്ക് അപ്പുറമുള്ള ഒരു ഫയലിലേക്ക് എഴുതാൻ ശ്രമിക്കുമ്പോൾ ഒരു പിശക് സംഭവിക്കില്ല.

നടപടിക്രമം നാല് തവണ ആവർത്തിച്ചതിന് ശേഷം, ഒരേ ടോറന്റിന്റെ വിവിധ ഭാഗങ്ങൾ അടങ്ങിയ നാല് ഫയലുകൾ എന്റെ പിസിയിൽ ലഭിച്ചു. ഇനി അവരെ ഒന്നിപ്പിക്കുക മാത്രമാണ് ബാക്കിയുള്ളത്. നടപടിക്രമം അടിസ്ഥാനപരമായി ലളിതമാണ്. നാല് ഫയലുകളിലൊന്നിൽ തന്നിരിക്കുന്ന സ്ഥാനത്ത് സീറോ ബൈറ്റുകൾ നിലവിലുണ്ടെങ്കിൽ അത് മറ്റൊരു മൂല്യം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കേണ്ടതുണ്ട്.

ഇത്രയും ലളിതമായ ഒരു പ്രോഗ്രാം ഇന്റർനെറ്റിൽ വേണമെന്ന് എനിക്ക് തോന്നി. ഇത്തരമൊരു പ്രശ്നം ആരും നേരിട്ടിട്ടില്ലേ? എന്നാൽ ഏതൊക്കെ കീവേഡുകൾ തിരയണമെന്ന് എനിക്കറിയില്ലെന്ന് ഞാൻ മനസ്സിലാക്കി. അതിനാൽ, ഈ ടാസ്‌ക്കിനായി ഞാൻ പെട്ടെന്ന് ഒരു ലുവാ സ്‌ക്രിപ്റ്റ് സൃഷ്‌ടിച്ചു, ഇപ്പോൾ ഞാൻ അത് ഒപ്റ്റിമൈസ് ചെയ്‌തു. ഇതാണ് ഞാൻ പങ്കിടാൻ ആഗ്രഹിക്കുന്നത്.

ഭാഗങ്ങളായി ടോറന്റ് ഡൗൺലോഡ് ചെയ്യുന്നു

1. ആദ്യ ഉപകരണത്തിൽ ടോറന്റ് ഡൗൺലോഡ് ചെയ്യാൻ ആരംഭിക്കുക
2. റോം നിറയുന്നത് വരെ കാത്തിരിക്കുക
3. ഡൗൺലോഡ് താൽക്കാലികമായി നിർത്തുക
4. രണ്ടാമത്തെ ഉപകരണത്തിലേക്ക് ഫയൽ കൈമാറുകയും ഫയലിന്റെ പേരിൽ ഒരു നമ്പർ ചേർക്കുകയും ചെയ്യുക
5. ഫയൽ പൂർണ്ണമായി ഡൗൺലോഡ് ചെയ്യുന്നതുവരെ ഞങ്ങൾ ആദ്യ പോയിന്റിലേക്ക് മടങ്ങുന്നു

ഭാഗങ്ങൾ ഒരു ഫയലിലേക്ക് ലയിപ്പിക്കുന്നു

അവസാന ഭാഗം ലഭിച്ച ശേഷം, അവ ഒരു മുഴുവൻ ഫയലിലേക്ക് ശേഖരിക്കേണ്ടത് ആവശ്യമാണ്.

ചുമതല ലളിതമാണ്:

1. എല്ലാ ഭാഗങ്ങളും ഒരേസമയം വായിക്കുന്നു
2. ചില ഭാഗങ്ങളിൽ സ്ഥാനം പൂജ്യം ബൈറ്റല്ലെങ്കിൽ, ഞങ്ങൾ അത് ഔട്ട്പുട്ടിലേക്ക് എഴുതുന്നു, അല്ലെങ്കിൽ പൂജ്യം എഴുതുന്നു

ഫംഗ്ഷൻ merge_part ത്രെഡുകളുടെ ഒരു നിര സ്വീകരിക്കുന്നു streams_in വലിപ്പത്തിന്റെ ഒരു ഭാഗം വായിക്കുന്നു buffer_length വിവിധ ത്രെഡുകളിൽ നിന്നുള്ള ഭാഗങ്ങൾ ലയിപ്പിച്ചതിന്റെ ഫലം നൽകുന്നു.

function merge_part(streams_in, buffer_length)
    local out_part
    for _, stream in ipairs(streams_in) do
        local in_part = stream:read(buffer_length)

        if not out_part then
            out_part = in_part -- просто копируем часть из первого файла
        elseif in_part and #in_part > 0 then

            if #out_part < #in_part then
                out_part, in_part = in_part, out_part
            end

            if out_part ~= in_part  -- данные различаются
                and in_part:find("[^ ]")   -- есть данные в in_part
                and out_part:find(" ", 1, true) -- есть пустые места в out_part
            then 
                local find_index = 1
--[[

ഫംഗ്ഷൻ string.gsub ടാസ്ക്കിന് അനുയോജ്യമാണ്, കാരണം അത് പൂജ്യങ്ങൾ നിറഞ്ഞ കഷണങ്ങൾ കണ്ടെത്തുകയും അതിന് നൽകിയിരിക്കുന്നത് നൽകുകയും ചെയ്യും.

--]]
                out_part = out_part:gsub(" +", function(zero_string)

                    if #in_part < find_index then
                        return -- не на что менять
                    end
--[[

string.gsub പൊരുത്തം കണ്ടെത്തിയ സ്ഥാനം അറിയിക്കുന്നില്ല. അതിനാൽ, സ്ഥാനത്തിനായി ഞങ്ങൾ ഒരു സമാന്തര തിരയൽ നടത്തുന്നു zero_string ഫംഗ്ഷൻ ഉപയോഗിച്ച് string.find. ആദ്യത്തെ സീറോ ബൈറ്റ് കണ്ടെത്തിയാൽ മതി.

--]]
                    local start_index = out_part:find(" ", find_index, true)
                    find_index = start_index + #zero_string

--[[

ഇപ്പോൾ അകത്തുണ്ടെങ്കിൽ in_part എന്നതിനുള്ള ഡാറ്റയുണ്ട് out_part അവ പകർത്തുക.

--]]
                    if #in_part >= start_index then
                        local end_index = start_index + #zero_string - 1
--[[

നിന്ന് മുറിക്കുക in_part പൂജ്യങ്ങളുടെ ക്രമവുമായി ബന്ധപ്പെട്ട ഭാഗം.

--]]
                        local part = in_part:sub(start_index, end_index)

                        if (part:byte(1) ~= 0) or part:find("[^ ]") then
--[[

В part ഡാറ്റ ഉണ്ട്.

--]]
                            if #part == #zero_string then
                                return part
                            else
--[[

part പൂജ്യങ്ങളുടെ ഒരു ശ്രേണിയേക്കാൾ കുറവായി മാറി. നമുക്ക് അത് അവരോടൊപ്പം നൽകാം.

--]]
                                return part..zero_string:sub(1, end_index - #in_part)
                            end
                        end
                    end
                end)
            end
        end
    end
    return out_part
end

തീരുമാനം

അങ്ങനെ, ഞങ്ങൾക്ക് ഈ ഫയൽ ഒരു പിസിയിൽ ഡൗൺലോഡ് ചെയ്യാനും കൂട്ടിച്ചേർക്കാനും കഴിഞ്ഞു. ലയനത്തിനുശേഷം, ഞാൻ ടാബ്‌ലെറ്റിൽ നിന്ന് ടോറന്റ് ഫയൽ പുറത്തെടുത്തു. ഞാൻ എന്റെ പിസിയിൽ ഒരു ടോറന്റ് ക്ലയന്റ് ഇൻസ്റ്റാൾ ചെയ്യുകയും അതുപയോഗിച്ച് ഫയൽ പരിശോധിക്കുകയും ചെയ്തു.

ടാബ്‌ലെറ്റിൽ അവസാനമായി ഡൗൺലോഡ് ചെയ്‌ത ഭാഗം വിതരണത്തിൽ അവശേഷിക്കുന്നു, എന്നാൽ ഇതിന് മുമ്പ് ഭാഗങ്ങൾ വീണ്ടും പരിശോധിക്കുന്നത് പ്രവർത്തനക്ഷമമാക്കുകയും ഫയൽ വീണ്ടും ഡൗൺലോഡ് ചെയ്യാതിരിക്കാൻ അൺചെക്ക് ചെയ്യുകയും വേണം.

ഉപയോഗിച്ചത്:

1. ഒരു ടാബ്‌ലെറ്റിൽ ഫ്ലഡ് ടോറന്റ് ക്ലയന്റ്.
2. പിസിയിലെ ടോറന്റ് ക്ലയന്റ് qBittorent.
3. ലുവാ സ്ക്രിപ്റ്റ്

അവലംബം: www.habr.com