शीर्ष 10 खोज शब्द खोजने के लिए एल्गोरिथम

Question

मैं वर्तमान में एक साक्षात्कार की तैयारी कर रहा हूं, और इसने मुझे एक प्रश्न याद दिलाया, जो मुझे पिछले साक्षात्कार में एक बार पूछा गया था, जो कुछ इस तरह था:

"आपको Google पर शीर्ष 10 खोज शब्दों को लगातार प्रदर्शित करने के लिए कुछ सॉफ़्टवेयर डिज़ाइन करने के लिए कहा गया है। आपको एक ऐसे फ़ीड तक पहुंच प्रदान की जाती है जो वर्तमान में Google पर खोजे जा रहे खोज शब्दों की एक अंतहीन वास्तविक समय स्ट्रीम प्रदान करता है। बताएं कि एल्गोरिथ्म और डेटा संरचनाएं क्या हैं। आप इसे लागू करने के लिए उपयोग करेंगे। आप दो भिन्नताओं को डिजाइन करेंगे:

(i) सभी समय के शीर्ष 10 खोज शब्दों को प्रदर्शित करें (जब से आपने फ़ीड पढ़ना शुरू किया है)।

(ii) पिछले महीने के लिए केवल शीर्ष १० खोज शब्द प्रदर्शित करें, जो प्रति घंटा अपडेट किया गया है।

आप शीर्ष 10 सूची प्राप्त करने के लिए एक सन्निकटन का उपयोग कर सकते हैं, लेकिन आपको अपनी पसंद को सही ठहराना होगा। "
मैंने इस साक्षात्कार में बमबारी की और अभी भी वास्तव में पता नहीं है कि इसे कैसे लागू किया जाए।

पहला भाग अनंत सूची के लगातार बढ़ते उप-क्रम में 10 सबसे लगातार वस्तुओं के लिए पूछता है। मैंने चयन एल्गोरिदम में देखा, लेकिन इस समस्या को हल करने के लिए कोई भी ऑनलाइन संस्करण नहीं खोज सका।

दूसरा भाग एक परिमित सूची का उपयोग करता है, लेकिन बड़ी मात्रा में डेटा संसाधित होने के कारण, आप वास्तव में खोज के पूरे महीने को मेमोरी में स्टोर नहीं कर सकते हैं और हर घंटे हिस्टोग्राम की गणना कर सकते हैं।

इस समस्या को इस तथ्य से और अधिक कठिन बना दिया जाता है कि शीर्ष 10 सूची को लगातार अपडेट किया जा रहा है, इसलिए किसी तरह आपको स्लाइडिंग विंडो पर अपने शीर्ष 10 की गणना करने की आवश्यकता है।

कोई विचार?

Comments

@ बेल्यूराजा - यह बेवकूफी भरा साक्षात्कार नहीं है, यह ओपी की ओर से एक बुरी व्याख्या है। यह एक अनंत सूची में सबसे लगातार वस्तुओं के लिए नहीं पूछ रहा है, यह एक अनंत सूची के एक परिमित बाद के सबसे लगातार मदों के लिए पूछ रहा है। अपना सादृश्य जारी रखने के लिए,what is the most frequent item in the subsequence [2; 2; 3; 3; 3; 4; 4; 4; 4; 5; 5] of your sequence?

— IVlad

@BlueRaja - यह निश्चित रूप से एक कठिन सवाल है, लेकिन मैं यह नहीं देखता कि यह बेवकूफ क्यों है - यह एक बहुत ही विशिष्ट समस्या का प्रतिनिधि लगता है कि विशाल डेटा सेट वाली कंपनियों का सामना किया जाता है। @IVlad - मेरे सुझाव के अनुसार, मेरी ओर से यह शब्द खराब है!

— डेल

Answer 1

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

इस क्षेत्र में उपयोगी पुस्तक: मुथुकृष्णन - "डेटा स्ट्रीम: एल्गोरिदम और अनुप्रयोग"

हाथ में समस्या का निकटतम संदर्भ जो मैंने ऊपर से उठाया था: मंकू, मोटवानी - "डेटा धाराओं पर अनुमानित आवृत्ति मायने रखता है" [pdf]

वैसे, स्टैनफोर्ड का मोटवानी, (संपादित करें) बहुत महत्वपूर्ण "रैंडमाइज्ड अल्गोरिथम" पुस्तक का लेखक था । इस पुस्तक का 11 वां अध्याय इस समस्या से संबंधित है । संपादित करें: क्षमा करें, बुरा संदर्भ, वह विशेष अध्याय एक अलग समस्या पर है। जाँच करने के बाद, मैं इसके बजाय ऑनलाइन उपलब्ध मुथुकृष्णन की पुस्तक के खंड 5.1.2 की सिफारिश करता हूं ।

हे, अच्छा साक्षात्कार सवाल।

Comments

+1 बहुत दिलचस्प चीजें, सामान को पढ़ने के लिए "टैग" करने के लिए साइटों पर एक रास्ता होना चाहिए। साझा करने के लिए धन्यवाद।

— रामाधीर सिंह

@ कोल्लम: मेरे बुकमार्क में एक पठन फ़ोल्डर है; तुम बस इतना कर सकते थे। मुझे पता है कि उन लिंक को खान में जोड़ा जा रहा है :)

— कैम

+1। स्ट्रीमिंग एल्गोरिदम वास्तव में यहाँ विषय है, और मुथु की पुस्तक (अब तक लिखी गई एकमात्र पुस्तक, AFAIK) महान है।

— श्रीवत्सआर

+1। संबंधित: en.wikipedia.org/wiki/Online_algorithm । Btw, मोटवानी हाल ही में निधन हो गया है, तो शायद था एक लेखक अधिक सटीक है।

बहुत अजीब। मैं उन्हें पुस्तक से जानता था, लेकिन वह निश्चित रूप से इस वजह से अधिक प्रसिद्ध रहे होंगे: "मोटवानी पेजर अल्गोरिद्म पर एक प्रभावशाली प्रारंभिक पत्र के सह-लेखक (लैरी पेज और सर्गेई ब्रिन और टेरी विनोग्रैड के साथ) थे। Google की खोज तकनीकों के लिए आधार। "( en.wikipedia.org/wiki/Rajeev_Motwani )

— दिमित्रिस आंद्रेउ

Answer 2

आवृत्ति अनुमान अवलोकन

कुछ प्रसिद्ध एल्गोरिदम हैं जो निश्चित मात्रा में भंडारण का उपयोग करके ऐसी धारा के लिए आवृत्ति अनुमान प्रदान कर सकते हैं। मिसरा और ग्रिज (1982) द्वारा एक बार-बार किया गया है। N आइटमों की सूची से , यह सभी आइटमों को खोजता है जो n - k समय से अधिक होता है , k - 1 काउंटरों का उपयोग करके । यह बोयर और मूर की का सामान्यीकरण है अधिकांश एल्गोरिथ्म (फिशर-Salzberg, 1982), जहां कश्मीर है 2. Manku और मोटवानी के LossyCounting (2002) और Metwally के SpaceSaving (2005) एल्गोरिदम समान अंतरिक्ष आवश्यकताओं है, लेकिन कुछ के तहत और अधिक सटीक अनुमान प्रदान कर सकते हैं शर्तेँ।

