["   \n  \n ਇਹ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ?: \\nimport sys\\nclass NAME _ 1: \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸਵੈ, ਬੁਝਾਰਤ): \\n self.visited = ਗਲਤ \\n self.puzzle = ਬੁਝਾਰਤ \\n self.parents =[] \\n self.g = 1\\n self.f = 0\\n\\n\\ngoal = [0,1,2,3,4,5,6,7,8] \\nboundaries = [] \\nallPuzzles = [] \\n\\n\\n\\ndef ਪਜੱਲਜੇਨ (ਰੂਟ): \\n\\n ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ =root.puzzle.index (0) \\n ਦਿਸ਼ਾਵਾਂ = [] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 0: \\n ਦਿਸ਼ਾਵਾਂ = [1,3] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 1: \\n ਦਿਸ਼ਾਵਾਂ = [0,2,4] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 2: \\n ਦਿਸ਼ਾਵਾਂ = [1,5] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 3: \\n ਦਿਸ਼ਾਵਾਂ = [0,4,6] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 4: \\n ਦਿਸ਼ਾਵਾਂ = [1,3,5,7] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 5: \\n ਦਿਸ਼ਾਵਾਂ = [2,4,8] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 6: \\n ਦਿਸ਼ਾਵਾਂ = [3,7] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 7: \\n ਦਿਸ਼ਾਵਾਂ = [4,6,8] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 8: ਦਿਸ਼ਾਵਾਂ ਵਿੱਚ ਕੋਆਰਡੀਨੇਟ ਲਈ n ਦਿਸ਼ਾਵਾਂ = [5,7] \\n\\n\\n\\n: \\n ਨਿਊਪਜ਼ਲ = root.puzzle.copy () \\n ਟੈਂਪ = ਨਿਊਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] \\nਨਿਊਪੁਜ਼ਲ [ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ] = ਟੈਂਪ\\ਨ ਨਿਊਪੁਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] = 0\\ਨ ਜੇਕਰ ਨਿਊਪੁਜ਼ਲ ਸਾਰੇਪੁਜ਼ਲ ਵਿੱਚ ਨਹੀਂ ਹੈਃ \\ਨ ਨਿਊਨੋਡ = ਐੱਨ. ਏ. ਐੱਮ. ਈ. _ 1 (ਨਿਊਪੁਜ਼ਲ) \\ਨ newNode.g = root.g + 1\\ਨnewNode.parents = root.parents.copy () \\n newNode.parents.append (root.puzzle) \\n newNode.f = h (newNode.puzzle) + newNode.g \\n boundaries.append (ਨਵਾਂ ਨੋਡ) \\nallPuzzles.append (newNode.puzzle) \\n\\n\\n\\n\\ndefh (ਬੁਝਾਰਤ): \\n\\n ਗੁੰਮ ਥਾਂ = 0\\n ਮੈਨਹੱਟਨ = 0\\n ਬੁਝਾਰਤ ਵਿੱਚ ਨੰਬਰ ਲਈਃ \\n ਜੇਕਰ ਨੰਬਰ! = 0: \\n ਜੇਕਰ ਨੰਬਰ! = puzzle.index (ਨੰਬਰ): \\n ਗੁੰਮ ਥਾਂ + = 1\\n\\n x1 = puzzle.index (ਨੰਬਰ)% 3\\n y1 = puzzle.index (ਨੰਬਰ)// 3\\n x2 = ਨੰਬਰ% 3\\n y2 = ਨੰਬਰ '] ", 'ਇਹ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ?: ਇੰਪੋਰਟ ਸਿਸ ਕਲਾਸ ਨਾਮ _ 1: ਡਿਫ _ _ ਇਨਿਟ _ (ਸਵੈ, ਬੁਝਾਰਤ): self.visited = ਗਲਤ self.puzzle = ਬੁਝਾਰਤ self.parents = [] self.g = 1self.f = 0 ਟੀਚਾ = [0,1,2,3,4,5,6,7,8] ਹੱਦਾਂ = [] ਸਾਰੇਪੁਜ਼ਲਜ਼ = [] ਡਿਫ ਬੁਝਾਰਤਜੈਨ (ਰੂਟ): ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = root.puzzle.index (0) ਦਿਸ਼ਾਵਾਂ = [] ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 0: ਦਿਸ਼ਾਵਾਂ = [1,3] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 1: ਦਿਸ਼ਾਵਾਂ = [0,2,4] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 2: ਦਿਸ਼ਾਵਾਂ = [1,5] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 3:ਦਿਸ਼ਾਵਾਂ = [0,4,6] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 4: ਦਿਸ਼ਾਵਾਂ = [1,3,5,7] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 5: ਦਿਸ਼ਾਵਾਂ = [2,4,8] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 6: ਦਿਸ਼ਾਵਾਂ =[3,7] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 7: ਦਿਸ਼ਾਵਾਂ = [4,6,8] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 8: ਦਿਸ਼ਾਵਾਂ = [5,7] ਦਿਸ਼ਾਵਾਂ ਵਿੱਚ ਨਿਰਦੇਸ਼ਾਂਕ ਲਈਃ ਨਵਾਂ ਪਜ਼ਲ =root.puzzle.copy () ਟੈਂਪ = ਨਵਾਂ ਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] ਨਵਾਂ ਪਜ਼ਲ [ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ] = ਟੈਂਪ ਨਵਾਂ ਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] = 0 ਜੇਕਰ ਨਵਾਂ ਪਜ਼ਲ ਸਾਰੇ ਪਜ਼ਲ ਵਿੱਚ ਨਹੀਂ ਹੈਃ ਨਵਾਂ ਨੋਡ =ਨਾਮ _ 1 (ਨਵਾਂ ਪਜ਼ਲ) newNode.g = root.g + 1 newNode.parents = root.parents.copy () newNode.parents.append (root.puzzle) newNode.f = h (newNode.puzzle) +newNode.g boundaries.append (ਨਵਾਂ ਨੋਡ) allPuzzles.append (newNode.puzzle) def h (ਬੁਝਾਰਤ): ਗੁੰਮ = 0 ਮੈਨਹੱਟਨ = 0 ਬੁਝਾਰਤ ਵਿੱਚ ਨੰਬਰ ਲਈਃ ਜੇਕਰ ਨੰਬਰ! =0: ਜੇਕਰ ਨੰਬਰ! = puzzle.index (ਨੰਬਰ): ਗੁੰਮ + = 1 x1 = puzzle.index (ਨੰਬਰ)% 3 y1 = puzzle.index (ਨੰਬਰ)// 3 x2 = ਨੰਬਰ% 3 y2 = ਨੰਬਰ', " ਇਹ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ?: \\nimport sys\\nclass NAME _ 1: \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸਵੈ, ਬੁਝਾਰਤ): \\n self.visited = ਗਲਤ \\n self.puzzle = ਬੁਝਾਰਤ \\n self.parents =[] \\n self.g = 1\\n self.f = 0\\n\\n\\ngoal = [0,1,2,3,4,5,6,7,8] \\nboundaries = [] \\nallPuzzles = [] \\n\\n\\n\\ndef ਪਜੱਲਜੇਨ (ਰੂਟ): \\n\\n ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ =root.puzzle.index (0) \\n ਦਿਸ਼ਾਵਾਂ = [] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 0: \\n ਦਿਸ਼ਾਵਾਂ = [1,3] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 1: \\n ਦਿਸ਼ਾਵਾਂ = [0,2,4] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 2: \\n ਦਿਸ਼ਾਵਾਂ = [1,5] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 3: \\n ਦਿਸ਼ਾਵਾਂ = [0,4,6] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 4: \\n ਦਿਸ਼ਾਵਾਂ = [1,3,5,7] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 5: \\n ਦਿਸ਼ਾਵਾਂ = [2,4,8] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 6: \\n ਦਿਸ਼ਾਵਾਂ = [3,7] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 7: \\n ਦਿਸ਼ਾਵਾਂ = [4,6,8] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 8: ਦਿਸ਼ਾਵਾਂ ਵਿੱਚ ਕੋਆਰਡੀਨੇਟ ਲਈ n ਦਿਸ਼ਾਵਾਂ = [5,7] \\n\\n\\n\\n: \\n ਨਿਊਪਜ਼ਲ = root.puzzle.copy () \\n ਟੈਂਪ = ਨਿਊਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] \\nਨਿਊਪੁਜ਼ਲ [ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ] = ਟੈਂਪ\\ਨ ਨਿਊਪੁਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] = 0\\ਨ ਜੇਕਰ ਨਿਊਪੁਜ਼ਲ ਸਾਰੇਪੁਜ਼ਲ ਵਿੱਚ ਨਹੀਂ ਹੈਃ \\ਨ ਨਿਊਨੋਡ = ਐੱਨ. ਏ. ਐੱਮ. ਈ. _ 1 (ਨਿਊਪੁਜ਼ਲ) \\ਨ newNode.g = root.g + 1\\ਨnewNode.parents = root.parents.copy () \\n newNode.parents.append (root.puzzle) \\n newNode.f = h (newNode.puzzle) + newNode.g \\n boundaries.append (ਨਵਾਂ ਨੋਡ) \\nallPuzzles.append (newNode.puzzle) \\n\\n\\n\\n\\ndefh (ਬੁਝਾਰਤ): \\n\\n ਗੁੰਮ ਥਾਂ = 0\\n ਮੈਨਹੱਟਨ = 0\\n ਬੁਝਾਰਤ ਵਿੱਚ ਨੰਬਰ ਲਈਃ \\n ਜੇਕਰ ਨੰਬਰ! = 0: \\n ਜੇਕਰ ਨੰਬਰ! = puzzle.index (ਨੰਬਰ): \\n ਗੁੰਮ ਥਾਂ + = 1\\n\\n x1 = puzzle.index (ਨੰਬਰ)% 3\\n y1 = puzzle.index (ਨੰਬਰ)// 3\\n x2 = ਨੰਬਰ% 3\\n y2 = ਨੰਬਰ ',' ਉਹਕੋਡ 8-ਪਜ਼ਲ ਸਮੱਸਿਆ ਦੀਆਂ ਬੁਝਾਰਤਾਂ ਪੈਦਾ ਕਰਦਾ ਹੈ। 8-ਪਜ਼ਲ ਸਮੱਸਿਆ ਕੰਪਿਊਟਰ ਸਾਇੰਸ ਵਿੱਚ ਇੱਕ ਕਲਾਸਿਕ ਸਮੱਸਿਆ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਸਲਾਈਡਿੰਗ ਬੁਝਾਰਤ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।ਸਮੱਸਿਆ. ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ 3x3 ਬੋਰਡ ਉੱਤੇ ਟਾਇਲਾਂ ਨੂੰ ਇੱਕ ਖਾਸ ਸਥਿਤੀ ਵਿੱਚ ਲਿਜਾਇਆ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਟਾਇਲਾਂ ਨਿਰਧਾਰਤ ਕ੍ਰਮ ਵਿੱਚ ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਨੂੰ ਹਿਲਾਉਂਦੀਆਂ ਹਨ। ਕੋਡ8-ਪਜ਼ਲ ਸਮੱਸਿਆ ਦੇ ਸਾਰੇ ਸੰਭਵ ਬੁਝਾਰਤਾਂ ਨੂੰ ਇੱਕ ਆਵਰਤੀ ਫੰਕਸ਼ਨ 'ਪਜ਼ਲਜਨ' ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਇੱਕ ਰੂਟ NAME _ 1 ਨੂੰ ਇੰਪੁੱਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਹੈ'ਨਾਮ _ 1' ਆਬਜੈਕਟ ਜੋ ਬੁਝਾਰਤ ਦੀ ਸ਼ੁਰੂਆਤੀ ਸਥਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਫਿਰ ਬੁਝਾਰਤ ਵਿੱਚ ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਟਾਇਲਾਂ ਨੂੰ ਹਿਲਾ ਕੇ ਸਾਰੇ ਸੰਭਵ ਬੁਝਾਰਤਾਂ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕ੍ਰਮ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ ਬੁਝਾਰਤ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਵਿਲੱਖਣ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਧਿਆਨ ਰੱਖਦਾ ਹੈ, ਜੋ 'ਨਾਮ _ 1' ਆਬਜੈਕਟ ਦੇ 'ਵਿਜ਼ਿਟ ਕੀਤੇ' ਗੁਣ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਇਹ ਫੰਕਸ਼ਨ ਹਰੇਕ ਬੁਝਾਰਤ ਦੇ ਖੋਜ ਮੁੱਲ ਦੀ ਵੀ ਗਣਨਾ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਹਰੇਕ ਟਾਇਲ ਦੀ ਮੈਨਹੱਟਨ ਦੂਰੀ ਦਾ ਇਸ ਦੇ ਟੀਚੇ ਦੀ ਸਥਿਤੀ ਤੱਕ ਦਾ ਜੋਡ਼ ਹੈ।'h' ਫੰਕਸ਼ਨ ਗੁੰਮ ਹੋਈਆਂ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਮੈਨਹੱਟਨ ਦੀਆਂ ਦੂਰੀਆਂ ਦੇ ਜੋਡ਼ ਦਾ ਧਿਆਨ ਰੱਖ ਕੇ ਇੱਕ ਬੁਝਾਰਤ ਦੇ ਖੋਜ ਮੁੱਲ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ।ਹਰੇਕ ਟਾਇਲ ਆਪਣੇ ਟੀਚੇ ਦੀ ਸਥਿਤੀ ਤੱਕ ਪਹੁੰਚਦੀ ਹੈ। ਅੰਤ ਵਿੱਚ, ਕੋਡ ਸਾਰੇ ਤਿਆਰ ਕੀਤੇ ਬੁਝਾਰਤਾਂ ਅਤੇ ਹੱਲ ਲਈ ਉਹਨਾਂ ਦੇ ਸਬੰਧਤ ਰਸਤੇ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ। ',' ਸਮੇਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੋ।ਗੁੰਝਲਤਾ '] ", 'ਇਹ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ?: ਇੰਪੋਰਟ ਸਿਸ ਕਲਾਸ ਨਾਮ _ 1: ਡਿਫ _ _ ਇਨਿਟ _ (ਸਵੈ, ਬੁਝਾਰਤ): self.visited = ਗਲਤ self.puzzle = ਬੁਝਾਰਤ self.parents = [] self.g = 1self.f = 0 ਟੀਚਾ = [0,1,2,3,4,5,6,7,8] ਹੱਦਾਂ = [] ਸਾਰੇਪੁਜ਼ਲਜ਼ = [] ਡਿਫ ਬੁਝਾਰਤਜੈਨ (ਰੂਟ): ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = root.puzzle.index (0) ਦਿਸ਼ਾਵਾਂ = [] ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 0: ਦਿਸ਼ਾਵਾਂ = [1,3] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 1: ਦਿਸ਼ਾਵਾਂ = [0,2,4] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 2: ਦਿਸ਼ਾਵਾਂ = [1,5] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 3:ਦਿਸ਼ਾਵਾਂ = [0,4,6] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 4: ਦਿਸ਼ਾਵਾਂ = [1,3,5,7] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 5: ਦਿਸ਼ਾਵਾਂ = [2,4,8] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 6: ਦਿਸ਼ਾਵਾਂ =[3,7] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 7: ਦਿਸ਼ਾਵਾਂ = [4,6,8] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 8: ਦਿਸ਼ਾਵਾਂ = [5,7] ਦਿਸ਼ਾਵਾਂ ਵਿੱਚ ਨਿਰਦੇਸ਼ਾਂਕ ਲਈਃ ਨਵਾਂ ਪਜ਼ਲ =root.puzzle.copy () ਟੈਂਪ = ਨਵਾਂ ਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] ਨਵਾਂ ਪਜ਼ਲ [ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ] = ਟੈਂਪ ਨਵਾਂ ਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] = 0 ਜੇਕਰ ਨਵਾਂ ਪਜ਼ਲ ਸਾਰੇ ਪਜ਼ਲ ਵਿੱਚ ਨਹੀਂ ਹੈਃ ਨਵਾਂ ਨੋਡ =ਨਾਮ _ 1 (ਨਵਾਂ ਪਜ਼ਲ) newNode.g = root.g + 1 newNode.parents = root.parents.copy () newNode.parents.append (root.puzzle) newNode.f = h (newNode.puzzle) +newNode.g boundaries.append (ਨਵਾਂ ਨੋਡ) allPuzzles.append (newNode.puzzle) def h (ਬੁਝਾਰਤ): ਗੁੰਮ = 0 ਮੈਨਹੱਟਨ = 0 ਬੁਝਾਰਤ ਵਿੱਚ ਨੰਬਰ ਲਈਃ ਜੇਕਰ ਨੰਬਰ! =0: ਜੇਕਰ ਨੰਬਰ! = puzzle.index (ਨੰਬਰ): ਗੁੰਮ + = 1 x1 = puzzle.index (ਨੰਬਰ)% 3 y1 = puzzle.index (ਨੰਬਰ)// 3 x2 = ਨੰਬਰ% 3 y2 = ਨੰਬਰ', " ਇਹ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ?: \\nimport sys\\nclass NAME _ 1: \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸਵੈ, ਬੁਝਾਰਤ): \\n self.visited = ਗਲਤ \\n self.puzzle = ਬੁਝਾਰਤ \\n self.parents =[] \\n self.g = 1\\n self.f = 0\\n\\n\\ngoal = [0,1,2,3,4,5,6,7,8] \\nboundaries = [] \\nallPuzzles = [] \\n\\n\\n\\ndef ਪਜੱਲਜੇਨ (ਰੂਟ): \\n\\n ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ =root.puzzle.index (0) \\n ਦਿਸ਼ਾਵਾਂ = [] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 0: \\n ਦਿਸ਼ਾਵਾਂ = [1,3] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 1: \\n ਦਿਸ਼ਾਵਾਂ = [0,2,4] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 2: \\n ਦਿਸ਼ਾਵਾਂ = [1,5] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 3: \\n ਦਿਸ਼ਾਵਾਂ = [0,4,6] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 4: \\n ਦਿਸ਼ਾਵਾਂ = [1,3,5,7] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 5: \\n ਦਿਸ਼ਾਵਾਂ = [2,4,8] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 6: \\n ਦਿਸ਼ਾਵਾਂ = [3,7] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 7: \\n ਦਿਸ਼ਾਵਾਂ = [4,6,8] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 8: ਦਿਸ਼ਾਵਾਂ ਵਿੱਚ ਕੋਆਰਡੀਨੇਟ ਲਈ n ਦਿਸ਼ਾਵਾਂ = [5,7] \\n\\n\\n\\n: \\n ਨਿਊਪਜ਼ਲ = root.puzzle.copy () \\n ਟੈਂਪ = ਨਿਊਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] \\nਨਿਊਪੁਜ਼ਲ [ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ] = ਟੈਂਪ\\ਨ ਨਿਊਪੁਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] = 0\\ਨ ਜੇਕਰ ਨਿਊਪੁਜ਼ਲ ਸਾਰੇਪੁਜ਼ਲ ਵਿੱਚ ਨਹੀਂ ਹੈਃ \\ਨ ਨਿਊਨੋਡ = ਐੱਨ. ਏ. ਐੱਮ. ਈ. _ 1 (ਨਿਊਪੁਜ਼ਲ) \\ਨ newNode.g = root.g + 1\\ਨnewNode.parents = root.parents.copy () \\n newNode.parents.append (root.puzzle) \\n newNode.f = h (newNode.puzzle) + newNode.g \\n boundaries.append (ਨਵਾਂ ਨੋਡ) \\nallPuzzles.append (newNode.puzzle) \\n\\n\\n\\n\\ndefh (ਬੁਝਾਰਤ): \\n\\n ਗੁੰਮ ਥਾਂ = 0\\n ਮੈਨਹੱਟਨ = 0\\n ਬੁਝਾਰਤ ਵਿੱਚ ਨੰਬਰ ਲਈਃ \\n ਜੇਕਰ ਨੰਬਰ! = 0: \\n ਜੇਕਰ ਨੰਬਰ! = puzzle.index (ਨੰਬਰ): \\n ਗੁੰਮ ਥਾਂ + = 1\\n\\n x1 = puzzle.index (ਨੰਬਰ)% 3\\n y1 = puzzle.index (ਨੰਬਰ)// 3\\n x2 = ਨੰਬਰ% 3\\n y2 = ਨੰਬਰ ',' ਉਹਕੋਡ 8-ਪਜ਼ਲ ਸਮੱਸਿਆ ਦੀਆਂ ਬੁਝਾਰਤਾਂ ਪੈਦਾ ਕਰਦਾ ਹੈ। 8-ਪਜ਼ਲ ਸਮੱਸਿਆ ਕੰਪਿਊਟਰ ਸਾਇੰਸ ਵਿੱਚ ਇੱਕ ਕਲਾਸਿਕ ਸਮੱਸਿਆ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਸਲਾਈਡਿੰਗ ਬੁਝਾਰਤ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।ਸਮੱਸਿਆ. ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ 3x3 ਬੋਰਡ ਉੱਤੇ ਟਾਇਲਾਂ ਨੂੰ ਇੱਕ ਖਾਸ ਸਥਿਤੀ ਵਿੱਚ ਲਿਜਾਇਆ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਟਾਇਲਾਂ ਨਿਰਧਾਰਤ ਕ੍ਰਮ ਵਿੱਚ ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਨੂੰ ਹਿਲਾਉਂਦੀਆਂ ਹਨ। ਕੋਡ8-ਪਜ਼ਲ ਸਮੱਸਿਆ ਦੇ ਸਾਰੇ ਸੰਭਵ ਬੁਝਾਰਤਾਂ ਨੂੰ ਇੱਕ ਆਵਰਤੀ ਫੰਕਸ਼ਨ 'ਪਜ਼ਲਜਨ' ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਇੱਕ ਰੂਟ NAME _ 1 ਨੂੰ ਇੰਪੁੱਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਹੈ'ਨਾਮ _ 1' ਆਬਜੈਕਟ ਜੋ ਬੁਝਾਰਤ ਦੀ ਸ਼ੁਰੂਆਤੀ ਸਥਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਫਿਰ ਬੁਝਾਰਤ ਵਿੱਚ ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਟਾਇਲਾਂ ਨੂੰ ਹਿਲਾ ਕੇ ਸਾਰੇ ਸੰਭਵ ਬੁਝਾਰਤਾਂ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕ੍ਰਮ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ ਬੁਝਾਰਤ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਵਿਲੱਖਣ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਧਿਆਨ ਰੱਖਦਾ ਹੈ, ਜੋ 'ਨਾਮ _ 1' ਆਬਜੈਕਟ ਦੇ 'ਵਿਜ਼ਿਟ ਕੀਤੇ' ਗੁਣ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਇਹ ਫੰਕਸ਼ਨ ਹਰੇਕ ਬੁਝਾਰਤ ਦੇ ਖੋਜ ਮੁੱਲ ਦੀ ਵੀ ਗਣਨਾ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਹਰੇਕ ਟਾਇਲ ਦੀ ਮੈਨਹੱਟਨ ਦੂਰੀ ਦਾ ਇਸ ਦੇ ਟੀਚੇ ਦੀ ਸਥਿਤੀ ਤੱਕ ਦਾ ਜੋਡ਼ ਹੈ।'h' ਫੰਕਸ਼ਨ ਗੁੰਮ ਹੋਈਆਂ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਮੈਨਹੱਟਨ ਦੀਆਂ ਦੂਰੀਆਂ ਦੇ ਜੋਡ਼ ਦਾ ਧਿਆਨ ਰੱਖ ਕੇ ਇੱਕ ਬੁਝਾਰਤ ਦੇ ਖੋਜ ਮੁੱਲ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ।ਹਰੇਕ ਟਾਇਲ ਆਪਣੇ ਟੀਚੇ ਦੀ ਸਥਿਤੀ ਤੱਕ ਪਹੁੰਚਦੀ ਹੈ। ਅੰਤ ਵਿੱਚ, ਕੋਡ ਸਾਰੇ ਤਿਆਰ ਕੀਤੇ ਬੁਝਾਰਤਾਂ ਅਤੇ ਹੱਲ ਲਈ ਉਹਨਾਂ ਦੇ ਸਬੰਧਤ ਰਸਤੇ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ। ',' ਸਮੇਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੋ।ਗੁੰਝਲਤਾ ', ਇਸ ਕੋਡ ਦੀ ਸਮਾਂ ਗੁੰਝਲਤਾ O (2 ^ 8) ਹੈ, ਜਿੱਥੇ 2 ^ 8 8-ਪਜ਼ਲ ਸਮੱਸਿਆ ਦੀਆਂ ਸੰਭਵ ਅਵਸਥਾਵਾਂ ਦੀ ਸੰਖਿਆ ਹੈ, ਜੋ ਕਿ ਦੀ ਸੰਖਿਆ ਹੈ3x3 ਬੋਰਡ ਉੱਤੇ ਟਾਇਲਾਂ ਦੀ ਸੰਭਵ ਸਥਿਤੀ। \\n\\n ਕੋਡ ਇੱਕ ਆਵਰਤੀ ਫੰਕਸ਼ਨ 'ਪਜ਼ਲਜੇਨ' ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਸਾਰੇ ਸੰਭਵ ਬੁਝਾਰਤਾਂ ਨੂੰ ਹਿਲਾ ਕੇ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਨਿਰਧਾਰਤ ਕ੍ਰਮ ਵਿੱਚ ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਟਾਇਲ, ਅਤੇ ਇਹ ਹਰੇਕ ਬੁਝਾਰਤ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਵਿਲੱਖਣ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਧਿਆਨ ਰੱਖਦਾ ਹੈ, ਜੋ ਕਿ 'ਵਿਜ਼ਿਟਡ' ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।'NAME _ 1' ਆਬਜੈਕਟ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ। ਜਿਵੇਂ-ਜਿਵੇਂ ਵਿਲੱਖਣ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ ਵਧਦੀ ਹੈ, ਸੰਭਵ ਅਵਸਥਾਵਾਂ ਦੀ ਗਿਣਤੀ ਤੇਜ਼ੀ ਨਾਲ ਵਧਦੀ ਹੈ, ਜਿਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਇੱਕਓ (2 ^ 8) ਦੀ ਸਮਾਂ ਗੁੰਝਲਤਾ। \\n\\n ਇਸ ਤੋਂ ਇਲਾਵਾ, 'ਐਚ' ਫੰਕਸ਼ਨ ਕਿਸੇ ਬੁਝਾਰਤ ਦੇ ਖੋਜ ਮੁੱਲ ਦੀ ਗਣਨਾ ਗਲਤ ਸਥਾਨਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਧਿਆਨ ਰੱਖ ਕੇ ਕਰਦਾ ਹੈ।ਟਾਇਲਾਂ ਅਤੇ ਹਰੇਕ ਟਾਇਲ ਦੀ ਮੈਨਹੱਟਨ ਦੂਰੀਆਂ ਦਾ ਜੋਡ਼ ਇਸ ਦੇ ਟੀਚੇ ਦੀ ਸਥਿਤੀ ਤੱਕ। ਫੰਕਸ਼ਨ ਨੰਬਰ ਦਾ ਧਿਆਨ ਰੱਖਣ ਲਈ 'ਵਿਜ਼ਿਟਡ' ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈਹਰੇਕ ਬੁਝਾਰਤ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਵਿਲੱਖਣ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ, ਇਸ ਤਰ੍ਹਾਂ ਸੰਭਵ ਅਵਸਥਾਵਾਂ ਦੀ ਗਿਣਤੀ ਵਿੱਚ ਵਾਧਾ ਹੁੰਦਾ ਹੈ, ਜੋ ਕੰਪਿਊਟੇਸ਼ਨ ਟਾਈਮ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ।'ਸੀਮਾਵਾਂ' ਸੂਚੀ ਜੋ 'ਨਾਮ _ 1' ਵਸਤੂਆਂ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ ਜੋ ਹਰੇਕ ਬੁਝਾਰਤ ਲਈ ਹੁਣ ਤੱਕ ਪਾਏ ਗਏ ਸਭ ਤੋਂ ਵਧੀਆ ਹੱਲ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। 'ਸੀਮਾਵਾਂ' ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਇਸ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈਹਰੇਕ ਬੁਝਾਰਤ ਲਈ ਲੱਭੇ ਗਏ ਸਭ ਤੋਂ ਵਧੀਆ ਹੱਲ ਦਾ ਧਿਆਨ ਰੱਖੋ, ਜੋ ਬੁਝਾਰਤਾਂ ਦੀ ਗਿਣਤੀ ਵਧਣ ਨਾਲ ਗਣਨਾ ਦਾ ਸਮਾਂ ਵਧਾਉਂਦਾ ਹੈ। \\n\\n ਅੰਤ ਵਿੱਚ, ਕੋਡ'ਆਲਪਜ਼ਲਜ਼' ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਸਾਰੇ ਤਿਆਰ ਕੀਤੇ ਬੁਝਾਰਤਾਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ। ਇਸ ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਸਾਰੇ ਤਿਆਰ ਕੀਤੇ ਬੁਝਾਰਤਾਂ ਦਾ ਧਿਆਨ ਰੱਖਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਬੁਝਾਰਤ ਵਧ ਜਾਂਦੀ ਹੈ।ਜਿਵੇਂ ਜਿਵੇਂ ਬੁਝਾਰਤਾਂ ਦੀ ਗਿਣਤੀ ਵਧਦੀ ਜਾਂਦੀ ਹੈ, ਕੰਪਿਊਟੇਸ਼ਨ ਟਾਈਮ ਵਧਦਾ ਜਾਂਦਾ ਹੈ। ਕੁੱਲ ਮਿਲਾ ਕੇ, ਇਸ ਕੋਡ ਦੀ ਸਮਾਂ ਗੁੰਝਲਤਾ O (2 ^ 8) ਹੈ ਜੋ ਕਿ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੈ ਅਤੇ ਇਸ ਲਈ ਕੁਸ਼ਲ ਨਹੀਂ ਹੈ।ਵੱਡੀਆਂ ਬੁਝਾਰਤਾਂ. ',' ਕੀ ਤੁਸੀਂ ਸਮੇਂ ਦੀ ਗੁੰਝਲਤਾ ਬਾਰੇ ਜੋ ਕਿਹਾ ਹੈ ਉਸ ਬਾਰੇ ਕੋਡ ਵਿੱਚ ਸੁਧਾਰ ਕਰ ਸਕਦੇ ਹੋ? ' ", 'ਇਹ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ?: ਇੰਪੋਰਟ ਸਿਸ ਕਲਾਸ ਨਾਮ _ 1: ਡਿਫ _ _ ਇਨਿਟ _ (ਸਵੈ, ਬੁਝਾਰਤ): self.visited = ਗਲਤ self.puzzle = ਬੁਝਾਰਤ self.parents = [] self.g = 1self.f = 0 ਟੀਚਾ = [0,1,2,3,4,5,6,7,8] ਹੱਦਾਂ = [] ਸਾਰੇਪੁਜ਼ਲਜ਼ = [] ਡਿਫ ਬੁਝਾਰਤਜੈਨ (ਰੂਟ): ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = root.puzzle.index (0) ਦਿਸ਼ਾਵਾਂ = [] ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 0: ਦਿਸ਼ਾਵਾਂ = [1,3] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 1: ਦਿਸ਼ਾਵਾਂ = [0,2,4] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 2: ਦਿਸ਼ਾਵਾਂ = [1,5] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 3:ਦਿਸ਼ਾਵਾਂ = [0,4,6] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 4: ਦਿਸ਼ਾਵਾਂ = [1,3,5,7] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 5: ਦਿਸ਼ਾਵਾਂ = [2,4,8] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 6: ਦਿਸ਼ਾਵਾਂ =[3,7] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 7: ਦਿਸ਼ਾਵਾਂ = [4,6,8] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 8: ਦਿਸ਼ਾਵਾਂ = [5,7] ਦਿਸ਼ਾਵਾਂ ਵਿੱਚ ਨਿਰਦੇਸ਼ਾਂਕ ਲਈਃ ਨਵਾਂ ਪਜ਼ਲ =root.puzzle.copy () ਟੈਂਪ = ਨਵਾਂ ਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] ਨਵਾਂ ਪਜ਼ਲ [ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ] = ਟੈਂਪ ਨਵਾਂ ਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] = 0 ਜੇਕਰ ਨਵਾਂ ਪਜ਼ਲ ਸਾਰੇ ਪਜ਼ਲ ਵਿੱਚ ਨਹੀਂ ਹੈਃ ਨਵਾਂ ਨੋਡ =ਨਾਮ _ 1 (ਨਵਾਂ ਪਜ਼ਲ) newNode.g = root.g + 1 newNode.parents = root.parents.copy () newNode.parents.append (root.puzzle) newNode.f = h (newNode.puzzle) +newNode.g boundaries.append (ਨਵਾਂ ਨੋਡ) allPuzzles.append (newNode.puzzle) def h (ਬੁਝਾਰਤ): ਗੁੰਮ = 0 ਮੈਨਹੱਟਨ = 0 ਬੁਝਾਰਤ ਵਿੱਚ ਨੰਬਰ ਲਈਃ ਜੇਕਰ ਨੰਬਰ! =0: ਜੇਕਰ ਨੰਬਰ! = puzzle.index (ਨੰਬਰ): ਗੁੰਮ + = 1 x1 = puzzle.index (ਨੰਬਰ)% 3 y1 = puzzle.index (ਨੰਬਰ)// 3 x2 = ਨੰਬਰ% 3 y2 = ਨੰਬਰ', " ਇਹ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ?: \\nimport sys\\nclass NAME _ 1: \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸਵੈ, ਬੁਝਾਰਤ): \\n self.visited = ਗਲਤ \\n self.puzzle = ਬੁਝਾਰਤ \\n self.parents =[] \\n self.g = 1\\n self.f = 0\\n\\n\\ngoal = [0,1,2,3,4,5,6,7,8] \\nboundaries = [] \\nallPuzzles = [] \\n\\n\\n\\ndef ਪਜੱਲਜੇਨ (ਰੂਟ): \\n\\n ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ =root.puzzle.index (0) \\n ਦਿਸ਼ਾਵਾਂ = [] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 0: \\n ਦਿਸ਼ਾਵਾਂ = [1,3] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 1: \\n ਦਿਸ਼ਾਵਾਂ = [0,2,4] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 2: \\n ਦਿਸ਼ਾਵਾਂ = [1,5] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 3: \\n ਦਿਸ਼ਾਵਾਂ = [0,4,6] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 4: \\n ਦਿਸ਼ਾਵਾਂ = [1,3,5,7] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 5: \\n ਦਿਸ਼ਾਵਾਂ = [2,4,8] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 6: \\n ਦਿਸ਼ਾਵਾਂ = [3,7] \\n ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 7: \\n ਦਿਸ਼ਾਵਾਂ = [4,6,8] \\n ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 8: ਦਿਸ਼ਾਵਾਂ ਵਿੱਚ ਕੋਆਰਡੀਨੇਟ ਲਈ n ਦਿਸ਼ਾਵਾਂ = [5,7] \\n\\n\\n\\n: \\n ਨਿਊਪਜ਼ਲ = root.puzzle.copy () \\n ਟੈਂਪ = ਨਿਊਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] \\nਨਿਊਪੁਜ਼ਲ [ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ] = ਟੈਂਪ\\ਨ ਨਿਊਪੁਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] = 0\\ਨ ਜੇਕਰ ਨਿਊਪੁਜ਼ਲ ਸਾਰੇਪੁਜ਼ਲ ਵਿੱਚ ਨਹੀਂ ਹੈਃ \\ਨ ਨਿਊਨੋਡ = ਐੱਨ. ਏ. ਐੱਮ. ਈ. _ 1 (ਨਿਊਪੁਜ਼ਲ) \\ਨ newNode.g = root.g + 1\\ਨnewNode.parents = root.parents.copy () \\n newNode.parents.append (root.puzzle) \\n newNode.f = h (newNode.puzzle) + newNode.g \\n boundaries.append (ਨਵਾਂ ਨੋਡ) \\nallPuzzles.append (newNode.puzzle) \\n\\n\\n\\n\\ndefh (ਬੁਝਾਰਤ): \\n\\n ਗੁੰਮ ਥਾਂ = 0\\n ਮੈਨਹੱਟਨ = 0\\n ਬੁਝਾਰਤ ਵਿੱਚ ਨੰਬਰ ਲਈਃ \\n ਜੇਕਰ ਨੰਬਰ! = 0: \\n ਜੇਕਰ ਨੰਬਰ! = puzzle.index (ਨੰਬਰ): \\n ਗੁੰਮ ਥਾਂ + = 1\\n\\n x1 = puzzle.index (ਨੰਬਰ)% 3\\n y1 = puzzle.index (ਨੰਬਰ)// 3\\n x2 = ਨੰਬਰ% 3\\n y2 = ਨੰਬਰ ',' ਉਹਕੋਡ 8-ਪਜ਼ਲ ਸਮੱਸਿਆ ਦੀਆਂ ਬੁਝਾਰਤਾਂ ਪੈਦਾ ਕਰਦਾ ਹੈ। 8-ਪਜ਼ਲ ਸਮੱਸਿਆ ਕੰਪਿਊਟਰ ਸਾਇੰਸ ਵਿੱਚ ਇੱਕ ਕਲਾਸਿਕ ਸਮੱਸਿਆ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਸਲਾਈਡਿੰਗ ਬੁਝਾਰਤ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।ਸਮੱਸਿਆ. ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ 3x3 ਬੋਰਡ ਉੱਤੇ ਟਾਇਲਾਂ ਨੂੰ ਇੱਕ ਖਾਸ ਸਥਿਤੀ ਵਿੱਚ ਲਿਜਾਇਆ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਟਾਇਲਾਂ ਨਿਰਧਾਰਤ ਕ੍ਰਮ ਵਿੱਚ ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਨੂੰ ਹਿਲਾਉਂਦੀਆਂ ਹਨ। ਕੋਡ8-ਪਜ਼ਲ ਸਮੱਸਿਆ ਦੇ ਸਾਰੇ ਸੰਭਵ ਬੁਝਾਰਤਾਂ ਨੂੰ ਇੱਕ ਆਵਰਤੀ ਫੰਕਸ਼ਨ 'ਪਜ਼ਲਜਨ' ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਇੱਕ ਰੂਟ NAME _ 1 ਨੂੰ ਇੰਪੁੱਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਹੈ'ਨਾਮ _ 1' ਆਬਜੈਕਟ ਜੋ ਬੁਝਾਰਤ ਦੀ ਸ਼ੁਰੂਆਤੀ ਸਥਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਫਿਰ ਬੁਝਾਰਤ ਵਿੱਚ ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਟਾਇਲਾਂ ਨੂੰ ਹਿਲਾ ਕੇ ਸਾਰੇ ਸੰਭਵ ਬੁਝਾਰਤਾਂ ਪੈਦਾ ਕਰਦਾ ਹੈ।ਕ੍ਰਮ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ ਬੁਝਾਰਤ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਵਿਲੱਖਣ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਧਿਆਨ ਰੱਖਦਾ ਹੈ, ਜੋ 'ਨਾਮ _ 1' ਆਬਜੈਕਟ ਦੇ 'ਵਿਜ਼ਿਟ ਕੀਤੇ' ਗੁਣ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਇਹ ਫੰਕਸ਼ਨ ਹਰੇਕ ਬੁਝਾਰਤ ਦੇ ਖੋਜ ਮੁੱਲ ਦੀ ਵੀ ਗਣਨਾ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਹਰੇਕ ਟਾਇਲ ਦੀ ਮੈਨਹੱਟਨ ਦੂਰੀ ਦਾ ਇਸ ਦੇ ਟੀਚੇ ਦੀ ਸਥਿਤੀ ਤੱਕ ਦਾ ਜੋਡ਼ ਹੈ।'h' ਫੰਕਸ਼ਨ ਗੁੰਮ ਹੋਈਆਂ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਮੈਨਹੱਟਨ ਦੀਆਂ ਦੂਰੀਆਂ ਦੇ ਜੋਡ਼ ਦਾ ਧਿਆਨ ਰੱਖ ਕੇ ਇੱਕ ਬੁਝਾਰਤ ਦੇ ਖੋਜ ਮੁੱਲ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ।ਹਰੇਕ ਟਾਇਲ ਆਪਣੇ ਟੀਚੇ ਦੀ ਸਥਿਤੀ ਤੱਕ ਪਹੁੰਚਦੀ ਹੈ। ਅੰਤ ਵਿੱਚ, ਕੋਡ ਸਾਰੇ ਤਿਆਰ ਕੀਤੇ ਬੁਝਾਰਤਾਂ ਅਤੇ ਹੱਲ ਲਈ ਉਹਨਾਂ ਦੇ ਸਬੰਧਤ ਰਸਤੇ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ। ',' ਸਮੇਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੋ।ਗੁੰਝਲਤਾ ', ਇਸ ਕੋਡ ਦੀ ਸਮਾਂ ਗੁੰਝਲਤਾ O (2 ^ 8) ਹੈ, ਜਿੱਥੇ 2 ^ 8 8-ਪਜ਼ਲ ਸਮੱਸਿਆ ਦੀਆਂ ਸੰਭਵ ਅਵਸਥਾਵਾਂ ਦੀ ਸੰਖਿਆ ਹੈ, ਜੋ ਕਿ ਦੀ ਸੰਖਿਆ ਹੈ3x3 ਬੋਰਡ ਉੱਤੇ ਟਾਇਲਾਂ ਦੀ ਸੰਭਵ ਸਥਿਤੀ। \\n\\n ਕੋਡ ਇੱਕ ਆਵਰਤੀ ਫੰਕਸ਼ਨ 'ਪਜ਼ਲਜੇਨ' ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਸਾਰੇ ਸੰਭਵ ਬੁਝਾਰਤਾਂ ਨੂੰ ਹਿਲਾ ਕੇ ਤਿਆਰ ਕਰਦਾ ਹੈ।ਨਿਰਧਾਰਤ ਕ੍ਰਮ ਵਿੱਚ ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਟਾਇਲ, ਅਤੇ ਇਹ ਹਰੇਕ ਬੁਝਾਰਤ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਵਿਲੱਖਣ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਧਿਆਨ ਰੱਖਦਾ ਹੈ, ਜੋ ਕਿ 'ਵਿਜ਼ਿਟਡ' ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।'NAME _ 1' ਆਬਜੈਕਟ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ। ਜਿਵੇਂ-ਜਿਵੇਂ ਵਿਲੱਖਣ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ ਵਧਦੀ ਹੈ, ਸੰਭਵ ਅਵਸਥਾਵਾਂ ਦੀ ਗਿਣਤੀ ਤੇਜ਼ੀ ਨਾਲ ਵਧਦੀ ਹੈ, ਜਿਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਇੱਕਓ (2 ^ 8) ਦੀ ਸਮਾਂ ਗੁੰਝਲਤਾ। \\n\\n ਇਸ ਤੋਂ ਇਲਾਵਾ, 'ਐਚ' ਫੰਕਸ਼ਨ ਕਿਸੇ ਬੁਝਾਰਤ ਦੇ ਖੋਜ ਮੁੱਲ ਦੀ ਗਣਨਾ ਗਲਤ ਸਥਾਨਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਧਿਆਨ ਰੱਖ ਕੇ ਕਰਦਾ ਹੈ।ਟਾਇਲਾਂ ਅਤੇ ਹਰੇਕ ਟਾਇਲ ਦੀ ਮੈਨਹੱਟਨ ਦੂਰੀਆਂ ਦਾ ਜੋਡ਼ ਇਸ ਦੇ ਟੀਚੇ ਦੀ ਸਥਿਤੀ ਤੱਕ। ਫੰਕਸ਼ਨ ਨੰਬਰ ਦਾ ਧਿਆਨ ਰੱਖਣ ਲਈ 'ਵਿਜ਼ਿਟਡ' ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈਹਰੇਕ ਬੁਝਾਰਤ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਵਿਲੱਖਣ ਟਾਇਲਾਂ ਦੀ ਗਿਣਤੀ, ਇਸ ਤਰ੍ਹਾਂ ਸੰਭਵ ਅਵਸਥਾਵਾਂ ਦੀ ਗਿਣਤੀ ਵਿੱਚ ਵਾਧਾ ਹੁੰਦਾ ਹੈ, ਜੋ ਕੰਪਿਊਟੇਸ਼ਨ ਟਾਈਮ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ।'ਸੀਮਾਵਾਂ' ਸੂਚੀ ਜੋ 'ਨਾਮ _ 1' ਵਸਤੂਆਂ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ ਜੋ ਹਰੇਕ ਬੁਝਾਰਤ ਲਈ ਹੁਣ ਤੱਕ ਪਾਏ ਗਏ ਸਭ ਤੋਂ ਵਧੀਆ ਹੱਲ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। 'ਸੀਮਾਵਾਂ' ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਇਸ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈਹਰੇਕ ਬੁਝਾਰਤ ਲਈ ਲੱਭੇ ਗਏ ਸਭ ਤੋਂ ਵਧੀਆ ਹੱਲ ਦਾ ਧਿਆਨ ਰੱਖੋ, ਜੋ ਬੁਝਾਰਤਾਂ ਦੀ ਗਿਣਤੀ ਵਧਣ ਨਾਲ ਗਣਨਾ ਦਾ ਸਮਾਂ ਵਧਾਉਂਦਾ ਹੈ। \\n\\n ਅੰਤ ਵਿੱਚ, ਕੋਡ'ਆਲਪਜ਼ਲਜ਼' ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਸਾਰੇ ਤਿਆਰ ਕੀਤੇ ਬੁਝਾਰਤਾਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ। ਇਸ ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਸਾਰੇ ਤਿਆਰ ਕੀਤੇ ਬੁਝਾਰਤਾਂ ਦਾ ਧਿਆਨ ਰੱਖਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਬੁਝਾਰਤ ਵਧ ਜਾਂਦੀ ਹੈ।ਜਿਵੇਂ ਜਿਵੇਂ ਬੁਝਾਰਤਾਂ ਦੀ ਗਿਣਤੀ ਵਧਦੀ ਜਾਂਦੀ ਹੈ, ਕੰਪਿਊਟੇਸ਼ਨ ਟਾਈਮ ਵਧਦਾ ਜਾਂਦਾ ਹੈ। ਕੁੱਲ ਮਿਲਾ ਕੇ, ਇਸ ਕੋਡ ਦੀ ਸਮਾਂ ਗੁੰਝਲਤਾ O (2 ^ 8) ਹੈ ਜੋ ਕਿ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੈ ਅਤੇ ਇਸ ਲਈ ਕੁਸ਼ਲ ਨਹੀਂ ਹੈ।ਵੱਡੀਆਂ ਬੁਝਾਰਤਾਂ. ',' ਕੀ ਤੁਸੀਂ ਸਮੇਂ ਦੀ ਗੁੰਝਲਤਾ ਬਾਰੇ ਜੋ ਕਿਹਾ ਹੈ ਉਸ ਬਾਰੇ ਕੋਡ ਵਿੱਚ ਸੁਧਾਰ ਕਰ ਸਕਦੇ ਹੋ? ',' ਸਮੇਂ ਦੇ ਸੰਬੰਧ ਵਿੱਚ ਕੋਡ ਨੂੰ ਸੁਧਾਰਨ ਦਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ।ਗੁੰਝਲਤਾ ਇੱਕ ਪੁਨਰਵਰਤੀ ਪਹੁੰਚ ਦੀ ਬਜਾਏ ਇੱਕ ਚੌਡ਼ਾਈ-ਪਹਿਲੀ ਖੋਜ (ਬੀ. ਐੱਫ. ਐੱਸ.) ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ। ਇਹ ਸੰਭਵ ਸਥਿਤੀਆਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਏਗਾ ਅਤੇਇਸ ਲਈ ਸਮੇਂ ਦੀ ਗੁੰਝਲਤਾ ਨੂੰ ਘਟਾਓ। \\n\\n ਕੋਡ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਦਾ ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਇੱਕ ਸੂਚਿਤ ਖੋਜ ਰਣਨੀਤੀ ਦੇ ਨਾਲ ਇੱਕ ਖੋਜ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ, ਜਿਵੇਂ ਕਿਇਹ ਵਿਧੀ ਇੱਕ ਹਿਊਰਿਸਟਿਕ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਜੋ ਮੌਜੂਦਾ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ ਟੀਚਾ ਅਵਸਥਾ ਤੱਕ ਦੀ ਦੂਰੀ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾਉਂਦੀ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਤਰਜੀਹ ਦੇਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।ਖੋਜ। ਇਹ ਐਲਗੋਰਿਦਮ ਨੂੰ ਪਹਿਲਾਂ ਸਭ ਤੋਂ ਵੱਧ ਆਸਵੰਦ ਮਾਰਗਾਂ ਉੱਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ, ਜਿਸ ਨਾਲ ਉਹਨਾਂ ਰਾਜਾਂ ਦੀ ਗਿਣਤੀ ਘੱਟ ਹੋ ਜਾਵੇਗੀ ਜਿਨ੍ਹਾਂ ਦੀ ਜ਼ਰੂਰਤ ਹੈਇੱਕ ਹੋਰ ਪਹੁੰਚ ਇੱਕ ਵੰਡ ਅਤੇ ਜਿੱਤ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ, ਜਿੱਥੇ ਸਮੱਸਿਆ ਨੂੰ ਛੋਟੀਆਂ ਉਪ-ਸਮੱਸਿਆਵਾਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਹੱਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਪੁਨਰਵਰਤੀ। ਇਹ ਸਥਿਤੀਆਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾ ਕੇ ਸਮੱਸਿਆ ਨੂੰ ਵਧੇਰੇ ਕੁਸ਼ਲ ਤਰੀਕੇ ਨਾਲ ਹੱਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ। \\n\\n ਇੱਕ ਹੋਰ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ aਇੱਕ ਪੁਨਰਵਰਤੀ ਪਹੁੰਚ ਅਤੇ ਇੱਕ ਬੀ. ਐੱਫ. ਐੱਸ. ਪਹੁੰਚ ਦਾ ਸੁਮੇਲ। ਇਹ ਐਲਗੋਰਿਦਮ ਨੂੰ ਸੰਖਿਆ ਨੂੰ ਬਣਾਈ ਰੱਖਦੇ ਹੋਏ ਸਾਰੀਆਂ ਸੰਭਵ ਸਥਿਤੀਆਂ ਦੀ ਪਡ਼ਚੋਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ।ਉਹਨਾਂ ਅਵਸਥਾਵਾਂ ਦੀ ਗਿਣਤੀ ਜਿਨ੍ਹਾਂ ਨੂੰ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਛੋਟਾ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n\\n ਇਹ ਵੀ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਸਿਰਫ ਸਮੇਂ ਦੀ ਗੁੰਝਲਤਾ ਹੀ ਇਕੋ ਗੱਲ ਨਹੀਂ ਹੈ।ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਵੇਲੇ ਵਿਚਾਰਨ ਲਈ ਕਾਰਕ। ਹੋਰ ਕਾਰਕ ਜਿਵੇਂ ਕਿ ਯਾਦਦਾਸ਼ਤ ਦੀ ਵਰਤੋਂ, ਪਡ਼੍ਹਨਯੋਗਤਾ ਅਤੇ ਰੱਖ-ਰਖਾਅ ਨੂੰ ਵੀ ਧਿਆਨ ਵਿੱਚ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।'ਮੈਨੂੰ ਬਿਹਤਰ ਕੋਡ ਦਿਓ'] ", 'ਇਹ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ?: ਇੰਪੋਰਟ ਸਿਸ ਕਲਾਸ ਨਾਮ _ 1: ਡਿਫ _ _ ਇਨਿਟ _ (ਸਵੈ, ਬੁਝਾਰਤ): self.visited = ਗਲਤ self.puzzle = ਬੁਝਾਰਤ self.parents = [] self.g = 1self.f = 0 ਟੀਚਾ = [0,1,2,3,4,5,6,7,8] ਹੱਦਾਂ = [] ਸਾਰੇਪੁਜ਼ਲਜ਼ = [] ਡਿਫ ਬੁਝਾਰਤਜੈਨ (ਰੂਟ): ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = root.puzzle.index (0) ਦਿਸ਼ਾਵਾਂ = [] ਜੇਕਰਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 0: ਦਿਸ਼ਾਵਾਂ = [1,3] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 1: ਦਿਸ਼ਾਵਾਂ = [0,2,4] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 2: ਦਿਸ਼ਾਵਾਂ = [1,5] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 3:ਦਿਸ਼ਾਵਾਂ = [0,4,6] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 4: ਦਿਸ਼ਾਵਾਂ = [1,3,5,7] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 5: ਦਿਸ਼ਾਵਾਂ = [2,4,8] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 6: ਦਿਸ਼ਾਵਾਂ =[3,7] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 7: ਦਿਸ਼ਾਵਾਂ = [4,6,8] ਜੇਕਰ ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ = = 8: ਦਿਸ਼ਾਵਾਂ = [5,7] ਦਿਸ਼ਾਵਾਂ ਵਿੱਚ ਨਿਰਦੇਸ਼ਾਂਕ ਲਈਃ ਨਵਾਂ ਪਜ਼ਲ =root.puzzle.copy () ਟੈਂਪ = ਨਵਾਂ ਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] ਨਵਾਂ ਪਜ਼ਲ [ਜ਼ੀਰੋਪੋਜੀਸ਼ਨ] = ਟੈਂਪ ਨਵਾਂ ਪਜ਼ਲ [ਕੋਆਰਡੀਨੇਟ] = 0 ਜੇਕਰ ਨਵਾਂ ਪਜ਼ਲ ਸਾਰੇ ਪਜ਼ਲ ਵਿੱਚ ਨਹੀਂ ਹੈਃ ਨਵਾਂ ਨੋਡ =ਨਾਮ _ 1 (ਨਵਾਂ ਪਜ਼ਲ) newNode.g = root.g + 1 newNode.parents = root.parents.copy () newNode.parents.append (root.puzzle) newNode.f = h (newNode.puzzle) +newNode.g boundaries.append (ਨਵਾਂ ਨੋਡ) allPuzzles.append (newNode.puzzle) def h (ਬੁਝਾਰਤ): ਗੁੰਮ = 0 ਮੈਨਹੱਟਨ = 0 ਬੁਝਾਰਤ ਵਿੱਚ ਨੰਬਰ ਲਈਃ ਜੇਕਰ ਨੰਬਰ! =0: ਜੇਕਰ ਨੰਬਰ! = puzzle.index (ਨੰਬਰ): ਗੁੰਮ + = 1 x1 = puzzle.index (ਨੰਬਰ)% 3 y1 = puzzle.index (ਨੰਬਰ)// 3 x2 = ਨੰਬਰ% 3 y2 = ਨੰਬਰ \n ']