16GB ਖਾਲੀ ਥਾਂ ਦੇ ਨਾਲ ਟੈਬਲੇਟ ਰਾਹੀਂ 4GB ਟੋਰੈਂਟ ਡਾਊਨਲੋਡ ਕਰਨਾ

ਚੁਣੌਤੀ:

ਇੰਟਰਨੈਟ ਤੋਂ ਬਿਨਾਂ ਇੱਕ ਪੀਸੀ ਹੈ, ਪਰ USB ਦੁਆਰਾ ਫਾਈਲ ਟ੍ਰਾਂਸਫਰ ਕਰਨਾ ਸੰਭਵ ਹੈ. ਇੰਟਰਨੈਟ ਦੇ ਨਾਲ ਇੱਕ ਟੈਬਲੇਟ ਹੈ ਜਿਸ ਤੋਂ ਇਸ ਫਾਈਲ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਆਪਣੀ ਟੈਬਲੇਟ 'ਤੇ ਲੋੜੀਂਦਾ ਟੋਰੈਂਟ ਡਾਊਨਲੋਡ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਇੱਥੇ ਲੋੜੀਂਦੀ ਖਾਲੀ ਥਾਂ ਨਹੀਂ ਹੈ। ਟੋਰੈਂਟ ਵਿੱਚ ਫਾਈਲ ਇੱਕ ਅਤੇ ਵੱਡੀ ਹੈ।

ਹੱਲ ਲਈ ਮਾਰਗ:

ਮੈਂ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਟੋਰੈਂਟ ਸ਼ੁਰੂ ਕੀਤਾ। ਜਦੋਂ ਖਾਲੀ ਥਾਂ ਲਗਭਗ ਖਤਮ ਹੋ ਗਈ ਸੀ, ਮੈਂ ਡਾਊਨਲੋਡ ਨੂੰ ਰੋਕ ਦਿੱਤਾ। ਮੈਂ ਟੈਬਲੇਟ ਨੂੰ ਪੀਸੀ ਨਾਲ ਕਨੈਕਟ ਕੀਤਾ ਅਤੇ ਫਾਈਲ ਨੂੰ ਟੈਬਲੇਟ ਤੋਂ ਪੀਸੀ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤਾ। ਮੈਂ ਰੁਕਿਆ ਅਤੇ ਮੇਰੇ ਹੈਰਾਨੀ ਨਾਲ ਫਾਈਲ ਦੁਬਾਰਾ ਬਣ ਗਈ ਅਤੇ ਟੋਰੈਂਟ ਨੇ ਇਸ ਤਰ੍ਹਾਂ ਡਾਉਨਲੋਡ ਕਰਨਾ ਜਾਰੀ ਰੱਖਿਆ ਜਿਵੇਂ ਕੁਝ ਹੋਇਆ ਹੀ ਨਹੀਂ ਸੀ।

ਇਸ ਤੱਥ ਦੇ ਕਾਰਨ ਕਿ ਟੋਰੈਂਟ ਕਲਾਇੰਟ ਸਪਾਰਸ ਫਲੈਗ ਨੂੰ ਫਾਈਲ ਵਿੱਚ ਸੈਟ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਇਹ ਪ੍ਰਾਪਤ ਡੇਟਾ ਨੂੰ ਲਿਖਦਾ ਹੈ, ਸਿਸਟਮ ਇੱਕ ਵਾਰ ਵਿੱਚ 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

ਸਿੱਟਾ

ਇਸ ਤਰ੍ਹਾਂ, ਅਸੀਂ ਇਸ ਫਾਈਲ ਨੂੰ ਪੀਸੀ 'ਤੇ ਡਾਊਨਲੋਡ ਅਤੇ ਅਸੈਂਬਲ ਕਰਨ ਦੇ ਯੋਗ ਸੀ। ਅਭੇਦ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਮੈਂ ਟੈਬਲੈੱਟ ਤੋਂ ਟੋਰੈਂਟ ਫਾਈਲ ਨੂੰ ਬਾਹਰ ਕੱਢ ਲਿਆ। ਮੈਂ ਆਪਣੇ ਪੀਸੀ 'ਤੇ ਇੱਕ ਟੋਰੈਂਟ ਕਲਾਇੰਟ ਸਥਾਪਿਤ ਕੀਤਾ ਅਤੇ ਇਸ ਨਾਲ ਫਾਈਲ ਦੀ ਜਾਂਚ ਕੀਤੀ।

ਟੈਬਲੇਟ 'ਤੇ ਆਖਰੀ ਡਾਉਨਲੋਡ ਕੀਤੇ ਹਿੱਸੇ ਨੂੰ ਵੰਡ 'ਤੇ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਤੁਹਾਨੂੰ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਭਾਗਾਂ ਦੀ ਮੁੜ-ਚੈਕਿੰਗ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਫਾਈਲ ਨੂੰ ਅਨਚੈਕ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਤਾਂ ਜੋ ਇਹ ਦੁਬਾਰਾ ਡਾਊਨਲੋਡ ਨਾ ਹੋਵੇ।

ਵਰਤਿਆ:

1. ਇੱਕ ਟੈਬਲੇਟ 'ਤੇ ਫਲੱਡ ਟੋਰੈਂਟ ਕਲਾਇੰਟ।
2. PC 'ਤੇ ਟੋਰੈਂਟ ਕਲਾਇੰਟ qBittorent।
3. ਲੂਆ ਸਕ੍ਰਿਪਟ

ਸਰੋਤ: www.habr.com