याद रखने वाली महत्वपूर्ण बात यह है कि ये एल्गोरिदम केवल आवृत्ति अनुमान प्रदान कर सकते हैं। विशेष रूप से, मिश्रा-ग्रिज अनुमान (n / k) आइटम द्वारा वास्तविक आवृत्ति की गणना कर सकता है ।

मान लीजिए कि आप एक एल्गोरिथ्म जो निश्चित ही एक आइटम की पहचान कर सकता था केवल अगर यह समय की 50% से अधिक होता है। इस एल्गोरिथ्म को एन अलग-अलग वस्तुओं की एक धारा को खिलाएं , और फिर कुल 2N - 1 आइटम के लिए एक आइटम, x की एक और एन - 1 प्रतियां जोड़ें । यदि एल्गोरिथ्म आपको बताता है कि x कुल का 50% से अधिक है, तो यह पहली धारा में रहा होगा; यदि ऐसा नहीं होता है, तो x प्रारंभिक स्ट्रीम में नहीं था। इस निर्धारण को करने के लिए एल्गोरिथ्म के लिए, इसे प्रारंभिक स्ट्रीम (या इसकी लंबाई के अनुपात में कुछ सारांश) को स्टोर करना होगा! तो, हम अपने आप को साबित कर सकते हैं कि इस तरह के "सटीक" एल्गोरिथ्म के लिए आवश्यक स्थान N ( एन ) होगा।

इसके बजाय, यहाँ वर्णित ये आवृत्ति एल्गोरिदम एक अनुमान प्रदान करते हैं, जो किसी भी वस्तु की पहचान करते हैं जो सीमा से अधिक है, साथ ही कुछ वस्तुओं के साथ जो एक निश्चित मार्जिन से नीचे आती हैं। उदाहरण के लिए मेजॉरिटी एल्गोरिथ्म, एक काउंटर का उपयोग करके, हमेशा एक परिणाम देगा; यदि कोई वस्तु धारा के 50% से अधिक है, तो वह मिल जाएगी। लेकिन यह आपको एक आइटम भी दे सकता है जो केवल एक बार होता है। आप डेटा पर दूसरा पास बनाए बिना (एक बार फिर से, एक ही काउंटर का उपयोग करके, लेकिन केवल उस आइटम की तलाश में) बिना नहीं जान पाएंगे।

लगातार एल्गोरिथम

यहाँ मिश्रा-Gries 'का एक सरल विवरण दिया गया है लगातार एल्गोरिथ्म। डेमनीन (2002) और अन्य ने एल्गोरिथम को अनुकूलित किया है, लेकिन यह आपको जिस्ट देता है।

दहलीज अंश निर्दिष्ट करें, 1 / k ; कोई भी आइटम जो n / k समय से अधिक होता है, वह मिल जाएगा। एक खाली मानचित्र बनाएं (लाल-काले पेड़ की तरह); कुंजियाँ खोज शब्द होंगी, और मान उस शब्द के लिए एक काउंटर होंगे।

1. प्रत्येक आइटम को स्ट्रीम में देखें।
2. यदि शब्द मानचित्र में मौजूद है, तो संबंधित काउंटर को बढ़ाएँ।
3. अन्यथा, यदि मानचित्र k - 1 प्रविष्टियों से कम है , तो शब्द को एक के एक काउंटर के साथ मानचित्र में जोड़ें।
4. हालाँकि, यदि मानचित्र में k - 1 प्रविष्टियाँ पहले से हैं, तो हर प्रविष्टि में काउंटर को घटाएँ। यदि इस प्रक्रिया के दौरान कोई भी काउंटर शून्य पर पहुंचता है, तो उसे मानचित्र से हटा दें।

ध्यान दें कि आप एक निश्चित मात्रा में भंडारण (बस निश्चित आकार के नक्शे) के साथ डेटा की एक अनंत राशि संसाधित कर सकते हैं। आवश्यक भंडारण की मात्रा केवल ब्याज की सीमा पर निर्भर करती है, और धारा का आकार कोई फर्क नहीं पड़ता।

खोज की गिनती

इस संदर्भ में, शायद आप एक घंटे की खोजों को बफर करते हैं, और उस घंटे के डेटा पर इस प्रक्रिया को करते हैं। यदि आप इस घंटे के खोज लॉग पर दूसरा पास ले सकते हैं, तो आप पहले पास में पहचाने गए शीर्ष "उम्मीदवारों" की घटनाओं की सटीक गणना प्राप्त कर सकते हैं। या, शायद सिंगल पास बनाने के लिए ठीक है, और सभी उम्मीदवारों को रिपोर्ट करें, यह जानते हुए कि कोई भी वस्तु जो होनी चाहिए, शामिल है, और किसी भी अतिरिक्त बस शोर है जो अगले घंटे में गायब हो जाएगा।

कोई भी अभ्यर्थी जो वास्तव में ब्याज की सीमा से अधिक है, एक सारांश के रूप में संग्रहीत किया जाता है। इन सारांशों का एक महीने का मूल्य रखें, प्रत्येक घंटे सबसे पुराना फेंक दें, और आपके पास सबसे आम खोज शब्दों का एक अच्छा अनुमान होगा।

Comments

मेरा मानना ​​है कि यह समाधान एक फ़िल्टर के रूप में कार्य कर सकता है, जिससे आपके लिए खोज की शर्तों की संख्या कम हो जाती है। यदि कोई शब्द इसे मानचित्र में बनाता है, तो इसे वास्तविक आँकड़ों पर नज़र रखना शुरू करें, भले ही यह मानचित्र से बाहर हो। फिर आप डेटा पर दूसरा पास छोड़ सकते हैं, और आपके द्वारा एकत्र किए गए सीमित आंकड़ों से एक सॉर्ट किए गए शीर्ष 10 का उत्पादन कर सकते हैं।

— डॉल्फ

मुझे काउंटरों को कम करके पेड़ से कम-खोज की गई शर्तों को समझने का सुंदर तरीका पसंद है। लेकिन एक बार नक्शा "पूर्ण" होने के बाद, आने वाले हर नए खोज शब्द के लिए एक क्षरण कदम की आवश्यकता नहीं होगी? और एक बार ऐसा होने के बाद, नए खोज शब्दों में यह परिणाम जल्दी से नक्शे से नहीं हटाया जाएगा, क्योंकि उनके पास अपने काउंटरों के लिए पर्याप्त रूप से वेतन वृद्धि का मौका है?

— डेल

