Python: ट्रिम किए गए मानों का पुनर्वितरण (Redistribute Trimmed Values)

Python में सूची के दोनों छोर से K तत्वों को ट्रिम (हटाकर) करके, हटाए गए मानों के योग को शेष तत्वों में समान रूप से पुनर्वितरित करना।

एल्गोरिदम

1. पूरी सूची का योग निकालें
2. दोनों छोर से K-K तत्व हटाकर ट्रिम की गई सूची बनाएं
3. ट्रिम की गई सूची का योग निकालें
4. हटाए गए मानों का योग = कुल योग - ट्रिम किया गया योग
5. प्रत्येक शेष तत्व में जोड़ने वाला मान = हटाए गए योग / शेष तत्वों की संख्या
6. प्रत्येक शेष तत्व में यह मान जोड़ें

उदाहरण

my_list = [11, 26, 24, 75, 96, 37, 48, 29, 93]
print("मूल सूची:", my_list)

K = 2
print(f"K = {K} (दोनों छोर से 2-2 तत्व हटाएंगे)")

# चरण 1: कुल योग
full_sum = sum(my_list)
print(f"कुल योग: {full_sum}")  # 439

# चरण 2: ट्रिम की गई सूची (K से शुरू, अंत से K पहले तक)
trimmed_list = my_list[K:len(my_list) - K]
print(f"ट्रिम की गई सूची: {trimmed_list}")  # [24, 75, 96, 37, 48]

# चरण 3: ट्रिम की गई सूची का योग
trim_sum = sum(trimmed_list)
print(f"ट्रिम की गई सूची का योग: {trim_sum}")  # 280

# चरण 4: हटाए गए मानों का योग
removed_sum = full_sum - trim_sum
print(f"हटाए गए मानों का योग: {removed_sum}")  # 159

# चरण 5: प्रति तत्व जोड़ने वाला मान
add_value = removed_sum / len(trimmed_list)
print(f"प्रति तत्व जोड़ें: {add_value}")  # 31.8

# चरण 6: पुनर्वितरण
result = [ele + add_value for ele in trimmed_list]
print("पुनर्वितरण के बाद:", result)

आउटपुट

मूल सूची: [11, 26, 24, 75, 96, 37, 48, 29, 93]
K = 2 (दोनों छोर से 2-2 तत्व हटाएंगे)
कुल योग: 439
ट्रिम की गई सूची: [24, 75, 96, 37, 48]
ट्रिम की गई सूची का योग: 280
हटाए गए मानों का योग: 159
प्रति तत्व जोड़ें: 31.8
पुनर्वितरण के बाद: [55.8, 106.8, 127.8, 68.8, 79.8]

फंक्शन के रूप में

def redistribute_trimmed(values, k):
    """दोनों छोर से k तत्व हटाकर उनके योग को शेष में पुनर्वितरित करें"""
    if len(values) <= 2 * k:
        raise ValueError("सूची बहुत छोटी है, 2k से अधिक तत्व चाहिए")
    
    full_sum = sum(values)
    trimmed = values[k:len(values) - k]
    trim_sum = sum(trimmed)
    add_value = (full_sum - trim_sum) / len(trimmed)
    
    return [x + add_value for x in trimmed]

# उपयोग
data = [11, 26, 24, 75, 96, 37, 48, 29, 93]
print(redistribute_trimmed(data, 2))  # [55.8, 106.8, 127.8, 68.8, 79.8]
print(redistribute_trimmed(data, 1))  # [55.75, 97.75, 118.75, 59.75, 70.75, 71.75]

किनारे के मामले

def safe_redistribute(values, k):
    """सुरक्षित संस्करण जिसमें एरर हैंडलिंग है"""
    n = len(values)
    if n <= 2 * k:
        return f"एरर: सूची में {n} तत्व हैं, लेकिन 2*{k}={2*k} तत्व हटाने हैं"
    if k < 0:
        return "एरर: K ऋणात्मक नहीं हो सकता"
    
    trimmed = values[k:n-k]
    if not trimmed:
        return "एरर: ट्रिम के बाद कोई तत्व नहीं बचा"
    
    add_val = (sum(values) - sum(trimmed)) / len(trimmed)
    return [x + add_val for x in trimmed]

# टेस्ट
print(safe_redistribute([1,2,3], 2))      # एरर: बहुत छोटी
print(safe_redistribute([1,2,3,4,5], 1))  # [3.5, 4.5, 5.5]
print(safe_redistribute([10,20,30], 0))   # [10, 20, 30] (कोई ट्रिम नहीं)

व्यावहारिक अनुप्रयोग

यह तकनीक सांख्यिकी में विंसोराइजेशन (Winsorizing) या ट्रिम्ड मीन (trimmed mean) की गणना में उपयोगी होती है, जहां बाहरी मानों (outliers) के प्रभाव को कम किया जाता है।

संबंधित सांख्यिकीय अवधारणाएं

import numpy as np
from scipy import stats

data = [11, 26, 24, 75, 96, 37, 48, 29, 93]

# ट्रिम्ड मीन (20% दोनों छोर से)
trimmed_mean = stats.trim_mean(data, 0.2)
print(f"ट्रिम्ड मीन (20%): {trimmed_mean}")

# विंसोराइज्ड मीन (मानों को सीमित करना, हटाना नहीं)
winsorized = stats.mstats.winsorize(data, limits=[0.2, 0.2])
print(f"विंसोराइज्ड मीन: {np.mean(winsorized)}")

# सामान्य मीन
print(f"सामान्य मीन: {np.mean(data)}")