पायथन में सभी गेंदों को वर्तमान स्थिति में ले जाने के लिए कुल दूरी दिखाने वाली सूची खोजने का प्रोग्राम

मान लीजिए हमारे पास nums नामक एक बाइनरी सूची है जिसमें केवल 0 और 1 हैं जहां 0 खाली सेल दर्शाता है और 1 दर्शाता है कि सेल एक गेंद से भरा है। हमें L नामक एक नई सूची ढूंढनी है, जिसका आकार भी nums के आकार के समान है, जहां L[i] को सभी गेंदों को L[i] पर ले जाने के लिए आवश्यक कुल दूरी पर सेट किया गया है। यहां इंडेक्स j से इंडेक्स i पर गेंद को ले जाने की दूरी |j - i| है।

इसलिए, यदि इनपुट है nums = [1, 1, 0, 1], तो आउटपुट होगा [4, 3, 4, 5], क्योंकि:

• L[0] = |0 - 0| + |1 - 0| + |3 - 0|
• L[1] = |0 - 1| + |1 - 1| + |3 - 1|
• L[2] = |0 - 2| + |1 - 2| + |3 - 2|
• L[3] = |0 - 3| + |1 - 3| + |3 - 3|

इसलिए, सभी गेंदों को L[1] पर ले जाने के लिए हमें इंडेक्स 0 से 1 तक गेंद को दूरी 1 से और इंडेक्स 3 से 1 तक गेंद को दूरी 2 से ले जाना होगा।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे:

• यदि nums खाली है, तो:
  • एक नई सूची लौटाएं
• left_count := 0
• right_count := 0
• left_sum := 0
• right_sum := 0
• result := एक नई सूची
• प्रत्येक इंडेक्स और मान num के लिए nums में, करें:
  • यदि num शून्येतर है, तो:
    • right_count := right_count + 1
    • right_sum := right_sum + इंडेक्स
• प्रत्येक इंडेक्स और मान num के लिए nums में, करें:
  • (left_sum + right_sum) को result के अंत में डालें
  • यदि num शून्येतर है, तो:
    • right_count := right_count - 1
    • left_count := left_count + 1
  • left_sum := left_sum + left_count
  • right_sum := right_sum - right_count
• result लौटाएं

उदाहरण

बेहतर समझ के लिए निम्नलिखित कार्यान्वयन देखें:

def solve(nums):
    if not nums:
        return []
    left_count = right_count = 0
    left_sum = right_sum = 0
    result = []
    for index, num in enumerate(nums):
        if num:
            right_count += 1
            right_sum += index
    for index, num in enumerate(nums):
        result.append(left_sum + right_sum)
        if num:
            right_count -= 1
            left_count += 1
        left_sum += left_count
        right_sum -= right_count
    return result
nums = [1, 1, 0, 1]
print(solve(nums))

इनपुट

[1, 1, 0, 1]

आउटपुट

[4, 3, 4, 5]