@del - ध्यान रखें कि यह एल्गोरिथ्म उन शब्दों का पता लगाने के लिए है जो एक निर्दिष्ट सीमा आवृत्ति से अधिक है, सबसे सामान्य शब्द खोजने के लिए जरूरी नहीं है। यदि सबसे सामान्य शब्द निर्दिष्ट सीमा से नीचे आते हैं, तो वे आम तौर पर नहीं मिलेंगे। नए शब्दों को "बहुत जल्दी" हटाने के बारे में आपकी चिंता इस मामले से जुड़ी हो सकती है। इसे देखने का एक तरीका लोकप्रियता में वास्तविक "सिग्नल" हैं, वे "शोर" से दूर से खड़े होंगे। लेकिन कभी-कभी, कोई संकेत नहीं मिलते हैं, बस यादृच्छिक खोज स्थिर।

— एरिक्सन

@erickson - सही - मुझे जो मिल रहा है वह यह है कि इस एल्गोरिथ्म के साथ धारणा यह है कि शीर्ष 10 शब्द माप विंडो में समान रूप से वितरित किए गए हैं। लेकिन जब तक आप माप की खिड़की को छोटा रखते हैं (जैसे 1 घंटा), यह शायद एक मान्य धारणा होगी।

— डेल

@ हिर्सन, जबकि एक समान वितरण की आवश्यकता नहीं है, मुझे आश्चर्य है कि यह अधिक यथार्थवादी वितरण (पावर-लॉ, जिप्सी) में कैसे काम करेगा। मान लेते हैं कि हमारे पास N के अलग-अलग शब्द हैं, और क्षमता K के लाल-काले पेड़ को रखें, उम्मीद है कि यह K सबसे लगातार शब्दों के साथ समाप्त होगा। यदि (N - K) शब्दों की संचयी आवृत्ति, K के लगातार शब्दों की संचयी आवृत्ति से अधिक है, तो अंत में पेड़ में कचरा समाहित करने की गारंटी है। क्या आप सहमत हैं?

— दिमित्री आंद्रेउ

Answer 3

यह एक शोध परियोजना है, जिससे मैं वर्तमान में गुजर रहा हूं। आवश्यकता लगभग आपकी है, और हमने समस्या को हल करने के लिए अच्छे एल्गोरिदम विकसित किए हैं।

इनपुट

इनपुट अंग्रेजी शब्दों या वाक्यांशों का एक अंतहीन प्रवाह है (हम उन्हें देखें tokens)।

उत्पादन

1. आउटपुट टॉप एन टोकन हमने अब तक देखे हैं (सभी टोकन से हमने देखा है!)
2. आउटपुट टॉप एन टोकन एक ऐतिहासिक विंडो में, कहते हैं, आखिरी दिन या आखिरी सप्ताह।

इस शोध का एक अनुप्रयोग ट्विटर या फेसबुक में विषय के गर्म विषय या रुझानों का पता लगाना है। हमारे पास एक क्रॉलर है जो वेबसाइट पर क्रॉल करता है, जो शब्दों की एक धारा उत्पन्न करता है, जो सिस्टम में फीड करेगा। सिस्टम तब समग्र या ऐतिहासिक रूप से शीर्ष आवृत्ति के शब्दों या वाक्यांशों का उत्पादन करेगा। पिछले कुछ हफ़्ते में कल्पना करें कि "विश्व कप" वाक्यांश कई बार ट्विटर पर दिखाई देगा। तो "पॉल ऑक्टोपस" करता है। :)

स्ट्रिंगर्स इन्टर्गर

सिस्टम में प्रत्येक शब्द के लिए एक पूर्णांक आईडी है। यद्यपि इंटरनेट पर लगभग अनंत संभव शब्द हैं, लेकिन शब्दों के एक बड़े सेट को जमा करने के बाद, नए शब्दों को खोजने की संभावना कम और कम हो जाती है। हमने पहले से ही 4 मिलियन अलग-अलग शब्द पाए हैं, और प्रत्येक के लिए एक अद्वितीय आईडी असाइन किया है। डेटा का यह पूरा सेट मेमोरी में हैश टेबल के रूप में लोड किया जा सकता है, लगभग 300 एमबी मेमोरी का उपभोग करता है। (हमने अपनी खुद की हैश टेबल लागू कर दी है। जावा के कार्यान्वयन में बड़ी मेमोरी ओवरहेड लगती है)

प्रत्येक वाक्यांश को तब पूर्णांक की एक सरणी के रूप में पहचाना जा सकता है।

यह महत्वपूर्ण है, क्योंकि पूर्णांक की तुलना में छंटाई और तुलना स्ट्रिंग्स की तुलना में बहुत तेज है।

पुरालेख डेटा

सिस्टम प्रत्येक टोकन के लिए संग्रह डेटा रखता है। मूलतः यह जोड़े हैं (Token, Frequency)। हालाँकि, डेटा संग्रहीत करने वाली तालिका इतनी विशाल होगी कि हमें तालिका को भौतिक रूप से विभाजित करना होगा। एक बार विभाजन योजना टोकन के कुछ हिस्सों पर आधारित है। यदि टोकन एक शब्द है, तो यह 1 ग्राम है। यदि टोकन दो-शब्द वाक्यांश है, तो यह 2gram है। और यही चलता है। मोटे तौर पर 4 ग्राम पर हमारे पास 1 बिलियन रिकॉर्ड है, जिसमें टेबल का आकार लगभग 60GB है।

आने वाली धाराओं को संसाधित करना

सिस्टम आने वाले वाक्यों को अवशोषित कर लेगा जब तक कि मेमोरी पूरी तरह से उपयोग नहीं हो जाती (हां, हमें मेमोरी मैनजर की आवश्यकता है)। एन वाक्यों को लेने और स्मृति में संग्रहीत करने के बाद, सिस्टम रुक जाता है, और प्रत्येक वाक्य को शब्दों और वाक्यांशों में बदलना शुरू कर देता है। प्रत्येक टोकन (शब्द या वाक्यांश) को गिना जाता है।

अत्यधिक लगातार टोकन के लिए, उन्हें हमेशा स्मृति में रखा जाता है। कम लगातार टोकन के लिए, उन्हें आईडी के आधार पर क्रमबद्ध किया जाता है (याद रखें कि हम स्ट्रिंग को पूर्णांकों की एक सरणी में अनुवाद करते हैं), और एक डिस्क फ़ाइल में क्रमबद्ध।

(हालांकि, आपकी समस्या के लिए, चूंकि आप केवल शब्दों की गिनती कर रहे हैं, तो आप सभी शब्द-आवृत्ति मानचित्र को केवल मेमोरी में रख सकते हैं। सावधानीपूर्वक डिज़ाइन किया गया डेटा 4 मिलियन विभिन्न शब्दों के लिए केवल 300MB मेमोरी का उपभोग करेगा। कुछ संकेत: ASCII char का उपयोग करें। स्ट्रिंग्स का प्रतिनिधित्व करते हैं), और यह बहुत स्वीकार्य है।

इस बीच, एक और प्रक्रिया होगी जो सिस्टम द्वारा उत्पन्न किसी भी डिस्क फ़ाइल को खोजने के बाद सक्रिय हो जाती है, फिर उसे विलय करना शुरू करें। चूंकि डिस्क फ़ाइल को क्रमबद्ध किया गया है, इसलिए विलय विलय की तरह एक समान प्रक्रिया लेगा। कुछ डिज़ाइन को यहाँ पर भी ध्यान रखने की आवश्यकता है, क्योंकि हम बहुत सारे रैंडम डिस्क सीकों से बचना चाहते हैं। विचार एक ही समय में पढ़ने (मर्ज प्रक्रिया) / लिखने (सिस्टम आउटपुट) से बचने के लिए है, और मर्ज प्रक्रिया को एक डिस्क में लिखते हुए एक डिस्क को पढ़ने दें। यह एक लॉकिंग को लागू करने के समान है।

दिन के अंत मे

दिन के अंत में, सिस्टम में मेमोरी में संग्रहीत आवृत्ति के साथ कई बार टोकन होंगे, और कई अन्य कम लगातार टोकन कई डिस्क फ़ाइलों में संग्रहीत होते हैं (और प्रत्येक फ़ाइल को सॉर्ट किया जाता है)।

सिस्टम इन-मेमोरी मैप को डिस्क फ़ाइल में फ्लश करता है (इसे सॉर्ट करें)। अब, समस्या सॉर्ट की गई डिस्क फ़ाइल के एक सेट को मर्ज करना है। इसी तरह की प्रक्रिया का उपयोग करके, हमें अंत में एक सॉर्ट की गई डिस्क फ़ाइल मिलेगी।

फिर, अंतिम कार्य सॉर्ट की गई डिस्क फ़ाइल को आर्काइव डेटाबेस में मर्ज करना है। संग्रह डेटाबेस के आकार पर निर्भर करता है, एल्गोरिथ्म नीचे की तरह काम करता है अगर यह काफी बड़ा है:

   for each record in sorted disk file
        update archive database by increasing frequency
        if rowcount == 0 then put the record into a list
   end for

   for each record in the list of having rowcount == 0
        insert into archive database
   end for

अंतर्ज्ञान यह है कि कुछ समय बाद, डालने की संख्या छोटी और छोटी हो जाएगी। अधिक से अधिक ऑपरेशन केवल अपडेट करने पर होगा। और यह अपडेट इंडेक्स द्वारा दंडित नहीं किया जाएगा।

आशा है कि यह पूरी व्याख्या मदद करेगी। :)

Comments

मुझे नहीं मिला। शब्दों के पूर्णांक आईडी में कोई व्यक्ति किस प्रकार की सार्थक छँटाई या तुलना कर सकता है? क्या संख्याएँ मनमानी नहीं हैं?

— दिमित्रिस आंद्रेउ

इसके अलावा, शब्दों की बारंबारता की गणना Google के MapReduce पेपर ( labs.google.com/papers/mapreduce.html ) में पहला उदाहरण है , इसे मुट्ठी भर लाइनों में हल करना। आप अपने डेटा को Google ऐप एंगाइन पर भी ले जा सकते हैं और ऐसा MapReduce ( code.google.com/p/appengine-mapreduce ) कर सकते हैं

— दिमित्री आंद्रेउ

@ डिट्रिस आंद्रेउ: पूर्णांकों पर छंटनी स्ट्रिंग्स पर अधिक तेज़ होगी। ऐसा इसलिए है क्योंकि दो पूर्णांक की तुलना दो तार की तुलना में तेज है।

— साइलेंट SoNG

@ डमिट्रिस आंद्रेउ: इस समस्या को हल करने के लिए Google का मानचित्रण एक अच्छा वितरित दृष्टिकोण है। आह! लिंक प्रदान करने के लिए धन्यवाद। हां, कई मशीनों का उपयोग करना हमारे लिए अच्छा होगा। अच्छा तरीका।

— साइलेंट SoNG

@ डमिट्रिस आंद्रेउ: अब तक मैं केवल सिंगल मशीन छांटने के दृष्टिकोण पर विचार कर रहा हूं। वितरण में सॉर्ट करने के लिए एक अच्छा विचार क्या है।

— साइलेंट SoNG

Answer 4

आप बाइनरी सर्च ट्री के साथ संयुक्त हैश टेबल का उपयोग कर सकते हैं । एक डिक्शनरी लागू करें जो आपको बताए कि प्रत्येक खोज शब्द को कितनी बार खोजा गया है।<search term, count>

जाहिर है कि शीर्ष 10 पाने के लिए हर घंटे पूरी हैश तालिका को पुनरावृत्त करना बहुत बुरा है। लेकिन यह वह Google है जिसके बारे में हम बात कर रहे हैं, इसलिए आप मान सकते हैं कि शीर्ष दस सभी मिलेंगे, 10 000 से अधिक हिट कहेंगे (हालांकि यह संभवतः बहुत बड़ी संख्या है)। इसलिए हर बार जब खोज शब्द की गिनती 10 000 से अधिक हो जाती है, तो उसे BST में डालें। फिर हर घंटे, आपको केवल BST से पहले 10 प्राप्त करने होंगे, जिसमें अपेक्षाकृत कम प्रविष्टियाँ होनी चाहिए।

यह शीर्ष -10-सभी समय की समस्या को हल करता है।

---

वास्तव में मुश्किल हिस्सा मासिक रिपोर्ट में एक और जगह ले रहा है, उदाहरण के लिए, "स्टैक ओवरफ्लो" पिछले दो महीनों के लिए 50 000 हिट हो सकता है, लेकिन पिछले महीने केवल 10 000, जबकि "अमेज़ॅन" में 40 हो सकते हैं पिछले दो महीनों के लिए 000 लेकिन पिछले महीने के लिए 30 000। आप चाहते हैं कि "अमेज़ॅन" आपके मासिक धर्म में "स्टैक ओवरफ्लो" से पहले आए)। ऐसा करने के लिए, मैं सभी प्रमुख (10 000 से अधिक ऑल-टाइम खोजों के ऊपर) खोज शब्दों को संग्रहीत करूंगा, एक 30-दिन की सूची जो आपको बताती है कि प्रत्येक दिन कितनी बार उस शब्द को खोजा गया था। यह सूची एक FIFO कतार की तरह काम करेगी: आप पहले दिन को हटाते हैं और प्रत्येक दिन (या प्रत्येक घंटे) एक नया डालते हैं, लेकिन तब आपको अधिक जानकारी संग्रहीत करने की आवश्यकता हो सकती है, जिसका अर्थ है अधिक मेमोरी / स्पेस। यदि मेमोरी कोई समस्या नहीं है। यह, अन्यथा उस "सन्निकटन" के लिए जाएं

यह एक अच्छी शुरुआत की तरह लग रहा है। फिर आप उन शर्तों को pruning के बारे में चिंता कर सकते हैं जिनके पास> 10 000 हिट हैं, लेकिन लंबे समय तक और इस तरह से सामान नहीं है।

