👩‍👦 🐱 🤜 पूर्ण पाठ खोज: जटिल कार्यों के लिए एलिस्टिक्स-विशिष्ट विशेषताएं 🤽🏼 🤛🏻 👧🏾

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

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

आवश्यकताओं

कम से कम 50,000 दस्तावेजों के डेटाबेस का उपयोग करके Elacsticsearch पर एक खोज बनाएँ।
अनुरोधों को उच्च गति प्रतिक्रिया प्रदान करें - 300 एमएस से कम।
यह सुनिश्चित करने के लिए कि अनुरोध छोटे थे, और सेवा सबसे खराब मोबाइल इंटरनेट की स्थितियों में भी उपलब्ध थी।
UX परिप्रेक्ष्य से खोज तर्क को यथासंभव सहज बनाएं। यह अनिवार्य रूप से था कि इंटरफ़ेस खोज तर्क को प्रतिबिंबित करेगा - और इसके विपरीत।
उच्च प्रदर्शन और कम निर्भरता के लिए सिस्टम तत्वों के बीच इंटरलेयर्स की संख्या को कम करें।
किसी भी समय एल्गोरिथ्म को नई परिस्थितियों के साथ पूरक करने का अवसर प्रदान करने के लिए (उदाहरण के लिए, उत्पाद विवरण की स्वचालित पीढ़ी)।
यथासंभव सरल और सुविधाजनक परियोजना के खोज भाग के लिए आगे समर्थन करें।

हमने जल्दबाज़ी नहीं की और सरल शुरुआत करने का फैसला किया।

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

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

हमने पहले प्रोटोटाइप को एक साथ रखा जिसमें हमने एक डेटाबेस (PostgreSQL) से ES दस्तावेजों में संरचना को स्थानांतरित किया:

{"mappings" : { "recipe" : { "_source" : { "enabled" : true }, "properties" : { "recipe_id" : {"type" : "integer"}, "recipe_name" : {"type" : "text"}, "ingredients" : { "type" : "nested", "properties": { "ingredient_id": "integer", "ingredient_name": "string", "manufacturer_id": "integer", "manufacturer_name": "string", "percent": "float" } } } } }}

इस मैपिंग के आधार पर, हमें लगभग निम्नलिखित दस्तावेज मिलते हैं (हम एनडीए के कारण परियोजना से श्रमिक को नहीं दिखा सकते हैं):

 { "recipe_id": 1, "recipe_name": "AAA & BBB", "ingredients": [ { "ingredient_id": 1, "ingredient_name": "AAA", "manufacturer_id": 3, "manufacturer_name": "Manufacturer 3", "percent": 1 }, { "ingredient_id": 2, "ingredient_name": "BBB", "manufacturer_id": 4, "manufacturer_name": "Manufacturer 4", "percent": 3 } ] }

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

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

प्रतिक्रिया की गति और आकार के लिए आवश्यकताओं के बारे में मत भूलना - उस समय तक एपीआई में उत्तर इस तरह से प्रारूपित किए गए थे कि उपयोगी जानकारी की मात्रा में वृद्धि हो: प्रत्येक जसन ऑब्जेक्ट में कुंजियाँ एक अक्षर तक कम हो गई थीं। इसलिए, कुछ किलोबाइट के ईएस में प्रश्न अस्वीकार्य लक्जरी बन गए।

और उस पल में, हमने महसूस किया कि PHP में साहचर्य सरणियों के रूप में विशाल प्रश्नों का निर्माण किसी प्रकार का भयंकर व्यसन है। इसके अलावा, नियंत्रक पूरी तरह से अपठनीय हो गए हैं, अपने लिए देखें:

 public function searchSimilar() { /*...*/ $conditions[] = [ "nested" => [ "path" => "ingredients", "score_mode" => "max", "query" => [ "bool" => [ "must" => [ ["term" => ["ingredients.ingredient_id" => $ingredient_id]], ["range" => ["ingredients.percent"=>[ "lte"=>$percent + 5, "gte"=>$percent - 5 ]]] ] ] ] ] ]; $parameters['body']['query']['bool']['should'][0]['bool']['should'] = $conditions; /*...*/ $equal_conditions[] = [ "nested" => [ "path" => "flavors", "query" => [ "bool" => [ "must" => [ ["term" => ["ingredients.percent" => $percent]] ] ] ] ] ]; $parameters['body']['query']['bool']['should'][1]['bool']['must'] = $equal_conditions; /*...*/ return $this->client->search($parameters); }

गीतात्मक विषयांतर: जब दस्तावेज़ में नेस्टेड फ़ील्ड्स की बात आती है, तो यह पता चला कि हम फ़ॉर्म की एक क्वेरी को पूरा नहीं कर सकते हैं:

 "query": { "bool": { "nested": { "bool": { "should": [ ... ] } } } }

एक साधारण कारण के लिए - आप नेस्टेड फ़िल्टर के अंदर बहु-खोज नहीं कर सकते। इसलिए, मुझे यह करना पड़ा:

 "query": { "bool": { "should": [ {"nested": { "path": "flavors", "score_mode": "max", "query": { "bool": { ... } } }} ] } }

