ਕੋਡ ਨੂੰ ਵਧੇਰੇ ਸ਼ਾਨਦਾਰ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗ ਬਣਾਉਣ ਲਈ ਸੋਧੋ, ਇਸ ਵਿੱਚ ਹੋਰ ਟਿੱਪਣੀਆਂ ਸ਼ਾਮਲ ਕਰੋ, ਤੁਸੀਂ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਮ ਬਦਲ ਸਕਦੇ ਹੋਃ #ਲੁਕਹੈੱਡ ਨੂੰ ਮਿਲਾਓ \\n ਨਤੀਜਾ = ਸੈੱਟ () \\n ਲਈ iI ਵਿੱਚਃ #i ਇੱਕ ਆਈਟਮ ਹੈ I ਵਿੱਚ j ਲਈ \\n ਜੁਡ਼ਵਾਂ = [] \\n: \\n ਜੇਕਰ i.production.left = = j.production.left ਅਤੇ i.production.right = = j.production.right ਅਤੇi.dot_index = = j.dot_index ਅਤੇ i.lookahead! = j.lookahead: \\n twins.append (j) \\n ਜੇਕਰ ਜੁਡ਼ਵਾਂ! = []: \\n ਸੁਮੇਲ = i.lookahead \\n ਜੁਡ਼ਵਾਂ ਵਿੱਚ ਜੁਡ਼ਵਾਂ ਲਈਃ \\nਜੋਡ਼ = ਸੰਯੋਜਨ। twin.lookahead \\n ਫਲੈਗ _ ਇਨ = ਨਤੀਜੇ ਵਿੱਚ r ਲਈ ਗਲਤਃ \\n ਜੇਕਰ r.production.left = = i.production.left ਅਤੇ r.production.right = = =i.production.right ਅਤੇ r.dot_index = = i.dot_index ਅਤੇ r.lookahead = = ਸੁਮੇਲਃ \\n ਫਲੈਗ _ ਇਨ = ਸੱਚਾ \\n ਬਰੇਕ \\n ਜੇਕਰ ਫਲੈਗ _ ਇਨ ਨਹੀਂ ਤਾਂਃ \\nresult.add (ਆਈਟਮ (ਉਤਪਾਦਨ = i.production, ਡਾਟ _ ਇੰਡੈਕਸ = i.dot_index, ਲੁਕਹੈੱਡ = ਸੁਮੇਲ)) \\n ਹੋਰਃ \\n result.add (i) '] ", 'ਕੋਡ ਨੂੰ ਵਧੇਰੇ ਸ਼ਾਨਦਾਰ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗ ਬਣਾਉਣ ਲਈ ਸੋਧੋ, ਇਸ ਵਿੱਚ ਹੋਰ ਟਿੱਪਣੀਆਂ ਸ਼ਾਮਲ ਕਰੋ, ਤੁਸੀਂ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਮ ਬਦਲ ਸਕਦੇ ਹੋਃ #ਆਈ ਵਿੱਚ ਆਈ ਲਈ ਲੁਕਹੈੱਡ ਨਤੀਜਾ = ਸੈੱਟ () ਨੂੰ ਜੋਡ਼ ਸਕਦੇ ਹੋਃI ਵਿੱਚ j ਲਈ #i ਇੱਕ ਆਈਟਮ ਜੁਡ਼ਵਾਂ = [] ਹੈਃ ਜੇਕਰ i.production.left = = j.production.left ਅਤੇ i.production.right = = j.production.right ਅਤੇ i.dot_index = = =j.dot_index ਅਤੇ i.lookahead! = j.lookahead: twins.append (j) ਜੇ ਜੁਡ਼ਵਾਂ! = []: ਜੋਡ਼ = i.lookahead ਜੁਡ਼ਵਾਂ ਵਿੱਚ ਜੁਡ਼ਵਾਂ ਲਈਃ ਸੰਯੋਜਨ = ਸੰਯੋਜਨ।twin.lookahead ਫਲੈਗ _ ਇਨ = ਨਤੀਜੇ ਵਿੱਚ r ਲਈ ਗਲਤਃ ਜੇਕਰ r.production.left = = i.production.left ਅਤੇ r.production.right = = i.production.right ਅਤੇ r.dot_index= = i.dot_index ਅਤੇ r.lookahead = = ਸੁਮੇਲਃ ਫਲੈਗ _ ਇਨ = ਸੱਚਾ ਬਰੇਕ ਜੇਕਰ ਫਲੈਗ _ ਇਨ ਨਹੀਂ ਹੈਃ result.add (ਆਈਟਮ (ਉਤਪਾਦਨ = i.production, ਡਾਟ _ ਇੰਡੈਕਸ = i.dot_index,ਲੁਕਹੈੱਡ = ਸੰਯੋਜਨ)) ਹੋਰਃ result.add (i)', ' [\'ਕੋਡ ਨੂੰ ਵਧੇਰੇ ਸ਼ਾਨਦਾਰ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗ ਬਣਾਉਣ ਲਈ ਸੋਧੋ, ਇਸ ਵਿੱਚ ਹੋਰ ਟਿੱਪਣੀਆਂ ਸ਼ਾਮਲ ਕਰੋ, ਤੁਸੀਂ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਮ ਬਦਲ ਸਕਦੇ ਹੋਃ #ਲੁਕਹੈੱਡ ਨੂੰ ਮਿਲਾਓ \\n ਨਤੀਜਾ = ਸੈੱਟ () \\n ਲਈ iI ਵਿੱਚਃ #i ਇੱਕ ਆਈਟਮ ਹੈ I ਵਿੱਚ j ਲਈ \\n ਜੁਡ਼ਵਾਂ = [] \\n: \\n ਜੇਕਰ i.production.left = = j.production.left ਅਤੇ i.production.right = = j.production.right ਅਤੇi.dot_index = = j.dot_index ਅਤੇ i.lookahead! = j.lookahead: \\n twins.append (j) \\n ਜੇਕਰ ਜੁਡ਼ਵਾਂ! = []: \\n ਸੁਮੇਲ = i.lookahead \\n ਜੁਡ਼ਵਾਂ ਵਿੱਚ ਜੁਡ਼ਵਾਂ ਲਈਃ \\nਜੋਡ਼ = ਸੰਯੋਜਨ। twin.lookahead \\n ਫਲੈਗ _ ਇਨ = ਨਤੀਜੇ ਵਿੱਚ r ਲਈ ਗਲਤਃ \\n ਜੇਕਰ r.production.left = = i.production.left ਅਤੇ r.production.right = = =i.production.right ਅਤੇ r.dot_index = = i.dot_index ਅਤੇ r.lookahead = = ਸੁਮੇਲਃ \\n ਫਲੈਗ _ ਇਨ = ਸੱਚਾ \\n ਬਰੇਕ \\n ਜੇਕਰ ਫਲੈਗ _ ਇਨ ਨਹੀਂ ਤਾਂਃ \\nresult.add (ਆਈਟਮ (ਉਤਪਾਦਨ = i.production, ਡਾਟ _ ਇੰਡੈਕਸ = i.dot_index, ਲੁਕਹੈੱਡ = ਸੰਯੋਜਨ)) \\n ਹੋਰਃ \\n result.add (i) \', "ਯਕੀਨਨ! ਇੱਥੇ ਇੱਕ ਹੋਰ ਪਡ਼੍ਹਨਯੋਗ ਹੈ।ਅਤੇ ਜੋਡ਼ੀਆਂ ਟਿੱਪਣੀਆਂ ਦੇ ਨਾਲ ਕੋਡ ਦਾ ਸ਼ਾਨਦਾਰ ਸੰਸਕਰਣਃ \\n "\'ਪਾਈਥਨ \\n #ਆਈਟਮਾਂ ਦੇ ਸ਼ੁਰੂਆਤੀ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\nI = [\\n ਆਈਟਮ (ਉਤਪਾਦਨ = [1,2], ਡਾਟ _ ਇੰਡੈਕਸ = 0,ਲੁਕਹੈੱਡ = 0), \\n ਆਈਟਮ (ਉਤਪਾਦਨ = [3,4], ਡਾਟ _ ਇੰਡੈਕਸ = 1, ਲੁਕਹੈੱਡ = 0), \\n ਆਈਟਮ (ਉਤਪਾਦਨ = [5,6], ਡਾਟ _ ਇੰਡੈਕਸ = 2, ਲੁਕਹੈੱਡ = 0), \\n ਆਈਟਮ (ਉਤਪਾਦਨ = [7,8],ਡਾਟ _ ਇੰਡੈਕਸ = 3, ਲੁਕਹੈੱਡ = 0) \\n] \\n\\n #ਲੁਕਹੈੱਡ ਮੁੱਲਾਂ ਦੇ ਸੰਜੋਗਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਸੈੱਟ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n ਦਾ ਨਤੀਜਾ = ਸੈੱਟ () \\n\\n #ਵਿੱਚ ਹਰੇਕ ਆਈਟਮ ਰਾਹੀਂ ਦੁਹਰਾਓI ਵਿੱਚ i ਲਈ ਸ਼ੁਰੂਆਤੀ ਸੈੱਟਃ \\n #I ਵਿੱਚ j ਲਈ ਜੁਡ਼ਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਬਣਾਓਃ \\n #ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਉਤਪਾਦਨ ਅਤੇ ਡਾਟ _ ਇੰਡੈਕਸ ਮੁੱਲ ਦੋਵਾਂ ਲਈ ਇੱਕੋ ਜਿਹੇ ਹਨ।ਆਈਟਮਾਂ \\n ਜੇਕਰ i.production.left = = j.production.left ਅਤੇ i.production.right = = j.production.right ਅਤੇ i.dot_index = = j.dot_index: \\n #ਜਾਂਚ ਕਰੋ ਕਿ ਕੀਲੁਕਹੈੱਡ ਮੁੱਲ ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ ਜੇਕਰ i.lookahead! = j.lookahead: \\n twins.append (j) \\n #ਜੇ ਕੋਈ ਜੁਡ਼ਵਾਂ ਹਨ, ਤਾਂ ਉਹਨਾਂ ਦੇ ਲੁਕਹੈੱਡ ਮੁੱਲਾਂ ਨੂੰ ਜੋਡ਼ਦੇ ਹਨ ਜੇਕਰਜੁਡ਼ਵਾਂ! = []: \\n ਜੁਡ਼ਵਾਂ ਵਿੱਚ ਜੁਡ਼ਵਾਂ ਲਈਃ \\n #ਜਾਂ ਜੁਡ਼ਵਾਂ ਦੇ ਲੁੱਕਹੈੱਡ ਮੁੱਲ \\n ਸੰਯੋਜਨ = i.lookahead। twin.lookahead \\n #ਚੈੱਕ ਕਰੋ ਕਿ ਕੀ ਸੰਯੋਜਨ ਹੈਨਤੀਜਾ ਸੈੱਟ \\n ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਜੋਡ਼ਿਆ ਜਾ ਚੁੱਕਾ ਹੈ ਜੇਕਰ ਨਤੀਜੇ ਵਿੱਚ ਜੋਡ਼ਃ \\n #ਜੇਕਰ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਸਾਨੂੰ ਇਸ ਨੂੰ ਦੁਬਾਰਾ ਜੋਡ਼ਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ \\n ਬਰੇਕ \\n ਹੋਰਃ \\n #ਜੇਕਰ ਅਜਿਹਾ ਨਹੀਂ ਹੋਇਆ ਹੈ,ਇਸ ਨੂੰ ਸ਼ਾਮਲ ਕਰੋ \\n result.add (ਸੁਮੇਲ) \\n ਹੋਰਃ \\n #ਜੇ ਕੋਈ ਜੁਡ਼ਵਾਂ ਨਹੀਂ ਹਨ, ਤਾਂ ਆਈਟਮ ਨੂੰ ਨਤੀਜਾ ਸੈੱਟ \\n result.add (i) \\n \'\\n ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ ਕੋਡ ਦਾ ਇਹ ਸੰਸਕਰਣ ਹੈਕੋਡ ਦੇ ਹਰੇਕ ਭਾਗ ਦੀ ਵਿਆਖਿਆ ਕਰਨ ਲਈ ਟਿੱਪਣੀਆਂ ਜੋਡ਼ ਕੇ ਅਤੇ ਕੋਡ ਨੂੰ ਵਧੇਰੇ ਬਣਾਉਣ ਲਈ ਵਰਣਨਯੋਗ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਧੇਰੇ ਪਡ਼੍ਹਨਯੋਗਸਵੈ-ਵਿਆਖਿਆਤਮਕ. \',\' ਕੋਡ ਨੂੰ ਵਧੇਰੇ ਸ਼ਾਨਦਾਰ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗ ਬਣਾਉਣ ਲਈ ਸੋਧ ਕਰੋ, ਇਸ ਵਿੱਚ ਹੋਰ ਟਿੱਪਣੀਆਂ ਸ਼ਾਮਲ ਕਰੋ, ਤੁਸੀਂ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਮ ਬਦਲ ਸਕਦੇ ਹੋਃ ਡਿਫ ਗੋਟੋ (I, X): #ਵਾਪਸੀਆਈਟਮਾਂ ਦਾ ਇੱਕ ਸਮੂਹ I ਵਿੱਚ i ਲਈ \\n J = ਸੈੱਟ () \\n: #i ਇੱਕ ਆਈਟਮ ਹੈ \\n ਕੋਸ਼ਿਸ਼ ਕਰੋਃ \\n ਜੇਕਰ i.production. ਠੀਕ ਹੈ [i.dot_index] = = X: \\n J.add (ਆਈਟਮ (ਉਤਪਾਦਨ = i.production,ਡਾਟ _ ਇੰਡੈਕਸ = i.dot_index + 1, ਲੁਕਹੈੱਡ = i.lookahead)) \\n ਨੂੰ ਛੱਡ ਕੇਃ \\n ਜਾਰੀ ਰੱਖੋ \\n ਰਿਟਰਨ ਕਲੋਜ਼ਰ (J) \'] ', 'ਕੋਡ ਨੂੰ ਵਧੇਰੇ ਸ਼ਾਨਦਾਰ ਅਤੇ ਪਡ਼੍ਹਨਯੋਗ ਬਣਾਉਣ ਲਈ ਸੋਧੋ, ਇਸ ਵਿੱਚ ਹੋਰ ਟਿੱਪਣੀਆਂ ਸ਼ਾਮਲ ਕਰੋ, ਤੁਸੀਂ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਮ ਬਦਲ ਸਕਦੇ ਹੋਃ #ਆਈ ਵਿੱਚ ਆਈ ਲਈ ਲੁਕਹੈੱਡ ਨਤੀਜਾ = ਸੈੱਟ () ਨੂੰ ਜੋਡ਼ ਸਕਦੇ ਹੋਃI ਵਿੱਚ j ਲਈ #i ਇੱਕ ਆਈਟਮ ਜੁਡ਼ਵਾਂ = [] ਹੈਃ ਜੇਕਰ i.production.left = = j.production.left ਅਤੇ i.production.right = = j.production.right ਅਤੇ i.dot_index = = =j.dot_index ਅਤੇ i.lookahead! = j.lookahead: twins.append (j) ਜੇ ਜੁਡ਼ਵਾਂ! = []: ਜੋਡ਼ = i.lookahead ਜੁਡ਼ਵਾਂ ਵਿੱਚ ਜੁਡ਼ਵਾਂ ਲਈਃ ਸੰਯੋਜਨ = ਸੰਯੋਜਨ।twin.lookahead ਫਲੈਗ _ ਇਨ = ਨਤੀਜੇ ਵਿੱਚ r ਲਈ ਗਲਤਃ ਜੇਕਰ r.production.left = = i.production.left ਅਤੇ r.production.right = = i.production.right ਅਤੇ r.dot_index= = i.dot_index ਅਤੇ r.lookahead = = ਸੁਮੇਲਃ ਫਲੈਗ _ ਇਨ = ਸੱਚਾ ਬਰੇਕ ਜੇਕਰ ਫਲੈਗ _ ਇਨ ਨਹੀਂ ਹੈਃ result.add (ਆਈਟਮ (ਉਤਪਾਦਨ = i.production, ਡਾਟ _ ਇੰਡੈਕਸ = i.dot_index,ਲੁਕਹੈੱਡ = ਸੰਯੋਜਨ)) ਹੋਰਃ result.add (i) \n ']