Answer 5

मामला i)

सभी खोजकर्ताओं के लिए एक हैशटेबल बनाए रखें, साथ ही हैशटेबल से अलग सॉर्ट की गई टॉप-टेन सूची। जब भी कोई खोज होती है, तो हैशटेबल में उचित आइटम को बढ़ाएं और यह देखने के लिए जांचें कि क्या उस आइटम को अब टॉप-टेन सूची में 10 वें आइटम के साथ स्विच किया जाना चाहिए।

शीर्ष-दस सूची के लिए ओ (1) लुकअप, और हैशटेबल में अधिकतम हे (लॉग (एन)) सम्मिलन (एक आत्म-संतुलन बाइनरी ट्री द्वारा प्रबंधित टकराव मानकर)।

मामला ii) एक विशाल हैशटेबल और एक छोटी सूची को बनाए रखने के बजाय, हम एक हैशटेबल और सभी वस्तुओं की एक क्रमबद्ध सूची बनाए रखते हैं। जब भी कोई खोज की जाती है, तो उस शब्द को हैशटेबल में बढ़ा दिया जाता है, और सॉर्ट की गई सूची में यह देखने के लिए शब्द की जांच की जा सकती है कि क्या यह उसके बाद के शब्द के साथ स्विच होना चाहिए। एक स्व-संतुलन बाइनरी ट्री इसके लिए अच्छी तरह से काम कर सकता है, क्योंकि हमें इसे जल्दी से क्वेरी करने में सक्षम होना चाहिए (बाद में इस पर अधिक)।

इसके अलावा हम एक फीफो सूची (कतार) के रूप में 'घंटे' की सूची भी बनाए रखते हैं। प्रत्येक 'घंटे' तत्व में उस विशेष घंटे के भीतर की गई सभी खोजों की एक सूची होगी। उदाहरण के लिए, हमारी सूची कुछ घंटों की हो सकती है:

Time: 0 hours
      -Search Terms:
          -free stuff: 56
          -funny pics: 321
          -stackoverflow: 1234
Time: 1 hour
      -Search Terms:
          -ebay: 12
          -funny pics: 1
          -stackoverflow: 522
          -BP sucks: 92

फिर, प्रत्येक घंटे: यदि सूची में कम से कम 720 घंटे लंबे (30 दिनों में घंटों की संख्या) है, तो सूची में पहले तत्व को देखें, और प्रत्येक खोज शब्द के लिए, उचित मात्रा में हैशटेबल में उस तत्व को घटाएं । बाद में, उस पहले घंटे के तत्व को सूची से हटा दें।

तो मान लें कि हम घंटे 721 पर हैं, और हम अपनी सूची में पहले घंटे (ऊपर) को देखने के लिए तैयार हैं। हम हैशटेबल में ५६ तक मुफ्त सामान, ३२१ तक मज़ेदार पिक्स, इत्यादि की कमी करेंगे, और फिर सूची से घंटे ० को पूरी तरह से हटा देंगे क्योंकि हमें इसे फिर से देखने की आवश्यकता नहीं होगी।

जिस कारण से हम उन सभी शब्दों की एक क्रमबद्ध सूची बनाए रखते हैं जो तीव्र प्रश्नों की अनुमति देते हैं, क्योंकि प्रत्येक घंटे के बाद जब हम 720 घंटे पहले खोज शब्दों से गुजरते हैं, तो हमें यह सुनिश्चित करने की आवश्यकता होती है कि शीर्ष-दस सूची छँटाई बनी रहे। इसलिए जब हम उदाहरण के लिए हैशटेबल में 56 से 'फ्री स्टफ' को घटाते हैं, तो हम यह देखना चाहेंगे कि यह अब सूची में कहां है। क्योंकि यह एक स्व-संतुलन बाइनरी ट्री है, जो कि सभी को ओ (लॉग (एन)) समय में अच्छी तरह से पूरा किया जा सकता है।

---

संपादित करें: अंतरिक्ष के लिए शुद्धता का बलिदान ...

यह पहले एक में एक बड़ी सूची को लागू करने के लिए भी उपयोगी हो सकता है, जैसा कि दूसरे में। सभी लेकिन शीर्ष दूर करने के लिए एक क्रॉन जॉब रन: फिर हम दोनों ही मामलों पर निम्नलिखित अंतरिक्ष अनुकूलन लागू हो सकते हैं एक्स सूची में आइटम। यह स्थान की आवश्यकता को कम रखेगा (और परिणामस्वरूप सूची में तेज़ी से प्रश्न करें)। बेशक, यह एक अनुमानित परिणाम होगा, लेकिन इसकी अनुमति है। उपलब्ध मेमोरी के आधार पर एप्लिकेशन को तैनात करने से पहले x की गणना की जा सकती है, और अधिक मेमोरी उपलब्ध होने पर गतिशील रूप से समायोजित किया जा सकता है।

Answer 6

किसी न किसी सोच ...

शीर्ष 10 के लिए हर समय

• एक हैश संग्रह का उपयोग करना जहां प्रत्येक पद के लिए एक गिनती संग्रहीत है (शब्दों को पवित्र करें, आदि)
• एक क्रमबद्ध सरणी जिसमें चल रहे शीर्ष 10 होते हैं, इस सरणी में एक शब्द / संख्या को इस सरणी में जोड़ा जाता है जब भी किसी पद की संख्या सरणी में सबसे छोटी संख्या के बराबर या उससे अधिक हो जाती है।

मासिक शीर्ष 10 के लिए प्रति घंटा अपडेट किया गया:

• मॉडुलो 744 (एक महीने के दौरान घंटों की संख्या) शुरू करने के बाद से बीते हुए घंटों की संख्या पर अनुक्रमित सरणी का उपयोग करना, जो सरणी प्रविष्टियों में हैश संग्रह होता है जहां इस घंटे-स्लॉट के दौरान सामना किए गए प्रत्येक शब्द के लिए एक गिनती संग्रहीत होती है। जब भी घंटे-स्लॉट काउंटर बदलता है, तो एक प्रविष्टि रीसेट की जाती है
• घंटे-स्लॉट पर अनुक्रमित सरणी के आँकड़े को तब एकत्र करने की आवश्यकता होती है, जब घंटे-स्लॉट पर अनुक्रमित इस सरणी की सामग्री को कॉपी और सपाट करके वर्तमान घंटे-स्लॉट काउंटर में परिवर्तन (एक बार एक घंटे में अधिकतम) होता है।

इर्रर ... समझ में आता है? मैंने ऐसा नहीं सोचा था कि मैं वास्तविक जीवन में ऐसा करूंगा

आह हाँ, उल्लेख करना भूल गया, मासिक आँकड़ों के लिए आवश्यक प्रति घंटा "नकल / चपटा" वास्तव में सभी समय के शीर्ष 10 के लिए उपयोग किए गए समान कोड का पुन: उपयोग कर सकता है, एक अच्छा दुष्प्रभाव।