यानी सबसे पहले, शर्तों की एक सरणी घोषित की गई थी, और प्रत्येक स्थिति के अंदर नेस्टेड फ़ील्ड द्वारा खोज की गई थी। एलीटेसर्च के दृष्टिकोण से, यह अधिक सही और तार्किक है। परिणामस्वरूप, हमने स्वयं देखा कि जब हम अतिरिक्त खोज शब्द जोड़ते हैं तो यह तार्किक था।

और यहाँ हमने ES में निर्मित ~~Google~~ टेम्प्लेट की खोज की। पसंद मूंछ पर गिर गई - एक काफी सुविधाजनक तर्क-कम टेम्पलेट इंजन। संपूर्ण अनुरोध निकाय और सभी संचारित डेटा को बिना परिवर्तनों के व्यावहारिक रूप से इसमें डालना संभव था, जिसके परिणामस्वरूप अंतिम अनुरोध ने रूप लिया:

 { "template": "template1", "params": params{} }

टेम्पलेट का शरीर केवल मामूली और पठनीय निकला - केवल JSON और स्वयं मूंछों के निर्देश। टेम्पलेट Elasticsearch में ही संग्रहीत है और नाम से पुकारा जाता है।

 /* search_similar.mustache */ { "query": { "bool": { "should": [ {"bool": { "minimum_should_match": {{ minimumShouldMatch }}, "should": [ {{#ingredientsList}} // mustache         ingredientsList {{#ingredients}} //         ingredients {"nested": { "path": "ingredients", "score_mode": "max", "query": { "bool": { "must": [ {"term": {"ingredients.flavor_id": {{ id }} }}, {"range": {"ingredients.percent" : { "lte": {{ lte }}, "gte": {{ gte }} }}} ] } } }} {{^isLast}},{{/isLast}} //    {{/ingredients}} {{/ingredientsList}} ] }} ] } } } /*  */ { "template": "search_similar", "params": { "minimumShouldMatch": 1, "ingredientsList": { "ingredients": [ {"id": 1, "lte": 10, "gte": 5, "isLast": true } ] } } }

नतीजतन, आउटपुट पर हमें एक टेम्पलेट मिला जिसमें हमने केवल आवश्यक अवयवों की एक सरणी पारित की। तार्किक रूप से, अनुरोध, सशर्त रूप से, निम्नलिखित से बहुत भिन्न नहीं था:

 SELECT * FROM ingredients LEFT JOIN recipes ON recipes.id = ingredient.recipe_id WHERE ingredients.id in (1,2,3) AND ingredients.id not in (4,5,6) AND ingredients.percent BETWEEN 10.0 AND 20.0

लेकिन उसने तेजी से काम किया, और यह आगे के अनुरोधों के लिए तैयार आधार था।

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

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

 { "ingredient_id": 1, "ingredient_name": "AAA", "manufacturer_id": 3, "manufacturer_name": "Manufacturer 3", "percent": 1, "level_1": 2, "level_2": 4, "level_3": 6, "level_4": 7, "level_5": 12 }

नुस्खा की "शुद्धता" की स्थिति से एक खोज निर्दिष्ट करने की आवश्यकता भी थी। उदाहरण के लिए, हमें एक ऐसी रेसिपी की ज़रूरत थी जहाँ बीफ, नमक और काली मिर्च के अलावा कुछ न हो। फिर हमें ऐसे व्यंजनों का वज़न करना पड़ा जहाँ पहले स्तर पर केवल गोमांस था और दूसरे पर केवल मसाले थे (मसालों का पहला टैग शून्य था)। यहां मुझे धोखा देना पड़ा: चूंकि मूंछें तर्क के बिना एक टेम्पलेट है, इसलिए किसी भी गणना की कोई बात नहीं हो सकती है; यहाँ ES स्क्रिप्ट के अनुरोध में स्क्रिप्ट के भाग को कार्यान्वित करना आवश्यक था - Pless। इसका सिंटैक्स जावा के जितना संभव हो उतना करीब है, इसलिए इसमें कोई कठिनाई नहीं थी। परिणामस्वरूप, हमारे पास JSON बनाने वाला मूंछ-टेम्प्लेट था, जिसमें गणना के कुछ भाग, जैसे छँटाई और फ़िल्टरिंग, को पीसल पर लागू किया गया था:

 "filter": [ {{#levelsList}} {{#levels}} {"script": { "script": " int total=0; for (ingredient in params._source.ingredients){ if ([0,{{tag}}].contains(ingredient.level_{{id}})) total+=1; } return (total==params._source.ingredients.length); " }} {{^isLast}},{{/isLast}} {{/levels}} {{/levelsList}} ]

इसके बाद, स्क्रिप्ट के शरीर को पठनीयता के लिए स्वरूपित किया जाता है, अनुरोधों में लाइन ब्रेक का उपयोग नहीं किया जा सकता है।

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

 "filter": [ {"script":{ "script": " double nest=0,rest=0; for (ingredient in params._source.ingredients){ if([{{#tags}}{{tagId}}{{^isLast}},{{/isLast}}{{/tags}}].contains(flavor.level_{{tags.0.levelId}})){ nest+= ingredient.percent; }else{ if (ingredient.percent>rest){rest = ingredient.percent} } } return(nest>=rest); " }} ]

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

परियोजना के मध्यवर्ती चरणों में से एक पर, हमें निम्नलिखित चीज़ों की आवश्यकता थी: सभी उपलब्ध समूहों की सूची और प्रत्येक में पदों की संख्या प्रदर्शित करें। प्रचलित प्रश्न के रूप में यहाँ भी यही समस्या सामने आई: 10,000 व्यंजनों में से, सामग्री के आधार पर लगभग 10 समूह तैयार किए गए थे। हालाँकि, इन समूहों में कुल मिलाकर लगभग 40,000 व्यंजन बने, जो वास्तविकता के अनुरूप नहीं थे। फिर हमने समानांतर प्रश्नों की ओर खुदाई शुरू की।

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

 /*   */ $params = config('elastic.params'); $params['body'] = config('elastic.top_list'); return (Elastic::getClient()->search($params))['aggregations']['tags']['buckets']; /*   */

उसके बाद, हमें मूल्यांकन करने की आवश्यकता है:

वर्तमान रचना के लिए कितने व्यंजन उपलब्ध हैं;
रचना में हम कौन सी अन्य सामग्री जोड़ सकते हैं (कभी-कभी हमने घटक जोड़ा और एक खाली नमूना मिला);
चयनित में से कौन सी सामग्री हम इस स्तर पर केवल लोगों के रूप में चिह्नित कर सकते हैं

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

 /*  */ "aggs" : { //      "tags" :{ //    "terms" :{ "field" : "ingredients.level_{{ level }}", "order" : {"_term" : "asc"}, "exclude" : [ {{#exclude}}{{ id }},{{/exclude}} 0] }, "aggs": { "reverse_nested": {} } //    ,    } } /*   */ foreach ($not_only as $element) { $parameters['body'][] = config('elastic.params'); $parameters['body'][] = self::getParamsBody( $body, collect($only->all())->push($element), $max_level, 0, 0 ); } /*   */ $parameters['body'][] = config('elastic.params'); $parameters['body'][] = self::getParamsBody( $body, $only, $max_level, $from, $size') ); /*     */ $parameters['max_concurrent_searches'] = 1 + $not_only->count(); return (Elastic::getClient()->msearchTemplate($parameters))['responses'];

नतीजतन, हमें एक अनुरोध मिला जो सभी आवश्यक व्यंजनों और उनकी कुल संख्या (यह प्रतिक्रिया ["हिट"] ["कुल"] से लिया गया था) पाता है। सादगी के लिए, यह अनुरोध सूची में अंतिम स्थान पर दर्ज किया गया था।

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

 { "from": {{ from }}, "size": {{ size }}, "query": { "bool": { "must": [ {{#ingredientTags}} {{#tagList}} {"bool": { "should": [ {"term": {"level_{{ levelId }}": {{ tagId }} }} ] }} {{^isLast}},{{/isLast}} {{/tagList}} {{/ingredientTags}} ], "filter": [ {"script":{ "script": " double nest=0,rest=0; for(ingredient in params._source. ingredients){ if([{{#tags}}{{tagId}}{{^isLast}},{{/isLast}}{{/tags}}].contains(ingredient.level_{{tags.0.levelId}})){ nest+= ingredient.percent; }else{ if (ingredient.percent>rest){ rest= ingredient.percent } } } return(nest>=rest); " }} {{#levelsList}}, {{#levels}} {"script": { "script": " int total=0; for(ingredient in params._source.ingredients){ if ([0,{{tag}}].contains(ingredient.level_{{id}})) total+=1; } return (total==params._source.ingredients.length); " }} {{^isLast}},{{/isLast}} {{/levels}} {{/levelsList}} ] } }, "aggs" : { "tags" :{ "terms" :{ "field" : "ingredients.level_{{ level }}", "order" : {"_term" : "asc"}, "exclude" : [ {{#exclude}}{{ id }},{{/exclude}} 0] }, "aggs": { "reverse_nested": {} } } }, "sort": [ {"_score": {"order": "desc"}} ] }

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

परियोजना के परिणाम

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

प्रदर्शन के मुद्दे पर, हम परियोजना की आवश्यकताओं को पूरा करते हैं, और हम खुद प्रसन्न हैं कि अनुरोध के लिए औसत प्रतिक्रिया समय 250-300 एमएस है।

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

"सभी बेहतरीन और मछली के लिए धन्यवाद!" (सी)

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

पूर्ण पाठ खोज: जटिल कार्यों के लिए एलिस्टिक्स-विशिष्ट विशेषताएं

More articles: