मेरे पास एक शब्दकोश है d जिसकी कुंजियां n पूर्णांक हैं। कुंजियाँ आवश्यक रूप से क्रमागत संख्याएँ नहीं हैं, तथापि, यह ज्ञात है कि d में num_negative क्रमागत कुंजियाँ हैं (-num_negative,0) और num_positive श्रेणी में क्रमागत कुंजियाँ (0,num_positive) . मैं इससे एक और शब्दकोश d2 बनाना चाहता हूं, जिसकी कुंजियां [0, n] की सीमा में लगातार पूर्णांक हैं, निम्नलिखित बाधाओं को देखते हुए:

(1) जिन तत्वों की कुंजी num_positive से d में थी, उनकी d2 में भी वही कुंजी होगी।

(2) जिन तत्वों की d में समूह num_negative से ऋणात्मक कुंजी i थी, उनके पास d2 में n+i की कुंजी होगी।

एक उदाहरण:

# num_positive = 2, num_negative = 3, n=8

# num_positive group = {0,1}
# num_negative gorup = {-3,-2,-1}

d = {-6: 'h', -3: 'a', -2: 'b', -1: 'c', 0: 'd', 1: 'e', 68: 'f', 99: 'g'}
d2 = {0: 'd', 1: 'e', 2: 'g', 3: 'h', 4: 'f', 5: 'a', 6: 'b', 7: 'c'}
0
user1767774 15 अक्टूबर 2017, 12:41

2 जवाब

सबसे बढ़िया उत्तर

अगर मैं सही ढंग से समझूं, तो लगातार श्रेणी के बाहर की चाबियों वाले आइटम परिणामी शब्दकोश में अपरिभाषित प्लेसमेंट हैं। इसलिए, मेरे समाधान में, उन्हें परिणामी शब्दकोश में एक मनमाना क्रम में डाला जाता है, जो कि लगातार श्रेणी [0, len(d)) में अभी भी मुक्त हैं। अधिक विवरण के लिए टिप्पणियाँ देखें।


from collections import OrderedDict

d = {-6: 'h', -3: 'a', -2: 'b', -1: 'c', 0: 'd', 1: 'e', 68: 'f', 99: 'g'}
remainder = {}

rPos = range(0, 2 + 1) # Positive consecutive range.
rNeg = range(-3, 0) # Negative consecutive range.
n = len(d)

d2 = OrderedDict([(i, None) for i in range(0, n)])

for k, v in d.items():
    if k in rNeg: # Checks if in negative consecutive range.
        d2[n + k] = v
    elif k in rPos: # Checks if in positive negative range.
        d2[k] = v
    else: # Key is outside of either range.
        remainder[k] = v

for k, v in d2.items():
    if v is None: # Finds a key still available for use.
        # Pops an arbitrary element from the remainder and inserts its
        # value into the new dict using an available key.
        d2[k] = remainder.popitem()[1]

Input: {-6: 'h', -3: 'a', -2: 'b', -1: 'c', 0: 'd', 1: 'e', 68: 'f', 99: 'g'}
Output: OrderedDict([(0, 'd'), (1, 'e'), (2, 'g'), (3, 'f'), (4, 'h'), (5, 'a'), (6, 'b'), (7, 'c')])
2
bgfvdu3w 15 अक्टूबर 2017, 14:10

निम्नलिखित कोड इसे करना चाहिए।

d1={}

for key,val in d.items(): 
   if key in pos and key<=n :               #the elements that had a key from the group num_positive in d, will have the same key in d2
       d1[key] = val 
   elif key in neg and ((key+n) in range(n+1)) :             #the elements that had a negative key i from the group num_negative in d, will have the key n+i in d2
       d1[key+n] = val 

#ड्राइवर मान:

IN : n = 8
IN : pos = [0,1]
IN : neg = [-3,-2,-1]
IN : d = {-6: 'h', -3: 'a', -2: 'b', -1: 'c', 0: 'd', 1: 'e', 68: 'f', 99: 'g'} 

OUT : d1 = {5: 'a', 6: 'b', 7: 'c', 0: 'd', 1: 'e'}

नोट: ओपी के आउटपुट में कुछ विसंगतियां हैं। उनमें से कुछ परिभाषित की तुलना में अलग तरह से व्यवहार करते हैं।

इसलिए, दी गई बाधाओं का पालन नहीं करने वाली कुंजियों को अनदेखा कर दिया जाता है।

1
Kaushik NP 15 अक्टूबर 2017, 13:42