Answer 7

सटीक समाधान

सबसे पहले, एक समाधान जो सही परिणाम की गारंटी देता है, लेकिन बहुत अधिक मेमोरी (एक बड़ा नक्शा) की आवश्यकता होती है।

"ऑल-टाइम" संस्करण

मान के रूप में क्वेरीज़ को कुंजियों और उनकी संख्या के साथ हैश मैप बनाए रखें। इसके अतिरिक्त, अब तक की सूची में 10 सबसे अधिक बार पूछे जाने वाले प्रश्नों और 10 वीं सबसे अक्सर गणना (एक सीमा) की गिनती रखें।

जैसे ही प्रश्नों की धारा पढ़ी जाती है, नक्शे को लगातार अपडेट करें। हर बार जब कोई गणना वर्तमान सीमा से अधिक हो जाती है, तो निम्न कार्य करें: "शीर्ष 10" सूची से 10 वीं क्वेरी को हटा दें, इसे उस क्वेरी से बदलें जिसे आपने अभी अपडेट किया है, और थ्रेशोल्ड को भी अपडेट करें।

"पिछले महीने" संस्करण

उसी "टॉप 10" सूची को रखें और इसे ऊपर की तरह ही अपडेट करें। इसके अलावा, एक समान मानचित्र रखें, लेकिन इस बार मान के रूप में 30 * 24 = 720 गणना (प्रत्येक घंटे के लिए एक) के वैक्टर को स्टोर करें। हर घंटे हर कुंजी के लिए निम्न कार्य करें: वेक्टर के सबसे पुराने काउंटर को हटा दें, अंत में एक नया जोड़ें (प्रारंभ में 0)। यदि वेक्टर सर्व-शून्य है, तो मानचित्र से कुंजी निकालें। इसके अलावा, हर घंटे आपको खरोंच से "शीर्ष 10" सूची की गणना करनी होगी।

नोट: हाँ, इस बार हम एक के बजाय 720 पूर्णांक संग्रहीत कर रहे हैं, लेकिन बहुत कम कुंजियाँ हैं (ऑल-टाइम संस्करण में वास्तव में लंबी पूंछ है)।

अनुमान

ये अनुमान सही समाधान की गारंटी नहीं देते हैं, लेकिन स्मृति-खपत कम होते हैं।

1. हर N-th क्वेरी को प्रोसेस करें, बाकी को स्किप कर दें।
2. (केवल ऑल-टाइम वैरिएंट के लिए) मैप में अधिकांश M की-वैल्यू जोड़े रखें (M उतना ही बड़ा होना चाहिए जितना आप खर्च कर सकें)। यह एक LRU कैश का एक प्रकार है: हर बार जब आप एक क्वेरी पढ़ते हैं जो नक्शे में नहीं होती है, तो गिनती 1 के साथ हाल ही में उपयोग किए गए क्वेरी को हटा दें और इसे वर्तमान में संसाधित क्वेरी से बदल दें।

Comments

मुझे सन्निकटन में संभाव्य दृष्टिकोण 1 पसंद है। लेकिन सन्निकटन 2 (LRU कैश) का उपयोग करते हुए, क्या होता है यदि शर्तें जो बहुत लोकप्रिय नहीं थीं, शुरू में लोकप्रिय हो गईं? क्या उन्हें हर बार जोड़े जाने के बाद त्याग नहीं किया जाएगा, क्योंकि उनकी गिनती बहुत कम होगी?

— डेल

@del आप सही हैं, दूसरा सन्निकटन केवल प्रश्नों की कुछ धाराओं के लिए काम करेगा। यह कम विश्वसनीय है, लेकिन एक ही समय में कम संसाधनों की आवश्यकता होती है। नोट: आप दोनों अनुमानों को भी जोड़ सकते हैं।

— Bolo

Answer 8

पिछले महीने के लिए शीर्ष 10 खोज शब्द

स्मृति कुशल अनुक्रमण / डेटा संरचना का उपयोग करना, जैसे कि कसकर पैक की गई कोशिशें ( कोशिशों पर विकिपीडिया प्रविष्टियों से ) लगभग स्मृति आवश्यकताओं और n - शब्दों की संख्या के बीच कुछ संबंध को परिभाषित करता है।

ऐसी स्थिति में जब आवश्यक मेमोरी उपलब्ध हो ( अनुमान 1 ), आप सटीक मासिक आँकड़ा रख सकते हैं और इसे हर महीने हर समय आँकड़ों में जोड़ सकते हैं।

यहाँ एक धारणा यह भी है कि 'पिछले महीने' को निश्चित खिड़की के रूप में व्याख्यायित किया गया है। लेकिन भले ही मासिक विंडो उपरोक्त प्रक्रिया को खिसका रही हो, सिद्धांत को दर्शाता है (स्लाइडिंग को दिए गए आकार की निश्चित खिड़कियों के साथ अनुमानित किया जा सकता है)।

यह मुझे राउंड-रॉबिन डेटाबेस की याद दिलाता है कि कुछ आँकड़ों की गणना 'ऑल टाइम' पर की जाती है (इस अर्थ में कि सभी डेटा को बरकरार नहीं रखा जाता है; rrd अधिकतम अवधि का विवरण औसतन, संक्षेप में या अधिकतम मानों का चयन करके, विवरणों को नापसंद करता है) दिए गए कार्य में जो विवरण खो गया है वह कम आवृत्ति की वस्तुओं पर जानकारी है, जो त्रुटियों को प्रस्तुत कर सकता है)।

अनुमान १

यदि हम पूरे महीने के लिए सही आंकड़े नहीं रख सकते हैं, तो हमें एक निश्चित अवधि पी को खोजने में सक्षम होना चाहिए, जिसके लिए हमें सही आंकड़े रखने में सक्षम होना चाहिए। उदाहरण के लिए, यह मानते हुए कि हमारे पास कुछ समय अवधि P पर सही आँकड़े हैं, जो महीने n समय में जाता है।
परफेक्ट आंकड़े फंक्शन को परिभाषित करते हैं f(search_term) -> search_term_occurance।

यदि हम सभी nसही स्टेट टेबल को स्मृति में रख सकते हैं, तो मासिक आँकड़ों को खिसकाने की गणना इस तरह की जा सकती है:

• नवीनतम अवधि के लिए आँकड़े जोड़ें
• सबसे पुरानी अवधि के लिए आँकड़े निकालें (इसलिए हमें nसही स्टेट टेबल रखना होगा )

हालाँकि, यदि हम केवल शीर्ष स्तर (मासिक) पर शीर्ष 10 रखते हैं तो हम निश्चित अवधि के पूर्ण आँकड़ों से बहुत सारे डेटा को त्यागने में सक्षम होंगे। यह पहले से ही एक कार्यशील प्रक्रिया देता है जो निश्चित हो गया है (पी अवधि के लिए सही स्टेट टेबल पर ऊपरी बाध्य मान) स्मृति आवश्यकताओं।

