प्रारंभिक सार्वजनिक पेशकश नीलामी

Question

छवि प्रतिलेखन:

एक कंपनी आईपीओ के लिए पंजीकरण करती है। सभी शेयर एक समय सीमा के दौरान बोली लगाने के लिए वेबसाइट पर उपलब्ध हैं जिन्हें बोली खिड़की कहा जाता है। बोली विंडो के अंत में एक नीलामी तर्क का उपयोग यह तय करने के लिए किया जाता है कि कितने उपलब्ध शेयर किस बोलीदाता के पास जाते हैं जब तक कि सभी शेयरों को आवंटित नहीं किया जाता है, या सभी बोलीदाताओं को वे शेयर प्राप्त होते हैं जिनकी वे बोली लगाते हैं, जो भी पहले आता है।

जब तक बोली विंडो बंद नहीं होती है तब तक बोली [उपयोगकर्ता, # शेयर, बोली मूल्य, टाइमस्टैम्प] के रूप में उपयोगकर्ताओं से आती है।

नीलामी तर्क शेयरों को निम्नानुसार प्रदान करता है:

1. सबसे अधिक मूल्य वाली बोली लगाने वाले को उन शेयरों का # हिस्सा मिलता है जिनकी वे बोली लगाते हैं

2. यदि कई बोलीकर्ताओं ने एक ही कीमत पर बोली लगाई है, तो बोली लगाने वालों को उसी क्रम में शेयर दिए जाते हैं, जिसमें वे अपनी बोली लगाते हैं (पहले बोली लगाते हैं)

सभी उपयोगकर्ताओं के उपयोगकर्ता सूचीबद्ध करें जिन्हें सभी शेयर आवंटित होने के बाद भी 1 शेयर नहीं मिला।

इनपुट

• 
  [उपयोगकर्ता नाम, # शेयर, $ बोली, टाइमस्टैम्प] का प्रतिनिधित्व करने वाली सूची की बोलियों की सूची
• totalShares
  शेयरों की कुल # वितरित करने के लिए।

ऐसा करने के लिए

बोलीदाताओं के बीच शेयर वितरित करें और 0 शेयर पाने वाले बोलीदाताओं के उपयोगकर्ता वापस लौटें।

शेयर वितरण तर्क:

1. उच्चतम प्रस्ताव वाली बोली लगाने वाले को वे सभी शेयर मिलते हैं जिनकी वे बोली लगाते हैं, और फिर
2. यदि $ बोली मूल्य में संबंध हैं, तो पहले बोली लगाने वाले को शेयर असाइन करें।

मुझे लगता है कि मैं जिस समाधान के साथ आया हूं वह अपेक्षाकृत सरल है। ऐसा लगता है कि मैं सभी किनारे के मामलों को पारित कर सकता हूं।

सवाल

मुझे एक संदिग्ध स्थिति मिली है:
बोली मूल्य और समय समान हैं और सभी बोलीदाताओं के लिए पर्याप्त शेयर नहीं हैं अर्थात: bidsहै [[0,2,10,0], [1,2,10,0]]और totalSharesहै 2। यह स्पष्ट नहीं है कि यदि 1 शेयर प्रत्येक को दिया जाना चाहिए, या यदि उपयोगकर्ता 0 दोनों को बस मिल जाए।

कोड

क्या मेरा समाधान किसी भी तरह से अनुकूलित किया जा सकता है?

def getUnallocatesUsers(bids, totalShares):
  s = 0
  for b in bids:
      s += b[1]  
  if totalShares >= s: return []  # no losers because enough shares to go around

  bids.sort(key = lambda x: (-x[2],x[3]))  # sort by highest bid, then timestamp for ties
  losers = []
  for b in bids:
    if totalShares <= 0: losers.append(b[0])
    else:
      totalShares -= b[1]
  return losers

Answer 1

समस्या में दिए गए फ़ंक्शन नाम का उपयोग करें:

def getUnallottedUsers(bids, totalShares):

समस्या सभी बोलीदाताओं के लिए पर्याप्त शेयर होने की संभावना के बारे में कोई जानकारी प्रदान नहीं करती है, इसलिए आईएमओ पहला फॉर-लूप समयपूर्व अनुकूलन का एक उदाहरण है।

"जादू संख्या" के बजाय स्थिरांक का उपयोग करें। सार्थक नामों का उपयोग करें। PEP8 को आम प्रारूपण सम्मेलनों के बारे में देखें। कोड को पठनीय बनाने में ये चीजें बहुत आगे जाती हैं।

USERID = 0
SHARES = 1
PRICE = 2
TIME = 3

bids.sort(key=lambda bid:(-bid[PRICE], bid[TIME]))

for index, bid in enumerate(bids):
    totalShares -= bid[SHARES]

    if totalShares <= 0:
        break

पूछे गए प्रश्न का उत्तर दें: "फ़ंक्शन को पूर्णांक की एक सूची वापस करनी चाहिए, प्रत्येक बोलीदाताओं के लिए एक आईडी जो कोई शेयर प्राप्त नहीं करते हैं, आरोही क्रमबद्ध हैं "

return sorted(bid[USERID] for bid in bids[index + 1:])

सभी एक साथ:

USERID = 0
SHARES = 1
PRICE = 2
TIME = 3

def getUnallottedUsers(bids, totalShares):
    bids.sort(key=lambda bid:(-bid[PRICE], bid[TIME]))

    for index, bid in enumerate(bids):
        totalShares -= bid[SHARES]

        if totalShares <= 0:
            break

    return sorted(bid[USERID] for bid in bids[index + 1:])

या एक पुनरावृत्ति का उपयोग करें:

    bids = iter(bids)
    while totalShares > 0:
        price = next(bid)[PRICE]
        totalShares -= price

    return sorted(bid[USERID] for bid in bids)