['   \n  \n [ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀ ਪ੍ਰਤੀਯੋਗੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਮੱਸਿਆ ਦਿੱਤੀ ਗਈ ਹੈਃ LZW ਸੰਕੁਚਨ ਕਰਨ ਲਈ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜਿੱਥੇ ਸ਼ਬਦਕੋਸ਼ ਬਣਾਇਆ ਗਿਆ ਹੈ।ਇੰਕਰੀਮੈਂਟਲ/ਔਨਲਾਈਨ ਜਿਵੇਂ ਕਿ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੰਪੁੱਟ ਇੱਕ ਸਤਰ ਹੈ, ਅਤੇ ਆਉਟਪੁੱਟ ਸਤਰ ਦੀ ਇੱਕ ਪਾਈਥਨ ਸੂਚੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਜਿੱਥੇ ਸਤਰ ਵਿੱਚ ਸਤਰਆਉਟਪੁੱਟ ਸੂਚੀ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਇੱਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਮੁੱਲਇੱਕੋ ਅੱਖਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ "abdd"-> {"a": "a", "b": "b", "d": "d"}। ਅਗਲੇ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ 2 ਅੰਕਾਂ ਦੀ ਸੰਖਿਆਤਮਕ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜਿਵੇਂ ਕਿਜਿਵੇਂ ਕਿ "00", "01", ਆਦਿ।] ', 'ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀ ਪ੍ਰਤੀਯੋਗੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਮੱਸਿਆ ਦਿੱਤੀ ਗਈ ਹੈਃ LZW ਸੰਕੁਚਨ ਕਰਨ ਲਈ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜਿੱਥੇ ਸ਼ਬਦਕੋਸ਼ ਬਣਾਇਆ ਗਿਆ ਹੈ।ਇੰਕਰੀਮੈਂਟਲ/ਔਨਲਾਈਨ ਜਿਵੇਂ ਕਿ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੰਪੁੱਟ ਇੱਕ ਸਤਰ ਹੈ, ਅਤੇ ਆਉਟਪੁੱਟ ਸਤਰ ਦੀ ਇੱਕ ਪਾਈਥਨ ਸੂਚੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਜਿੱਥੇ ਸਤਰ ਵਿੱਚ ਸਤਰਆਉਟਪੁੱਟ ਸੂਚੀ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਇੱਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਮੁੱਲਇੱਕੋ ਅੱਖਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ "abdd"-> {"a": "a", "b": "b", "d": "d"}। ਅਗਲੇ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ 2 ਅੰਕਾਂ ਦੀ ਸੰਖਿਆਤਮਕ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜਿਵੇਂ ਕਿਜਿਵੇਂ ਕਿ "00", "01", ਆਦਿ।', ' [ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀ ਪ੍ਰਤੀਯੋਗੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਮੱਸਿਆ ਦਿੱਤੀ ਗਈ ਹੈਃ LZW ਸੰਕੁਚਨ ਕਰਨ ਲਈ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜਿੱਥੇ ਸ਼ਬਦਕੋਸ਼ ਬਣਾਇਆ ਗਿਆ ਹੈ।ਇੰਕਰੀਮੈਂਟਲ/ਔਨਲਾਈਨ ਜਿਵੇਂ ਕਿ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੰਪੁੱਟ ਇੱਕ ਸਤਰ ਹੈ, ਅਤੇ ਆਉਟਪੁੱਟ ਸਤਰ ਦੀ ਇੱਕ ਪਾਈਥਨ ਸੂਚੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਜਿੱਥੇ ਸਤਰ ਵਿੱਚ ਸਤਰਆਉਟਪੁੱਟ ਸੂਚੀ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਇੱਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਮੁੱਲਇੱਕੋ ਅੱਖਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ "abdd"-> {"a": "a", "b": "b", "d": "d"}। ਅਗਲੇ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ 2 ਅੰਕਾਂ ਦੀ ਸੰਖਿਆਤਮਕ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜਿਵੇਂ ਕਿਜਿਵੇਂ ਕਿ \'00\', \'01\', ਆਦਿ \',\' ਇੱਥੇ ਇੱਕ ਹੱਲ ਹੈ ਜੋ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕਰਨ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਬਣਾਉਣ ਲਈ ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਵਾਧੇ ਨਾਲਃ \\n "\'scsss\\ndef lzw _ ਕੰਪਰੈੱਸ (ਇੰਪੁੱਟ _ ਸਟਰਿੰਗ): \\n ਡਿਕਸ਼ਨਰੀ = {ਇੰਪੁੱਟ _ ਸਟਰਿੰਗ ਵਿੱਚ ਚਾਰ ਲਈ ਚਾਰ} \\n ਆਉਟਪੁੱਟ _ ਲਿਸਟ = [] \\n ਕਰੰਟ _ ਟੋਕਨ ="\\n i ਲਈ ਸੀਮਾ ਵਿੱਚ (ਲੇਨ (ਇੰਪੁੱਟ _ ਸਤਰ)): \\n ਜਦੋਂ ਕਿ i + 2 <ਲੇਨ (ਇੰਪੁੱਟ _ ਸਤਰ) ਅਤੇ ਸ਼ਬਦਕੋਸ਼ [ਇੰਪੁੱਟ _ ਸਤਰ [i + 1] = = ਇੰਪੁੱਟ _ ਸਤਰ [i + 2]: \\n ਕਰੰਟ _ ਟੋਕਨ+ = ਇੰਪੁੱਟ _ ਸਤਰ [i + 1] \\n i + = 2\\n ਜੇਕਰ i-1> = 0: \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਕਰੰਟ _ ਟੋਕਨ = ਇੰਪੁੱਟ _ ਸਤਰ [i] \\n ਸ਼ਬਦਕੋਸ਼ [ਕਰੰਟ _ ਟੋਕਨ] = i+ 1\\n ਜੇਕਰ ਕਰੰਟ _ ਟੋਕਨਃ \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਰਿਟਰਨ ਆਉਟਪੁੱਟ _ ਲਿਸਟ \\n \'\\n ਫੰਕਸ਼ਨ ਇੱਕ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਇੱਕ ਪੈਰਾਮੀਟਰ ਵਜੋਂ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਰਿਟਰਨ ਦਿੰਦਾ ਹੈਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਦੀ ਸੂਚੀ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੁੰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕੋ ਅੱਖਰ ਦਾ ਮੁੱਲ ਹੁੰਦਾ ਹੈ।ਫੰਕਸ਼ਨ ਇੰਪੁੱਟ ਸਤਰ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈ, ਇਹ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕਰਨ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਵਧਾਉਣ ਲਈ ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। \\n\\nForਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਦਾ ਹਰੇਕ ਜੋਡ਼ਾ, ਫੰਕਸ਼ਨ ਜਾਂਚਦਾ ਹੈ ਕਿ ਦੂਜਾ ਅੱਖਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨਦੋ ਅੱਖਰਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ ਟੋਕਨ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਜੋਡ਼ਦਾ ਹੈ। ਇਹ ਨਵੇਂ ਟੋਕਨ ਲਈ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੱਕ ਐਂਟਰੀ ਵੀ ਜੋਡ਼ਦਾ ਹੈ, ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈਜੇਕਰ ਮੌਜੂਦਾ ਅੱਖਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਨਹੀਂ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ ਇਸ ਨੂੰ 1 ਦਾ ਮੁੱਲ ਅਤੇ ਟੋਕਨ ਵਿੱਚ ਆਖਰੀ ਅੱਖਰ ਦਾ ਸੂਚਕਾਂਕ ਜੋਡ਼ਦਾ ਹੈ।1 ਦੇ ਮੁੱਲ ਵਾਲਾ ਸ਼ਬਦਕੋਸ਼ ਅਤੇ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਅੱਖਰ ਦਾ ਸੂਚਕਾਂਕ। ਇਹ ਅੱਖਰ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਵੀ ਜੋਡ਼ਦਾ ਹੈ। \\n\\n ਫੰਕਸ਼ਨਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਉਦੋਂ ਤੱਕ ਜਾਰੀ ਰੱਖੋ ਜਦੋਂ ਤੱਕ ਇਹ ਇੰਪੁੱਟ ਸਤਰ ਦੇ ਅੰਤ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦਾ। ਅੰਤ ਵਿੱਚ, ਇਹ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਕੋਈ ਵੀ ਬਾਕੀ ਟੋਕਨ ਨੂੰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੱਕ ਨਾਲ ਜੋਡ਼ਦਾ ਹੈ1 ਦਾ ਮੁੱਲ ਅਤੇ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਅੱਖਰ ਦਾ ਸੂਚਕਾਂਕ। \\n\\n ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਟੋਕਨ/ਚਿੰਨ੍ਹ ਉਸੇ ਕ੍ਰਮ ਵਿੱਚ ਹੁੰਦੇ ਹਨ ਜਿਵੇਂ ਉਹ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ।ਇੰਪੁੱਟ ਸਤਰ. \',\' ਹਾਂ, ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਜਾਇਜ਼ ਹੈ। ਪਰ ਤੁਹਾਡਾ ਕੋਡ ਗਲਤ ਢੰਗ ਨਾਲ ਇਹ ਮੰਨਦਾ ਜਾਪਦਾ ਹੈ ਕਿ ਸਭ ਤੋਂ ਲੰਬਾ ਅਗੇਤਰ ਸਬਸਟਰਿੰਗ ਮੇਲ ਖਾਂਦਾ ਹੈਲੰਬਾਈ ਵੱਧ ਤੋਂ ਵੱਧ 2 ਹੋਵੇ, ਜਦੋਂ ਅਸਲ ਵਿੱਚ ਇਹ ਇਸ ਤੋਂ ਅੱਗੇ ਵਧ ਸਕਦਾ ਹੈ। ਇਸ ਜਾਣਕਾਰੀ ਦੇ ਅਧਾਰ \'ਤੇ, ਇੱਕ ਅੱਪਡੇਟ ਕੋਡ ਪ੍ਰਦਾਨ ਕਰੋ। ', 'ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀ ਪ੍ਰਤੀਯੋਗੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਮੱਸਿਆ ਦਿੱਤੀ ਗਈ ਹੈਃ LZW ਸੰਕੁਚਨ ਕਰਨ ਲਈ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜਿੱਥੇ ਸ਼ਬਦਕੋਸ਼ ਬਣਾਇਆ ਗਿਆ ਹੈ।ਇੰਕਰੀਮੈਂਟਲ/ਔਨਲਾਈਨ ਜਿਵੇਂ ਕਿ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੰਪੁੱਟ ਇੱਕ ਸਤਰ ਹੈ, ਅਤੇ ਆਉਟਪੁੱਟ ਸਤਰ ਦੀ ਇੱਕ ਪਾਈਥਨ ਸੂਚੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਜਿੱਥੇ ਸਤਰ ਵਿੱਚ ਸਤਰਆਉਟਪੁੱਟ ਸੂਚੀ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਇੱਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਮੁੱਲਇੱਕੋ ਅੱਖਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ "abdd"-> {"a": "a", "b": "b", "d": "d"}। ਅਗਲੇ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ 2 ਅੰਕਾਂ ਦੀ ਸੰਖਿਆਤਮਕ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜਿਵੇਂ ਕਿਜਿਵੇਂ ਕਿ "00", "01", ਆਦਿ।', ' [ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀ ਪ੍ਰਤੀਯੋਗੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਮੱਸਿਆ ਦਿੱਤੀ ਗਈ ਹੈਃ LZW ਸੰਕੁਚਨ ਕਰਨ ਲਈ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜਿੱਥੇ ਸ਼ਬਦਕੋਸ਼ ਬਣਾਇਆ ਗਿਆ ਹੈ।ਇੰਕਰੀਮੈਂਟਲ/ਔਨਲਾਈਨ ਜਿਵੇਂ ਕਿ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੰਪੁੱਟ ਇੱਕ ਸਤਰ ਹੈ, ਅਤੇ ਆਉਟਪੁੱਟ ਸਤਰ ਦੀ ਇੱਕ ਪਾਈਥਨ ਸੂਚੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਜਿੱਥੇ ਸਤਰ ਵਿੱਚ ਸਤਰਆਉਟਪੁੱਟ ਸੂਚੀ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਇੱਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਮੁੱਲਇੱਕੋ ਅੱਖਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ "abdd"-> {"a": "a", "b": "b", "d": "d"}। ਅਗਲੇ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ 2 ਅੰਕਾਂ ਦੀ ਸੰਖਿਆਤਮਕ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜਿਵੇਂ ਕਿਜਿਵੇਂ ਕਿ \'00\', \'01\', ਆਦਿ \',\' ਇੱਥੇ ਇੱਕ ਹੱਲ ਹੈ ਜੋ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕਰਨ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਬਣਾਉਣ ਲਈ ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਵਾਧੇ ਨਾਲਃ \\n "\'scsss\\ndef lzw _ ਕੰਪਰੈੱਸ (ਇੰਪੁੱਟ _ ਸਟਰਿੰਗ): \\n ਡਿਕਸ਼ਨਰੀ = {ਇੰਪੁੱਟ _ ਸਟਰਿੰਗ ਵਿੱਚ ਚਾਰ ਲਈ ਚਾਰ} \\n ਆਉਟਪੁੱਟ _ ਲਿਸਟ = [] \\n ਕਰੰਟ _ ਟੋਕਨ ="\\n i ਲਈ ਸੀਮਾ ਵਿੱਚ (ਲੇਨ (ਇੰਪੁੱਟ _ ਸਤਰ)): \\n ਜਦੋਂ ਕਿ i + 2 <ਲੇਨ (ਇੰਪੁੱਟ _ ਸਤਰ) ਅਤੇ ਸ਼ਬਦਕੋਸ਼ [ਇੰਪੁੱਟ _ ਸਤਰ [i + 1] = = ਇੰਪੁੱਟ _ ਸਤਰ [i + 2]: \\n ਕਰੰਟ _ ਟੋਕਨ+ = ਇੰਪੁੱਟ _ ਸਤਰ [i + 1] \\n i + = 2\\n ਜੇਕਰ i-1> = 0: \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਕਰੰਟ _ ਟੋਕਨ = ਇੰਪੁੱਟ _ ਸਤਰ [i] \\n ਸ਼ਬਦਕੋਸ਼ [ਕਰੰਟ _ ਟੋਕਨ] = i+ 1\\n ਜੇਕਰ ਕਰੰਟ _ ਟੋਕਨਃ \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਰਿਟਰਨ ਆਉਟਪੁੱਟ _ ਲਿਸਟ \\n \'\\n ਫੰਕਸ਼ਨ ਇੱਕ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਇੱਕ ਪੈਰਾਮੀਟਰ ਵਜੋਂ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਰਿਟਰਨ ਦਿੰਦਾ ਹੈਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਦੀ ਸੂਚੀ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੁੰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕੋ ਅੱਖਰ ਦਾ ਮੁੱਲ ਹੁੰਦਾ ਹੈ।ਫੰਕਸ਼ਨ ਇੰਪੁੱਟ ਸਤਰ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈ, ਇਹ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕਰਨ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਵਧਾਉਣ ਲਈ ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। \\n\\nForਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਦਾ ਹਰੇਕ ਜੋਡ਼ਾ, ਫੰਕਸ਼ਨ ਜਾਂਚਦਾ ਹੈ ਕਿ ਦੂਜਾ ਅੱਖਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨਦੋ ਅੱਖਰਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ ਟੋਕਨ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਜੋਡ਼ਦਾ ਹੈ। ਇਹ ਨਵੇਂ ਟੋਕਨ ਲਈ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੱਕ ਐਂਟਰੀ ਵੀ ਜੋਡ਼ਦਾ ਹੈ, ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈਜੇਕਰ ਮੌਜੂਦਾ ਅੱਖਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਨਹੀਂ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ ਇਸ ਨੂੰ 1 ਦਾ ਮੁੱਲ ਅਤੇ ਟੋਕਨ ਵਿੱਚ ਆਖਰੀ ਅੱਖਰ ਦਾ ਸੂਚਕਾਂਕ ਜੋਡ਼ਦਾ ਹੈ।1 ਦੇ ਮੁੱਲ ਵਾਲਾ ਸ਼ਬਦਕੋਸ਼ ਅਤੇ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਅੱਖਰ ਦਾ ਸੂਚਕਾਂਕ। ਇਹ ਅੱਖਰ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਵੀ ਜੋਡ਼ਦਾ ਹੈ। \\n\\n ਫੰਕਸ਼ਨਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਉਦੋਂ ਤੱਕ ਜਾਰੀ ਰੱਖੋ ਜਦੋਂ ਤੱਕ ਇਹ ਇੰਪੁੱਟ ਸਤਰ ਦੇ ਅੰਤ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦਾ। ਅੰਤ ਵਿੱਚ, ਇਹ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਕੋਈ ਵੀ ਬਾਕੀ ਟੋਕਨ ਨੂੰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੱਕ ਨਾਲ ਜੋਡ਼ਦਾ ਹੈ1 ਦਾ ਮੁੱਲ ਅਤੇ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਅੱਖਰ ਦਾ ਸੂਚਕਾਂਕ। \\n\\n ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਟੋਕਨ/ਚਿੰਨ੍ਹ ਉਸੇ ਕ੍ਰਮ ਵਿੱਚ ਹੁੰਦੇ ਹਨ ਜਿਵੇਂ ਉਹ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ।ਇੰਪੁੱਟ ਸਤਰ. \',\' ਹਾਂ, ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਜਾਇਜ਼ ਹੈ। ਪਰ ਤੁਹਾਡਾ ਕੋਡ ਗਲਤ ਢੰਗ ਨਾਲ ਇਹ ਮੰਨਦਾ ਜਾਪਦਾ ਹੈ ਕਿ ਸਭ ਤੋਂ ਲੰਬਾ ਅਗੇਤਰ ਸਬਸਟਰਿੰਗ ਮੇਲ ਖਾਂਦਾ ਹੈਲੰਬਾਈ ਵੱਧ ਤੋਂ ਵੱਧ 2 ਹੋਵੇ, ਜਦੋਂ ਅਸਲ ਵਿੱਚ ਇਹ ਇਸ ਤੋਂ ਅੱਗੇ ਵਧ ਸਕਦਾ ਹੈ। ਇਸ ਜਾਣਕਾਰੀ ਦੇ ਅਧਾਰ \'ਤੇ, ਇੱਕ ਅੱਪਡੇਟ ਕੋਡ ਪ੍ਰਦਾਨ ਕਰੋ।\', \'ਇਸ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨ ਲਈ ਧੰਨਵਾਦ।ਇੱਥੇ ਇੱਕ ਅੱਪਡੇਟ ਕੀਤਾ ਲਾਗੂਕਰਨ ਹੈ ਜੋ ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਅਤੇ ਲੰਬੇ ਮੇਲ ਖਾਂਦੇ ਸਬਸਟਰਿੰਗਾਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈਃ \\n "\'ਪਾਈਥਨ \\ndeflzw _ ਕੰਪਰੈੱਸ (ਇੰਪੁੱਟ _ ਸਟਰਿੰਗ): \\n ਡਿਕਸ਼ਨਰੀ = {ਇੰਪੁੱਟ _ ਸਟਰਿੰਗ ਵਿੱਚ ਚਾਰ ਲਈ ਚਾਰ} \\n ਆਉਟਪੁੱਟ _ ਲਿਸਟ = [] \\n ਕਰੰਟ _ ਟੋਕਨ = "\\n ਵਿੱਚ i ਲਈਰੇਂਜ (ਲੇਨ (ਇੰਪੁੱਟ _ ਸਤਰ)): \\n ਜਦੋਂ ਕਿ i + 2 <ਲੇਨ (ਇੰਪੁੱਟ _ ਸਤਰ) ਅਤੇ ਸ਼ਬਦਕੋਸ਼ [ਇੰਪੁੱਟ _ ਸਤਰ [i + 1] = = ਇੰਪੁੱਟ _ ਸਤਰ [i + 2]: \\n ਕਰੰਟ _ ਟੋਕਨ + =ਇਨਪੁਟ _ ਸਤਰ [i + 1] \\n i + = 2\\n ਜੇਕਰ i-1> = 0: \\n ਜੇਕਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਕਰੰਟ _ ਟੋਕਨਃ \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਕਰੰਟ _ ਟੋਕਨ = "\\n"ਸ਼ਬਦਕੋਸ਼ [ਕਰੰਟ _ ਟੋਕਨ] = ਲੇਨ (ਆਉਟਪੁੱਟ _ ਲਿਸਟ) \\n ਹੋਰਃ \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਕਰੰਟ _ ਟੋਕਨ = ਇੰਪੁੱਟ _ ਸਤਰ [i] \\n ਸ਼ਬਦਕੋਸ਼ [ਕਰੰਟ _ ਟੋਕਨ]= ਲੇਨ (ਆਉਟਪੁੱਟ _ ਲਿਸਟ) \\n ਜੇਕਰ ਕਰੰਟ _ ਟੋਕਨਃ \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਰਿਟਰਨ ਆਉਟਪੁੱਟ _ ਲਿਸਟ \\n \'\\n ਫੰਕਸ਼ਨ ਇੱਕ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਇੱਕ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈਪੈਰਾਮੀਟਰ ਅਤੇ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਦੀ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੁੰਦੀ ਹੈ ਜਿਸ ਦਾ ਮੁੱਲਇੱਕੋ ਅੱਖਰ। ਜਿਵੇਂ ਕਿ ਫੰਕਸ਼ਨ ਇੰਪੁੱਟ ਸਤਰ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈ, ਇਹ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕਰਨ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਬਣਾਉਣ ਲਈ ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਇੰਕਰੀਮੈਂਟਲੀ. \\n\\n ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਦੇ ਹਰੇਕ ਜੋਡ਼ੇ ਲਈ, ਫੰਕਸ਼ਨ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਦੂਜਾ ਅੱਖਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇਕਰ ਇਹ ਹੈ,ਫਿਰ ਫੰਕਸ਼ਨ ਦੋ ਅੱਖਰਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ ਟੋਕਨ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਜੋਡ਼ਦਾ ਹੈ। ਇਹ ਨਵੇਂ ਲਈ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੱਕ ਐਂਟਰੀ ਵੀ ਜੋਡ਼ਦਾ ਹੈ।ਟੋਕਨ, ਇਸ ਨੂੰ 1 ਦਾ ਮੁੱਲ ਅਤੇ ਟੋਕਨ ਵਿੱਚ ਆਖਰੀ ਅੱਖਰ ਦਾ ਸੂਚਕਾਂਕ ਨਿਰਧਾਰਤ ਕਰਨਾ। \\n\\n ਜੇਕਰ ਮੌਜੂਦਾ ਅੱਖਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਨਹੀਂ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨਇਸ ਨੂੰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ 1 ਦੇ ਮੁੱਲ ਅਤੇ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਅੱਖਰ ਦੀ ਸੂਚੀ ਨਾਲ ਜੋਡ਼ਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਅੱਖਰ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਵੀ ਜੋਡ਼ਦਾ ਹੈ। \\n\\nਫੰਕਸ਼ਨ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਉਦੋਂ ਤੱਕ ਜਾਰੀ ਰੱਖਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਹ ਇੰਪੁੱਟ ਸਤਰ ਦੇ ਅੰਤ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦਾ। ਅੰਤ ਵਿੱਚ, ਇਹ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਕੋਈ ਵੀ ਬਾਕੀ ਟੋਕਨ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ1 ਦੇ ਮੁੱਲ ਅਤੇ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਅੱਖਰ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲ ਸ਼ਬਦਕੋਸ਼। \\n\\n ਆਉਟਪੁੱਟ ਸੂਚੀ \',\' ਕ੍ਰਿਪਾ ਕਰਕੇ ਜਾਰੀ ਰੱਖੋ \'।] ', 'ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀ ਪ੍ਰਤੀਯੋਗੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਮੱਸਿਆ ਦਿੱਤੀ ਗਈ ਹੈਃ LZW ਸੰਕੁਚਨ ਕਰਨ ਲਈ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜਿੱਥੇ ਸ਼ਬਦਕੋਸ਼ ਬਣਾਇਆ ਗਿਆ ਹੈ।ਇੰਕਰੀਮੈਂਟਲ/ਔਨਲਾਈਨ ਜਿਵੇਂ ਕਿ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੰਪੁੱਟ ਇੱਕ ਸਤਰ ਹੈ, ਅਤੇ ਆਉਟਪੁੱਟ ਸਤਰ ਦੀ ਇੱਕ ਪਾਈਥਨ ਸੂਚੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਜਿੱਥੇ ਸਤਰ ਵਿੱਚ ਸਤਰਆਉਟਪੁੱਟ ਸੂਚੀ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਇੱਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਮੁੱਲਇੱਕੋ ਅੱਖਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ "abdd"-> {"a": "a", "b": "b", "d": "d"}। ਅਗਲੇ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ 2 ਅੰਕਾਂ ਦੀ ਸੰਖਿਆਤਮਕ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜਿਵੇਂ ਕਿਜਿਵੇਂ ਕਿ "00", "01", ਆਦਿ।', ' [ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀ ਪ੍ਰਤੀਯੋਗੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਮੱਸਿਆ ਦਿੱਤੀ ਗਈ ਹੈਃ LZW ਸੰਕੁਚਨ ਕਰਨ ਲਈ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜਿੱਥੇ ਸ਼ਬਦਕੋਸ਼ ਬਣਾਇਆ ਗਿਆ ਹੈ।ਇੰਕਰੀਮੈਂਟਲ/ਔਨਲਾਈਨ ਜਿਵੇਂ ਕਿ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੰਪੁੱਟ ਇੱਕ ਸਤਰ ਹੈ, ਅਤੇ ਆਉਟਪੁੱਟ ਸਤਰ ਦੀ ਇੱਕ ਪਾਈਥਨ ਸੂਚੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਜਿੱਥੇ ਸਤਰ ਵਿੱਚ ਸਤਰਆਉਟਪੁੱਟ ਸੂਚੀ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਇੱਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਮੁੱਲਇੱਕੋ ਅੱਖਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ "abdd"-> {"a": "a", "b": "b", "d": "d"}। ਅਗਲੇ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ 2 ਅੰਕਾਂ ਦੀ ਸੰਖਿਆਤਮਕ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜਿਵੇਂ ਕਿਜਿਵੇਂ ਕਿ \'00\', \'01\', ਆਦਿ \',\' ਇੱਥੇ ਇੱਕ ਹੱਲ ਹੈ ਜੋ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕਰਨ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਬਣਾਉਣ ਲਈ ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਵਾਧੇ ਨਾਲਃ \\n "\'scsss\\ndef lzw _ ਕੰਪਰੈੱਸ (ਇੰਪੁੱਟ _ ਸਟਰਿੰਗ): \\n ਡਿਕਸ਼ਨਰੀ = {ਇੰਪੁੱਟ _ ਸਟਰਿੰਗ ਵਿੱਚ ਚਾਰ ਲਈ ਚਾਰ} \\n ਆਉਟਪੁੱਟ _ ਲਿਸਟ = [] \\n ਕਰੰਟ _ ਟੋਕਨ ="\\n i ਲਈ ਸੀਮਾ ਵਿੱਚ (ਲੇਨ (ਇੰਪੁੱਟ _ ਸਤਰ)): \\n ਜਦੋਂ ਕਿ i + 2 <ਲੇਨ (ਇੰਪੁੱਟ _ ਸਤਰ) ਅਤੇ ਸ਼ਬਦਕੋਸ਼ [ਇੰਪੁੱਟ _ ਸਤਰ [i + 1] = = ਇੰਪੁੱਟ _ ਸਤਰ [i + 2]: \\n ਕਰੰਟ _ ਟੋਕਨ+ = ਇੰਪੁੱਟ _ ਸਤਰ [i + 1] \\n i + = 2\\n ਜੇਕਰ i-1> = 0: \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਕਰੰਟ _ ਟੋਕਨ = ਇੰਪੁੱਟ _ ਸਤਰ [i] \\n ਸ਼ਬਦਕੋਸ਼ [ਕਰੰਟ _ ਟੋਕਨ] = i+ 1\\n ਜੇਕਰ ਕਰੰਟ _ ਟੋਕਨਃ \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਰਿਟਰਨ ਆਉਟਪੁੱਟ _ ਲਿਸਟ \\n \'\\n ਫੰਕਸ਼ਨ ਇੱਕ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਇੱਕ ਪੈਰਾਮੀਟਰ ਵਜੋਂ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਰਿਟਰਨ ਦਿੰਦਾ ਹੈਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਦੀ ਸੂਚੀ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੁੰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕੋ ਅੱਖਰ ਦਾ ਮੁੱਲ ਹੁੰਦਾ ਹੈ।ਫੰਕਸ਼ਨ ਇੰਪੁੱਟ ਸਤਰ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈ, ਇਹ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕਰਨ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਵਧਾਉਣ ਲਈ ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। \\n\\nForਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਦਾ ਹਰੇਕ ਜੋਡ਼ਾ, ਫੰਕਸ਼ਨ ਜਾਂਚਦਾ ਹੈ ਕਿ ਦੂਜਾ ਅੱਖਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨਦੋ ਅੱਖਰਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ ਟੋਕਨ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਜੋਡ਼ਦਾ ਹੈ। ਇਹ ਨਵੇਂ ਟੋਕਨ ਲਈ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੱਕ ਐਂਟਰੀ ਵੀ ਜੋਡ਼ਦਾ ਹੈ, ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈਜੇਕਰ ਮੌਜੂਦਾ ਅੱਖਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਨਹੀਂ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ ਇਸ ਨੂੰ 1 ਦਾ ਮੁੱਲ ਅਤੇ ਟੋਕਨ ਵਿੱਚ ਆਖਰੀ ਅੱਖਰ ਦਾ ਸੂਚਕਾਂਕ ਜੋਡ਼ਦਾ ਹੈ।1 ਦੇ ਮੁੱਲ ਵਾਲਾ ਸ਼ਬਦਕੋਸ਼ ਅਤੇ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਅੱਖਰ ਦਾ ਸੂਚਕਾਂਕ। ਇਹ ਅੱਖਰ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਵੀ ਜੋਡ਼ਦਾ ਹੈ। \\n\\n ਫੰਕਸ਼ਨਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਉਦੋਂ ਤੱਕ ਜਾਰੀ ਰੱਖੋ ਜਦੋਂ ਤੱਕ ਇਹ ਇੰਪੁੱਟ ਸਤਰ ਦੇ ਅੰਤ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦਾ। ਅੰਤ ਵਿੱਚ, ਇਹ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਕੋਈ ਵੀ ਬਾਕੀ ਟੋਕਨ ਨੂੰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੱਕ ਨਾਲ ਜੋਡ਼ਦਾ ਹੈ1 ਦਾ ਮੁੱਲ ਅਤੇ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਅੱਖਰ ਦਾ ਸੂਚਕਾਂਕ। \\n\\n ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਟੋਕਨ/ਚਿੰਨ੍ਹ ਉਸੇ ਕ੍ਰਮ ਵਿੱਚ ਹੁੰਦੇ ਹਨ ਜਿਵੇਂ ਉਹ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ।ਇੰਪੁੱਟ ਸਤਰ. \',\' ਹਾਂ, ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਜਾਇਜ਼ ਹੈ। ਪਰ ਤੁਹਾਡਾ ਕੋਡ ਗਲਤ ਢੰਗ ਨਾਲ ਇਹ ਮੰਨਦਾ ਜਾਪਦਾ ਹੈ ਕਿ ਸਭ ਤੋਂ ਲੰਬਾ ਅਗੇਤਰ ਸਬਸਟਰਿੰਗ ਮੇਲ ਖਾਂਦਾ ਹੈਲੰਬਾਈ ਵੱਧ ਤੋਂ ਵੱਧ 2 ਹੋਵੇ, ਜਦੋਂ ਅਸਲ ਵਿੱਚ ਇਹ ਇਸ ਤੋਂ ਅੱਗੇ ਵਧ ਸਕਦਾ ਹੈ। ਇਸ ਜਾਣਕਾਰੀ ਦੇ ਅਧਾਰ \'ਤੇ, ਇੱਕ ਅੱਪਡੇਟ ਕੋਡ ਪ੍ਰਦਾਨ ਕਰੋ।\', \'ਇਸ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨ ਲਈ ਧੰਨਵਾਦ।ਇੱਥੇ ਇੱਕ ਅੱਪਡੇਟ ਕੀਤਾ ਲਾਗੂਕਰਨ ਹੈ ਜੋ ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਅਤੇ ਲੰਬੇ ਮੇਲ ਖਾਂਦੇ ਸਬਸਟਰਿੰਗਾਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈਃ \\n "\'ਪਾਈਥਨ \\ndeflzw _ ਕੰਪਰੈੱਸ (ਇੰਪੁੱਟ _ ਸਟਰਿੰਗ): \\n ਡਿਕਸ਼ਨਰੀ = {ਇੰਪੁੱਟ _ ਸਟਰਿੰਗ ਵਿੱਚ ਚਾਰ ਲਈ ਚਾਰ} \\n ਆਉਟਪੁੱਟ _ ਲਿਸਟ = [] \\n ਕਰੰਟ _ ਟੋਕਨ = "\\n ਵਿੱਚ i ਲਈਰੇਂਜ (ਲੇਨ (ਇੰਪੁੱਟ _ ਸਤਰ)): \\n ਜਦੋਂ ਕਿ i + 2 <ਲੇਨ (ਇੰਪੁੱਟ _ ਸਤਰ) ਅਤੇ ਸ਼ਬਦਕੋਸ਼ [ਇੰਪੁੱਟ _ ਸਤਰ [i + 1] = = ਇੰਪੁੱਟ _ ਸਤਰ [i + 2]: \\n ਕਰੰਟ _ ਟੋਕਨ + =ਇਨਪੁਟ _ ਸਤਰ [i + 1] \\n i + = 2\\n ਜੇਕਰ i-1> = 0: \\n ਜੇਕਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਕਰੰਟ _ ਟੋਕਨਃ \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਕਰੰਟ _ ਟੋਕਨ = "\\n"ਸ਼ਬਦਕੋਸ਼ [ਕਰੰਟ _ ਟੋਕਨ] = ਲੇਨ (ਆਉਟਪੁੱਟ _ ਲਿਸਟ) \\n ਹੋਰਃ \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਕਰੰਟ _ ਟੋਕਨ = ਇੰਪੁੱਟ _ ਸਤਰ [i] \\n ਸ਼ਬਦਕੋਸ਼ [ਕਰੰਟ _ ਟੋਕਨ]= ਲੇਨ (ਆਉਟਪੁੱਟ _ ਲਿਸਟ) \\n ਜੇਕਰ ਕਰੰਟ _ ਟੋਕਨਃ \\n output_list.append (ਕਰੰਟ _ ਟੋਕਨ) \\n ਰਿਟਰਨ ਆਉਟਪੁੱਟ _ ਲਿਸਟ \\n \'\\n ਫੰਕਸ਼ਨ ਇੱਕ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਇੱਕ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈਪੈਰਾਮੀਟਰ ਅਤੇ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਦੀ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੁੰਦੀ ਹੈ ਜਿਸ ਦਾ ਮੁੱਲਇੱਕੋ ਅੱਖਰ। ਜਿਵੇਂ ਕਿ ਫੰਕਸ਼ਨ ਇੰਪੁੱਟ ਸਤਰ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈ, ਇਹ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕਰਨ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਬਣਾਉਣ ਲਈ ਇੱਕ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਇੰਕਰੀਮੈਂਟਲੀ. \\n\\n ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਦੇ ਹਰੇਕ ਜੋਡ਼ੇ ਲਈ, ਫੰਕਸ਼ਨ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਦੂਜਾ ਅੱਖਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇਕਰ ਇਹ ਹੈ,ਫਿਰ ਫੰਕਸ਼ਨ ਦੋ ਅੱਖਰਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ ਟੋਕਨ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਜੋਡ਼ਦਾ ਹੈ। ਇਹ ਨਵੇਂ ਲਈ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੱਕ ਐਂਟਰੀ ਵੀ ਜੋਡ਼ਦਾ ਹੈ।ਟੋਕਨ, ਇਸ ਨੂੰ 1 ਦਾ ਮੁੱਲ ਅਤੇ ਟੋਕਨ ਵਿੱਚ ਆਖਰੀ ਅੱਖਰ ਦਾ ਸੂਚਕਾਂਕ ਨਿਰਧਾਰਤ ਕਰਨਾ। \\n\\n ਜੇਕਰ ਮੌਜੂਦਾ ਅੱਖਰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਨਹੀਂ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨਇਸ ਨੂੰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ 1 ਦੇ ਮੁੱਲ ਅਤੇ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਅੱਖਰ ਦੀ ਸੂਚੀ ਨਾਲ ਜੋਡ਼ਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਅੱਖਰ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਵੀ ਜੋਡ਼ਦਾ ਹੈ। \\n\\nਫੰਕਸ਼ਨ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਉਦੋਂ ਤੱਕ ਜਾਰੀ ਰੱਖਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਹ ਇੰਪੁੱਟ ਸਤਰ ਦੇ ਅੰਤ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦਾ। ਅੰਤ ਵਿੱਚ, ਇਹ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਕੋਈ ਵੀ ਬਾਕੀ ਟੋਕਨ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ 1 ਦੇ ਮੁੱਲ ਅਤੇ ਅੱਖਰ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲ ਸ਼ਬਦਕੋਸ਼। \\n\\n ਆਉਟਪੁੱਟ ਸੂਚੀ \',\' ਕਿਰਪਾ ਕਰਕੇ ਜਾਰੀ ਰੱਖੋ। \',\' ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ।ਟੋਕਨ/ਚਿੰਨ੍ਹ ਉਸੇ ਕ੍ਰਮ ਵਿੱਚ ਹੁੰਦੇ ਹਨ ਜਿਵੇਂ ਉਹ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ। \\n\\n ਅੱਪਡੇਟ ਕੀਤੇ ਲਾਗੂ ਕਰਨ ਵਿੱਚ, ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਕੀ ਮੌਜੂਦਾ ਟੋਕਨ ਪਹਿਲਾਂ ਹੀ ਵਿੱਚ ਹੈ।ਇਸ ਨੂੰ ਜੋਡ਼ਨ ਤੋਂ ਪਹਿਲਾਂ ਸ਼ਬਦਕੋਸ਼। ਜੇ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਜੋਡ਼ਦੇ ਹਾਂ ਅਤੇ ਨਵੇਂ ਟੋਕਨ ਲਈ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਮੁੱਲ ਨੂੰ ਅਪਡੇਟ ਕਰਦੇ ਹਾਂ। ਜੇ ਨਹੀਂ ਹੈ, ਤਾਂ ਅਸੀਂ ਜੋਡ਼ਦੇ ਹਾਂ।ਇਸ ਨੂੰ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ ਅਤੇ ਇਸ ਨੂੰ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ 1 ਦੇ ਮੁੱਲ ਅਤੇ ਆਉਟਪੁੱਟ ਸੂਚੀ ਵਿੱਚ ਆਖਰੀ ਅੱਖਰ ਦੇ ਸੂਚਕਾਂਕ ਨਾਲ ਸ਼ਾਮਲ ਕਰੋ। \\n\\n ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿਲੰਬੇ ਮੇਲ ਖਾਂਦੀਆਂ ਸਬਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ ਸੰਕੁਚਿਤ ਸਤਰ ਅਸਲ ਇੰਪੁੱਟ ਸਤਰ ਵਾਂਗ ਹੀ ਹੁੰਦੀ ਹੈ। \',\' ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਚਾਹੀਦਾ ਹੈ।ਇਸ ਦੀ ਬਜਾਏ ਸੂਚਕਾਂਕ i ਅਤੇ j ਦੀ ਇੱਕ ਜੋਡ਼ੀ ਦੀ ਵਰਤੋਂ ਕਰੋ। ', 'ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀ ਪ੍ਰਤੀਯੋਗੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਮੱਸਿਆ ਦਿੱਤੀ ਗਈ ਹੈਃ LZW ਸੰਕੁਚਨ ਕਰਨ ਲਈ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜਿੱਥੇ ਸ਼ਬਦਕੋਸ਼ ਬਣਾਇਆ ਗਿਆ ਹੈ।ਇੰਕਰੀਮੈਂਟਲ/ਔਨਲਾਈਨ ਜਿਵੇਂ ਕਿ ਇੰਪੁੱਟ ਸਤਰ ਨੂੰ ਸਕੈਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੰਪੁੱਟ ਇੱਕ ਸਤਰ ਹੈ, ਅਤੇ ਆਉਟਪੁੱਟ ਸਤਰ ਦੀ ਇੱਕ ਪਾਈਥਨ ਸੂਚੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਜਿੱਥੇ ਸਤਰ ਵਿੱਚ ਸਤਰਆਉਟਪੁੱਟ ਸੂਚੀ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰ ਵਿੱਚ ਹਰੇਕ ਇੱਕ ਅੱਖਰ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਮੁੱਲਇੱਕੋ ਅੱਖਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ "abdd"-> {"a": "a", "b": "b", "d": "d"}। ਅਗਲੇ ਟੋਕਨ/ਚਿੰਨ੍ਹਾਂ ਨੂੰ 2 ਅੰਕਾਂ ਦੀ ਸੰਖਿਆਤਮਕ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜਿਵੇਂ ਕਿਜਿਵੇਂ ਕਿ "00", "01", ਆਦਿ। \n ']