ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ'] ", 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', " ['ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', '.', 'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ)। \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n '] ", 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', " ['ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', '.', 'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n ', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਭੁਲੱਕਡ਼ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਭੁਲੱਕਡ਼ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ 'ਤੇ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ.', 'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।' ", 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', " ['ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', '.', 'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n ', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਲਾਬੀਰਿੰਥ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਲਾਬੀਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ 'ਤੇ ਲੋਡ਼ੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ.', 'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।', '1. ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਲੂਪਸ, ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਕੋਡ ਵਿੱਚ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ। \\n\\n2. ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ-ਛੋਟੇ ਅਤੇ ਸਰਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲੋ।ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ 'ਡੀ. ਐੱਫ.' ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੰਕਸ਼ਨ। \\n\\n3. ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂਃ ਤਰਜੀਹਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮ ਅਤੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਲੂਪ ਇਟਰੇਟਰ। \\n\\n4. ਚੇਨ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨਃ ਚੇਨ ਮਲਟੀਪਲਢੰਗ ਜਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠੇ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਵਸਤੂ ਉੱਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ। \\n\\n5. ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰੋਵ੍ਹਾਈਟਸਪੇਸ-ਪਡ਼੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬੇਲੋਡ਼ੀ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਖਾਲੀ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। \\n\\n6. ਟਰਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਓਪਰੇਟਰਃ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਸਧਾਰਨ ਜੇਕਰ-ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਬਦਲੋ। \\n\\n7. ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇਨਲਾਈਨ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।ਇੱਕ ਥਾਂ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੁੱਖ ਕੋਡ ਦੇ ਅੰਦਰ ਇਨਲਾਈਨਿੰਗ ਕਰਨ' ਤੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n8. ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓਃ ਜਿਵੇਂ ਕਿਇਹ ਇੱਕ ਕੋਡ-ਗੋਲਫ ਚੁਣੌਤੀ ਹੈ, ਅੰਤਿਮ ਕੋਡ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਟਿੱਪਣੀ ਜਾਂ ਵਿਆਖਿਆ ਨੂੰ ਹਟਾਓ। \\n\\n9. ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਉਹਨਾਂ ਦੇ ਲੰਬੇ ਬਰਾਬਰ ਦੀ ਬਜਾਏ '+ =', '-=', ਅਤੇ '* ='। \\n\\n10. ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਮਿਲਾਓਃ ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਓਰੇਂਜ ਜਾਂ ਹੋਰ ਦੁਹਰਾਉਣ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਜੋਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਿੰਗਲ ਲੂਪ। \\n\\n ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀ ਰੇਂਜ ਦੀ ਲੰਬਾਈ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦੇ ਹੋ।ਕੋਡ ਆਪਣੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ. ',' ਅਜੇ ਤੱਕ ਕੋਈ ਕੋਡ ਲਿਖੇ ਬਿਨਾਂ, ਲੋਡ਼ੀਂਦੀਆਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ। ' ", 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', " ['ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', '.', 'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n ', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਲਾਬੀਰਿੰਥ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਲਾਬੀਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ 'ਤੇ ਲੋਡ਼ੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ.', 'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।', '1. ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਲੂਪਸ, ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਕੋਡ ਵਿੱਚ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ। \\n\\n2. ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ-ਛੋਟੇ ਅਤੇ ਸਰਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲੋ।ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ 'ਡੀ. ਐੱਫ.' ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੰਕਸ਼ਨ। \\n\\n3. ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂਃ ਤਰਜੀਹਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮ ਅਤੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਲੂਪ ਇਟਰੇਟਰ। \\n\\n4. ਚੇਨ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨਃ ਚੇਨ ਮਲਟੀਪਲਢੰਗ ਜਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠੇ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਵਸਤੂ ਉੱਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ। \\n\\n5. ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰੋਵ੍ਹਾਈਟਸਪੇਸ-ਪਡ਼੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬੇਲੋਡ਼ੀ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਖਾਲੀ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। \\n\\n6. ਟਰਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਓਪਰੇਟਰਃ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਸਧਾਰਨ ਜੇਕਰ-ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਬਦਲੋ। \\n\\n7. ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇਨਲਾਈਨ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।ਇੱਕ ਥਾਂ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੁੱਖ ਕੋਡ ਦੇ ਅੰਦਰ ਇਨਲਾਈਨਿੰਗ ਕਰਨ' ਤੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n8. ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓਃ ਜਿਵੇਂ ਕਿਇਹ ਇੱਕ ਕੋਡ-ਗੋਲਫ ਚੁਣੌਤੀ ਹੈ, ਅੰਤਿਮ ਕੋਡ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਟਿੱਪਣੀ ਜਾਂ ਵਿਆਖਿਆ ਨੂੰ ਹਟਾਓ। \\n\\n9. ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਉਹਨਾਂ ਦੇ ਲੰਬੇ ਬਰਾਬਰ ਦੀ ਬਜਾਏ '+ =', '-=', ਅਤੇ '* ='। \\n\\n10. ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਮਿਲਾਓਃ ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਓਰੇਂਜ ਜਾਂ ਹੋਰ ਦੁਹਰਾਉਣ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਜੋਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਿੰਗਲ ਲੂਪ। \\n\\n ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀ ਰੇਂਜ ਦੀ ਲੰਬਾਈ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦੇ ਹੋ।ਕੋਡ ਆਪਣੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ. ',' ਅਜੇ ਤੱਕ ਕੋਈ ਕੋਡ ਲਿਖੇ ਬਿਨਾਂ, ਲੋਡ਼ੀਂਦੀਆਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ। ',' ਇੱਥੇ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਲੋਡ਼ੀਂਦੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਰੂਪ ਰੇਖਾਃ \\n\\n ਕਲਾਸਾਂਃ \\n1. ਹੈਕਸਾਗਨਃ \\n-ਇੱਕ ਸਿੰਗਲ ਹੈਕਸਾਗੋਨਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਗਰਿੱਡ ਵਿੱਚ ਸੈੱਲ। \\n-ਇਸ ਵਿੱਚ ਆਪਣੀ ਸਥਿਤੀ, ਗੁਆਂਢੀਆਂ ਅਤੇ ਰਾਜ (ਕੰਧ ਜਾਂ ਮਾਰਗ) ਲਈ ਗੁਣ ਹੁੰਦੇ ਹਨ। \\n\\n2. ਭੁਲੱਕਡ਼ਃ \\n-ਸਮੁੱਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈਭੁਲੱਕਡ਼. \\n-ਗਰਿੱਡ ਅਕਾਰ, ਹੈਕਸਾਗੋਨਲ ਸੈੱਲਾਂ, ਅਤੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ। \\n-ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ। \\n\\nਫੰਕਸ਼ਨਃ \\n1. ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, ਗਰਿੱਡ _ ਸਾਈਜ਼): \\n-ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਟੀਕਿੰਟਰ ਦਾ ਕੈਨਵਸ. \\n\\n2. ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਲੈਬਰਿੰਥ): \\n-ਇੱਕ ਮੈਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਲੈਬਰਿੰਥ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕਰੂਸਕਲ ਦਾ ਐਲਗੋਰਿਦਮ। \\n-ਇੱਕ ਭੁਲੱਕਡ਼ ਵਸਤੂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈ ਅਤੇ ਭੁਲੱਕਡ਼ ਬਣਾਉਣ ਲਈ ਇਸ ਦੇ ਸੈੱਲਾਂ ਨੂੰ ਸੋਧਦਾ ਹੈ। \\n\\n3. ਵਿਜ਼ੂਅਲਾਈਜ਼ _ ਲੈਬਰਿੰਥ (ਕੈਨਵਸ,ਲੈਬਰਿੰਥ): \\n-ਲੈਬਰਿੰਥ ਦੀ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਪੈਦਾ ਹੋਈ ਲੈਬਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਦਾ ਹੈ। \\n\\n4.ਕ੍ਰਿਏਟ _ ਸਟਾਰਟ _ ਐਂਡ _ ਪੁਆਇੰਟਸ (ਭੁਲੱਕਡ਼): \\n-ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਦੋਵਾਂ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਅੰਕ. \\n\\n5. ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, ਭੁਲੱਕਡ਼): \\n-ਉਪਭੋਗਤਾ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਕੀਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੁਲੱਕਡ਼ ਰਾਹੀਂ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ।ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ। \\n\\n6. ਚੈੱਕ _ ਵਿੰਗਿੰਗ _ ਕੰਡੀਸ਼ਨ (ਭੁਲੱਕਡ਼): \\n-ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈਪੂਰਾ ਹੋਣ ਉੱਤੇ ਵਧਾਈ ਸੰਦੇਸ਼। \\n\\n7. ਮੁੱਖ (): \\n-ਮੁੱਖ ਫੰਕਸ਼ਨ ਜੋ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ। \\n-ਸ਼ੁਰੂ ਕਰਦਾ ਹੈਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ, ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਉਂਦੀ ਹੈ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਇਸ ਦੀ ਕਲਪਨਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਲਈ ਸੁਣਦੀ ਹੈ।ਲਾਗੂ ਕੀਤਾ ਕੋਡ. '] ", 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n \', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਲਾਬੀਰਿੰਥ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਲਾਬੀਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ \'ਤੇ ਲੋਡ਼ੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ.\', \'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।\', \'1. ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਲੂਪਸ, ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਕੋਡ ਵਿੱਚ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ। \\n\\n2. ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ-ਛੋਟੇ ਅਤੇ ਸਰਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲੋ।ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ \'ਡੀ. ਐੱਫ.\' ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੰਕਸ਼ਨ। \\n\\n3. ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂਃ ਤਰਜੀਹਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮ ਅਤੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਲੂਪ ਇਟਰੇਟਰ। \\n\\n4. ਚੇਨ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨਃ ਚੇਨ ਮਲਟੀਪਲਢੰਗ ਜਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠੇ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਵਸਤੂ ਉੱਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ। \\n\\n5. ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰੋਵ੍ਹਾਈਟਸਪੇਸ-ਪਡ਼੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬੇਲੋਡ਼ੀ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਖਾਲੀ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। \\n\\n6. ਟਰਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਓਪਰੇਟਰਃ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਸਧਾਰਨ ਜੇਕਰ-ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਬਦਲੋ। \\n\\n7. ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇਨਲਾਈਨ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।ਇੱਕ ਥਾਂ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ \'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੁੱਖ ਕੋਡ ਦੇ ਅੰਦਰ ਇਨਲਾਈਨਿੰਗ ਕਰਨ\' ਤੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n8. ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓਃ ਜਿਵੇਂ ਕਿਇਹ ਇੱਕ ਕੋਡ-ਗੋਲਫ ਚੁਣੌਤੀ ਹੈ, ਅੰਤਿਮ ਕੋਡ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਟਿੱਪਣੀ ਜਾਂ ਵਿਆਖਿਆ ਨੂੰ ਹਟਾਓ। \\n\\n9. ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਉਹਨਾਂ ਦੇ ਲੰਬੇ ਬਰਾਬਰ ਦੀ ਬਜਾਏ \'+ =\', \'-=\', ਅਤੇ \'* =\'। \\n\\n10. ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਮਿਲਾਓਃ ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਓਰੇਂਜ ਜਾਂ ਹੋਰ ਦੁਹਰਾਉਣ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਜੋਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਿੰਗਲ ਲੂਪ। \\n\\n ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀ ਰੇਂਜ ਦੀ ਲੰਬਾਈ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦੇ ਹੋ।ਕੋਡ ਆਪਣੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ. \',\' ਅਜੇ ਤੱਕ ਕੋਈ ਕੋਡ ਲਿਖੇ ਬਿਨਾਂ, ਲੋਡ਼ੀਂਦੀਆਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ। \',\' ਇੱਥੇ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਲੋਡ਼ੀਂਦੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਰੂਪ ਰੇਖਾਃ \\n\\n ਕਲਾਸਾਂਃ \\n1. ਹੈਕਸਾਗਨਃ \\n-ਇੱਕ ਸਿੰਗਲ ਹੈਕਸਾਗੋਨਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਗਰਿੱਡ ਵਿੱਚ ਸੈੱਲ। \\n-ਇਸ ਵਿੱਚ ਆਪਣੀ ਸਥਿਤੀ, ਗੁਆਂਢੀਆਂ ਅਤੇ ਰਾਜ (ਕੰਧ ਜਾਂ ਮਾਰਗ) ਲਈ ਗੁਣ ਹੁੰਦੇ ਹਨ। \\n\\n2. ਭੁਲੱਕਡ਼ਃ \\n-ਸਮੁੱਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈਭੁਲੱਕਡ਼. \\n-ਗਰਿੱਡ ਅਕਾਰ, ਹੈਕਸਾਗੋਨਲ ਸੈੱਲਾਂ, ਅਤੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ। \\n-ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ। \\n\\nਫੰਕਸ਼ਨਃ \\n1. ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, ਗਰਿੱਡ _ ਸਾਈਜ਼): \\n-ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਟੀਕਿੰਟਰ ਦਾ ਕੈਨਵਸ. \\n\\n2. ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਲੈਬਰਿੰਥ): \\n-ਇੱਕ ਮੈਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਲੈਬਰਿੰਥ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕਰੂਸਕਲ ਦਾ ਐਲਗੋਰਿਦਮ। \\n-ਇੱਕ ਭੁਲੱਕਡ਼ ਵਸਤੂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈ ਅਤੇ ਭੁਲੱਕਡ਼ ਬਣਾਉਣ ਲਈ ਇਸ ਦੇ ਸੈੱਲਾਂ ਨੂੰ ਸੋਧਦਾ ਹੈ। \\n\\n3. ਵਿਜ਼ੂਅਲਾਈਜ਼ _ ਲੈਬਰਿੰਥ (ਕੈਨਵਸ,ਲੈਬਰਿੰਥ): \\n-ਲੈਬਰਿੰਥ ਦੀ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਪੈਦਾ ਹੋਈ ਲੈਬਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਦਾ ਹੈ। \\n\\n4.ਕ੍ਰਿਏਟ _ ਸਟਾਰਟ _ ਐਂਡ _ ਪੁਆਇੰਟਸ (ਭੁਲੱਕਡ਼): \\n-ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਦੋਵਾਂ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਅੰਕ. \\n\\n5. ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, ਭੁਲੱਕਡ਼): \\n-ਉਪਭੋਗਤਾ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਕੀਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੁਲੱਕਡ਼ ਰਾਹੀਂ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ।ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ। \\n\\n6. ਚੈੱਕ _ ਵਿੰਗਿੰਗ _ ਕੰਡੀਸ਼ਨ (ਭੁਲੱਕਡ਼): \\n-ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈਪੂਰਾ ਹੋਣ ਉੱਤੇ ਵਧਾਈ ਸੰਦੇਸ਼। \\n\\n7. ਮੁੱਖ (): \\n-ਮੁੱਖ ਫੰਕਸ਼ਨ ਜੋ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ। \\n-ਸ਼ੁਰੂ ਕਰਦਾ ਹੈਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ, ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਉਂਦੀ ਹੈ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਇਸ ਦੀ ਕਲਪਨਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਲਈ ਸੁਣਦੀ ਹੈ।ਲਾਗੂ ਕੀਤਾ ਕੋਡ. \', "ਇੱਥੇ ਪਾਈਥਨ ਦੇ ਟਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਛੋਟਾ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਇਸ ਤਰ੍ਹਾਂ ਹੈ।(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਰੇਂਜ (6) ਵਿੱਚ i ਲਈ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈਰੇਂਜ (n)] ਲਈ i ਲਈ ਰੇਂਜ (n)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (g): \\n v, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (g)-1, ਲੇਨ (g)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y= ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, ((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2)), (1-(y% 2),-1 + (y% 2)2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\n\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = 500, ਉਚਾਈ = 500)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, 16,12) \\ngenਾਰੇਟ _ ਲੈਬਰਿੰਥ (ਗਰਿੱਡ)\\nroot.mainloop () \\n "\'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿਇਸ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਸੰਖੇਪਤਾ ਲਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਜਾਂ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਤਿਆਰ ਕੀਤਾ ਕੋਡ, ਫਿਕਸ ਪ੍ਰਸਤਾਵਾਂ ਦੇ ਨਾਲ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n \', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਲਾਬੀਰਿੰਥ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਲਾਬੀਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ \'ਤੇ ਲੋਡ਼ੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ.\', \'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।\', \'1. ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਲੂਪਸ, ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਕੋਡ ਵਿੱਚ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ। \\n\\n2. ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ-ਛੋਟੇ ਅਤੇ ਸਰਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲੋ।ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ \'ਡੀ. ਐੱਫ.\' ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੰਕਸ਼ਨ। \\n\\n3. ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂਃ ਤਰਜੀਹਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮ ਅਤੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਲੂਪ ਇਟਰੇਟਰ। \\n\\n4. ਚੇਨ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨਃ ਚੇਨ ਮਲਟੀਪਲਢੰਗ ਜਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠੇ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਵਸਤੂ ਉੱਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ। \\n\\n5. ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰੋਵ੍ਹਾਈਟਸਪੇਸ-ਪਡ਼੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬੇਲੋਡ਼ੀ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਖਾਲੀ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। \\n\\n6. ਟਰਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਓਪਰੇਟਰਃ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਸਧਾਰਨ ਜੇਕਰ-ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਬਦਲੋ। \\n\\n7. ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇਨਲਾਈਨ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।ਇੱਕ ਥਾਂ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ \'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੁੱਖ ਕੋਡ ਦੇ ਅੰਦਰ ਇਨਲਾਈਨਿੰਗ ਕਰਨ\' ਤੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n8. ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓਃ ਜਿਵੇਂ ਕਿਇਹ ਇੱਕ ਕੋਡ-ਗੋਲਫ ਚੁਣੌਤੀ ਹੈ, ਅੰਤਿਮ ਕੋਡ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਟਿੱਪਣੀ ਜਾਂ ਵਿਆਖਿਆ ਨੂੰ ਹਟਾਓ। \\n\\n9. ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਉਹਨਾਂ ਦੇ ਲੰਬੇ ਬਰਾਬਰ ਦੀ ਬਜਾਏ \'+ =\', \'-=\', ਅਤੇ \'* =\'। \\n\\n10. ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਮਿਲਾਓਃ ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਓਰੇਂਜ ਜਾਂ ਹੋਰ ਦੁਹਰਾਉਣ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਜੋਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਿੰਗਲ ਲੂਪ। \\n\\n ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀ ਰੇਂਜ ਦੀ ਲੰਬਾਈ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦੇ ਹੋ।ਕੋਡ ਆਪਣੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ. \',\' ਅਜੇ ਤੱਕ ਕੋਈ ਕੋਡ ਲਿਖੇ ਬਿਨਾਂ, ਲੋਡ਼ੀਂਦੀਆਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ। \',\' ਇੱਥੇ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਲੋਡ਼ੀਂਦੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਰੂਪ ਰੇਖਾਃ \\n\\n ਕਲਾਸਾਂਃ \\n1. ਹੈਕਸਾਗਨਃ \\n-ਇੱਕ ਸਿੰਗਲ ਹੈਕਸਾਗੋਨਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਗਰਿੱਡ ਵਿੱਚ ਸੈੱਲ। \\n-ਇਸ ਵਿੱਚ ਆਪਣੀ ਸਥਿਤੀ, ਗੁਆਂਢੀਆਂ ਅਤੇ ਰਾਜ (ਕੰਧ ਜਾਂ ਮਾਰਗ) ਲਈ ਗੁਣ ਹੁੰਦੇ ਹਨ। \\n\\n2. ਭੁਲੱਕਡ਼ਃ \\n-ਸਮੁੱਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈਭੁਲੱਕਡ਼. \\n-ਗਰਿੱਡ ਅਕਾਰ, ਹੈਕਸਾਗੋਨਲ ਸੈੱਲਾਂ, ਅਤੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ। \\n-ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ। \\n\\nਫੰਕਸ਼ਨਃ \\n1. ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, ਗਰਿੱਡ _ ਸਾਈਜ਼): \\n-ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਟੀਕਿੰਟਰ ਦਾ ਕੈਨਵਸ. \\n\\n2. ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਲੈਬਰਿੰਥ): \\n-ਇੱਕ ਮੈਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਲੈਬਰਿੰਥ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕਰੂਸਕਲ ਦਾ ਐਲਗੋਰਿਦਮ। \\n-ਇੱਕ ਭੁਲੱਕਡ਼ ਵਸਤੂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈ ਅਤੇ ਭੁਲੱਕਡ਼ ਬਣਾਉਣ ਲਈ ਇਸ ਦੇ ਸੈੱਲਾਂ ਨੂੰ ਸੋਧਦਾ ਹੈ। \\n\\n3. ਵਿਜ਼ੂਅਲਾਈਜ਼ _ ਲੈਬਰਿੰਥ (ਕੈਨਵਸ,ਲੈਬਰਿੰਥ): \\n-ਲੈਬਰਿੰਥ ਦੀ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਪੈਦਾ ਹੋਈ ਲੈਬਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਦਾ ਹੈ। \\n\\n4.ਕ੍ਰਿਏਟ _ ਸਟਾਰਟ _ ਐਂਡ _ ਪੁਆਇੰਟਸ (ਭੁਲੱਕਡ਼): \\n-ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਦੋਵਾਂ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਅੰਕ. \\n\\n5. ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, ਭੁਲੱਕਡ਼): \\n-ਉਪਭੋਗਤਾ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਕੀਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੁਲੱਕਡ਼ ਰਾਹੀਂ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ।ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ। \\n\\n6. ਚੈੱਕ _ ਵਿੰਗਿੰਗ _ ਕੰਡੀਸ਼ਨ (ਭੁਲੱਕਡ਼): \\n-ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈਪੂਰਾ ਹੋਣ ਉੱਤੇ ਵਧਾਈ ਸੰਦੇਸ਼। \\n\\n7. ਮੁੱਖ (): \\n-ਮੁੱਖ ਫੰਕਸ਼ਨ ਜੋ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ। \\n-ਸ਼ੁਰੂ ਕਰਦਾ ਹੈਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ, ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਉਂਦੀ ਹੈ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਇਸ ਦੀ ਕਲਪਨਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਲਈ ਸੁਣਦੀ ਹੈ।ਲਾਗੂ ਕੀਤਾ ਕੋਡ. \', "ਇੱਥੇ ਪਾਈਥਨ ਦੇ ਟਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਛੋਟਾ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਇਸ ਤਰ੍ਹਾਂ ਹੈ।(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਰੇਂਜ (6) ਵਿੱਚ i ਲਈ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈਰੇਂਜ (n)] ਲਈ i ਲਈ ਰੇਂਜ (n)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (g): \\n v, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (g)-1, ਲੇਨ (g)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y= ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, ((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2)), (1-(y% 2),-1 + (y% 2)2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\n\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = 500, ਉਚਾਈ = 500)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, 16,12) \\ngenਾਰੇਟ _ ਲੈਬਰਿੰਥ (ਗਰਿੱਡ)\\nroot.mainloop () \\n "\'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿਇਸ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਸੰਖੇਪਤਾ ਲਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਜਾਂ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਤਿਆਰ ਕੀਤਾ ਕੋਡ, ਫਿਕਸ ਪ੍ਰਸਤਾਵਾਂ ਦੇ ਨਾਲ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' 1. ਮੁੱਦਾਃ ਸੀਮਤ ਵਿੰਡੋ ਸਾਈਜ਼ ਅਤੇ ਫਿਕਸਡ ਗਰਿੱਡ ਸਾਈਜ਼ \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਨੂੰ ਅਨੁਕੂਲ ਕਰੋ ਅਤੇਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਚਾਈ, ਅਤੇ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਗਰਿੱਡ ਅਕਾਰ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕਰੋ। ਕੈਨਵਸ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਅਨੁਕੂਲ ਕਰੋਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਅਨੁਸਾਰ. \\n\\n2. ਮੁੱਦਾਃ ਕੋਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆ ਜਾਂ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਨਾਲ ਕੀਬੋਰਡ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰੋਜੋ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇਹ ਕੋਡ ਦੀ ਲੰਬਾਈ ਵਧਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਪ੍ਰਦਾਨ ਕਰੇਗਾਉਪਭੋਗੀ ਨੇਵੀਗੇਸ਼ਨ ਅਤੇ ਜਿੱਤ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਾਰਜਕੁਸ਼ਲਤਾ। \\n\\n3. ਮੁੱਦਾਃ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਭੁਲੇਖਾ ਪੀਡ਼੍ਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ \\n ਫਿਕਸਃਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਬਿਹਤਰ ਗੁੰਝਲਤਾ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਵਧੇਰੇ ਫਿਟਿੰਗ ਮੇਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal \'s।ਥੋਡ਼੍ਹਾ ਲੰਬਾ ਕੋਡ ਪਰ ਸਮੁੱਚੀ ਗੁੰਝਲਤਾ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n4. ਮੁੱਦਾਃ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਦਾ ਕੋਈ ਸਪਸ਼ਟ ਸੰਕੇਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਰੰਗ ਸੰਸ਼ੋਧਿਤ ਕਰੋਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਬਾਕੀ ਗੁੰਝਲਤਾ ਤੋਂ ਵੱਖ ਕਰਨ ਲਈ। ਇਸ ਲਈ ਕੋਡ ਵਿੱਚ ਮਾਮੂਲੀ ਤਬਦੀਲੀ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ ਅਤੇ ਨਹੀਂਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਉੱਤੇ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। \\n\\n5. ਮੁੱਦਾਃ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਲਈ ਕੋਈ ਵਿਜ਼ੂਅਲ ਫੀਡਬੈਕ ਨਹੀਂ \\n ਫਿਕਸਃ ਲਈ ਇੱਕ ਵਿਜ਼ੂਅਲ ਸੂਚਕ ਲਾਗੂ ਕਰੋਭੁਲੱਕਡ਼ ਵਿੱਚ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ, ਜਿਵੇਂ ਕਿ ਮੌਜੂਦਾ ਹੈਕਸਾਗਨ ਦਾ ਰੰਗ ਬਦਲਣਾ। ਇਸ ਲਈ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸੋਧ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ।ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਦੀ ਮਾਤਰਾ ਅਤੇ ਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਤੇ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰੇਗਾ। \\n\\n ਇਨ੍ਹਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਨਾਲ, ਕੋਡ ਵਧੇਰੇ ਕਾਰਜਸ਼ੀਲ ਹੋ ਜਾਵੇਗਾ ਅਤੇ", \'ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਗਲਤੀਆਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿਓ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ।\' ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n \', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਲਾਬੀਰਿੰਥ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਲਾਬੀਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ \'ਤੇ ਲੋਡ਼ੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ.\', \'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।\', \'1. ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਲੂਪਸ, ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਕੋਡ ਵਿੱਚ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ। \\n\\n2. ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ-ਛੋਟੇ ਅਤੇ ਸਰਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲੋ।ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ \'ਡੀ. ਐੱਫ.\' ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੰਕਸ਼ਨ। \\n\\n3. ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂਃ ਤਰਜੀਹਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮ ਅਤੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਲੂਪ ਇਟਰੇਟਰ। \\n\\n4. ਚੇਨ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨਃ ਚੇਨ ਮਲਟੀਪਲਢੰਗ ਜਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠੇ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਵਸਤੂ ਉੱਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ। \\n\\n5. ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰੋਵ੍ਹਾਈਟਸਪੇਸ-ਪਡ਼੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬੇਲੋਡ਼ੀ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਖਾਲੀ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। \\n\\n6. ਟਰਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਓਪਰੇਟਰਃ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਸਧਾਰਨ ਜੇਕਰ-ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਬਦਲੋ। \\n\\n7. ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇਨਲਾਈਨ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।ਇੱਕ ਥਾਂ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ \'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੁੱਖ ਕੋਡ ਦੇ ਅੰਦਰ ਇਨਲਾਈਨਿੰਗ ਕਰਨ\' ਤੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n8. ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓਃ ਜਿਵੇਂ ਕਿਇਹ ਇੱਕ ਕੋਡ-ਗੋਲਫ ਚੁਣੌਤੀ ਹੈ, ਅੰਤਿਮ ਕੋਡ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਟਿੱਪਣੀ ਜਾਂ ਵਿਆਖਿਆ ਨੂੰ ਹਟਾਓ। \\n\\n9. ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਉਹਨਾਂ ਦੇ ਲੰਬੇ ਬਰਾਬਰ ਦੀ ਬਜਾਏ \'+ =\', \'-=\', ਅਤੇ \'* =\'। \\n\\n10. ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਮਿਲਾਓਃ ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਓਰੇਂਜ ਜਾਂ ਹੋਰ ਦੁਹਰਾਉਣ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਜੋਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਿੰਗਲ ਲੂਪ। \\n\\n ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀ ਰੇਂਜ ਦੀ ਲੰਬਾਈ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦੇ ਹੋ।ਕੋਡ ਆਪਣੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ. \',\' ਅਜੇ ਤੱਕ ਕੋਈ ਕੋਡ ਲਿਖੇ ਬਿਨਾਂ, ਲੋਡ਼ੀਂਦੀਆਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ। \',\' ਇੱਥੇ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਲੋਡ਼ੀਂਦੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਰੂਪ ਰੇਖਾਃ \\n\\n ਕਲਾਸਾਂਃ \\n1. ਹੈਕਸਾਗਨਃ \\n-ਇੱਕ ਸਿੰਗਲ ਹੈਕਸਾਗੋਨਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਗਰਿੱਡ ਵਿੱਚ ਸੈੱਲ। \\n-ਇਸ ਵਿੱਚ ਆਪਣੀ ਸਥਿਤੀ, ਗੁਆਂਢੀਆਂ ਅਤੇ ਰਾਜ (ਕੰਧ ਜਾਂ ਮਾਰਗ) ਲਈ ਗੁਣ ਹੁੰਦੇ ਹਨ। \\n\\n2. ਭੁਲੱਕਡ਼ਃ \\n-ਸਮੁੱਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈਭੁਲੱਕਡ਼. \\n-ਗਰਿੱਡ ਅਕਾਰ, ਹੈਕਸਾਗੋਨਲ ਸੈੱਲਾਂ, ਅਤੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ। \\n-ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ। \\n\\nਫੰਕਸ਼ਨਃ \\n1. ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, ਗਰਿੱਡ _ ਸਾਈਜ਼): \\n-ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਟੀਕਿੰਟਰ ਦਾ ਕੈਨਵਸ. \\n\\n2. ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਲੈਬਰਿੰਥ): \\n-ਇੱਕ ਮੈਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਲੈਬਰਿੰਥ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕਰੂਸਕਲ ਦਾ ਐਲਗੋਰਿਦਮ। \\n-ਇੱਕ ਭੁਲੱਕਡ਼ ਵਸਤੂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈ ਅਤੇ ਭੁਲੱਕਡ਼ ਬਣਾਉਣ ਲਈ ਇਸ ਦੇ ਸੈੱਲਾਂ ਨੂੰ ਸੋਧਦਾ ਹੈ। \\n\\n3. ਵਿਜ਼ੂਅਲਾਈਜ਼ _ ਲੈਬਰਿੰਥ (ਕੈਨਵਸ,ਲੈਬਰਿੰਥ): \\n-ਲੈਬਰਿੰਥ ਦੀ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਪੈਦਾ ਹੋਈ ਲੈਬਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਦਾ ਹੈ। \\n\\n4.ਕ੍ਰਿਏਟ _ ਸਟਾਰਟ _ ਐਂਡ _ ਪੁਆਇੰਟਸ (ਭੁਲੱਕਡ਼): \\n-ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਦੋਵਾਂ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਅੰਕ. \\n\\n5. ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, ਭੁਲੱਕਡ਼): \\n-ਉਪਭੋਗਤਾ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਕੀਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੁਲੱਕਡ਼ ਰਾਹੀਂ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ।ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ। \\n\\n6. ਚੈੱਕ _ ਵਿੰਗਿੰਗ _ ਕੰਡੀਸ਼ਨ (ਭੁਲੱਕਡ਼): \\n-ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈਪੂਰਾ ਹੋਣ ਉੱਤੇ ਵਧਾਈ ਸੰਦੇਸ਼। \\n\\n7. ਮੁੱਖ (): \\n-ਮੁੱਖ ਫੰਕਸ਼ਨ ਜੋ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ। \\n-ਸ਼ੁਰੂ ਕਰਦਾ ਹੈਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ, ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਉਂਦੀ ਹੈ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਇਸ ਦੀ ਕਲਪਨਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਲਈ ਸੁਣਦੀ ਹੈ।ਲਾਗੂ ਕੀਤਾ ਕੋਡ. \', "ਇੱਥੇ ਪਾਈਥਨ ਦੇ ਟਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਛੋਟਾ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਇਸ ਤਰ੍ਹਾਂ ਹੈ।(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਰੇਂਜ (6) ਵਿੱਚ i ਲਈ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈਰੇਂਜ (n)] ਲਈ i ਲਈ ਰੇਂਜ (n)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (g): \\n v, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (g)-1, ਲੇਨ (g)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y= ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, ((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2)), (1-(y% 2),-1 + (y% 2)2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\n\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = 500, ਉਚਾਈ = 500)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, 16,12) \\ngenਾਰੇਟ _ ਲੈਬਰਿੰਥ (ਗਰਿੱਡ)\\nroot.mainloop () \\n "\'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿਇਸ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਸੰਖੇਪਤਾ ਲਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਜਾਂ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਤਿਆਰ ਕੀਤਾ ਕੋਡ, ਫਿਕਸ ਪ੍ਰਸਤਾਵਾਂ ਦੇ ਨਾਲ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' 1. ਮੁੱਦਾਃ ਸੀਮਤ ਵਿੰਡੋ ਸਾਈਜ਼ ਅਤੇ ਫਿਕਸਡ ਗਰਿੱਡ ਸਾਈਜ਼ \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਨੂੰ ਅਨੁਕੂਲ ਕਰੋ ਅਤੇਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਚਾਈ, ਅਤੇ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਗਰਿੱਡ ਅਕਾਰ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕਰੋ। ਕੈਨਵਸ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਅਨੁਕੂਲ ਕਰੋਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਅਨੁਸਾਰ. \\n\\n2. ਮੁੱਦਾਃ ਕੋਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆ ਜਾਂ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਨਾਲ ਕੀਬੋਰਡ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰੋਜੋ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇਹ ਕੋਡ ਦੀ ਲੰਬਾਈ ਵਧਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਪ੍ਰਦਾਨ ਕਰੇਗਾਉਪਭੋਗੀ ਨੇਵੀਗੇਸ਼ਨ ਅਤੇ ਜਿੱਤ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਾਰਜਕੁਸ਼ਲਤਾ। \\n\\n3. ਮੁੱਦਾਃ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਭੁਲੇਖਾ ਪੀਡ਼੍ਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ \\n ਫਿਕਸਃਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਬਿਹਤਰ ਗੁੰਝਲਤਾ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਵਧੇਰੇ ਫਿਟਿੰਗ ਮੇਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal \'s।ਥੋਡ਼੍ਹਾ ਲੰਬਾ ਕੋਡ ਪਰ ਸਮੁੱਚੀ ਗੁੰਝਲਤਾ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n4. ਮੁੱਦਾਃ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਦਾ ਕੋਈ ਸਪਸ਼ਟ ਸੰਕੇਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਰੰਗ ਸੰਸ਼ੋਧਿਤ ਕਰੋਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਬਾਕੀ ਗੁੰਝਲਤਾ ਤੋਂ ਵੱਖ ਕਰਨ ਲਈ। ਇਸ ਲਈ ਕੋਡ ਵਿੱਚ ਮਾਮੂਲੀ ਤਬਦੀਲੀ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ ਅਤੇ ਨਹੀਂਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਉੱਤੇ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। \\n\\n5. ਮੁੱਦਾਃ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਲਈ ਕੋਈ ਵਿਜ਼ੂਅਲ ਫੀਡਬੈਕ ਨਹੀਂ \\n ਫਿਕਸਃ ਲਈ ਇੱਕ ਵਿਜ਼ੂਅਲ ਸੂਚਕ ਲਾਗੂ ਕਰੋਭੁਲੱਕਡ਼ ਵਿੱਚ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ, ਜਿਵੇਂ ਕਿ ਮੌਜੂਦਾ ਹੈਕਸਾਗਨ ਦਾ ਰੰਗ ਬਦਲਣਾ। ਇਸ ਲਈ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸੋਧ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ।ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਦੀ ਮਾਤਰਾ ਅਤੇ ਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਤੇ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰੇਗਾ। \\n\\n ਇਨ੍ਹਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਨਾਲ, ਕੋਡ ਵਧੇਰੇ ਕਾਰਜਸ਼ੀਲ ਹੋ ਜਾਵੇਗਾ ਅਤੇਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ ਵੀ ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ "., \'ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਗਲਤੀਆਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿਓ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ।ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹੋਏ, ਕੁੱਝ ਗਲਤੀਆਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਅਨੁਸਾਰੀ ਫਿਕਸ ਹੁੰਦੇ ਹਨਃ \\n\\n1. ਗਲਤੀਃ ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਇੱਕ ਵਰਗ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਦੀ ਬਜਾਏ ਗਰਿੱਡ। \\n ਫਿਕਸਃ ਹੈਕਸਾਗੋਨਲ ਸਥਿਤੀਆਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰਕੇ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਤਿਆਰ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ ਸੋਧੋ ਅਤੇਗੁਆਂਢੀ। \\n\\n2. ਗਲਤੀਃ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ ਫੰਕਸ਼ਨ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ। \\n ਫਿਕਸਃ ਬਦਲੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੇਂ ਐਲਗੋਰਿਦਮ ਦੇ ਨਾਲ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal. ਇਸ ਦੇ ਨਤੀਜੇ ਥੋਡ਼ੇ ਲੰਬੇ ਹੋ ਸਕਦੇ ਹਨਕੋਡ ਪਰ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n3. ਗਲਤੀਃ ਕੋਡ ਵਿੱਚ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ ਅਤੇ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਦੀ ਘਾਟ ਹੈ। \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ) ਨੂੰ ਸੰਭਾਲਣ ਅਤੇ ਉਹਨਾਂ ਦੇ ਇਨਪੁਟ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ। ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਚੈੱਕ ਸ਼ਾਮਲ ਕਰੋਪਤਾ ਲਗਾਓ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ। \\n\\n4. ਗਲਤੀਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਸਥਿਰ ਹੈ ਅਤੇ ਗਰਿੱਡ ਅਨੁਸਾਰ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ।ਅਕਾਰ. \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਅਨੁਕੂਲ ਕਰੋ। ਇਹ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇਸ ਲਈ ਵਧੇਰੇ ਲਚਕਦਾਰ ਬਣਾਵੇਗਾ।ਵੱਖ-ਵੱਖ ਗਰਿੱਡ ਅਕਾਰ। \\n\\n ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਸ਼ੁਰੂਆਤੀ ਕੋਡ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਦਾ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਲਾਗੂਕਰਨ ਸੀ। ਇਹਨਾਂ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਕੇਗਲਤੀਆਂ, ਕੋਡ ਇੱਕ ਬਿਹਤਰ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਅਤੇ ਬਿਹਤਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰੇਗਾ ਜਦੋਂ ਕਿ ਅਜੇ ਵੀ ਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖੇਗਾ।ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤਾ ਕੋਡ. \'] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n \', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਲਾਬੀਰਿੰਥ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਲਾਬੀਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ \'ਤੇ ਲੋਡ਼ੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ.\', \'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।\', \'1. ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਲੂਪਸ, ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਕੋਡ ਵਿੱਚ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ। \\n\\n2. ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ-ਛੋਟੇ ਅਤੇ ਸਰਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲੋ।ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ \'ਡੀ. ਐੱਫ.\' ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੰਕਸ਼ਨ। \\n\\n3. ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂਃ ਤਰਜੀਹਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮ ਅਤੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਲੂਪ ਇਟਰੇਟਰ। \\n\\n4. ਚੇਨ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨਃ ਚੇਨ ਮਲਟੀਪਲਢੰਗ ਜਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠੇ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਵਸਤੂ ਉੱਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ। \\n\\n5. ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰੋਵ੍ਹਾਈਟਸਪੇਸ-ਪਡ਼੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬੇਲੋਡ਼ੀ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਖਾਲੀ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। \\n\\n6. ਟਰਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਓਪਰੇਟਰਃ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਸਧਾਰਨ ਜੇਕਰ-ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਬਦਲੋ। \\n\\n7. ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇਨਲਾਈਨ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।ਇੱਕ ਥਾਂ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ \'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੁੱਖ ਕੋਡ ਦੇ ਅੰਦਰ ਇਨਲਾਈਨਿੰਗ ਕਰਨ\' ਤੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n8. ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓਃ ਜਿਵੇਂ ਕਿਇਹ ਇੱਕ ਕੋਡ-ਗੋਲਫ ਚੁਣੌਤੀ ਹੈ, ਅੰਤਿਮ ਕੋਡ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਟਿੱਪਣੀ ਜਾਂ ਵਿਆਖਿਆ ਨੂੰ ਹਟਾਓ। \\n\\n9. ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਉਹਨਾਂ ਦੇ ਲੰਬੇ ਬਰਾਬਰ ਦੀ ਬਜਾਏ \'+ =\', \'-=\', ਅਤੇ \'* =\'। \\n\\n10. ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਮਿਲਾਓਃ ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਓਰੇਂਜ ਜਾਂ ਹੋਰ ਦੁਹਰਾਉਣ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਜੋਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਿੰਗਲ ਲੂਪ। \\n\\n ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀ ਰੇਂਜ ਦੀ ਲੰਬਾਈ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦੇ ਹੋ।ਕੋਡ ਆਪਣੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ. \',\' ਅਜੇ ਤੱਕ ਕੋਈ ਕੋਡ ਲਿਖੇ ਬਿਨਾਂ, ਲੋਡ਼ੀਂਦੀਆਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ। \',\' ਇੱਥੇ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਲੋਡ਼ੀਂਦੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਰੂਪ ਰੇਖਾਃ \\n\\n ਕਲਾਸਾਂਃ \\n1. ਹੈਕਸਾਗਨਃ \\n-ਇੱਕ ਸਿੰਗਲ ਹੈਕਸਾਗੋਨਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਗਰਿੱਡ ਵਿੱਚ ਸੈੱਲ। \\n-ਇਸ ਵਿੱਚ ਆਪਣੀ ਸਥਿਤੀ, ਗੁਆਂਢੀਆਂ ਅਤੇ ਰਾਜ (ਕੰਧ ਜਾਂ ਮਾਰਗ) ਲਈ ਗੁਣ ਹੁੰਦੇ ਹਨ। \\n\\n2. ਭੁਲੱਕਡ਼ਃ \\n-ਸਮੁੱਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈਭੁਲੱਕਡ਼. \\n-ਗਰਿੱਡ ਅਕਾਰ, ਹੈਕਸਾਗੋਨਲ ਸੈੱਲਾਂ, ਅਤੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ। \\n-ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ। \\n\\nਫੰਕਸ਼ਨਃ \\n1. ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, ਗਰਿੱਡ _ ਸਾਈਜ਼): \\n-ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਟੀਕਿੰਟਰ ਦਾ ਕੈਨਵਸ. \\n\\n2. ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਲੈਬਰਿੰਥ): \\n-ਇੱਕ ਮੈਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਲੈਬਰਿੰਥ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕਰੂਸਕਲ ਦਾ ਐਲਗੋਰਿਦਮ। \\n-ਇੱਕ ਭੁਲੱਕਡ਼ ਵਸਤੂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈ ਅਤੇ ਭੁਲੱਕਡ਼ ਬਣਾਉਣ ਲਈ ਇਸ ਦੇ ਸੈੱਲਾਂ ਨੂੰ ਸੋਧਦਾ ਹੈ। \\n\\n3. ਵਿਜ਼ੂਅਲਾਈਜ਼ _ ਲੈਬਰਿੰਥ (ਕੈਨਵਸ,ਲੈਬਰਿੰਥ): \\n-ਲੈਬਰਿੰਥ ਦੀ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਪੈਦਾ ਹੋਈ ਲੈਬਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਦਾ ਹੈ। \\n\\n4.ਕ੍ਰਿਏਟ _ ਸਟਾਰਟ _ ਐਂਡ _ ਪੁਆਇੰਟਸ (ਭੁਲੱਕਡ਼): \\n-ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਦੋਵਾਂ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਅੰਕ. \\n\\n5. ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, ਭੁਲੱਕਡ਼): \\n-ਉਪਭੋਗਤਾ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਕੀਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੁਲੱਕਡ਼ ਰਾਹੀਂ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ।ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ। \\n\\n6. ਚੈੱਕ _ ਵਿੰਗਿੰਗ _ ਕੰਡੀਸ਼ਨ (ਭੁਲੱਕਡ਼): \\n-ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈਪੂਰਾ ਹੋਣ ਉੱਤੇ ਵਧਾਈ ਸੰਦੇਸ਼। \\n\\n7. ਮੁੱਖ (): \\n-ਮੁੱਖ ਫੰਕਸ਼ਨ ਜੋ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ। \\n-ਸ਼ੁਰੂ ਕਰਦਾ ਹੈਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ, ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਉਂਦੀ ਹੈ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਇਸ ਦੀ ਕਲਪਨਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਲਈ ਸੁਣਦੀ ਹੈ।ਲਾਗੂ ਕੀਤਾ ਕੋਡ. \', "ਇੱਥੇ ਪਾਈਥਨ ਦੇ ਟਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਛੋਟਾ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਇਸ ਤਰ੍ਹਾਂ ਹੈ।(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਰੇਂਜ (6) ਵਿੱਚ i ਲਈ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈਰੇਂਜ (n)] ਲਈ i ਲਈ ਰੇਂਜ (n)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (g): \\n v, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (g)-1, ਲੇਨ (g)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y= ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, ((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2)), (1-(y% 2),-1 + (y% 2)2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\n\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = 500, ਉਚਾਈ = 500)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, 16,12) \\ngenਾਰੇਟ _ ਲੈਬਰਿੰਥ (ਗਰਿੱਡ)\\nroot.mainloop () \\n "\'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿਇਸ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਸੰਖੇਪਤਾ ਲਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਜਾਂ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਤਿਆਰ ਕੀਤਾ ਕੋਡ, ਫਿਕਸ ਪ੍ਰਸਤਾਵਾਂ ਦੇ ਨਾਲ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' 1. ਮੁੱਦਾਃ ਸੀਮਤ ਵਿੰਡੋ ਸਾਈਜ਼ ਅਤੇ ਫਿਕਸਡ ਗਰਿੱਡ ਸਾਈਜ਼ \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਨੂੰ ਅਨੁਕੂਲ ਕਰੋ ਅਤੇਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਚਾਈ, ਅਤੇ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਗਰਿੱਡ ਅਕਾਰ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕਰੋ। ਕੈਨਵਸ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਅਨੁਕੂਲ ਕਰੋਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਅਨੁਸਾਰ. \\n\\n2. ਮੁੱਦਾਃ ਕੋਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆ ਜਾਂ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਨਾਲ ਕੀਬੋਰਡ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰੋਜੋ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇਹ ਕੋਡ ਦੀ ਲੰਬਾਈ ਵਧਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਪ੍ਰਦਾਨ ਕਰੇਗਾਉਪਭੋਗੀ ਨੇਵੀਗੇਸ਼ਨ ਅਤੇ ਜਿੱਤ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਾਰਜਕੁਸ਼ਲਤਾ। \\n\\n3. ਮੁੱਦਾਃ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਭੁਲੇਖਾ ਪੀਡ਼੍ਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ \\n ਫਿਕਸਃਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਬਿਹਤਰ ਗੁੰਝਲਤਾ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਵਧੇਰੇ ਫਿਟਿੰਗ ਮੇਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal \'s।ਥੋਡ਼੍ਹਾ ਲੰਬਾ ਕੋਡ ਪਰ ਸਮੁੱਚੀ ਗੁੰਝਲਤਾ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n4. ਮੁੱਦਾਃ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਦਾ ਕੋਈ ਸਪਸ਼ਟ ਸੰਕੇਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਰੰਗ ਸੰਸ਼ੋਧਿਤ ਕਰੋਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਬਾਕੀ ਗੁੰਝਲਤਾ ਤੋਂ ਵੱਖ ਕਰਨ ਲਈ। ਇਸ ਲਈ ਕੋਡ ਵਿੱਚ ਮਾਮੂਲੀ ਤਬਦੀਲੀ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ ਅਤੇ ਨਹੀਂਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਉੱਤੇ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। \\n\\n5. ਮੁੱਦਾਃ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਲਈ ਕੋਈ ਵਿਜ਼ੂਅਲ ਫੀਡਬੈਕ ਨਹੀਂ \\n ਫਿਕਸਃ ਲਈ ਇੱਕ ਵਿਜ਼ੂਅਲ ਸੂਚਕ ਲਾਗੂ ਕਰੋਭੁਲੱਕਡ਼ ਵਿੱਚ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ, ਜਿਵੇਂ ਕਿ ਮੌਜੂਦਾ ਹੈਕਸਾਗਨ ਦਾ ਰੰਗ ਬਦਲਣਾ। ਇਸ ਲਈ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸੋਧ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ।ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਦੀ ਮਾਤਰਾ ਅਤੇ ਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਤੇ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰੇਗਾ। \\n\\n ਇਨ੍ਹਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਨਾਲ, ਕੋਡ ਵਧੇਰੇ ਕਾਰਜਸ਼ੀਲ ਹੋ ਜਾਵੇਗਾ ਅਤੇਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ ਵੀ ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ "., \'ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਗਲਤੀਆਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿਓ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ।ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹੋਏ, ਕੁੱਝ ਗਲਤੀਆਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਅਨੁਸਾਰੀ ਫਿਕਸ ਹੁੰਦੇ ਹਨਃ \\n\\n1. ਗਲਤੀਃ ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਇੱਕ ਵਰਗ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਦੀ ਬਜਾਏ ਗਰਿੱਡ। \\n ਫਿਕਸਃ ਹੈਕਸਾਗੋਨਲ ਸਥਿਤੀਆਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰਕੇ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਤਿਆਰ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ ਸੋਧੋ ਅਤੇਗੁਆਂਢੀ। \\n\\n2. ਗਲਤੀਃ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ ਫੰਕਸ਼ਨ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ। \\n ਫਿਕਸਃ ਬਦਲੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੇਂ ਐਲਗੋਰਿਦਮ ਦੇ ਨਾਲ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal. ਇਸ ਦੇ ਨਤੀਜੇ ਥੋਡ਼ੇ ਲੰਬੇ ਹੋ ਸਕਦੇ ਹਨਕੋਡ ਪਰ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n3. ਗਲਤੀਃ ਕੋਡ ਵਿੱਚ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ ਅਤੇ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਦੀ ਘਾਟ ਹੈ। \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ) ਨੂੰ ਸੰਭਾਲਣ ਅਤੇ ਉਹਨਾਂ ਦੇ ਇਨਪੁਟ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ। ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਚੈੱਕ ਸ਼ਾਮਲ ਕਰੋਪਤਾ ਲਗਾਓ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ। \\n\\n4. ਗਲਤੀਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਸਥਿਰ ਹੈ ਅਤੇ ਗਰਿੱਡ ਅਨੁਸਾਰ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ।ਅਕਾਰ. \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਅਨੁਕੂਲ ਕਰੋ। ਇਹ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇਸ ਲਈ ਵਧੇਰੇ ਲਚਕਦਾਰ ਬਣਾਵੇਗਾ।ਵੱਖ-ਵੱਖ ਗਰਿੱਡ ਅਕਾਰ। \\n\\n ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਸ਼ੁਰੂਆਤੀ ਕੋਡ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਦਾ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਲਾਗੂਕਰਨ ਸੀ। ਇਹਨਾਂ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਕੇਗਲਤੀਆਂ, ਕੋਡ ਇੱਕ ਬਿਹਤਰ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਅਤੇ ਬਿਹਤਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰੇਗਾ ਜਦੋਂ ਕਿ ਅਜੇ ਵੀ ਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖੇਗਾ।ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤਾ ਕੋਡ। \',\' ਇੱਥੇ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਦਾ ਇੱਕ ਅੱਪਡੇਟ ਕੀਤਾ ਸੰਸਕਰਣ ਹੈ।tkinter: \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ tkinter ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\n\\ndef ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): \\n ਰਿਟਰਨ [(c.create_polygon ([(lambda a, b: (a + s *)(i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =\\\'\\\', ਰਾਜ =\\\'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈਰੇਂਜ (6)], ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈ ਰੇਂਜ (ਐੱਨ)] ਵਿੱਚ i ਲਈ ਰੇਂਜ (ਐੱਨ)]\\ਐੱਨ ਐੱਨ ਡੀ ਐੱਫ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਜੀ):\\ਐੱਨ ਵੀ, ਐੱਸ, ਈ, ਸਟੈਕ = ਸੈੱਟ (), (0,0),(ਲੇਨ (ਜੀ)-1, ਲੇਨ (ਜੀ)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\n n = [(x + i, y + j) i ਲਈ, ((1,0), (0,0), (0,1), (0,0), (0,- 1), (-1 + (y% 2), 1-(y% 2), (1-(y% 2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <len (g) ਅਤੇ 0 <= y + j <len (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ।nx, ny = random.choice (n) \\n g [y] [x]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n g [ny] [nx]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n stack.append (((nx, ny)) \\n ਹੋਰਃ \\nstack.pop () \\n\\ndef ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,-1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬਾ\': (-1,0),\\\'ਸੱਜਾ\': (1,0)} ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\nnx, ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰ g [ny] [nx] ਹੈ।g [p [1]] [p [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਕਾਲਾ\') \\n p = (nx, ny) \\n g [p [1]] [p [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਲਾਲ\') \\n ਜੇਕਰ p = = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ"") \\n\\nn = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack () \\ngrid =ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\ngrid [ਪ੍ਲੇਯਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\')\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਲੈਂਬਡਾ ਈਃ ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ, ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ,ਗਰਿੱਡ))\\nroot.mainloop () \\n \'\\n\\n ਇਸ ਅੱਪਡੇਟ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਸਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਜਨਰੇਸ਼ਨ ਸ਼ਾਮਲ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੀਂ ਭੁਲੱਕਡ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਹੈ।ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ, NAME _ 3 ਨਾਲ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ, ਅਤੇ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰੋ ਜਦੋਂ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ।ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਹਰੇ ਅਤੇ ਨੀਲੇ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਲਾਲ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਕੋਡ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰੋ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n \', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਲਾਬੀਰਿੰਥ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਲਾਬੀਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ \'ਤੇ ਲੋਡ਼ੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ.\', \'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।\', \'1. ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਲੂਪਸ, ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਕੋਡ ਵਿੱਚ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ। \\n\\n2. ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ-ਛੋਟੇ ਅਤੇ ਸਰਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲੋ।ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ \'ਡੀ. ਐੱਫ.\' ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੰਕਸ਼ਨ। \\n\\n3. ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂਃ ਤਰਜੀਹਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮ ਅਤੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਲੂਪ ਇਟਰੇਟਰ। \\n\\n4. ਚੇਨ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨਃ ਚੇਨ ਮਲਟੀਪਲਢੰਗ ਜਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠੇ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਵਸਤੂ ਉੱਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ। \\n\\n5. ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰੋਵ੍ਹਾਈਟਸਪੇਸ-ਪਡ਼੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬੇਲੋਡ਼ੀ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਖਾਲੀ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। \\n\\n6. ਟਰਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਓਪਰੇਟਰਃ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਸਧਾਰਨ ਜੇਕਰ-ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਬਦਲੋ। \\n\\n7. ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇਨਲਾਈਨ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।ਇੱਕ ਥਾਂ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ \'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੁੱਖ ਕੋਡ ਦੇ ਅੰਦਰ ਇਨਲਾਈਨਿੰਗ ਕਰਨ\' ਤੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n8. ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓਃ ਜਿਵੇਂ ਕਿਇਹ ਇੱਕ ਕੋਡ-ਗੋਲਫ ਚੁਣੌਤੀ ਹੈ, ਅੰਤਿਮ ਕੋਡ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਟਿੱਪਣੀ ਜਾਂ ਵਿਆਖਿਆ ਨੂੰ ਹਟਾਓ। \\n\\n9. ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਉਹਨਾਂ ਦੇ ਲੰਬੇ ਬਰਾਬਰ ਦੀ ਬਜਾਏ \'+ =\', \'-=\', ਅਤੇ \'* =\'। \\n\\n10. ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਮਿਲਾਓਃ ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਓਰੇਂਜ ਜਾਂ ਹੋਰ ਦੁਹਰਾਉਣ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਜੋਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਿੰਗਲ ਲੂਪ। \\n\\n ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀ ਰੇਂਜ ਦੀ ਲੰਬਾਈ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦੇ ਹੋ।ਕੋਡ ਆਪਣੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ. \',\' ਅਜੇ ਤੱਕ ਕੋਈ ਕੋਡ ਲਿਖੇ ਬਿਨਾਂ, ਲੋਡ਼ੀਂਦੀਆਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ। \',\' ਇੱਥੇ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਲੋਡ਼ੀਂਦੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਰੂਪ ਰੇਖਾਃ \\n\\n ਕਲਾਸਾਂਃ \\n1. ਹੈਕਸਾਗਨਃ \\n-ਇੱਕ ਸਿੰਗਲ ਹੈਕਸਾਗੋਨਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਗਰਿੱਡ ਵਿੱਚ ਸੈੱਲ। \\n-ਇਸ ਵਿੱਚ ਆਪਣੀ ਸਥਿਤੀ, ਗੁਆਂਢੀਆਂ ਅਤੇ ਰਾਜ (ਕੰਧ ਜਾਂ ਮਾਰਗ) ਲਈ ਗੁਣ ਹੁੰਦੇ ਹਨ। \\n\\n2. ਭੁਲੱਕਡ਼ਃ \\n-ਸਮੁੱਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈਭੁਲੱਕਡ਼. \\n-ਗਰਿੱਡ ਅਕਾਰ, ਹੈਕਸਾਗੋਨਲ ਸੈੱਲਾਂ, ਅਤੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ। \\n-ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ। \\n\\nਫੰਕਸ਼ਨਃ \\n1. ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, ਗਰਿੱਡ _ ਸਾਈਜ਼): \\n-ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਟੀਕਿੰਟਰ ਦਾ ਕੈਨਵਸ. \\n\\n2. ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਲੈਬਰਿੰਥ): \\n-ਇੱਕ ਮੈਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਲੈਬਰਿੰਥ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕਰੂਸਕਲ ਦਾ ਐਲਗੋਰਿਦਮ। \\n-ਇੱਕ ਭੁਲੱਕਡ਼ ਵਸਤੂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈ ਅਤੇ ਭੁਲੱਕਡ਼ ਬਣਾਉਣ ਲਈ ਇਸ ਦੇ ਸੈੱਲਾਂ ਨੂੰ ਸੋਧਦਾ ਹੈ। \\n\\n3. ਵਿਜ਼ੂਅਲਾਈਜ਼ _ ਲੈਬਰਿੰਥ (ਕੈਨਵਸ,ਲੈਬਰਿੰਥ): \\n-ਲੈਬਰਿੰਥ ਦੀ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਪੈਦਾ ਹੋਈ ਲੈਬਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਦਾ ਹੈ। \\n\\n4.ਕ੍ਰਿਏਟ _ ਸਟਾਰਟ _ ਐਂਡ _ ਪੁਆਇੰਟਸ (ਭੁਲੱਕਡ਼): \\n-ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਦੋਵਾਂ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਅੰਕ. \\n\\n5. ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, ਭੁਲੱਕਡ਼): \\n-ਉਪਭੋਗਤਾ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਕੀਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੁਲੱਕਡ਼ ਰਾਹੀਂ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ।ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ। \\n\\n6. ਚੈੱਕ _ ਵਿੰਗਿੰਗ _ ਕੰਡੀਸ਼ਨ (ਭੁਲੱਕਡ਼): \\n-ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈਪੂਰਾ ਹੋਣ ਉੱਤੇ ਵਧਾਈ ਸੰਦੇਸ਼। \\n\\n7. ਮੁੱਖ (): \\n-ਮੁੱਖ ਫੰਕਸ਼ਨ ਜੋ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ। \\n-ਸ਼ੁਰੂ ਕਰਦਾ ਹੈਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ, ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਉਂਦੀ ਹੈ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਇਸ ਦੀ ਕਲਪਨਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਲਈ ਸੁਣਦੀ ਹੈ।ਲਾਗੂ ਕੀਤਾ ਕੋਡ. \', "ਇੱਥੇ ਪਾਈਥਨ ਦੇ ਟਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਛੋਟਾ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਇਸ ਤਰ੍ਹਾਂ ਹੈ।(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਰੇਂਜ (6) ਵਿੱਚ i ਲਈ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈਰੇਂਜ (n)] ਲਈ i ਲਈ ਰੇਂਜ (n)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (g): \\n v, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (g)-1, ਲੇਨ (g)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y= ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, ((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2)), (1-(y% 2),-1 + (y% 2)2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\n\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = 500, ਉਚਾਈ = 500)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, 16,12) \\ngenਾਰੇਟ _ ਲੈਬਰਿੰਥ (ਗਰਿੱਡ)\\nroot.mainloop () \\n "\'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿਇਸ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਸੰਖੇਪਤਾ ਲਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਜਾਂ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਤਿਆਰ ਕੀਤਾ ਕੋਡ, ਫਿਕਸ ਪ੍ਰਸਤਾਵਾਂ ਦੇ ਨਾਲ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' 1. ਮੁੱਦਾਃ ਸੀਮਤ ਵਿੰਡੋ ਸਾਈਜ਼ ਅਤੇ ਫਿਕਸਡ ਗਰਿੱਡ ਸਾਈਜ਼ \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਨੂੰ ਅਨੁਕੂਲ ਕਰੋ ਅਤੇਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਚਾਈ, ਅਤੇ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਗਰਿੱਡ ਅਕਾਰ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕਰੋ। ਕੈਨਵਸ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਅਨੁਕੂਲ ਕਰੋਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਅਨੁਸਾਰ. \\n\\n2. ਮੁੱਦਾਃ ਕੋਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆ ਜਾਂ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਨਾਲ ਕੀਬੋਰਡ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰੋਜੋ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇਹ ਕੋਡ ਦੀ ਲੰਬਾਈ ਵਧਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਪ੍ਰਦਾਨ ਕਰੇਗਾਉਪਭੋਗੀ ਨੇਵੀਗੇਸ਼ਨ ਅਤੇ ਜਿੱਤ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਾਰਜਕੁਸ਼ਲਤਾ। \\n\\n3. ਮੁੱਦਾਃ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਭੁਲੇਖਾ ਪੀਡ਼੍ਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ \\n ਫਿਕਸਃਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਬਿਹਤਰ ਗੁੰਝਲਤਾ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਵਧੇਰੇ ਫਿਟਿੰਗ ਮੇਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal \'s।ਥੋਡ਼੍ਹਾ ਲੰਬਾ ਕੋਡ ਪਰ ਸਮੁੱਚੀ ਗੁੰਝਲਤਾ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n4. ਮੁੱਦਾਃ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਦਾ ਕੋਈ ਸਪਸ਼ਟ ਸੰਕੇਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਰੰਗ ਸੰਸ਼ੋਧਿਤ ਕਰੋਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਬਾਕੀ ਗੁੰਝਲਤਾ ਤੋਂ ਵੱਖ ਕਰਨ ਲਈ। ਇਸ ਲਈ ਕੋਡ ਵਿੱਚ ਮਾਮੂਲੀ ਤਬਦੀਲੀ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ ਅਤੇ ਨਹੀਂਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਉੱਤੇ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। \\n\\n5. ਮੁੱਦਾਃ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਲਈ ਕੋਈ ਵਿਜ਼ੂਅਲ ਫੀਡਬੈਕ ਨਹੀਂ \\n ਫਿਕਸਃ ਲਈ ਇੱਕ ਵਿਜ਼ੂਅਲ ਸੂਚਕ ਲਾਗੂ ਕਰੋਭੁਲੱਕਡ਼ ਵਿੱਚ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ, ਜਿਵੇਂ ਕਿ ਮੌਜੂਦਾ ਹੈਕਸਾਗਨ ਦਾ ਰੰਗ ਬਦਲਣਾ। ਇਸ ਲਈ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸੋਧ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ।ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਦੀ ਮਾਤਰਾ ਅਤੇ ਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਤੇ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰੇਗਾ। \\n\\n ਇਨ੍ਹਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਨਾਲ, ਕੋਡ ਵਧੇਰੇ ਕਾਰਜਸ਼ੀਲ ਹੋ ਜਾਵੇਗਾ ਅਤੇਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ ਵੀ ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ "., \'ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਗਲਤੀਆਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿਓ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ।ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹੋਏ, ਕੁੱਝ ਗਲਤੀਆਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਅਨੁਸਾਰੀ ਫਿਕਸ ਹੁੰਦੇ ਹਨਃ \\n\\n1. ਗਲਤੀਃ ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਇੱਕ ਵਰਗ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਦੀ ਬਜਾਏ ਗਰਿੱਡ। \\n ਫਿਕਸਃ ਹੈਕਸਾਗੋਨਲ ਸਥਿਤੀਆਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰਕੇ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਤਿਆਰ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ ਸੋਧੋ ਅਤੇਗੁਆਂਢੀ। \\n\\n2. ਗਲਤੀਃ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ ਫੰਕਸ਼ਨ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ। \\n ਫਿਕਸਃ ਬਦਲੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੇਂ ਐਲਗੋਰਿਦਮ ਦੇ ਨਾਲ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal. ਇਸ ਦੇ ਨਤੀਜੇ ਥੋਡ਼ੇ ਲੰਬੇ ਹੋ ਸਕਦੇ ਹਨਕੋਡ ਪਰ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n3. ਗਲਤੀਃ ਕੋਡ ਵਿੱਚ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ ਅਤੇ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਦੀ ਘਾਟ ਹੈ। \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ) ਨੂੰ ਸੰਭਾਲਣ ਅਤੇ ਉਹਨਾਂ ਦੇ ਇਨਪੁਟ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ। ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਚੈੱਕ ਸ਼ਾਮਲ ਕਰੋਪਤਾ ਲਗਾਓ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ। \\n\\n4. ਗਲਤੀਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਸਥਿਰ ਹੈ ਅਤੇ ਗਰਿੱਡ ਅਨੁਸਾਰ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ।ਅਕਾਰ. \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਅਨੁਕੂਲ ਕਰੋ। ਇਹ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇਸ ਲਈ ਵਧੇਰੇ ਲਚਕਦਾਰ ਬਣਾਵੇਗਾ।ਵੱਖ-ਵੱਖ ਗਰਿੱਡ ਅਕਾਰ। \\n\\n ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਸ਼ੁਰੂਆਤੀ ਕੋਡ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਦਾ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਲਾਗੂਕਰਨ ਸੀ। ਇਹਨਾਂ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਕੇਗਲਤੀਆਂ, ਕੋਡ ਇੱਕ ਬਿਹਤਰ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਅਤੇ ਬਿਹਤਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰੇਗਾ ਜਦੋਂ ਕਿ ਅਜੇ ਵੀ ਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖੇਗਾ।ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤਾ ਕੋਡ। \',\' ਇੱਥੇ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਦਾ ਇੱਕ ਅੱਪਡੇਟ ਕੀਤਾ ਸੰਸਕਰਣ ਹੈ।tkinter: \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ tkinter ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\n\\ndef ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): \\n ਰਿਟਰਨ [(c.create_polygon ([(lambda a, b: (a + s *)(i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =\\\'\\\', ਰਾਜ =\\\'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈਰੇਂਜ (6)], ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈ ਰੇਂਜ (ਐੱਨ)] ਵਿੱਚ i ਲਈ ਰੇਂਜ (ਐੱਨ)]\\ਐੱਨ ਐੱਨ ਡੀ ਐੱਫ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਜੀ):\\ਐੱਨ ਵੀ, ਐੱਸ, ਈ, ਸਟੈਕ = ਸੈੱਟ (), (0,0),(ਲੇਨ (ਜੀ)-1, ਲੇਨ (ਜੀ)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\n n = [(x + i, y + j) i ਲਈ, ((1,0), (0,0), (0,1), (0,0), (0,- 1), (-1 + (y% 2), 1-(y% 2), (1-(y% 2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <len (g) ਅਤੇ 0 <= y + j <len (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ।nx, ny = random.choice (n) \\n g [y] [x]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n g [ny] [nx]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n stack.append (((nx, ny)) \\n ਹੋਰਃ \\nstack.pop () \\n\\ndef ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,-1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬਾ\': (-1,0),\\\'ਸੱਜਾ\': (1,0)} ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\nnx, ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰ g [ny] [nx] ਹੈ।g [p [1]] [p [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਕਾਲਾ\') \\n p = (nx, ny) \\n g [p [1]] [p [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਲਾਲ\') \\n ਜੇਕਰ p = = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ"") \\n\\nn = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack () \\ngrid =ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\ngrid [ਪ੍ਲੇਯਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\')\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਲੈਂਬਡਾ ਈਃ ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ, ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ,ਗਰਿੱਡ))\\nroot.mainloop () \\n \'\\n\\n ਇਸ ਅੱਪਡੇਟ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਸਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਜਨਰੇਸ਼ਨ ਸ਼ਾਮਲ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੀਂ ਭੁਲੱਕਡ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਹੈ।ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ, NAME _ 3 ਨਾਲ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ, ਅਤੇ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰੋ ਜਦੋਂ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ।ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਹਰੇ ਅਤੇ ਨੀਲੇ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਲਾਲ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਕੋਡ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰੋ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' ਕੋਡ ਦੀ ਧਿਆਨ ਨਾਲ ਸਮੀਖਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇੱਕ ਸੰਟੈਕਸ ਗਲਤੀ ਹੈ ਅਤੇ ਇਸਦਾ ਅਨੁਸਾਰੀ ਸੁਧਾਰ ਹੈਃ \\n\\n1।ਗਲਤੀਃ \'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਫੰਕਸ਼ਨ ਅੱਪਡੇਟ ਕੀਤੇ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਵਾਪਸ ਨਹੀਂ ਕਰਦਾ। \\n ਫਿਕਸਃ \'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਫੰਕਸ਼ਨ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋਉਪਭੋਗਤਾ ਦੇ ਇੰਪੁੱਟ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਅੱਪਡੇਟ ਕੀਤਾ ਗਿਆ। ਫਿਰ, \'root.bind ()\' ਵਿਧੀ ਵਿੱਚ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ\'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਮੁੱਲ ਲਈ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\'। \\n\\nਇੱਥੇ ਕੋਡ ਦਾ ਸਹੀ ਸੰਸਕਰਣ ਹੈਃ \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ \'(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =\\\'\\\', ਅਵਸਥਾ =\\\'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈ ਸੀਮਾ (6) ਵਿੱਚ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\')ਜੇ ਲਈ ਰੇਂਜ (ਐੱਨ)] ਵਿੱਚ i ਲਈ ਰੇਂਜ (ਐੱਨ)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਜੀ): \\nv, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (ਜੀ)-1, ਲੇਨ (ਜੀ)-1), [(0,0)] \\n ਜਦੋਂ ਕਿਸਟੈਕਃ \\nx, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, j ਵਿੱਚ (((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2), (1-(y% 2)2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\nਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ (ਈਵੈਂਟ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,-1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬੇ\': (-1,0),\\\'ਸੱਜੇ\': (1,0)}. ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\n nx,ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰ g [ny] [nx] ਹੈ।g [p [1]] [p [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\') \\n ਜੇਕਰ p = = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ ਜਿੱਤ ਗਏ!") \\n ਰਿਟਰਨ p\\n\\n = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack () \\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\nਗ੍ਰਿਡ [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\')\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਲੈਂਬਡਾ ਈਃ ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨਃ = ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ,ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ, ਗਰਿੱਡ))\\nroot.mainloop () \\n \'\\n\' ਹੁਣ ਕੋਡ ਉਪਭੋਗਤਾ ਦੇ ਇੰਪੁੱਟ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਤੋਂ ਬਾਅਦ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਅਪਡੇਟ ਕਰਦਾ ਹੈ।ਆਖਰੀ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਸੰਟੈਕਸ ਗਲਤੀਆਂ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿੰਦੀਆਂ ਹਨ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੀਆਂ ਹਨ। ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n \', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਲਾਬੀਰਿੰਥ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਲਾਬੀਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ \'ਤੇ ਲੋਡ਼ੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ.\', \'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।\', \'1. ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਲੂਪਸ, ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਕੋਡ ਵਿੱਚ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ। \\n\\n2. ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ-ਛੋਟੇ ਅਤੇ ਸਰਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲੋ।ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ \'ਡੀ. ਐੱਫ.\' ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੰਕਸ਼ਨ। \\n\\n3. ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂਃ ਤਰਜੀਹਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮ ਅਤੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਲੂਪ ਇਟਰੇਟਰ। \\n\\n4. ਚੇਨ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨਃ ਚੇਨ ਮਲਟੀਪਲਢੰਗ ਜਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠੇ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਵਸਤੂ ਉੱਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ। \\n\\n5. ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰੋਵ੍ਹਾਈਟਸਪੇਸ-ਪਡ਼੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬੇਲੋਡ਼ੀ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਖਾਲੀ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। \\n\\n6. ਟਰਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਓਪਰੇਟਰਃ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਸਧਾਰਨ ਜੇਕਰ-ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਬਦਲੋ। \\n\\n7. ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇਨਲਾਈਨ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।ਇੱਕ ਥਾਂ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ \'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੁੱਖ ਕੋਡ ਦੇ ਅੰਦਰ ਇਨਲਾਈਨਿੰਗ ਕਰਨ\' ਤੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n8. ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓਃ ਜਿਵੇਂ ਕਿਇਹ ਇੱਕ ਕੋਡ-ਗੋਲਫ ਚੁਣੌਤੀ ਹੈ, ਅੰਤਿਮ ਕੋਡ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਟਿੱਪਣੀ ਜਾਂ ਵਿਆਖਿਆ ਨੂੰ ਹਟਾਓ। \\n\\n9. ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਉਹਨਾਂ ਦੇ ਲੰਬੇ ਬਰਾਬਰ ਦੀ ਬਜਾਏ \'+ =\', \'-=\', ਅਤੇ \'* =\'। \\n\\n10. ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਮਿਲਾਓਃ ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਓਰੇਂਜ ਜਾਂ ਹੋਰ ਦੁਹਰਾਉਣ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਜੋਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਿੰਗਲ ਲੂਪ। \\n\\n ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀ ਰੇਂਜ ਦੀ ਲੰਬਾਈ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦੇ ਹੋ।ਕੋਡ ਆਪਣੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ. \',\' ਅਜੇ ਤੱਕ ਕੋਈ ਕੋਡ ਲਿਖੇ ਬਿਨਾਂ, ਲੋਡ਼ੀਂਦੀਆਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ। \',\' ਇੱਥੇ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਲੋਡ਼ੀਂਦੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਰੂਪ ਰੇਖਾਃ \\n\\n ਕਲਾਸਾਂਃ \\n1. ਹੈਕਸਾਗਨਃ \\n-ਇੱਕ ਸਿੰਗਲ ਹੈਕਸਾਗੋਨਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਗਰਿੱਡ ਵਿੱਚ ਸੈੱਲ। \\n-ਇਸ ਵਿੱਚ ਆਪਣੀ ਸਥਿਤੀ, ਗੁਆਂਢੀਆਂ ਅਤੇ ਰਾਜ (ਕੰਧ ਜਾਂ ਮਾਰਗ) ਲਈ ਗੁਣ ਹੁੰਦੇ ਹਨ। \\n\\n2. ਭੁਲੱਕਡ਼ਃ \\n-ਸਮੁੱਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈਭੁਲੱਕਡ਼. \\n-ਗਰਿੱਡ ਅਕਾਰ, ਹੈਕਸਾਗੋਨਲ ਸੈੱਲਾਂ, ਅਤੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ। \\n-ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ। \\n\\nਫੰਕਸ਼ਨਃ \\n1. ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, ਗਰਿੱਡ _ ਸਾਈਜ਼): \\n-ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਟੀਕਿੰਟਰ ਦਾ ਕੈਨਵਸ. \\n\\n2. ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਲੈਬਰਿੰਥ): \\n-ਇੱਕ ਮੈਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਲੈਬਰਿੰਥ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕਰੂਸਕਲ ਦਾ ਐਲਗੋਰਿਦਮ। \\n-ਇੱਕ ਭੁਲੱਕਡ਼ ਵਸਤੂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈ ਅਤੇ ਭੁਲੱਕਡ਼ ਬਣਾਉਣ ਲਈ ਇਸ ਦੇ ਸੈੱਲਾਂ ਨੂੰ ਸੋਧਦਾ ਹੈ। \\n\\n3. ਵਿਜ਼ੂਅਲਾਈਜ਼ _ ਲੈਬਰਿੰਥ (ਕੈਨਵਸ,ਲੈਬਰਿੰਥ): \\n-ਲੈਬਰਿੰਥ ਦੀ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਪੈਦਾ ਹੋਈ ਲੈਬਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਦਾ ਹੈ। \\n\\n4.ਕ੍ਰਿਏਟ _ ਸਟਾਰਟ _ ਐਂਡ _ ਪੁਆਇੰਟਸ (ਭੁਲੱਕਡ਼): \\n-ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਦੋਵਾਂ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਅੰਕ. \\n\\n5. ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, ਭੁਲੱਕਡ਼): \\n-ਉਪਭੋਗਤਾ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਕੀਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੁਲੱਕਡ਼ ਰਾਹੀਂ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ।ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ। \\n\\n6. ਚੈੱਕ _ ਵਿੰਗਿੰਗ _ ਕੰਡੀਸ਼ਨ (ਭੁਲੱਕਡ਼): \\n-ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈਪੂਰਾ ਹੋਣ ਉੱਤੇ ਵਧਾਈ ਸੰਦੇਸ਼। \\n\\n7. ਮੁੱਖ (): \\n-ਮੁੱਖ ਫੰਕਸ਼ਨ ਜੋ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ। \\n-ਸ਼ੁਰੂ ਕਰਦਾ ਹੈਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ, ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਉਂਦੀ ਹੈ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਇਸ ਦੀ ਕਲਪਨਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਲਈ ਸੁਣਦੀ ਹੈ।ਲਾਗੂ ਕੀਤਾ ਕੋਡ. \', "ਇੱਥੇ ਪਾਈਥਨ ਦੇ ਟਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਛੋਟਾ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਇਸ ਤਰ੍ਹਾਂ ਹੈ।(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਰੇਂਜ (6) ਵਿੱਚ i ਲਈ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈਰੇਂਜ (n)] ਲਈ i ਲਈ ਰੇਂਜ (n)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (g): \\n v, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (g)-1, ਲੇਨ (g)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y= ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, ((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2)), (1-(y% 2),-1 + (y% 2)2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\n\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = 500, ਉਚਾਈ = 500)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, 16,12) \\ngenਾਰੇਟ _ ਲੈਬਰਿੰਥ (ਗਰਿੱਡ)\\nroot.mainloop () \\n "\'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿਇਸ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਸੰਖੇਪਤਾ ਲਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਜਾਂ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਤਿਆਰ ਕੀਤਾ ਕੋਡ, ਫਿਕਸ ਪ੍ਰਸਤਾਵਾਂ ਦੇ ਨਾਲ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' 1. ਮੁੱਦਾਃ ਸੀਮਤ ਵਿੰਡੋ ਸਾਈਜ਼ ਅਤੇ ਫਿਕਸਡ ਗਰਿੱਡ ਸਾਈਜ਼ \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਨੂੰ ਅਨੁਕੂਲ ਕਰੋ ਅਤੇਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਚਾਈ, ਅਤੇ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਗਰਿੱਡ ਅਕਾਰ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕਰੋ। ਕੈਨਵਸ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਅਨੁਕੂਲ ਕਰੋਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਅਨੁਸਾਰ. \\n\\n2. ਮੁੱਦਾਃ ਕੋਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆ ਜਾਂ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਨਾਲ ਕੀਬੋਰਡ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰੋਜੋ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇਹ ਕੋਡ ਦੀ ਲੰਬਾਈ ਵਧਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਪ੍ਰਦਾਨ ਕਰੇਗਾਉਪਭੋਗੀ ਨੇਵੀਗੇਸ਼ਨ ਅਤੇ ਜਿੱਤ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਾਰਜਕੁਸ਼ਲਤਾ। \\n\\n3. ਮੁੱਦਾਃ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਭੁਲੇਖਾ ਪੀਡ਼੍ਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ \\n ਫਿਕਸਃਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਬਿਹਤਰ ਗੁੰਝਲਤਾ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਵਧੇਰੇ ਫਿਟਿੰਗ ਮੇਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal \'s।ਥੋਡ਼੍ਹਾ ਲੰਬਾ ਕੋਡ ਪਰ ਸਮੁੱਚੀ ਗੁੰਝਲਤਾ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n4. ਮੁੱਦਾਃ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਦਾ ਕੋਈ ਸਪਸ਼ਟ ਸੰਕੇਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਰੰਗ ਸੰਸ਼ੋਧਿਤ ਕਰੋਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਬਾਕੀ ਗੁੰਝਲਤਾ ਤੋਂ ਵੱਖ ਕਰਨ ਲਈ। ਇਸ ਲਈ ਕੋਡ ਵਿੱਚ ਮਾਮੂਲੀ ਤਬਦੀਲੀ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ ਅਤੇ ਨਹੀਂਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਉੱਤੇ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। \\n\\n5. ਮੁੱਦਾਃ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਲਈ ਕੋਈ ਵਿਜ਼ੂਅਲ ਫੀਡਬੈਕ ਨਹੀਂ \\n ਫਿਕਸਃ ਲਈ ਇੱਕ ਵਿਜ਼ੂਅਲ ਸੂਚਕ ਲਾਗੂ ਕਰੋਭੁਲੱਕਡ਼ ਵਿੱਚ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ, ਜਿਵੇਂ ਕਿ ਮੌਜੂਦਾ ਹੈਕਸਾਗਨ ਦਾ ਰੰਗ ਬਦਲਣਾ। ਇਸ ਲਈ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸੋਧ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ।ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਦੀ ਮਾਤਰਾ ਅਤੇ ਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਤੇ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰੇਗਾ। \\n\\n ਇਨ੍ਹਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਨਾਲ, ਕੋਡ ਵਧੇਰੇ ਕਾਰਜਸ਼ੀਲ ਹੋ ਜਾਵੇਗਾ ਅਤੇਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ ਵੀ ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ "., \'ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਗਲਤੀਆਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿਓ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ।ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹੋਏ, ਕੁੱਝ ਗਲਤੀਆਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਅਨੁਸਾਰੀ ਫਿਕਸ ਹੁੰਦੇ ਹਨਃ \\n\\n1. ਗਲਤੀਃ ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਇੱਕ ਵਰਗ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਦੀ ਬਜਾਏ ਗਰਿੱਡ। \\n ਫਿਕਸਃ ਹੈਕਸਾਗੋਨਲ ਸਥਿਤੀਆਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰਕੇ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਤਿਆਰ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ ਸੋਧੋ ਅਤੇਗੁਆਂਢੀ। \\n\\n2. ਗਲਤੀਃ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ ਫੰਕਸ਼ਨ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ। \\n ਫਿਕਸਃ ਬਦਲੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੇਂ ਐਲਗੋਰਿਦਮ ਦੇ ਨਾਲ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal. ਇਸ ਦੇ ਨਤੀਜੇ ਥੋਡ਼ੇ ਲੰਬੇ ਹੋ ਸਕਦੇ ਹਨਕੋਡ ਪਰ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n3. ਗਲਤੀਃ ਕੋਡ ਵਿੱਚ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ ਅਤੇ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਦੀ ਘਾਟ ਹੈ। \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ) ਨੂੰ ਸੰਭਾਲਣ ਅਤੇ ਉਹਨਾਂ ਦੇ ਇਨਪੁਟ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ। ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਚੈੱਕ ਸ਼ਾਮਲ ਕਰੋਪਤਾ ਲਗਾਓ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ। \\n\\n4. ਗਲਤੀਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਸਥਿਰ ਹੈ ਅਤੇ ਗਰਿੱਡ ਅਨੁਸਾਰ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ।ਅਕਾਰ. \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਅਨੁਕੂਲ ਕਰੋ। ਇਹ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇਸ ਲਈ ਵਧੇਰੇ ਲਚਕਦਾਰ ਬਣਾਵੇਗਾ।ਵੱਖ-ਵੱਖ ਗਰਿੱਡ ਅਕਾਰ। \\n\\n ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਸ਼ੁਰੂਆਤੀ ਕੋਡ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਦਾ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਲਾਗੂਕਰਨ ਸੀ। ਇਹਨਾਂ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਕੇਗਲਤੀਆਂ, ਕੋਡ ਇੱਕ ਬਿਹਤਰ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਅਤੇ ਬਿਹਤਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰੇਗਾ ਜਦੋਂ ਕਿ ਅਜੇ ਵੀ ਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖੇਗਾ।ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤਾ ਕੋਡ। \',\' ਇੱਥੇ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਦਾ ਇੱਕ ਅੱਪਡੇਟ ਕੀਤਾ ਸੰਸਕਰਣ ਹੈ।tkinter: \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ tkinter ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\n\\ndef ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): \\n ਰਿਟਰਨ [(c.create_polygon ([(lambda a, b: (a + s *)(i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =\\\'\\\', ਰਾਜ =\\\'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈਰੇਂਜ (6)], ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈ ਰੇਂਜ (ਐੱਨ)] ਵਿੱਚ i ਲਈ ਰੇਂਜ (ਐੱਨ)]\\ਐੱਨ ਐੱਨ ਡੀ ਐੱਫ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਜੀ):\\ਐੱਨ ਵੀ, ਐੱਸ, ਈ, ਸਟੈਕ = ਸੈੱਟ (), (0,0),(ਲੇਨ (ਜੀ)-1, ਲੇਨ (ਜੀ)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\n n = [(x + i, y + j) i ਲਈ, ((1,0), (0,0), (0,1), (0,0), (0,- 1), (-1 + (y% 2), 1-(y% 2), (1-(y% 2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <len (g) ਅਤੇ 0 <= y + j <len (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ।nx, ny = random.choice (n) \\n g [y] [x]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n g [ny] [nx]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n stack.append (((nx, ny)) \\n ਹੋਰਃ \\nstack.pop () \\n\\ndef ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,-1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬਾ\': (-1,0),\\\'ਸੱਜਾ\': (1,0)} ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\nnx, ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰ g [ny] [nx] ਹੈ।g [p [1]] [p [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਕਾਲਾ\') \\n p = (nx, ny) \\n g [p [1]] [p [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਲਾਲ\') \\n ਜੇਕਰ p = = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ"") \\n\\nn = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack () \\ngrid =ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\ngrid [ਪ੍ਲੇਯਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\')\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਲੈਂਬਡਾ ਈਃ ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ, ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ,ਗਰਿੱਡ))\\nroot.mainloop () \\n \'\\n\\n ਇਸ ਅੱਪਡੇਟ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਸਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਜਨਰੇਸ਼ਨ ਸ਼ਾਮਲ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੀਂ ਭੁਲੱਕਡ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਹੈ।ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ, NAME _ 3 ਨਾਲ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ, ਅਤੇ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰੋ ਜਦੋਂ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ।ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਹਰੇ ਅਤੇ ਨੀਲੇ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਲਾਲ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਕੋਡ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰੋ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' ਕੋਡ ਦੀ ਧਿਆਨ ਨਾਲ ਸਮੀਖਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇੱਕ ਸੰਟੈਕਸ ਗਲਤੀ ਹੈ ਅਤੇ ਇਸਦਾ ਅਨੁਸਾਰੀ ਸੁਧਾਰ ਹੈਃ \\n\\n1।ਗਲਤੀਃ \'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਫੰਕਸ਼ਨ ਅੱਪਡੇਟ ਕੀਤੇ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਵਾਪਸ ਨਹੀਂ ਕਰਦਾ। \\n ਫਿਕਸਃ \'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਫੰਕਸ਼ਨ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋਉਪਭੋਗਤਾ ਦੇ ਇੰਪੁੱਟ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਅੱਪਡੇਟ ਕੀਤਾ ਗਿਆ। ਫਿਰ, \'root.bind ()\' ਵਿਧੀ ਵਿੱਚ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ\'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਮੁੱਲ ਲਈ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\'। \\n\\nਇੱਥੇ ਕੋਡ ਦਾ ਸਹੀ ਸੰਸਕਰਣ ਹੈਃ \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ \'(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =\\\'\\\', ਅਵਸਥਾ =\\\'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈ ਸੀਮਾ (6) ਵਿੱਚ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\')ਜੇ ਲਈ ਰੇਂਜ (ਐੱਨ)] ਵਿੱਚ i ਲਈ ਰੇਂਜ (ਐੱਨ)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਜੀ): \\nv, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (ਜੀ)-1, ਲੇਨ (ਜੀ)-1), [(0,0)] \\n ਜਦੋਂ ਕਿਸਟੈਕਃ \\nx, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, j ਵਿੱਚ (((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2), (1-(y% 2)2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\nਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ (ਈਵੈਂਟ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,-1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬੇ\': (-1,0),\\\'ਸੱਜੇ\': (1,0)}. ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\n nx,ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰ g [ny] [nx] ਹੈ।g [p [1]] [p [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\') \\n ਜੇਕਰ p = = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ ਜਿੱਤ ਗਏ!") \\n ਰਿਟਰਨ p\\n\\n = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack () \\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\nਗ੍ਰਿਡ [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\')\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਲੈਂਬਡਾ ਈਃ ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨਃ = ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ,ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ, ਗਰਿੱਡ))\\nroot.mainloop () \\n \'\\n\' ਹੁਣ ਕੋਡ ਉਪਭੋਗਤਾ ਦੇ ਇੰਪੁੱਟ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਤੋਂ ਬਾਅਦ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਅਪਡੇਟ ਕਰਦਾ ਹੈ।ਆਖਰੀ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਸੰਟੈਕਸ ਗਲਤੀਆਂ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿੰਦੇ ਹਨ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \', "ਨਵੀਨਤਮ ਪ੍ਰਦਾਨ ਕੀਤੇ ਕੋਡ ਦੀ ਪੂਰੀ ਸਮੀਖਿਆ ਕਰਨ\' ਤੇ,ਕੋਈ ਸੰਟੈਕਸ ਗਲਤੀਆਂ ਨਹੀਂ ਹਨ। ਕੋਡ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ, ਨੇਵੀਗੇਸ਼ਨ ਲਈ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।ਜਦੋਂ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ. \\n\\n ਕੋਡ ਕਾਰਜਸ਼ੀਲ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਸੰਖੇਪ ਲਾਗੂਕਰਨ ਹੁੰਦਾ ਹੈ।ਪਾਈਥਨ ਦੀ ਟਿੰਟਰ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ "", ਹੇਠ ਦਿੱਤੀ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਰਦੇ ਹੋਏ ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੋਃ \\n\\treturn [[(c.create_polygon ([(lambda a,b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਰਾਜ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਲਈi ਸੀਮਾ (6) ਵਿੱਚ], ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਸੀਮਾ (n) ਵਿੱਚ j ਲਈ] ਸੀਮਾ (n) ਵਿੱਚ i ਲਈ] \\n\\t ^ \\nਸਿੰਟੈਕਸਐਰਰੋਰਰਃ ਗਲਤ ਸੰਟੈਕਸ\\n "] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n \', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਲਾਬੀਰਿੰਥ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਲਾਬੀਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ \'ਤੇ ਲੋਡ਼ੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ.\', \'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।\', \'1. ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਲੂਪਸ, ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਕੋਡ ਵਿੱਚ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ। \\n\\n2. ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ-ਛੋਟੇ ਅਤੇ ਸਰਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲੋ।ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ \'ਡੀ. ਐੱਫ.\' ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੰਕਸ਼ਨ। \\n\\n3. ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂਃ ਤਰਜੀਹਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮ ਅਤੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਲੂਪ ਇਟਰੇਟਰ। \\n\\n4. ਚੇਨ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨਃ ਚੇਨ ਮਲਟੀਪਲਢੰਗ ਜਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠੇ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਵਸਤੂ ਉੱਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ। \\n\\n5. ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰੋਵ੍ਹਾਈਟਸਪੇਸ-ਪਡ਼੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬੇਲੋਡ਼ੀ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਖਾਲੀ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। \\n\\n6. ਟਰਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਓਪਰੇਟਰਃ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਸਧਾਰਨ ਜੇਕਰ-ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਬਦਲੋ। \\n\\n7. ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇਨਲਾਈਨ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।ਇੱਕ ਥਾਂ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ \'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੁੱਖ ਕੋਡ ਦੇ ਅੰਦਰ ਇਨਲਾਈਨਿੰਗ ਕਰਨ\' ਤੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n8. ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓਃ ਜਿਵੇਂ ਕਿਇਹ ਇੱਕ ਕੋਡ-ਗੋਲਫ ਚੁਣੌਤੀ ਹੈ, ਅੰਤਿਮ ਕੋਡ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਟਿੱਪਣੀ ਜਾਂ ਵਿਆਖਿਆ ਨੂੰ ਹਟਾਓ। \\n\\n9. ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਉਹਨਾਂ ਦੇ ਲੰਬੇ ਬਰਾਬਰ ਦੀ ਬਜਾਏ \'+ =\', \'-=\', ਅਤੇ \'* =\'। \\n\\n10. ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਮਿਲਾਓਃ ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਓਰੇਂਜ ਜਾਂ ਹੋਰ ਦੁਹਰਾਉਣ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਜੋਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਿੰਗਲ ਲੂਪ। \\n\\n ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀ ਰੇਂਜ ਦੀ ਲੰਬਾਈ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦੇ ਹੋ।ਕੋਡ ਆਪਣੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ. \',\' ਅਜੇ ਤੱਕ ਕੋਈ ਕੋਡ ਲਿਖੇ ਬਿਨਾਂ, ਲੋਡ਼ੀਂਦੀਆਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ। \',\' ਇੱਥੇ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਲੋਡ਼ੀਂਦੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਰੂਪ ਰੇਖਾਃ \\n\\n ਕਲਾਸਾਂਃ \\n1. ਹੈਕਸਾਗਨਃ \\n-ਇੱਕ ਸਿੰਗਲ ਹੈਕਸਾਗੋਨਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਗਰਿੱਡ ਵਿੱਚ ਸੈੱਲ। \\n-ਇਸ ਵਿੱਚ ਆਪਣੀ ਸਥਿਤੀ, ਗੁਆਂਢੀਆਂ ਅਤੇ ਰਾਜ (ਕੰਧ ਜਾਂ ਮਾਰਗ) ਲਈ ਗੁਣ ਹੁੰਦੇ ਹਨ। \\n\\n2. ਭੁਲੱਕਡ਼ਃ \\n-ਸਮੁੱਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈਭੁਲੱਕਡ਼. \\n-ਗਰਿੱਡ ਅਕਾਰ, ਹੈਕਸਾਗੋਨਲ ਸੈੱਲਾਂ, ਅਤੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ। \\n-ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ। \\n\\nਫੰਕਸ਼ਨਃ \\n1. ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, ਗਰਿੱਡ _ ਸਾਈਜ਼): \\n-ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਟੀਕਿੰਟਰ ਦਾ ਕੈਨਵਸ. \\n\\n2. ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਲੈਬਰਿੰਥ): \\n-ਇੱਕ ਮੈਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਲੈਬਰਿੰਥ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕਰੂਸਕਲ ਦਾ ਐਲਗੋਰਿਦਮ। \\n-ਇੱਕ ਭੁਲੱਕਡ਼ ਵਸਤੂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈ ਅਤੇ ਭੁਲੱਕਡ਼ ਬਣਾਉਣ ਲਈ ਇਸ ਦੇ ਸੈੱਲਾਂ ਨੂੰ ਸੋਧਦਾ ਹੈ। \\n\\n3. ਵਿਜ਼ੂਅਲਾਈਜ਼ _ ਲੈਬਰਿੰਥ (ਕੈਨਵਸ,ਲੈਬਰਿੰਥ): \\n-ਲੈਬਰਿੰਥ ਦੀ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਪੈਦਾ ਹੋਈ ਲੈਬਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਦਾ ਹੈ। \\n\\n4.ਕ੍ਰਿਏਟ _ ਸਟਾਰਟ _ ਐਂਡ _ ਪੁਆਇੰਟਸ (ਭੁਲੱਕਡ਼): \\n-ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਦੋਵਾਂ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਅੰਕ. \\n\\n5. ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, ਭੁਲੱਕਡ਼): \\n-ਉਪਭੋਗਤਾ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਕੀਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੁਲੱਕਡ਼ ਰਾਹੀਂ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ।ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ। \\n\\n6. ਚੈੱਕ _ ਵਿੰਗਿੰਗ _ ਕੰਡੀਸ਼ਨ (ਭੁਲੱਕਡ਼): \\n-ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈਪੂਰਾ ਹੋਣ ਉੱਤੇ ਵਧਾਈ ਸੰਦੇਸ਼। \\n\\n7. ਮੁੱਖ (): \\n-ਮੁੱਖ ਫੰਕਸ਼ਨ ਜੋ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ। \\n-ਸ਼ੁਰੂ ਕਰਦਾ ਹੈਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ, ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਉਂਦੀ ਹੈ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਇਸ ਦੀ ਕਲਪਨਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਲਈ ਸੁਣਦੀ ਹੈ।ਲਾਗੂ ਕੀਤਾ ਕੋਡ. \', "ਇੱਥੇ ਪਾਈਥਨ ਦੇ ਟਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਛੋਟਾ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਇਸ ਤਰ੍ਹਾਂ ਹੈ।(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਰੇਂਜ (6) ਵਿੱਚ i ਲਈ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈਰੇਂਜ (n)] ਲਈ i ਲਈ ਰੇਂਜ (n)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (g): \\n v, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (g)-1, ਲੇਨ (g)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y= ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, ((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2)), (1-(y% 2),-1 + (y% 2)2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\n\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = 500, ਉਚਾਈ = 500)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, 16,12) \\ngenਾਰੇਟ _ ਲੈਬਰਿੰਥ (ਗਰਿੱਡ)\\nroot.mainloop () \\n "\'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿਇਸ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਸੰਖੇਪਤਾ ਲਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਜਾਂ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਤਿਆਰ ਕੀਤਾ ਕੋਡ, ਫਿਕਸ ਪ੍ਰਸਤਾਵਾਂ ਦੇ ਨਾਲ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' 1. ਮੁੱਦਾਃ ਸੀਮਤ ਵਿੰਡੋ ਸਾਈਜ਼ ਅਤੇ ਫਿਕਸਡ ਗਰਿੱਡ ਸਾਈਜ਼ \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਨੂੰ ਅਨੁਕੂਲ ਕਰੋ ਅਤੇਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਚਾਈ, ਅਤੇ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਗਰਿੱਡ ਅਕਾਰ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕਰੋ। ਕੈਨਵਸ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਅਨੁਕੂਲ ਕਰੋਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਅਨੁਸਾਰ. \\n\\n2. ਮੁੱਦਾਃ ਕੋਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆ ਜਾਂ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਨਾਲ ਕੀਬੋਰਡ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰੋਜੋ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇਹ ਕੋਡ ਦੀ ਲੰਬਾਈ ਵਧਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਪ੍ਰਦਾਨ ਕਰੇਗਾਉਪਭੋਗੀ ਨੇਵੀਗੇਸ਼ਨ ਅਤੇ ਜਿੱਤ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਾਰਜਕੁਸ਼ਲਤਾ। \\n\\n3. ਮੁੱਦਾਃ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਭੁਲੇਖਾ ਪੀਡ਼੍ਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ \\n ਫਿਕਸਃਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਬਿਹਤਰ ਗੁੰਝਲਤਾ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਵਧੇਰੇ ਫਿਟਿੰਗ ਮੇਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal \'s।ਥੋਡ਼੍ਹਾ ਲੰਬਾ ਕੋਡ ਪਰ ਸਮੁੱਚੀ ਗੁੰਝਲਤਾ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n4. ਮੁੱਦਾਃ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਦਾ ਕੋਈ ਸਪਸ਼ਟ ਸੰਕੇਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਰੰਗ ਸੰਸ਼ੋਧਿਤ ਕਰੋਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਬਾਕੀ ਗੁੰਝਲਤਾ ਤੋਂ ਵੱਖ ਕਰਨ ਲਈ। ਇਸ ਲਈ ਕੋਡ ਵਿੱਚ ਮਾਮੂਲੀ ਤਬਦੀਲੀ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ ਅਤੇ ਨਹੀਂਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਉੱਤੇ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। \\n\\n5. ਮੁੱਦਾਃ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਲਈ ਕੋਈ ਵਿਜ਼ੂਅਲ ਫੀਡਬੈਕ ਨਹੀਂ \\n ਫਿਕਸਃ ਲਈ ਇੱਕ ਵਿਜ਼ੂਅਲ ਸੂਚਕ ਲਾਗੂ ਕਰੋਭੁਲੱਕਡ਼ ਵਿੱਚ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ, ਜਿਵੇਂ ਕਿ ਮੌਜੂਦਾ ਹੈਕਸਾਗਨ ਦਾ ਰੰਗ ਬਦਲਣਾ। ਇਸ ਲਈ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸੋਧ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ।ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਦੀ ਮਾਤਰਾ ਅਤੇ ਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਤੇ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰੇਗਾ। \\n\\n ਇਨ੍ਹਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਨਾਲ, ਕੋਡ ਵਧੇਰੇ ਕਾਰਜਸ਼ੀਲ ਹੋ ਜਾਵੇਗਾ ਅਤੇਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ ਵੀ ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ "., \'ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਗਲਤੀਆਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿਓ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ।ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹੋਏ, ਕੁੱਝ ਗਲਤੀਆਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਅਨੁਸਾਰੀ ਫਿਕਸ ਹੁੰਦੇ ਹਨਃ \\n\\n1. ਗਲਤੀਃ ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਇੱਕ ਵਰਗ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਦੀ ਬਜਾਏ ਗਰਿੱਡ। \\n ਫਿਕਸਃ ਹੈਕਸਾਗੋਨਲ ਸਥਿਤੀਆਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰਕੇ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਤਿਆਰ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ ਸੋਧੋ ਅਤੇਗੁਆਂਢੀ। \\n\\n2. ਗਲਤੀਃ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ ਫੰਕਸ਼ਨ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ। \\n ਫਿਕਸਃ ਬਦਲੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੇਂ ਐਲਗੋਰਿਦਮ ਦੇ ਨਾਲ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal. ਇਸ ਦੇ ਨਤੀਜੇ ਥੋਡ਼ੇ ਲੰਬੇ ਹੋ ਸਕਦੇ ਹਨਕੋਡ ਪਰ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n3. ਗਲਤੀਃ ਕੋਡ ਵਿੱਚ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ ਅਤੇ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਦੀ ਘਾਟ ਹੈ। \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ) ਨੂੰ ਸੰਭਾਲਣ ਅਤੇ ਉਹਨਾਂ ਦੇ ਇਨਪੁਟ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ। ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਚੈੱਕ ਸ਼ਾਮਲ ਕਰੋਪਤਾ ਲਗਾਓ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ। \\n\\n4. ਗਲਤੀਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਸਥਿਰ ਹੈ ਅਤੇ ਗਰਿੱਡ ਅਨੁਸਾਰ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ।ਅਕਾਰ. \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਅਨੁਕੂਲ ਕਰੋ। ਇਹ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇਸ ਲਈ ਵਧੇਰੇ ਲਚਕਦਾਰ ਬਣਾਵੇਗਾ।ਵੱਖ-ਵੱਖ ਗਰਿੱਡ ਅਕਾਰ। \\n\\n ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਸ਼ੁਰੂਆਤੀ ਕੋਡ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਦਾ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਲਾਗੂਕਰਨ ਸੀ। ਇਹਨਾਂ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਕੇਗਲਤੀਆਂ, ਕੋਡ ਇੱਕ ਬਿਹਤਰ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਅਤੇ ਬਿਹਤਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰੇਗਾ ਜਦੋਂ ਕਿ ਅਜੇ ਵੀ ਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖੇਗਾ।ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤਾ ਕੋਡ। \',\' ਇੱਥੇ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਦਾ ਇੱਕ ਅੱਪਡੇਟ ਕੀਤਾ ਸੰਸਕਰਣ ਹੈ।tkinter: \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ tkinter ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\n\\ndef ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): \\n ਰਿਟਰਨ [(c.create_polygon ([(lambda a, b: (a + s *)(i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =\\\'\\\', ਰਾਜ =\\\'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈਰੇਂਜ (6)], ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈ ਰੇਂਜ (ਐੱਨ)] ਵਿੱਚ i ਲਈ ਰੇਂਜ (ਐੱਨ)]\\ਐੱਨ ਐੱਨ ਡੀ ਐੱਫ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਜੀ):\\ਐੱਨ ਵੀ, ਐੱਸ, ਈ, ਸਟੈਕ = ਸੈੱਟ (), (0,0),(ਲੇਨ (ਜੀ)-1, ਲੇਨ (ਜੀ)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\n n = [(x + i, y + j) i ਲਈ, ((1,0), (0,0), (0,1), (0,0), (0,- 1), (-1 + (y% 2), 1-(y% 2), (1-(y% 2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <len (g) ਅਤੇ 0 <= y + j <len (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ।nx, ny = random.choice (n) \\n g [y] [x]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n g [ny] [nx]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n stack.append (((nx, ny)) \\n ਹੋਰਃ \\nstack.pop () \\n\\ndef ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,-1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬਾ\': (-1,0),\\\'ਸੱਜਾ\': (1,0)} ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\nnx, ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰ g [ny] [nx] ਹੈ।g [p [1]] [p [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਕਾਲਾ\') \\n p = (nx, ny) \\n g [p [1]] [p [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਲਾਲ\') \\n ਜੇਕਰ p = = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ"") \\n\\nn = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack () \\ngrid =ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\ngrid [ਪ੍ਲੇਯਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\')\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਲੈਂਬਡਾ ਈਃ ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ, ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ,ਗਰਿੱਡ))\\nroot.mainloop () \\n \'\\n\\n ਇਸ ਅੱਪਡੇਟ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਸਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਜਨਰੇਸ਼ਨ ਸ਼ਾਮਲ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੀਂ ਭੁਲੱਕਡ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਹੈ।ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ, NAME _ 3 ਨਾਲ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ, ਅਤੇ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰੋ ਜਦੋਂ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ।ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਹਰੇ ਅਤੇ ਨੀਲੇ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਲਾਲ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਕੋਡ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰੋ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' ਕੋਡ ਦੀ ਧਿਆਨ ਨਾਲ ਸਮੀਖਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇੱਕ ਸੰਟੈਕਸ ਗਲਤੀ ਹੈ ਅਤੇ ਇਸਦਾ ਅਨੁਸਾਰੀ ਸੁਧਾਰ ਹੈਃ \\n\\n1।ਗਲਤੀਃ \'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਫੰਕਸ਼ਨ ਅੱਪਡੇਟ ਕੀਤੇ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਵਾਪਸ ਨਹੀਂ ਕਰਦਾ। \\n ਫਿਕਸਃ \'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਫੰਕਸ਼ਨ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋਉਪਭੋਗਤਾ ਦੇ ਇੰਪੁੱਟ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਅੱਪਡੇਟ ਕੀਤਾ ਗਿਆ। ਫਿਰ, \'root.bind ()\' ਵਿਧੀ ਵਿੱਚ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ\'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਮੁੱਲ ਲਈ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\'। \\n\\nਇੱਥੇ ਕੋਡ ਦਾ ਸਹੀ ਸੰਸਕਰਣ ਹੈਃ \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ \'(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =\\\'\\\', ਅਵਸਥਾ =\\\'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈ ਸੀਮਾ (6) ਵਿੱਚ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\')ਜੇ ਲਈ ਰੇਂਜ (ਐੱਨ)] ਵਿੱਚ i ਲਈ ਰੇਂਜ (ਐੱਨ)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਜੀ): \\nv, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (ਜੀ)-1, ਲੇਨ (ਜੀ)-1), [(0,0)] \\n ਜਦੋਂ ਕਿਸਟੈਕਃ \\nx, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, j ਵਿੱਚ (((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2), (1-(y% 2)2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\nਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ (ਈਵੈਂਟ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,-1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬੇ\': (-1,0),\\\'ਸੱਜੇ\': (1,0)}. ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\n nx,ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰ g [ny] [nx] ਹੈ।g [p [1]] [p [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\') \\n ਜੇਕਰ p = = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ ਜਿੱਤ ਗਏ!") \\n ਰਿਟਰਨ p\\n\\n = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack () \\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\nਗ੍ਰਿਡ [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\')\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਲੈਂਬਡਾ ਈਃ ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨਃ = ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ,ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ, ਗਰਿੱਡ))\\nroot.mainloop () \\n \'\\n\' ਹੁਣ ਕੋਡ ਉਪਭੋਗਤਾ ਦੇ ਇੰਪੁੱਟ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਤੋਂ ਬਾਅਦ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਅਪਡੇਟ ਕਰਦਾ ਹੈ।ਆਖਰੀ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਸੰਟੈਕਸ ਗਲਤੀਆਂ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿੰਦੇ ਹਨ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \', "ਨਵੀਨਤਮ ਪ੍ਰਦਾਨ ਕੀਤੇ ਕੋਡ ਦੀ ਪੂਰੀ ਸਮੀਖਿਆ ਕਰਨ\' ਤੇ,ਕੋਈ ਸੰਟੈਕਸ ਗਲਤੀਆਂ ਨਹੀਂ ਹਨ। ਕੋਡ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ, ਨੇਵੀਗੇਸ਼ਨ ਲਈ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।ਜਦੋਂ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ. \\n\\n ਕੋਡ ਕਾਰਜਸ਼ੀਲ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਸੰਖੇਪ ਲਾਗੂਕਰਨ ਹੁੰਦਾ ਹੈ।ਪਾਈਥਨ ਦੀ ਟਿੰਟਰ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ "", ਹੇਠ ਦਿੱਤੀ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਰਦੇ ਹੋਏ ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੋਃ \\n\\treturn [[(c.create_polygon ([(lambda a,b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਰਾਜ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਲਈi ਰੇਂਜ (6) ਵਿੱਚ], ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਰੇਂਜ (n) ਵਿੱਚ j ਲਈ ਰੇਂਜ (n) ਵਿੱਚ i ਲਈ ਰੇਂਜ (n) ਵਿੱਚ] \\n\\t ^ \\nSyntaxErorr: ਅਮਾਨ੍ਯ ਸੰਟੈਕਸ \\n ", ਅਜਿਹਾ ਪ੍ਰਤੀਤ ਹੁੰਦਾ ਹੈ ਕਿ ਇੱਕ ਹੈਦਿੱਤੇ ਕੋਡ ਦੇ ਸੰਬੰਧ ਵਿੱਚ ਗ਼ਲਤਫ਼ਹਿਮੀ, ਕਿਉਂਕਿ ਦਿੱਤੀ ਗਈ ਲਾਈਨ ਵਿੱਚ ਕੋਈ ਸੰਟੈਕਸ ਗਲਤੀ ਨਹੀਂ ਹੈ। ਹਾਲਾਂਕਿ, ਮੈਂ \'ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ\' ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਾਂਗਾ।ਇਸ ਨੂੰ ਵਧੇਰੇ ਪਡ਼੍ਹਨਯੋਗ ਬਣਾਉਣ ਅਤੇ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਉਲਝਣ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨਃ \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟੀਕਿੰਟਰ ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\n\\ndefਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): n ਗਰਿੱਡ = [] n ਰੇਂਜ (n) ਵਿੱਚ i ਲਈਃ n ਕਤਾਰ = [] n ਰੇਂਜ (n) ਵਿੱਚ j ਲਈਃ n ਹੈਕਸ _ ਪੁਆਇੰਟ = [] n ਰੇਂਜ (6) ਵਿੱਚ k ਲਈਃ \\n a, b =c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2] \\n x, y = a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/2 \\nhex_points.append ((x, y)) \\n ਹੈਕਸਾਗਨ = c.create_polygon (ਹੈਕਸਾਗਨ ਅੰਕ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') \\n row.append (ਹੈਕਸਾਗਨ) \\n grid.append (ਕਤਾਰ) \\n ਵਾਪਸੀਗਰਿੱਡ \\n\\n #ਬਾਕੀ ਕੋਡ ਇੱਕੋ ਜਿਹਾ ਰਹਿੰਦਾ ਹੈ \\n\\nn = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732 /2)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ = \'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ = \'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\ngrid [ਪ੍ਲੇਯਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਲਾਲ\')\\nroot.bind (\'<ਕੁੰਜੀ>\', ਲੈਂਬਡਾ ਈਃ ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨਃ = ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ,ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ, ਗਰਿੱਡ))\\nroot.mainloop () \\n "\'\\n\\n ਮੁਡ਼ ਲਿਖਤ\' ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ \'ਫੰਕਸ਼ਨ ਵਧੇਰੇ ਪਡ਼੍ਹਨਯੋਗ ਹੈ, ਪਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਬਣੀ ਰਹਿੰਦੀ ਹੈਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਸੰਟੈਕਸ ਗਲਤੀਆਂ ਦੇ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।ਪਾਈਥਨ 3.7.9 \'] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n \', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਲਾਬੀਰਿੰਥ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਲਾਬੀਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ \'ਤੇ ਲੋਡ਼ੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ.\', \'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।\', \'1. ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਲੂਪਸ, ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਕੋਡ ਵਿੱਚ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ। \\n\\n2. ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ-ਛੋਟੇ ਅਤੇ ਸਰਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲੋ।ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ \'ਡੀ. ਐੱਫ.\' ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੰਕਸ਼ਨ। \\n\\n3. ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂਃ ਤਰਜੀਹਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮ ਅਤੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਲੂਪ ਇਟਰੇਟਰ। \\n\\n4. ਚੇਨ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨਃ ਚੇਨ ਮਲਟੀਪਲਢੰਗ ਜਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠੇ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਵਸਤੂ ਉੱਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ। \\n\\n5. ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰੋਵ੍ਹਾਈਟਸਪੇਸ-ਪਡ਼੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬੇਲੋਡ਼ੀ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਖਾਲੀ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। \\n\\n6. ਟਰਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਓਪਰੇਟਰਃ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਸਧਾਰਨ ਜੇਕਰ-ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਬਦਲੋ। \\n\\n7. ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇਨਲਾਈਨ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।ਇੱਕ ਥਾਂ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ \'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੁੱਖ ਕੋਡ ਦੇ ਅੰਦਰ ਇਨਲਾਈਨਿੰਗ ਕਰਨ\' ਤੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n8. ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓਃ ਜਿਵੇਂ ਕਿਇਹ ਇੱਕ ਕੋਡ-ਗੋਲਫ ਚੁਣੌਤੀ ਹੈ, ਅੰਤਿਮ ਕੋਡ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਟਿੱਪਣੀ ਜਾਂ ਵਿਆਖਿਆ ਨੂੰ ਹਟਾਓ। \\n\\n9. ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਉਹਨਾਂ ਦੇ ਲੰਬੇ ਬਰਾਬਰ ਦੀ ਬਜਾਏ \'+ =\', \'-=\', ਅਤੇ \'* =\'। \\n\\n10. ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਮਿਲਾਓਃ ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਓਰੇਂਜ ਜਾਂ ਹੋਰ ਦੁਹਰਾਉਣ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਜੋਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਿੰਗਲ ਲੂਪ। \\n\\n ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀ ਰੇਂਜ ਦੀ ਲੰਬਾਈ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦੇ ਹੋ।ਕੋਡ ਆਪਣੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ. \',\' ਅਜੇ ਤੱਕ ਕੋਈ ਕੋਡ ਲਿਖੇ ਬਿਨਾਂ, ਲੋਡ਼ੀਂਦੀਆਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ। \',\' ਇੱਥੇ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਲੋਡ਼ੀਂਦੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਰੂਪ ਰੇਖਾਃ \\n\\n ਕਲਾਸਾਂਃ \\n1. ਹੈਕਸਾਗਨਃ \\n-ਇੱਕ ਸਿੰਗਲ ਹੈਕਸਾਗੋਨਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਗਰਿੱਡ ਵਿੱਚ ਸੈੱਲ। \\n-ਇਸ ਵਿੱਚ ਆਪਣੀ ਸਥਿਤੀ, ਗੁਆਂਢੀਆਂ ਅਤੇ ਰਾਜ (ਕੰਧ ਜਾਂ ਮਾਰਗ) ਲਈ ਗੁਣ ਹੁੰਦੇ ਹਨ। \\n\\n2. ਭੁਲੱਕਡ਼ਃ \\n-ਸਮੁੱਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈਭੁਲੱਕਡ਼. \\n-ਗਰਿੱਡ ਅਕਾਰ, ਹੈਕਸਾਗੋਨਲ ਸੈੱਲਾਂ, ਅਤੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ। \\n-ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ। \\n\\nਫੰਕਸ਼ਨਃ \\n1. ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, ਗਰਿੱਡ _ ਸਾਈਜ਼): \\n-ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਟੀਕਿੰਟਰ ਦਾ ਕੈਨਵਸ. \\n\\n2. ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਲੈਬਰਿੰਥ): \\n-ਇੱਕ ਮੈਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਲੈਬਰਿੰਥ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕਰੂਸਕਲ ਦਾ ਐਲਗੋਰਿਦਮ। \\n-ਇੱਕ ਭੁਲੱਕਡ਼ ਵਸਤੂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈ ਅਤੇ ਭੁਲੱਕਡ਼ ਬਣਾਉਣ ਲਈ ਇਸ ਦੇ ਸੈੱਲਾਂ ਨੂੰ ਸੋਧਦਾ ਹੈ। \\n\\n3. ਵਿਜ਼ੂਅਲਾਈਜ਼ _ ਲੈਬਰਿੰਥ (ਕੈਨਵਸ,ਲੈਬਰਿੰਥ): \\n-ਲੈਬਰਿੰਥ ਦੀ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਪੈਦਾ ਹੋਈ ਲੈਬਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਦਾ ਹੈ। \\n\\n4.ਕ੍ਰਿਏਟ _ ਸਟਾਰਟ _ ਐਂਡ _ ਪੁਆਇੰਟਸ (ਭੁਲੱਕਡ਼): \\n-ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਦੋਵਾਂ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਅੰਕ. \\n\\n5. ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, ਭੁਲੱਕਡ਼): \\n-ਉਪਭੋਗਤਾ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਕੀਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੁਲੱਕਡ਼ ਰਾਹੀਂ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ।ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ। \\n\\n6. ਚੈੱਕ _ ਵਿੰਗਿੰਗ _ ਕੰਡੀਸ਼ਨ (ਭੁਲੱਕਡ਼): \\n-ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈਪੂਰਾ ਹੋਣ ਉੱਤੇ ਵਧਾਈ ਸੰਦੇਸ਼। \\n\\n7. ਮੁੱਖ (): \\n-ਮੁੱਖ ਫੰਕਸ਼ਨ ਜੋ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ। \\n-ਸ਼ੁਰੂ ਕਰਦਾ ਹੈਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ, ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਉਂਦੀ ਹੈ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਇਸ ਦੀ ਕਲਪਨਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਲਈ ਸੁਣਦੀ ਹੈ।ਲਾਗੂ ਕੀਤਾ ਕੋਡ. \', "ਇੱਥੇ ਪਾਈਥਨ ਦੇ ਟਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਛੋਟਾ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਇਸ ਤਰ੍ਹਾਂ ਹੈ।(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਰੇਂਜ (6) ਵਿੱਚ i ਲਈ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈਰੇਂਜ (n)] ਲਈ i ਲਈ ਰੇਂਜ (n)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (g): \\n v, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (g)-1, ਲੇਨ (g)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y= ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, ((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2)), (1-(y% 2),-1 + (y% 2)2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\n\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = 500, ਉਚਾਈ = 500)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, 16,12) \\ngenਾਰੇਟ _ ਲੈਬਰਿੰਥ (ਗਰਿੱਡ)\\nroot.mainloop () \\n "\'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿਇਸ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਸੰਖੇਪਤਾ ਲਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਜਾਂ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਤਿਆਰ ਕੀਤਾ ਕੋਡ, ਫਿਕਸ ਪ੍ਰਸਤਾਵਾਂ ਦੇ ਨਾਲ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' 1. ਮੁੱਦਾਃ ਸੀਮਤ ਵਿੰਡੋ ਸਾਈਜ਼ ਅਤੇ ਫਿਕਸਡ ਗਰਿੱਡ ਸਾਈਜ਼ \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਨੂੰ ਅਨੁਕੂਲ ਕਰੋ ਅਤੇਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਚਾਈ, ਅਤੇ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਗਰਿੱਡ ਅਕਾਰ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕਰੋ। ਕੈਨਵਸ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਅਨੁਕੂਲ ਕਰੋਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਅਨੁਸਾਰ. \\n\\n2. ਮੁੱਦਾਃ ਕੋਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆ ਜਾਂ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਨਾਲ ਕੀਬੋਰਡ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰੋਜੋ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇਹ ਕੋਡ ਦੀ ਲੰਬਾਈ ਵਧਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਪ੍ਰਦਾਨ ਕਰੇਗਾਉਪਭੋਗੀ ਨੇਵੀਗੇਸ਼ਨ ਅਤੇ ਜਿੱਤ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਾਰਜਕੁਸ਼ਲਤਾ। \\n\\n3. ਮੁੱਦਾਃ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਭੁਲੇਖਾ ਪੀਡ਼੍ਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ \\n ਫਿਕਸਃਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਬਿਹਤਰ ਗੁੰਝਲਤਾ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਵਧੇਰੇ ਫਿਟਿੰਗ ਮੇਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal \'s।ਥੋਡ਼੍ਹਾ ਲੰਬਾ ਕੋਡ ਪਰ ਸਮੁੱਚੀ ਗੁੰਝਲਤਾ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n4. ਮੁੱਦਾਃ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਦਾ ਕੋਈ ਸਪਸ਼ਟ ਸੰਕੇਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਰੰਗ ਸੰਸ਼ੋਧਿਤ ਕਰੋਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਬਾਕੀ ਗੁੰਝਲਤਾ ਤੋਂ ਵੱਖ ਕਰਨ ਲਈ। ਇਸ ਲਈ ਕੋਡ ਵਿੱਚ ਮਾਮੂਲੀ ਤਬਦੀਲੀ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ ਅਤੇ ਨਹੀਂਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਉੱਤੇ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। \\n\\n5. ਮੁੱਦਾਃ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਲਈ ਕੋਈ ਵਿਜ਼ੂਅਲ ਫੀਡਬੈਕ ਨਹੀਂ \\n ਫਿਕਸਃ ਲਈ ਇੱਕ ਵਿਜ਼ੂਅਲ ਸੂਚਕ ਲਾਗੂ ਕਰੋਭੁਲੱਕਡ਼ ਵਿੱਚ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ, ਜਿਵੇਂ ਕਿ ਮੌਜੂਦਾ ਹੈਕਸਾਗਨ ਦਾ ਰੰਗ ਬਦਲਣਾ। ਇਸ ਲਈ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸੋਧ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ।ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਦੀ ਮਾਤਰਾ ਅਤੇ ਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਤੇ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰੇਗਾ। \\n\\n ਇਨ੍ਹਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਨਾਲ, ਕੋਡ ਵਧੇਰੇ ਕਾਰਜਸ਼ੀਲ ਹੋ ਜਾਵੇਗਾ ਅਤੇਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ ਵੀ ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ "., \'ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਗਲਤੀਆਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿਓ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ।ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹੋਏ, ਕੁੱਝ ਗਲਤੀਆਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਅਨੁਸਾਰੀ ਫਿਕਸ ਹੁੰਦੇ ਹਨਃ \\n\\n1. ਗਲਤੀਃ ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਇੱਕ ਵਰਗ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਦੀ ਬਜਾਏ ਗਰਿੱਡ। \\n ਫਿਕਸਃ ਹੈਕਸਾਗੋਨਲ ਸਥਿਤੀਆਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰਕੇ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਤਿਆਰ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ ਸੋਧੋ ਅਤੇਗੁਆਂਢੀ। \\n\\n2. ਗਲਤੀਃ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ ਫੰਕਸ਼ਨ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ। \\n ਫਿਕਸਃ ਬਦਲੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੇਂ ਐਲਗੋਰਿਦਮ ਦੇ ਨਾਲ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal. ਇਸ ਦੇ ਨਤੀਜੇ ਥੋਡ਼ੇ ਲੰਬੇ ਹੋ ਸਕਦੇ ਹਨਕੋਡ ਪਰ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n3. ਗਲਤੀਃ ਕੋਡ ਵਿੱਚ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ ਅਤੇ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਦੀ ਘਾਟ ਹੈ। \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ) ਨੂੰ ਸੰਭਾਲਣ ਅਤੇ ਉਹਨਾਂ ਦੇ ਇਨਪੁਟ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ। ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਚੈੱਕ ਸ਼ਾਮਲ ਕਰੋਪਤਾ ਲਗਾਓ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ। \\n\\n4. ਗਲਤੀਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਸਥਿਰ ਹੈ ਅਤੇ ਗਰਿੱਡ ਅਨੁਸਾਰ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ।ਅਕਾਰ. \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਅਨੁਕੂਲ ਕਰੋ। ਇਹ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇਸ ਲਈ ਵਧੇਰੇ ਲਚਕਦਾਰ ਬਣਾਵੇਗਾ।ਵੱਖ-ਵੱਖ ਗਰਿੱਡ ਅਕਾਰ। \\n\\n ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਸ਼ੁਰੂਆਤੀ ਕੋਡ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਦਾ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਲਾਗੂਕਰਨ ਸੀ। ਇਹਨਾਂ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਕੇਗਲਤੀਆਂ, ਕੋਡ ਇੱਕ ਬਿਹਤਰ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਅਤੇ ਬਿਹਤਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰੇਗਾ ਜਦੋਂ ਕਿ ਅਜੇ ਵੀ ਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖੇਗਾ।ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤਾ ਕੋਡ। \',\' ਇੱਥੇ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਦਾ ਇੱਕ ਅੱਪਡੇਟ ਕੀਤਾ ਸੰਸਕਰਣ ਹੈ।tkinter: \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ tkinter ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\n\\ndef ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): \\n ਰਿਟਰਨ [(c.create_polygon ([(lambda a, b: (a + s *)(i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =\\\'\\\', ਰਾਜ =\\\'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈਰੇਂਜ (6)], ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈ ਰੇਂਜ (ਐੱਨ)] ਵਿੱਚ i ਲਈ ਰੇਂਜ (ਐੱਨ)]\\ਐੱਨ ਐੱਨ ਡੀ ਐੱਫ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਜੀ):\\ਐੱਨ ਵੀ, ਐੱਸ, ਈ, ਸਟੈਕ = ਸੈੱਟ (), (0,0),(ਲੇਨ (ਜੀ)-1, ਲੇਨ (ਜੀ)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\n n = [(x + i, y + j) i ਲਈ, ((1,0), (0,0), (0,1), (0,0), (0,- 1), (-1 + (y% 2), 1-(y% 2), (1-(y% 2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <len (g) ਅਤੇ 0 <= y + j <len (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ।nx, ny = random.choice (n) \\n g [y] [x]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n g [ny] [nx]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n stack.append (((nx, ny)) \\n ਹੋਰਃ \\nstack.pop () \\n\\ndef ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,-1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬਾ\': (-1,0),\\\'ਸੱਜਾ\': (1,0)} ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\nnx, ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰ g [ny] [nx] ਹੈ।g [p [1]] [p [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਕਾਲਾ\') \\n p = (nx, ny) \\n g [p [1]] [p [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਲਾਲ\') \\n ਜੇਕਰ p = = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ"") \\n\\nn = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack () \\ngrid =ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\ngrid [ਪ੍ਲੇਯਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\')\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਲੈਂਬਡਾ ਈਃ ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ, ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ,ਗਰਿੱਡ))\\nroot.mainloop () \\n \'\\n\\n ਇਸ ਅੱਪਡੇਟ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਸਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਜਨਰੇਸ਼ਨ ਸ਼ਾਮਲ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੀਂ ਭੁਲੱਕਡ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਹੈ।ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ, NAME _ 3 ਨਾਲ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ, ਅਤੇ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰੋ ਜਦੋਂ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ।ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਹਰੇ ਅਤੇ ਨੀਲੇ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਲਾਲ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਕੋਡ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰੋ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' ਕੋਡ ਦੀ ਧਿਆਨ ਨਾਲ ਸਮੀਖਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇੱਕ ਸੰਟੈਕਸ ਗਲਤੀ ਹੈ ਅਤੇ ਇਸਦਾ ਅਨੁਸਾਰੀ ਸੁਧਾਰ ਹੈਃ \\n\\n1।ਗਲਤੀਃ \'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਫੰਕਸ਼ਨ ਅੱਪਡੇਟ ਕੀਤੇ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਵਾਪਸ ਨਹੀਂ ਕਰਦਾ। \\n ਫਿਕਸਃ \'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਫੰਕਸ਼ਨ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋਉਪਭੋਗਤਾ ਦੇ ਇੰਪੁੱਟ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਅੱਪਡੇਟ ਕੀਤਾ ਗਿਆ। ਫਿਰ, \'root.bind ()\' ਵਿਧੀ ਵਿੱਚ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ\'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਮੁੱਲ ਲਈ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\'। \\n\\nਇੱਥੇ ਕੋਡ ਦਾ ਸਹੀ ਸੰਸਕਰਣ ਹੈਃ \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ \'(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =\\\'\\\', ਅਵਸਥਾ =\\\'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈ ਸੀਮਾ (6) ਵਿੱਚ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\')ਜੇ ਲਈ ਰੇਂਜ (ਐੱਨ)] ਵਿੱਚ i ਲਈ ਰੇਂਜ (ਐੱਨ)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਜੀ): \\nv, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (ਜੀ)-1, ਲੇਨ (ਜੀ)-1), [(0,0)] \\n ਜਦੋਂ ਕਿਸਟੈਕਃ \\nx, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, j ਵਿੱਚ (((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2), (1-(y% 2)2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\nਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ (ਈਵੈਂਟ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,-1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬੇ\': (-1,0),\\\'ਸੱਜੇ\': (1,0)}. ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\n nx,ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰ g [ny] [nx] ਹੈ।g [p [1]] [p [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\') \\n ਜੇਕਰ p = = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ ਜਿੱਤ ਗਏ!") \\n ਰਿਟਰਨ p\\n\\n = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack () \\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\nਗ੍ਰਿਡ [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\')\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਲੈਂਬਡਾ ਈਃ ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨਃ = ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ,ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ, ਗਰਿੱਡ))\\nroot.mainloop () \\n \'\\n\' ਹੁਣ ਕੋਡ ਉਪਭੋਗਤਾ ਦੇ ਇੰਪੁੱਟ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਤੋਂ ਬਾਅਦ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਅਪਡੇਟ ਕਰਦਾ ਹੈ।ਆਖਰੀ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਸੰਟੈਕਸ ਗਲਤੀਆਂ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿੰਦੇ ਹਨ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \', "ਨਵੀਨਤਮ ਪ੍ਰਦਾਨ ਕੀਤੇ ਕੋਡ ਦੀ ਪੂਰੀ ਸਮੀਖਿਆ ਕਰਨ\' ਤੇ,ਕੋਈ ਸੰਟੈਕਸ ਗਲਤੀਆਂ ਨਹੀਂ ਹਨ। ਕੋਡ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ, ਨੇਵੀਗੇਸ਼ਨ ਲਈ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।ਜਦੋਂ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ. \\n\\n ਕੋਡ ਕਾਰਜਸ਼ੀਲ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਸੰਖੇਪ ਲਾਗੂਕਰਨ ਹੁੰਦਾ ਹੈ।ਪਾਈਥਨ ਦੀ ਟਿੰਟਰ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ "", ਹੇਠ ਦਿੱਤੀ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਰਦੇ ਹੋਏ ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੋਃ \\n\\treturn [[(c.create_polygon ([(lambda a,b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਰਾਜ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਲਈi ਰੇਂਜ (6) ਵਿੱਚ], ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਰੇਂਜ (n) ਵਿੱਚ j ਲਈ ਰੇਂਜ (n) ਵਿੱਚ i ਲਈ ਰੇਂਜ (n) ਵਿੱਚ] \\n\\t ^ \\nSyntaxErorr: ਅਮਾਨ੍ਯ ਸੰਟੈਕਸ \\n ", ਅਜਿਹਾ ਪ੍ਰਤੀਤ ਹੁੰਦਾ ਹੈ ਕਿ ਇੱਕ ਹੈਦਿੱਤੇ ਕੋਡ ਦੇ ਸੰਬੰਧ ਵਿੱਚ ਗ਼ਲਤਫ਼ਹਿਮੀ, ਕਿਉਂਕਿ ਦਿੱਤੀ ਗਈ ਲਾਈਨ ਵਿੱਚ ਕੋਈ ਸੰਟੈਕਸ ਗਲਤੀ ਨਹੀਂ ਹੈ। ਹਾਲਾਂਕਿ, ਮੈਂ \'ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ\' ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਾਂਗਾ।ਇਸ ਨੂੰ ਵਧੇਰੇ ਪਡ਼੍ਹਨਯੋਗ ਬਣਾਉਣ ਅਤੇ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਉਲਝਣ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨਃ \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟੀਕਿੰਟਰ ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\n\\ndefਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): n ਗਰਿੱਡ = [] n ਰੇਂਜ (n) ਵਿੱਚ i ਲਈਃ n ਕਤਾਰ = [] n ਰੇਂਜ (n) ਵਿੱਚ j ਲਈਃ n ਹੈਕਸ _ ਪੁਆਇੰਟ = [] n ਰੇਂਜ (6) ਵਿੱਚ k ਲਈਃ \\n a, b =c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2] \\n x, y = a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/2 \\nhex_points.append ((x, y)) \\n ਹੈਕਸਾਗਨ = c.create_polygon (ਹੈਕਸਾਗਨ ਅੰਕ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') \\n row.append (ਹੈਕਸਾਗਨ) \\n grid.append (ਕਤਾਰ) \\n ਵਾਪਸੀਗਰਿੱਡ \\n\\n #ਬਾਕੀ ਕੋਡ ਇੱਕੋ ਜਿਹਾ ਰਹਿੰਦਾ ਹੈ \\n\\nn = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732 /2)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ = \'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ = \'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\ngrid [ਪ੍ਲੇਯਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਲਾਲ\')\\nroot.bind (\'<ਕੁੰਜੀ>\', ਲੈਂਬਡਾ ਈਃ ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨਃ = ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ,ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ, ਗਰਿੱਡ))\\nroot.mainloop () \\n "\'\\n\\n ਮੁਡ਼ ਲਿਖਤ\' ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ \'ਫੰਕਸ਼ਨ ਵਧੇਰੇ ਪਡ਼੍ਹਨਯੋਗ ਹੈ, ਪਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਬਣੀ ਰਹਿੰਦੀ ਹੈਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਸੰਟੈਕਸ ਗਲਤੀਆਂ ਦੇ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।ਪਾਈਥਨ 3.7.9 \',\' ਪਾਈਥਨ 3.7.9 ਪਾਈਥਨ 3.8 ਵਿੱਚ ਪੇਸ਼ ਕੀਤੇ ਗਏ ਅਸਾਈਨਮੈਂਟ ਸਮੀਕਰਨ (\': =\') ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ, ਸਾਨੂੰ ਕੋਡ ਨੂੰ ਸੋਧਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈਪਾਈਥਨ ਨਾਲ ਅਨੁਕੂਲ 3.7.9. ਇੱਥੇ ਅੱਪਡੇਟ ਕੀਤਾ ਕੋਡ ਹੈਃ \\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ tkinter ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\n\\ndef ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): \\nਵਾਪਸ ਕਰੋ [(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/)2, ਟੈਕਸਟ =\\\'\\\', ਅਵਸਥਾ =\\\'ਲੁਕਿਆ ਹੋਇਆ\\\')) [: 2]) i ਲਈ ਸੀਮਾ (6)] ਵਿੱਚ, ਟੈਗ =\\\'ਸੈੱਲ\', ਭਰੋ =\\\'ਚਿੱਟਾ\') ਜੇ ਲਈ ਸੀਮਾ (n) ਵਿੱਚ i ਲਈ ਸੀਮਾ (n)] \\n\\ndef ਵਿੱਚਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (g): \\n v, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (g)-1, ਲੇਨ (g)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\n =[(x + i, y + j) i ਲਈ, ((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2)), (1-(y% 2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 ਹੋਵੇ।<= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ] \\n ਜੇਕਰ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰੋ =\\\'ਕਾਲਾ\') \\ng [ny] [nx]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\n\\ndef ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ (ਘਟਨਾ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,- 1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬਾ\': (-1,0),\\\'ਸੱਜਾ\': (event.keysym, (0,0)}. ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\nnx, ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰg [ny] [nx]. itemcget (\\\'ਭਰਨ\') = =\\\'ਕਾਲਾ\': \\n g [p [1]] [p [0]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n p = (nx, ny) \\n g [p [1] [p [0]. itemconfig (ਭਰਨ =\\\'ਲਾਲ\') \\n ਜੇਕਰ p= = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ ਜਿੱਤ ਗਏ!") \\n ਰਿਟਰਨ p\\n\\n = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n *s * 1.732/2)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\nਗ੍ਰਿਡ [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\') \\n\\ndef \'ਤੇ _ ਕੁੰਜੀ (ਘਟਨਾ): \\n ਆਲਮੀ ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ \\n ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ =ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ (ਈਵੈਂਟ, ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ, ਗਰਿੱਡ) \\n\\ nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਆਨ _ ਕੀ)\\nroot.mainloop () \\n \'\\n\\n ਇਸ ਕੋਡ ਵਿੱਚ ਮੁੱਖ ਤਬਦੀਲੀ ਹੈ ਹਟਾਉਣਾਅਸਾਈਨਮੈਂਟ ਸਮੀਕਰਨ (\': =\') ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਘਟਨਾ ਨੂੰ ਸੰਭਾਲਣ ਲਈ \'ਆਨ _ ਕੀ\' ਫੰਕਸ਼ਨ ਨੂੰ ਜੋਡ਼ਨਾ। ਬਾਕੀ ਕੋਡ ਉਹੀ ਰਹਿੰਦਾ ਹੈ।ਅਤੇ ਪਾਈਥਨ ਨਾਲ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ 3.7.9. \', "ਹੇਠ ਦਿੱਤੀ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਰਦੇ ਹੋਏ, ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੋਃ \\n\\treturn[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2,ਟੈਕਸਟ = ", ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈ ਸੀਮਾ (6)] ਵਿੱਚ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈ ਸੀਮਾ (n) ਵਿੱਚ i ਲਈ ਸੀਮਾ (n) ਵਿੱਚ] \\n\\t ^ \\nSyntaxEror: ਅਵੈਧਸੰਟੈਕਸ \\n "] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਵਿੱਚ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੋ। \\n ਰੁਕਾਵਟਾਂਃ \\n-ਪਾਈਥਨ ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲਸਿਰਫ਼. \\n-ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ (ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ). \\n ਸੰਕਲਪ ਦੇ ਕਦਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। \\n \', 1. ਆਯਾਤ ਦੀ ਲੋਡ਼ ਹੈ।ਮੋਡੀਊਲਃ tkinter ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਜਿਵੇਂ ਕਿ random. \\n\\n2 ਆਯਾਤ ਕਰੋ। ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ਟਿੰਟਰ ਦੇ ਕੈਨਵਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਗਰਿੱਡ। ਇਹ ਫੰਕਸ਼ਨ ਛੇ ਗੁਆਂਢੀਆਂ ਵਾਲੇ ਹਰੇਕ ਸੈੱਲ ਦੇ ਨਾਲ ਹੈਕਸਾਗਨਾਂ ਦਾ ਇੱਕ ਗਰਿੱਡ ਬਣਾਏਗਾ। \\n\\n3. ਤਿਆਰ ਕਰੋਭੁਲੱਕਡ਼ਃ NAME _ 1 ਜਾਂ Kruskal ਦੇ ਐਲਗੋਰਿਦਮ ਵਰਗੇ ਇੱਕ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੋ। ਇਹ ਫੰਕਸ਼ਨਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲਵੇਗਾ ਅਤੇ ਸੈੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਦੀਆਂ ਕੰਧਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰੇਗਾ। \\n\\n4. ਭੁਲੱਕਡ਼ ਨੂੰ ਵੇਖੋਃ ਸੋਧ ਕਰੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਲਾਬੀਰਿੰਥ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਤਿਆਰ ਕੀਤੀ ਲਾਬੀਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਨ ਲਈਪੀਡ਼੍ਹੀ ਫੰਕਸ਼ਨ। \\n\\n5. ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂ ਜੋਡ਼ੋਃ ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਦੋ ਨੁਕਤੇ. \\n\\n6. ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲੋਃ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਲਈ ਘਟਨਾ ਬੰਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਗੁੰਝਲਤਾ ਵਿੱਚੋਂ ਲੰਘ ਸਕਦਾ ਹੈ।ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n\\n7. ਇੱਕ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਲਾਗੂ ਕਰੋ-ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਕਦੋਂ ਪਹੁੰਚ ਗਿਆ ਹੈ।ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਧਾਈ ਦੇਣ ਲਈ ਇੱਕ ਸੰਦੇਸ਼ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। \\n\\n8. ਮੁੱਖ ਲੂਪ ਬਣਾਓਃ ਮੁੱਖ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਮਿਲਾਓ।ਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਲੂਪ, ਗਰਿੱਡ ਨੂੰ ਅਰੰਭ ਕਰਨਾ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨਾ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਲਈ ਸੁਣਨਾ। \\n\\n9. ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓਃ ਸਮੀਖਿਆ ਕਰੋਕੋਡ ਕਰੋ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਸਮੁੱਚੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n\\n10. ਪ੍ਰੋਗਰਾਮ ਦੀ ਜਾਂਚਃ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ ਅਤੇ ਟੈਸਟ ਕਰੋ।ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਹ ਹੱਲ ਕਰਨ ਯੋਗ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਤੋਂ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ \'ਤੇ ਲੋਡ਼ੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ.\', \'ਸਭ ਤੋਂ ਛੋਟਾ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਹੱਲ ਗਿਣੋ।\', \'1. ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਲੂਪਸ, ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਕੋਡ ਵਿੱਚ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਨਾਲ। \\n\\n2. ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ-ਛੋਟੇ ਅਤੇ ਸਰਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲੋ।ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ \'ਡੀ. ਐੱਫ.\' ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੰਕਸ਼ਨ। \\n\\n3. ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂਃ ਤਰਜੀਹਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਿੰਗਲ-ਅੱਖਰ ਵੇਰੀਏਬਲ ਨਾਮ ਅਤੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਲੂਪ ਇਟਰੇਟਰ। \\n\\n4. ਚੇਨ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨਃ ਚੇਨ ਮਲਟੀਪਲਢੰਗ ਜਾਂ ਫੰਕਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠੇ, ਜੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕੋ ਵਸਤੂ ਉੱਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ। \\n\\n5. ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰੋਵ੍ਹਾਈਟਸਪੇਸ-ਪਡ਼੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬੇਲੋਡ਼ੀ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਖਾਲੀ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। \\n\\n6. ਟਰਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਓਪਰੇਟਰਃ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਸਧਾਰਨ ਜੇਕਰ-ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਬਦਲੋ। \\n\\n7. ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇਨਲਾਈਨ ਕਰੋ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।ਇੱਕ ਥਾਂ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਤੌਰ \'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੁੱਖ ਕੋਡ ਦੇ ਅੰਦਰ ਇਨਲਾਈਨਿੰਗ ਕਰਨ\' ਤੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n8. ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓਃ ਜਿਵੇਂ ਕਿਇਹ ਇੱਕ ਕੋਡ-ਗੋਲਫ ਚੁਣੌਤੀ ਹੈ, ਅੰਤਿਮ ਕੋਡ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਟਿੱਪਣੀ ਜਾਂ ਵਿਆਖਿਆ ਨੂੰ ਹਟਾਓ। \\n\\n9. ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਸ਼ਾਰਟਹੈਂਡ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਘਟਾਉਣ ਲਈ ਉਹਨਾਂ ਦੇ ਲੰਬੇ ਬਰਾਬਰ ਦੀ ਬਜਾਏ \'+ =\', \'-=\', ਅਤੇ \'* =\'। \\n\\n10. ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਮਿਲਾਓਃ ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਨੈਸਟਡ ਲੂਪਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਓਰੇਂਜ ਜਾਂ ਹੋਰ ਦੁਹਰਾਉਣ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਜੋਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਿੰਗਲ ਲੂਪ। \\n\\n ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਆਪਣੀ ਰੇਂਜ ਦੀ ਲੰਬਾਈ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾ ਸਕਦੇ ਹੋ।ਕੋਡ ਆਪਣੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ. \',\' ਅਜੇ ਤੱਕ ਕੋਈ ਕੋਡ ਲਿਖੇ ਬਿਨਾਂ, ਲੋਡ਼ੀਂਦੀਆਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰੋ। \',\' ਇੱਥੇ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਲੋਡ਼ੀਂਦੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਰੂਪ ਰੇਖਾਃ \\n\\n ਕਲਾਸਾਂਃ \\n1. ਹੈਕਸਾਗਨਃ \\n-ਇੱਕ ਸਿੰਗਲ ਹੈਕਸਾਗੋਨਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਗਰਿੱਡ ਵਿੱਚ ਸੈੱਲ। \\n-ਇਸ ਵਿੱਚ ਆਪਣੀ ਸਥਿਤੀ, ਗੁਆਂਢੀਆਂ ਅਤੇ ਰਾਜ (ਕੰਧ ਜਾਂ ਮਾਰਗ) ਲਈ ਗੁਣ ਹੁੰਦੇ ਹਨ। \\n\\n2. ਭੁਲੱਕਡ਼ਃ \\n-ਸਮੁੱਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈਭੁਲੱਕਡ਼. \\n-ਗਰਿੱਡ ਅਕਾਰ, ਹੈਕਸਾਗੋਨਲ ਸੈੱਲਾਂ, ਅਤੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਬਿੰਦੂਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ। \\n-ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।ਅਤੇ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ। \\n\\nਫੰਕਸ਼ਨਃ \\n1. ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, ਗਰਿੱਡ _ ਸਾਈਜ਼): \\n-ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਿੱਤੇ ਗਏ ਅਕਾਰ ਦਾ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਟੀਕਿੰਟਰ ਦਾ ਕੈਨਵਸ. \\n\\n2. ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਲੈਬਰਿੰਥ): \\n-ਇੱਕ ਮੈਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਲੈਬਰਿੰਥ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕਰੂਸਕਲ ਦਾ ਐਲਗੋਰਿਦਮ। \\n-ਇੱਕ ਭੁਲੱਕਡ਼ ਵਸਤੂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈ ਅਤੇ ਭੁਲੱਕਡ਼ ਬਣਾਉਣ ਲਈ ਇਸ ਦੇ ਸੈੱਲਾਂ ਨੂੰ ਸੋਧਦਾ ਹੈ। \\n\\n3. ਵਿਜ਼ੂਅਲਾਈਜ਼ _ ਲੈਬਰਿੰਥ (ਕੈਨਵਸ,ਲੈਬਰਿੰਥ): \\n-ਲੈਬਰਿੰਥ ਦੀ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਕੰਧਾਂ ਨੂੰ ਜੋਡ਼ ਕੇ ਜਾਂ ਹਟਾ ਕੇ ਟਿੰਟਰ ਕੈਨਵਸ ਉੱਤੇ ਪੈਦਾ ਹੋਈ ਲੈਬਰਿੰਥ ਦੀ ਕਲਪਨਾ ਕਰਦਾ ਹੈ। \\n\\n4.ਕ੍ਰਿਏਟ _ ਸਟਾਰਟ _ ਐਂਡ _ ਪੁਆਇੰਟਸ (ਭੁਲੱਕਡ਼): \\n-ਭੁਲੱਕਡ਼ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਦੋਵਾਂ ਵਿਚਕਾਰ ਇੱਕ ਹੱਲ ਕਰਨ ਯੋਗ ਮਾਰਗ ਹੈ।ਅੰਕ. \\n\\n5. ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, ਭੁਲੱਕਡ਼): \\n-ਉਪਭੋਗਤਾ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਕੀਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੁਲੱਕਡ਼ ਰਾਹੀਂ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ।ਜਾਂ ਮਾਊਸ ਇੰਪੁੱਟ। \\n\\n6. ਚੈੱਕ _ ਵਿੰਗਿੰਗ _ ਕੰਡੀਸ਼ਨ (ਭੁਲੱਕਡ਼): \\n-ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਬਿੰਦੂ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈਪੂਰਾ ਹੋਣ ਉੱਤੇ ਵਧਾਈ ਸੰਦੇਸ਼। \\n\\n7. ਮੁੱਖ (): \\n-ਮੁੱਖ ਫੰਕਸ਼ਨ ਜੋ ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈ। \\n-ਸ਼ੁਰੂ ਕਰਦਾ ਹੈਟੀਕਿੰਟਰ ਐਪਲੀਕੇਸ਼ਨ, ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਉਂਦੀ ਹੈ, ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਇਸ ਦੀ ਕਲਪਨਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਲਈ ਸੁਣਦੀ ਹੈ।ਲਾਗੂ ਕੀਤਾ ਕੋਡ. \', "ਇੱਥੇ ਪਾਈਥਨ ਦੇ ਟਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਛੋਟਾ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਇਸ ਤਰ੍ਹਾਂ ਹੈ।(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਰੇਂਜ (6) ਵਿੱਚ i ਲਈ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈਰੇਂਜ (n)] ਲਈ i ਲਈ ਰੇਂਜ (n)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (g): \\n v, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (g)-1, ਲੇਨ (g)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y= ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, ((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2)), (1-(y% 2),-1 + (y% 2)2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\n\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = 500, ਉਚਾਈ = 500)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, 16,12) \\ngenਾਰੇਟ _ ਲੈਬਰਿੰਥ (ਗਰਿੱਡ)\\nroot.mainloop () \\n "\'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿਇਸ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਸੰਖੇਪਤਾ ਲਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਜਾਂ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਤਿਆਰ ਕੀਤਾ ਕੋਡ, ਫਿਕਸ ਪ੍ਰਸਤਾਵਾਂ ਦੇ ਨਾਲ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' 1. ਮੁੱਦਾਃ ਸੀਮਤ ਵਿੰਡੋ ਸਾਈਜ਼ ਅਤੇ ਫਿਕਸਡ ਗਰਿੱਡ ਸਾਈਜ਼ \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਨੂੰ ਅਨੁਕੂਲ ਕਰੋ ਅਤੇਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਚਾਈ, ਅਤੇ ਇਸ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਗਰਿੱਡ ਅਕਾਰ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕਰੋ। ਕੈਨਵਸ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਅਨੁਕੂਲ ਕਰੋਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਅਨੁਸਾਰ. \\n\\n2. ਮੁੱਦਾਃ ਕੋਈ ਉਪਭੋਗਤਾ ਪਰਸਪਰ ਕ੍ਰਿਆ ਜਾਂ ਜਿੱਤਣ ਦੀ ਸ਼ਰਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਨਾਲ ਕੀਬੋਰਡ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰੋਜੋ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇਹ ਕੋਡ ਦੀ ਲੰਬਾਈ ਵਧਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਪ੍ਰਦਾਨ ਕਰੇਗਾਉਪਭੋਗੀ ਨੇਵੀਗੇਸ਼ਨ ਅਤੇ ਜਿੱਤ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਾਰਜਕੁਸ਼ਲਤਾ। \\n\\n3. ਮੁੱਦਾਃ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਭੁਲੇਖਾ ਪੀਡ਼੍ਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ \\n ਫਿਕਸਃਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਬਿਹਤਰ ਗੁੰਝਲਤਾ ਪੈਦਾ ਕਰਨ ਲਈ ਇੱਕ ਵਧੇਰੇ ਫਿਟਿੰਗ ਮੇਜ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal \'s।ਥੋਡ਼੍ਹਾ ਲੰਬਾ ਕੋਡ ਪਰ ਸਮੁੱਚੀ ਗੁੰਝਲਤਾ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n4. ਮੁੱਦਾਃ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਦਾ ਕੋਈ ਸਪਸ਼ਟ ਸੰਕੇਤ ਨਹੀਂ \\n ਫਿਕਸਃ ਰੰਗ ਸੰਸ਼ੋਧਿਤ ਕਰੋਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਬਾਕੀ ਗੁੰਝਲਤਾ ਤੋਂ ਵੱਖ ਕਰਨ ਲਈ। ਇਸ ਲਈ ਕੋਡ ਵਿੱਚ ਮਾਮੂਲੀ ਤਬਦੀਲੀ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ ਅਤੇ ਨਹੀਂਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਉੱਤੇ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। \\n\\n5. ਮੁੱਦਾਃ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਲਈ ਕੋਈ ਵਿਜ਼ੂਅਲ ਫੀਡਬੈਕ ਨਹੀਂ \\n ਫਿਕਸਃ ਲਈ ਇੱਕ ਵਿਜ਼ੂਅਲ ਸੂਚਕ ਲਾਗੂ ਕਰੋਭੁਲੱਕਡ਼ ਵਿੱਚ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ, ਜਿਵੇਂ ਕਿ ਮੌਜੂਦਾ ਹੈਕਸਾਗਨ ਦਾ ਰੰਗ ਬਦਲਣਾ। ਇਸ ਲਈ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸੋਧ ਦੀ ਲੋਡ਼ ਪਵੇਗੀ।ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਦੀ ਮਾਤਰਾ ਅਤੇ ਸਮੁੱਚੇ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ਤੇ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰੇਗਾ। \\n\\n ਇਨ੍ਹਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਨਾਲ, ਕੋਡ ਵਧੇਰੇ ਕਾਰਜਸ਼ੀਲ ਹੋ ਜਾਵੇਗਾ ਅਤੇਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ ਵੀ ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ "., \'ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਗਲਤੀਆਂ ਦੀ ਗਿਣਤੀ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿਓ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ।ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹੋਏ, ਕੁੱਝ ਗਲਤੀਆਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਅਨੁਸਾਰੀ ਫਿਕਸ ਹੁੰਦੇ ਹਨਃ \\n\\n1. ਗਲਤੀਃ ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ ਫੰਕਸ਼ਨ ਇੱਕ ਵਰਗ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਦੀ ਬਜਾਏ ਗਰਿੱਡ। \\n ਫਿਕਸਃ ਹੈਕਸਾਗੋਨਲ ਸਥਿਤੀਆਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰਕੇ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਤਿਆਰ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ ਸੋਧੋ ਅਤੇਗੁਆਂਢੀ। \\n\\n2. ਗਲਤੀਃ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ ਫੰਕਸ਼ਨ ਇੱਕ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ। \\n ਫਿਕਸਃ ਬਦਲੋਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡਾਂ ਲਈ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੇਂ ਐਲਗੋਰਿਦਮ ਦੇ ਨਾਲ ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ ਐਲਗੋਰਿਦਮ, ਜਿਵੇਂ ਕਿ NAME _ 1 ਜਾਂ Kruskal. ਇਸ ਦੇ ਨਤੀਜੇ ਥੋਡ਼ੇ ਲੰਬੇ ਹੋ ਸਕਦੇ ਹਨਕੋਡ ਪਰ ਭੁਲੱਕਡ਼ ਪੀਡ਼੍ਹੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗਾ। \\n\\n3. ਗਲਤੀਃ ਕੋਡ ਵਿੱਚ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ ਅਤੇ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਦੀ ਘਾਟ ਹੈ। \\n ਫਿਕਸਃ ਇੱਕ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਕੀਬੋਰਡ ਜਾਂ ਮਾਊਸ) ਨੂੰ ਸੰਭਾਲਣ ਅਤੇ ਉਹਨਾਂ ਦੇ ਇਨਪੁਟ ਦੇ ਅਧਾਰ ਉੱਤੇ ਉਪਭੋਗਤਾ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ। ਹਰੇਕ ਚਾਲ ਤੋਂ ਬਾਅਦ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਚੈੱਕ ਸ਼ਾਮਲ ਕਰੋਪਤਾ ਲਗਾਓ ਕਿ ਕੀ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ। \\n\\n4. ਗਲਤੀਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਸਥਿਰ ਹੈ ਅਤੇ ਗਰਿੱਡ ਅਨੁਸਾਰ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ।ਅਕਾਰ. \\n ਫਿਕਸਃ ਕੈਨਵਸ ਦੀ ਚੌਡ਼ਾਈ ਅਤੇ ਉਚਾਈ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੰਪੁੱਟ ਗਰਿੱਡ ਅਕਾਰ ਦੇ ਅਧਾਰ ਉੱਤੇ ਅਨੁਕੂਲ ਕਰੋ। ਇਹ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇਸ ਲਈ ਵਧੇਰੇ ਲਚਕਦਾਰ ਬਣਾਵੇਗਾ।ਵੱਖ-ਵੱਖ ਗਰਿੱਡ ਅਕਾਰ। \\n\\n ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਸ਼ੁਰੂਆਤੀ ਕੋਡ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਦਾ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਲਾਗੂਕਰਨ ਸੀ। ਇਹਨਾਂ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਕੇਗਲਤੀਆਂ, ਕੋਡ ਇੱਕ ਬਿਹਤਰ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਅਤੇ ਬਿਹਤਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰੇਗਾ ਜਦੋਂ ਕਿ ਅਜੇ ਵੀ ਸੰਖੇਪਤਾ ਬਣਾਈ ਰੱਖੇਗਾ।ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤਾ ਕੋਡ। \',\' ਇੱਥੇ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਲਈ ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਦਾ ਇੱਕ ਅੱਪਡੇਟ ਕੀਤਾ ਸੰਸਕਰਣ ਹੈ।tkinter: \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ tkinter ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\n\\ndef ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): \\n ਰਿਟਰਨ [(c.create_polygon ([(lambda a, b: (a + s *)(i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =\\\'\\\', ਰਾਜ =\\\'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈਰੇਂਜ (6)], ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈ ਰੇਂਜ (ਐੱਨ)] ਵਿੱਚ i ਲਈ ਰੇਂਜ (ਐੱਨ)]\\ਐੱਨ ਐੱਨ ਡੀ ਐੱਫ ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਜੀ):\\ਐੱਨ ਵੀ, ਐੱਸ, ਈ, ਸਟੈਕ = ਸੈੱਟ (), (0,0),(ਲੇਨ (ਜੀ)-1, ਲੇਨ (ਜੀ)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\n n = [(x + i, y + j) i ਲਈ, ((1,0), (0,0), (0,1), (0,0), (0,- 1), (-1 + (y% 2), 1-(y% 2), (1-(y% 2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <len (g) ਅਤੇ 0 <= y + j <len (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ।nx, ny = random.choice (n) \\n g [y] [x]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n g [ny] [nx]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਕਾਲਾ\') \\n stack.append (((nx, ny)) \\n ਹੋਰਃ \\nstack.pop () \\n\\ndef ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਘਟਨਾ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,-1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬਾ\': (-1,0),\\\'ਸੱਜਾ\': (1,0)} ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\nnx, ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰ g [ny] [nx] ਹੈ।g [p [1]] [p [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਕਾਲਾ\') \\n p = (nx, ny) \\n g [p [1]] [p [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਲਾਲ\') \\n ਜੇਕਰ p = = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ"") \\n\\nn = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack () \\ngrid =ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਬਣਾਓ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\ngrid [ਪ੍ਲੇਯਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\')\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਲੈਂਬਡਾ ਈਃ ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ, ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ,ਗਰਿੱਡ))\\nroot.mainloop () \\n \'\\n\\n ਇਸ ਅੱਪਡੇਟ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਸਹੀ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਜਨਰੇਸ਼ਨ ਸ਼ਾਮਲ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਵਧੇਰੇ ਢੁਕਵੀਂ ਭੁਲੱਕਡ਼ ਜਨਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਹੈ।ਡੂੰਘਾਈ-ਪਹਿਲੀ ਖੋਜ, NAME _ 3 ਨਾਲ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਹੈਂਡਲਿੰਗ, ਅਤੇ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰੋ ਜਦੋਂ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ।ਅੰਤ ਦੇ ਬਿੰਦੂਆਂ ਨੂੰ ਹਰੇ ਅਤੇ ਨੀਲੇ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਲਾਲ ਰੰਗ ਵਿੱਚ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਕੋਡ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰੋ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \',\' ਕੋਡ ਦੀ ਧਿਆਨ ਨਾਲ ਸਮੀਖਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇੱਕ ਸੰਟੈਕਸ ਗਲਤੀ ਹੈ ਅਤੇ ਇਸਦਾ ਅਨੁਸਾਰੀ ਸੁਧਾਰ ਹੈਃ \\n\\n1।ਗਲਤੀਃ \'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਫੰਕਸ਼ਨ ਅੱਪਡੇਟ ਕੀਤੇ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਵਾਪਸ ਨਹੀਂ ਕਰਦਾ। \\n ਫਿਕਸਃ \'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਫੰਕਸ਼ਨ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋਉਪਭੋਗਤਾ ਦੇ ਇੰਪੁੱਟ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਅੱਪਡੇਟ ਕੀਤਾ ਗਿਆ। ਫਿਰ, \'root.bind ()\' ਵਿਧੀ ਵਿੱਚ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ\'ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ\' ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਮੁੱਲ ਲਈ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\'। \\n\\nਇੱਥੇ ਕੋਡ ਦਾ ਸਹੀ ਸੰਸਕਰਣ ਹੈਃ \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ \'(c, n, s): \\n ਰਿਟਰਨ [[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/ 2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =\\\'\\\', ਅਵਸਥਾ =\\\'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈ ਸੀਮਾ (6) ਵਿੱਚ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\')ਜੇ ਲਈ ਰੇਂਜ (ਐੱਨ)] ਵਿੱਚ i ਲਈ ਰੇਂਜ (ਐੱਨ)] \\n\\ndef ਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (ਜੀ): \\nv, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (ਜੀ)-1, ਲੇਨ (ਜੀ)-1), [(0,0)] \\n ਜਦੋਂ ਕਿਸਟੈਕਃ \\nx, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\nn = [(x + i, y + j) i ਲਈ, j ਵਿੱਚ (((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2), (1-(y% 2)2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 <= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ ਤਾਂ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n g [ny] [nx]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\nਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ (ਈਵੈਂਟ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,-1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬੇ\': (-1,0),\\\'ਸੱਜੇ\': (1,0)}. ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\n nx,ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰ g [ny] [nx] ਹੈ।g [p [1]] [p [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\') \\n ਜੇਕਰ p = = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ ਜਿੱਤ ਗਏ!") \\n ਰਿਟਰਨ p\\n\\n = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas =tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack () \\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\nਗ੍ਰਿਡ [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\')\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਲੈਂਬਡਾ ਈਃ ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨਃ = ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ,ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ, ਗਰਿੱਡ))\\nroot.mainloop () \\n \'\\n\' ਹੁਣ ਕੋਡ ਉਪਭੋਗਤਾ ਦੇ ਇੰਪੁੱਟ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਤੋਂ ਬਾਅਦ \'ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ\' ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਅਪਡੇਟ ਕਰਦਾ ਹੈ।ਆਖਰੀ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਸੰਟੈਕਸ ਗਲਤੀਆਂ, ਅਤੇ ਉਹਨਾਂ ਸੁਧਾਰਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਦਿੰਦੇ ਹਨ ਜੋ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਰੱਖਦੇ ਹਨ। \', "ਨਵੀਨਤਮ ਪ੍ਰਦਾਨ ਕੀਤੇ ਕੋਡ ਦੀ ਪੂਰੀ ਸਮੀਖਿਆ ਕਰਨ\' ਤੇ,ਕੋਈ ਸੰਟੈਕਸ ਗਲਤੀਆਂ ਨਹੀਂ ਹਨ। ਕੋਡ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਪੈਦਾ ਕਰਦਾ ਹੈ, ਨੇਵੀਗੇਸ਼ਨ ਲਈ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।ਜਦੋਂ ਉਪਭੋਗਤਾ ਭੁਲੱਕਡ਼ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ. \\n\\n ਕੋਡ ਕਾਰਜਸ਼ੀਲ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਸੰਖੇਪ ਲਾਗੂਕਰਨ ਹੁੰਦਾ ਹੈ।ਪਾਈਥਨ ਦੀ ਟਿੰਟਰ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ "", ਹੇਠ ਦਿੱਤੀ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਰਦੇ ਹੋਏ ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੋਃ \\n\\treturn [[(c.create_polygon ([(lambda a,b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਰਾਜ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) ਲਈi ਰੇਂਜ (6) ਵਿੱਚ], ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਰੇਂਜ (n) ਵਿੱਚ j ਲਈ ਰੇਂਜ (n) ਵਿੱਚ i ਲਈ ਰੇਂਜ (n) ਵਿੱਚ] \\n\\t ^ \\nSyntaxErorr: ਅਮਾਨ੍ਯ ਸੰਟੈਕਸ \\n ", ਅਜਿਹਾ ਪ੍ਰਤੀਤ ਹੁੰਦਾ ਹੈ ਕਿ ਇੱਕ ਹੈਦਿੱਤੇ ਕੋਡ ਦੇ ਸੰਬੰਧ ਵਿੱਚ ਗ਼ਲਤਫ਼ਹਿਮੀ, ਕਿਉਂਕਿ ਦਿੱਤੀ ਗਈ ਲਾਈਨ ਵਿੱਚ ਕੋਈ ਸੰਟੈਕਸ ਗਲਤੀ ਨਹੀਂ ਹੈ। ਹਾਲਾਂਕਿ, ਮੈਂ \'ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ\' ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਾਂਗਾ।ਇਸ ਨੂੰ ਵਧੇਰੇ ਪਡ਼੍ਹਨਯੋਗ ਬਣਾਉਣ ਅਤੇ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਉਲਝਣ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨਃ \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟੀਕਿੰਟਰ ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\n\\ndefਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): n ਗਰਿੱਡ = [] n ਰੇਂਜ (n) ਵਿੱਚ i ਲਈਃ n ਕਤਾਰ = [] n ਰੇਂਜ (n) ਵਿੱਚ j ਲਈਃ n ਹੈਕਸ _ ਪੁਆਇੰਟ = [] n ਰੇਂਜ (6) ਵਿੱਚ k ਲਈਃ \\n a, b =c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2] \\n x, y = a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/2 \\nhex_points.append ((x, y)) \\n ਹੈਕਸਾਗਨ = c.create_polygon (ਹੈਕਸਾਗਨ ਅੰਕ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') \\n row.append (ਹੈਕਸਾਗਨ) \\n grid.append (ਕਤਾਰ) \\n ਵਾਪਸੀਗਰਿੱਡ \\n\\n #ਬਾਕੀ ਕੋਡ ਇੱਕੋ ਜਿਹਾ ਰਹਿੰਦਾ ਹੈ \\n\\nn = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n * s * 1.732 /2)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ = \'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ = \'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\ngrid [ਪ੍ਲੇਯਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਲਾਲ\')\\nroot.bind (\'<ਕੁੰਜੀ>\', ਲੈਂਬਡਾ ਈਃ ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨਃ = ਹੈਂਡਲ _ ਉਪਭੋਗਤਾ _ ਇੰਪੁੱਟ (ਈ,ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ, ਗਰਿੱਡ))\\nroot.mainloop () \\n "\'\\n\\n ਮੁਡ਼ ਲਿਖਤ\' ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ \'ਫੰਕਸ਼ਨ ਵਧੇਰੇ ਪਡ਼੍ਹਨਯੋਗ ਹੈ, ਪਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਬਣੀ ਰਹਿੰਦੀ ਹੈਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਲੈਬਰਿੰਥ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਸੰਟੈਕਸ ਗਲਤੀਆਂ ਦੇ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।ਪਾਈਥਨ 3.7.9 \',\' ਪਾਈਥਨ 3.7.9 ਪਾਈਥਨ 3.8 ਵਿੱਚ ਪੇਸ਼ ਕੀਤੇ ਗਏ ਅਸਾਈਨਮੈਂਟ ਸਮੀਕਰਨ (\': =\') ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ, ਸਾਨੂੰ ਕੋਡ ਨੂੰ ਸੋਧਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈਪਾਈਥਨ ਨਾਲ ਅਨੁਕੂਲ 3.7.9. ਇੱਥੇ ਅੱਪਡੇਟ ਕੀਤਾ ਕੋਡ ਹੈਃ \\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ tkinter ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\n\\ndef ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): \\nਵਾਪਸ ਕਰੋ [(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/)2, ਟੈਕਸਟ =\\\'\\\', ਅਵਸਥਾ =\\\'ਲੁਕਿਆ ਹੋਇਆ\\\')) [: 2]) i ਲਈ ਸੀਮਾ (6)] ਵਿੱਚ, ਟੈਗ =\\\'ਸੈੱਲ\', ਭਰੋ =\\\'ਚਿੱਟਾ\') ਜੇ ਲਈ ਸੀਮਾ (n) ਵਿੱਚ i ਲਈ ਸੀਮਾ (n)] \\n\\ndef ਵਿੱਚਜਨਰੇਟ _ ਲੈਬਰਿੰਥ (g): \\n v, s, e, ਸਟੈਕ = ਸੈੱਟ (), (0,0), (ਲੇਨ (g)-1, ਲੇਨ (g)-1), [(0,0)] \\n ਜਦੋਂ ਕਿ ਸਟੈਕਃ \\n x, y = ਸਟੈਕ [-1] \\n v.add ((x, y)) \\n =[(x + i, y + j) i ਲਈ, ((1,0), (-1,0), (0,1), (0,-1), (-1 + (y% 2), 1-(y% 2)), (1-(y% 2),-1 + (y% 2))) ਜੇਕਰ 0 <= x + i <ਲੇਨ (g) ਅਤੇ 0 ਹੋਵੇ।<= y + j <ਲੇਨ (g) ਅਤੇ (x + i, y + j) v ਵਿੱਚ ਨਹੀਂ ਹਨ] \\n ਜੇਕਰ n: \\nnx, ny = random.choice (n) \\ng [y] [x]. itemconfig (ਭਰੋ =\\\'ਕਾਲਾ\') \\ng [ny] [nx]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n stack.append ((nx, ny)) \\n ਹੋਰਃ \\n stack.pop () \\n\\ndef ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ (ਘਟਨਾ, p, g): \\n dx, dy = {\\\'ਅੱਪ\': (0,- 1),\\\'NAME _ 2\': (0,1),\\\'ਖੱਬਾ\': (-1,0),\\\'ਸੱਜਾ\': (event.keysym, (0,0)}. ਪ੍ਰਾਪਤ ਕਰੋ (event.keysym, (0,0)) \\nnx, ny = p [0] + dx, p [1] + dy\\n ਜੇਕਰg [ny] [nx]. itemcget (\\\'ਭਰਨ\') = =\\\'ਕਾਲਾ\': \\n g [p [1]] [p [0]. itemconfig (ਭਰਨ =\\\'ਕਾਲਾ\') \\n p = (nx, ny) \\n g [p [1] [p [0]. itemconfig (ਭਰਨ =\\\'ਲਾਲ\') \\n ਜੇਕਰ p= = (ਲੇਨ (g)-1, ਲੇਨ (g)-1): \\n ਪ੍ਰਿੰਟ ("ਤੁਸੀਂ ਜਿੱਤ ਗਏ!") \\n ਰਿਟਰਨ p\\n\\n = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s * 1.5, ਉਚਾਈ = n *s * 1.732/2)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ =\\\'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ =\\\'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\nਗ੍ਰਿਡ [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ =\\\'ਲਾਲ\') \\n\\ndef \'ਤੇ _ ਕੁੰਜੀ (ਘਟਨਾ): \\n ਆਲਮੀ ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ \\n ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ =ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ (ਈਵੈਂਟ, ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ, ਗਰਿੱਡ) \\n\\ nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਆਨ _ ਕੀ)\\nroot.mainloop () \\n \'\\n\\n ਇਸ ਕੋਡ ਵਿੱਚ ਮੁੱਖ ਤਬਦੀਲੀ ਹੈ ਹਟਾਉਣਾਅਸਾਈਨਮੈਂਟ ਸਮੀਕਰਨ (\': =\') ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਘਟਨਾ ਨੂੰ ਸੰਭਾਲਣ ਲਈ \'ਆਨ _ ਕੀ\' ਫੰਕਸ਼ਨ ਨੂੰ ਜੋਡ਼ਨਾ। ਬਾਕੀ ਕੋਡ ਉਹੀ ਰਹਿੰਦਾ ਹੈ।ਅਤੇ ਪਾਈਥਨ ਨਾਲ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ 3.7.9. \', "ਹੇਠ ਦਿੱਤੀ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਰਦੇ ਹੋਏ, ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੋਃ \\n\\treturn[(c.create_polygon ([(lambda a, b: (a + s * (i% 2) + j * s * 1.5, b + j * s * 1.732/2)) (* c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2,ਟੈਕਸਟ = ", ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2]) i ਲਈ ਸੀਮਾ (6)] ਵਿੱਚ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') ਜੇ ਲਈ ਸੀਮਾ (n) ਵਿੱਚ i ਲਈ ਸੀਮਾ (n) ਵਿੱਚ] \\n\\t ^ \\nSyntaxEror: ਅਵੈਧਸੰਟੈਕਸ \\n ", ਮੈਂ ਪਿਛਲੇ ਕੋਡ ਸਨਿੱਪਟ ਕਾਰਨ ਹੋਏ ਕਿਸੇ ਵੀ ਭੰਬਲਭੂਸੇ ਲਈ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ। ਦਿੱਤੇ ਗਏ ਕੋਡ ਵਿੱਚ ਕੋਈ ਸੰਟੈਕਸ ਗਲਤੀ ਨਹੀਂ ਹੈ। ਕੋਡ ਇੱਕ ਪੈਦਾ ਕਰਦਾ ਹੈਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਅਤੇ ਇਸ ਵਿੱਚ ਉਪਭੋਗਤਾ ਨੇਵੀਗੇਸ਼ਨ ਅਤੇ ਇੱਕ ਜਿੱਤਣ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਹੈ। ਹਾਲਾਂਕਿ, ਮੈਂ ਸਮਝਦਾ ਹਾਂ ਕਿ ਜ਼ਿਕਰ ਕੀਤੀ ਲਾਈਨ ਨੂੰ ਬਣਾਉਣਾ ਮੁਸ਼ਕਲ ਹੈ।ਪਡ਼੍ਹੋ ਕਿਉਂਕਿ ਇਹ ਕਾਫ਼ੀ ਸੰਘਣੀ ਹੈ। ਮੈਂ ਇਸ ਨੂੰ ਹੋਰ ਪਡ਼੍ਹਨਯੋਗ ਬਣਾਉਣ ਲਈ \'ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ\' ਫੰਕਸ਼ਨ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਾਂਗਾ।tk\\nimport random\\n\\ndef ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (c, n, s): \\n ਗਰਿੱਡ = [] \\n ਰੇਂਜ (n) ਵਿੱਚ i ਲਈਃ \\n ਕਤਾਰ = [] \\n ਰੇਂਜ (n) ਵਿੱਚ j ਲਈਃ \\n ਹੈਕਸ _ ਪੁਆਇੰਟ = [] \\n ਵਿੱਚ k ਲਈਰੇਂਜ (6): \\n a, b = c.coords (c.create_text (n * s * 1.5, n * s * 1.732/2, ਟੈਕਸਟ =, "ਅਵਸਥਾ = \'ਲੁਕਿਆ ਹੋਇਆ\')) [: 2] \\n x, y = a + s * (i% 2) + j * s * 1.5, b + j* s * 1.732/2\\n hex_points.append ((x, y)) \\n ਹੈਕਸਾਗਨ = c.create_polygon (ਹੈਕਸਾ _ ਪੁਆਇੰਟ, ਟੈਗ = \'ਸੈੱਲ\', ਭਰੋ = \'ਚਿੱਟਾ\') \\n row.append (ਹੈਕਸਾਗਨ) \\ngrid.append (ਕਤਾਰ) \\n ਰਿਟਰਨ ਗਰਿੱਡ \\n\\n #ਬਾਕੀ ਕੋਡ ਉਹੀ ਰਹਿੰਦਾ ਹੈ \\n\\n = 16\\ns = 12\\nroot = tk.Tk () \\ncanvas = tk.Canvas (ਰੂਟ, ਚੌਡ਼ਾਈ = n * s *1. 5, ਉਚਾਈ = n * s * 1.732/2)\\ncanvas.pack ()\\ngrid = ਕ੍ਰਿਏਟ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ (ਕੈਨਵਸ, n,s) \\ngenate _ ਭੂਲਭੁਲੈਯਾ (ਗਰਿੱਡ) \\ngrid [0] [0]. itemconfig (ਭਰੋ = \'ਹਰਾ\') \\ngrid [-1] [-1]. itemconfig (ਭਰੋ = \'ਨੀਲਾ\') \\nplayer _ ਸਥਿਤੀ = [0,0] \\nਗ੍ਰਿਡ [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [1]] [ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ [0]. ਆਈਟਮ ਕਨਫਿਗ (ਭਰੋ = \'ਲਾਲ\') \\n\\ndef on _ ਕੀ (ਈਵੈਂਟ): \\n ਆਲਮੀ ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ \\n ਪਲੇਅਰ _ ਪੋਜੀਸ਼ਨ =ਹੈਂਡਲ _ ਯੂਜਰ _ ਇੰਪੁੱਟ (ਈਵੈਂਟ, ਪਲੇਅਰ _ ਪੋਜ਼ੀਸ਼ਨ, ਗਰਿੱਡ) \\n\\ nroot.bind (\'<ਕੁੰਜੀ>\', ਆਨ _ ਕੀ)\\nroot.mainloop () \\n \'\\n\' ਮੁਡ਼ ਲਿਖਿਆ \'ਬਣਾਓ _ ਹੈਕਸਾਗੋਨਲ _ ਗਰਿੱਡ\' ਫੰਕਸ਼ਨਵਧੇਰੇ ਪਡ਼੍ਹਨਯੋਗ ਹੈ, ਪਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਉਹੀ ਰਹਿੰਦੀ ਹੈ। ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ ਭੁਲੱਕਡ਼ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਸੰਟੈਕਸ ਗਲਤੀਆਂ ਦੇ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ",ਹੇਠ ਲਿਖੀ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਰਦੇ ਹੋਏ, ਸਭ ਤੋਂ ਛੋਟੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਕੋਡ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੋਃ \\n\\tg [y] [x]. itemconfig (ਭਰੋ = \'ਕਾਲਾ\') \\nAttਟ੍ਰਿਬ੍ਯੂਟਐਰਰੋਰਰਃ \'ਇੰਟ\' ਆਬਜੈਕਟ ਵਿੱਚ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੈ।ਗੁਣ \'ਆਈਟਮਕੌਨਫਿਗ\' \\n \'] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ \n ']