16GB ખાલી જગ્યા સાથે ટેબ્લેટ દ્વારા 4GB ટોરેન્ટ ડાઉનલોડ કરી રહ્યું છે

એક કાર્ય:

ઇન્ટરનેટ વિના પીસી છે, પરંતુ યુએસબી દ્વારા ફાઇલ સ્થાનાંતરિત કરવું શક્ય છે. ઇન્ટરનેટ સાથે એક ટેબ્લેટ છે જેમાંથી આ ફાઇલ ટ્રાન્સફર કરી શકાય છે. તમે તમારા ટેબ્લેટ પર જરૂરી ટોરેન્ટ ડાઉનલોડ કરી શકો છો, પરંતુ ત્યાં પૂરતી ખાલી જગ્યા નથી. ટૉરેંટની ફાઇલ એક અને મોટી છે.

ઉકેલનો માર્ગ:

મેં ડાઉનલોડ કરવા માટે ટોરેન્ટ શરૂ કર્યું. જ્યારે ખાલી જગ્યા લગભગ જતી રહી, ત્યારે મેં ડાઉનલોડને થોભાવ્યું. મેં ટેબલેટને PC સાથે કનેક્ટ કર્યું અને ફાઇલને ટેબલેટમાંથી PC પર ખસેડી. મેં થોભાવ્યું અને મારા આશ્ચર્યની વાત એ છે કે ફાઈલ ફરીથી બનાવવામાં આવી અને ટૉરેંટ ડાઉનલોડ કરવાનું ચાલુ રાખ્યું જાણે કંઈ થયું જ ન હોય.

હકીકત એ છે કે ટોરેન્ટ ક્લાયંટ તે ફાઇલમાં સ્પાર્સ ફ્લેગ સેટ કરે છે જેમાં તે પ્રાપ્ત ડેટા લખે છે, સિસ્ટમ એક જ સમયે 16GB આરક્ષિત કરવાનો પ્રયાસ કરતી નથી અને 4GB થી વધુની ફાઇલ પર લખવાનો પ્રયાસ કરતી વખતે ભૂલ થશે નહીં.

પ્રક્રિયાને ચાર વખત પુનરાવર્તિત કર્યા પછી, મને મારા PC પર એક જ ટોરેન્ટના જુદા જુદા ભાગો ધરાવતી ચાર ફાઇલો મળી. હવે જે બાકી છે તે તેમને એકસાથે મૂકવાનું છે. પ્રક્રિયા આવશ્યકપણે સરળ છે. તમારે શૂન્ય બાઇટ્સને અન્ય મૂલ્ય સાથે બદલવાની જરૂર છે જો તે ચાર ફાઇલોમાંથી એકમાં આપેલ સ્થાન પર હાજર હોય.

મને લાગ્યું કે આટલો સરળ પ્રોગ્રામ ઇન્ટરનેટ પર હોવો જોઈએ. શું કોઈએ ક્યારેય આવી સમસ્યાનો સામનો કરવો પડ્યો નથી? પરંતુ મને સમજાયું કે મને એ પણ ખબર નથી કે તેના માટે કયા કીવર્ડ્સ શોધવા જોઈએ. તેથી, મેં આ કાર્ય માટે ઝડપથી લુઆ સ્ક્રિપ્ટ બનાવી છે અને હવે મેં તેને ઑપ્ટિમાઇઝ કરી છે. આ હું શેર કરવા માંગુ છું.

ટોરેન્ટને ભાગોમાં ડાઉનલોડ કરી રહ્યું છે

1. પ્રથમ ઉપકરણ પર ટોરેન્ટ ડાઉનલોડ કરવાનું શરૂ કરો
2. ROM ભરાય ત્યાં સુધી રાહ જુઓ
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

નિષ્કર્ષ

આમ, અમે આ ફાઇલને PC પર ડાઉનલોડ અને એસેમ્બલ કરવામાં સક્ષમ હતા. વિલીનીકરણ પછી, મેં ટેબ્લેટમાંથી ટોરેન્ટ ફાઇલ ખેંચી. મેં મારા PC પર ટોરેન્ટ ક્લાયંટ ઇન્સ્ટોલ કર્યું છે અને તેની સાથે ફાઇલ તપાસી છે.

ટેબ્લેટ પર છેલ્લો ડાઉનલોડ કરેલ ભાગ વિતરણ પર છોડી શકાય છે, પરંતુ તમારે આ પહેલા ભાગોની પુનઃ-ચેકીંગ સક્ષમ કરવાની જરૂર છે અને ફાઇલને અનચેક કરવાની જરૂર છે જેથી કરીને તે ફરીથી ડાઉનલોડ ન થાય.

વપરાયેલ:

1. ટેબ્લેટ પર ફ્લડ ટોરેન્ટ ક્લાયંટ.
2. PC પર ટોરેન્ટ ક્લાયંટ qBittorent.
3. લુઆ સ્ક્રિપ્ટ

સોર્સ: www.habr.com