उपरोक्त प्रक्रिया के साथ समस्या यह है कि यदि हम एक स्लाइडिंग विंडो के लिए केवल शीर्ष 10 शब्दों पर जानकारी रखते हैं (सभी समय के लिए समान), तो आँकड़े खोज शब्दों के लिए सही होने जा रहे हैं जो एक अवधि में चरम पर हैं, लेकिन शायद यह देखने के लिए नहीं है खोज शब्दों के लिए आँकड़े जो लगातार समय के साथ छल करते हैं।

यह शीर्ष 10 शब्दों से अधिक की जानकारी रखते हुए ऑफसेट किया जा सकता है, उदाहरण के लिए शीर्ष 100 शब्द, उम्मीद है कि शीर्ष 10 सही होंगे।

मुझे लगता है कि आगे के विश्लेषण में आँकड़ों का एक हिस्सा बनने के लिए होने वाली न्यूनतम घटनाओं का संबंध हो सकता है (जो अधिकतम त्रुटि से संबंधित है)।

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

उपरोक्त के लिए सबसे खराब मामला तब है जब आपके पास लगभग समान रूप से लगातार शब्द हैं और वे हर समय बदलते हैं (उदाहरण के लिए यदि केवल 100 शब्द ट्रैक करते हैं, तो यदि शीर्ष 150 शब्द समान रूप से आते हैं, लेकिन शीर्ष 50 पहले महीने में अधिक बार होते हैं और ऐसा न हो कि कुछ समय बाद आंकड़े सही तरीके से रखे जाएं)।

इसके अलावा एक और दृष्टिकोण हो सकता है जो मेमोरी साइज़ में तय नहीं है (अच्छी तरह से सख्ती से बोलना न तो ऊपर है), जो कि घटनाओं / अवधि (दिन, महीने, साल, सभी समय) के संदर्भ में न्यूनतम महत्व को परिभाषित करेगा, जिसके लिए उसे रखना है आँकड़े। यह एकत्रीकरण के दौरान प्रत्येक आँकड़ों में अधिकतम त्रुटि की गारंटी दे सकता है (फिर से राउंड रॉबिन देखें)।

Answer 9

"घड़ी पृष्ठ प्रतिस्थापन एल्गोरिदम" (जिसे "दूसरा-मौका" के रूप में भी जाना जाता है) के एक अनुकूलन के बारे में क्या ? मैं कल्पना कर सकता हूं कि यह बहुत अच्छी तरह से काम करेगा अगर खोज अनुरोध समान रूप से वितरित किए जाते हैं (इसका मतलब है कि सबसे अधिक खोजा गया शब्द लगातार 5mio बार की बजाय नियमित रूप से दिखाई देता है और फिर फिर कभी नहीं)।

यहाँ एल्गोरिथ्म का एक दृश्य प्रतिनिधित्व है:

Answer 10

एक विशाल हैश तालिका में खोज शब्दों की गिनती को संग्रहीत करें, जहां प्रत्येक नई खोज एक विशेष तत्व को एक के बाद बढ़ाए जाने का कारण बनती है। शीर्ष 20 या खोज शब्दों पर नज़र रखें; जब 11 वें स्थान पर तत्व बढ़ा हुआ हो, तो जांचें कि क्या उसे # 10 * के साथ पदों को स्वैप करने की आवश्यकता है (यह शीर्ष 10 को क्रमबद्ध रखने के लिए आवश्यक नहीं है; आप सभी की परवाह 10 वीं और 11 वीं के बीच के अंतर को आकर्षित कर रहे हैं)।

* _{इसी तरह की जाँच यह देखने के लिए किए जाने की आवश्यकता है कि क्या कोई नया खोज शब्द 11 वें स्थान पर है, इसलिए यह एल्गोरिथ्म अन्य खोज शब्दों तक भी सीमित हो जाता है - इसलिए मैं थोड़ा सरल कर रहा हूं।}

Comments

आप अपनी हैश तालिका के आकार को सीमित करना चाहते हैं। यदि आपको अनूठी खोजों की एक धारा मिलती है तो क्या होगा? आपको यह सुनिश्चित करने की आवश्यकता है कि आप अपने आप को नियमित रूप से लेकिन बार-बार खोजे जाने वाले शब्द को नोट करने से रोकते नहीं हैं। समय के साथ जो कि शीर्ष खोज शब्द हो सकता है, खासकर अगर अन्य सभी खोज शब्द "वर्तमान घटनाएँ" हैं, यानी अब बहुत खोजा गया है, लेकिन अगले सप्ताह ऐसा नहीं है। दरअसल, इस तरह के विचार आपके द्वारा किए जाने वाले अनुमान हो सकते हैं। उन्हें यह कहकर औचित्य दें, हम इस प्रकार की चीज़ों को नहीं पकड़ेंगे क्योंकि ऐसा करने से एल्गोरिथ्म का तरीका अधिक समय / स्थान महंगा हो जाता है।

— कैप १२३२

मुझे पूरा यकीन है कि Google के पास हर चीज़ की गिनती है - कुछ मायने नहीं हैं, हालांकि यह सांख्यिकीय रूप से बनाए रखा गया है, लेकिन जरूरत के अनुसार गणना की गई है।

— ईथर

Answer 11

कभी-कभी सबसे अच्छा जवाब "मुझे नहीं पता"।

बीमार एक गहरी छुरा ले लो। मेरी पहली वृत्ति परिणामों को क्यू में खिलाने के लिए होगी। एक प्रक्रिया लगातार क्यू में आने वाली वस्तुओं को संसाधित करेगी। प्रक्रिया एक उपस्थिति बनाए रखेगी

पद -> गिनती

हर बार क्यू आइटम संसाधित होने के बाद, आप बस खोज शब्द को देखते हैं और गिनती बढ़ाते हैं।

उसी समय, मैं मानचित्र में शीर्ष 10 प्रविष्टियों के संदर्भों की एक सूची बनाए रखूंगा।

वर्तमान में लागू की गई प्रविष्टि के लिए, देखें कि क्या इसकी गिनती शीर्ष 10 में सबसे छोटी प्रविष्टि की गिनती से अधिक है (यदि पहले से सूची में नहीं है)। यदि यह है, तो प्रविष्टि के साथ सबसे छोटा बदलें।

मुझे लगता है कि यह काम करेगा। कोई भी ऑपरेशन समय गहन नहीं है। आपको गणना मानचित्र के आकार को प्रबंधित करने का एक तरीका खोजना होगा। लेकिन यह एक साक्षात्कार उत्तर के लिए पर्याप्त होना चाहिए।

वे एक समाधान की उम्मीद नहीं कर रहे हैं, यह देखना चाहते हैं कि क्या आप सोच सकते हैं। आपको न तो समाधान लिखना है और न ही ...।

Comments

डेटा संरचना को एक कहा जाता है queue, Qएक अक्षर है :)।

— IVlad

अगर मैं साक्षात्कार आयोजित कर रहा था, "मुझे नहीं पता है कि <स्टॉप>" निश्चित रूप से सबसे अच्छा जवाब नहीं होगा। अपने दिमाग से सोचो। यदि आप नहीं जानते हैं, तो यह पता लगाएं - या कम से कम कोशिश करें।

— स्टीफन

साक्षात्कार में, जब मैं किसी को अपने 7 पृष्ठ पर हाइबरनेट के साथ 5 बार फिर से देखता हूं, और वे मुझे नहीं बता सकते हैं कि ओआरएम क्या है, मैं तुरंत साक्षात्कार समाप्त करता हूं। आईडी के बजाय वे इसे अपने फिर से शुरू पर नहीं डालते हैं और कहते हैं: "मुझे नहीं पता"। किसी को सब पता नहीं है। @IVIad, मैं नाटक कर रहा था मैं एक सी डेवलपर था और बिट्स को बचाने की कोशिश कर रहा था ...?)

— hvgotcodes

Answer 12

एक तरीका यह है कि प्रत्येक खोज के लिए, आप उस खोज शब्द और उसके समय की मोहर को संग्रहीत करते हैं। इस तरह, किसी भी समयावधि के लिए शीर्ष दस का पता लगाना निश्चित समय अवधि के भीतर सभी खोज शब्दों की तुलना करने का मामला है।

एल्गोरिथ्म सरल है, लेकिन दोष अधिक मेमोरी और समय की खपत होगी।

Answer 13

10 नोड्स के साथ एक सेले ट्री का उपयोग करने के बारे में क्या ? हर बार जब आप किसी मान (खोज शब्द) को एक्सेस करने का प्रयास करते हैं, जो पेड़ में निहित नहीं होता है, तो कोई भी पत्ता फेंक दें, इसके बजाय मान डालें और इसे एक्सेस करें।

इसके पीछे का विचार मेरे अन्य उत्तर की तरह ही है । इस धारणा के तहत कि खोज शब्द समान रूप से एक्सेस किए जाते हैं / नियमित रूप से इस समाधान को बहुत अच्छा प्रदर्शन करना चाहिए।

संपादित करें

वृक्ष में कुछ और खोज शब्द भी संग्रहीत किए जा सकते हैं (एक ही समाधान के लिए जाता है जो मैं अपने अन्य उत्तर में सुझाता हूं) एक नोड को हटाने के लिए नहीं जो बहुत जल्द फिर से एक्सेस किया जा सकता है। इसमें जितने अधिक मूल्य होते हैं, उतना ही बेहतर परिणाम मिलता है।

Answer 14

दूनो अगर मैं इसे सही समझता हूं या नहीं। मेरा समाधान ढेर का उपयोग कर रहा है। शीर्ष 10 खोज आइटम की वजह से, मैं आकार 10 के साथ एक ढेर का निर्माण करता हूं। फिर इस खोज को नई खोज के साथ अपडेट करें। यदि एक नई खोज की आवृत्ति ढेर (मैक्स हीप) शीर्ष से अधिक है, तो इसे अपडेट करें। छोटी आवृत्ति के साथ एक का त्याग करें।

लेकिन, विशिष्ट खोज की आवृत्ति की गणना किसी और चीज़ पर कैसे की जाएगी। शायद जैसा कि सभी ने कहा, डेटा स्ट्रीम एल्गोरिदम ...।

Answer 15

शुरुआत से ही सभी खोजों की गणना करने के लिए सेमी-स्केच का उपयोग करें, शीर्ष 10 के लिए इसके साथ आकार 10 का एक न्यूनतम-ढेर रखें। मासिक परिणाम के लिए, 30 सेमी-स्केच / हैश-टेबल और इसके साथ न्यूनतम-हीप रखें, प्रत्येक एक शुरुआत अंतिम 30, 29 .., 1 दिन से गिनती और अद्यतन। एक दिन के पास के रूप में, अंतिम को साफ़ करें और इसे दिन के रूप में उपयोग करें 1. प्रति घंटा परिणाम के लिए समान, 60 हैश-टेबल और मिन-हीप रखें और अंतिम 60, 59, ... 1 मिनट के लिए गिनती शुरू करें। एक मिनट पास के रूप में, अंतिम को साफ़ करें और इसे मिनट 1 के रूप में उपयोग करें।

मोंटली परिणाम 1 दिन की सीमा में सटीक होता है, प्रति घंटा परिणाम 1 मिनट की सीमा में सटीक होता है

Answer 16

जब आप निश्चित मात्रा में मेमोरी और एक 'अनंत' (बहुत बड़ी सोचें) टोकन की धारा रखते हैं तो समस्या सार्वभौमिक रूप से हल नहीं होती है।

एक मोटा स्पष्टीकरण ...

क्यों देखें, एक टोकन स्ट्रीम पर विचार करें जिसमें एक विशेष टोकन है (यानी, शब्द) इनपुट स्ट्रीम में प्रत्येक एन टोकन टी।

यह भी मान लें कि स्मृति अधिकांश एम टोकन पर संदर्भ (शब्द आईडी और मायने रखता है) रख सकती है।

इन शर्तों के साथ, एक इनपुट स्ट्रीम का निर्माण संभव है जहां टोकन टी का कभी भी पता नहीं लगाया जाएगा यदि एन काफी बड़ा है ताकि स्ट्रीम में टी के बीच अलग-अलग एम टोकन हों।

यह शीर्ष-एन एल्गोरिथ्म विवरण से स्वतंत्र है। यह केवल सीमा एम पर निर्भर करता है।

यह देखने के लिए कि यह सत्य क्यों है, दो समान टोकन के समूहों से बनी आने वाली धारा पर विचार करें:

T a1 a2 a3 ... a-M T b1 b2 b3 ... b-M ...

जहां a, और b हैं, सभी मान्य टोकन T के बराबर नहीं हैं।

ध्यान दें कि इस स्ट्रीम में, प्रत्येक a और bi के लिए T दो बार दिखाई देता है। फिर भी यह शायद ही कभी सिस्टम से अलग हो गया प्रतीत होता है।

एक खाली मेमोरी के साथ शुरू, पहला टोकन (टी) मेमोरी में एक स्लॉट लेगा (एम द्वारा बंधे)। तब A एक स्लॉट का उपभोग करेगा, जो M- समाप्त होने पर सभी तरह से (M-1) कर देगा।

जब एएमआई आता है तो एल्गोरिथ्म को एक प्रतीक को छोड़ना पड़ता है इसलिए इसे टी होने दें। अगला प्रतीक बी -1 होगा जिससे ए -1 फ्लश हो जाएगा, आदि।

इसलिए, टी वास्तविक गिनती बनाने के लिए स्मृति-निवासी लंबे समय तक नहीं रहेगा। संक्षेप में, कोई भी एल्गोरिथ्म कम पर्याप्त स्थानीय आवृत्ति लेकिन उच्च वैश्विक आवृत्ति (धारा की लंबाई से अधिक) का टोकन याद करेगा।