🛵 🧀 🏐 एक घड़ी का प्रबंधन कैसे करें? दूसरी प्रोग्रामिंग चैम्पियनशिप के फ्रंट-एंड ट्रैक का विश्लेषण 👧🏾 👨🏾‍🎓 🚶🏻

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

उ। इसे चिन्हित करें

^{लेखक: मैक्सिम सायसोव, कॉन्स्टेंटिन पेट्रीव}

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

शर्त

आपको एंटीमैटर के अध्ययन के लिए एक प्रयोगशाला में नौकरी मिली, जहां वे विभिन्न प्रयोग करते हैं। आपका विभाग उन प्रक्रियाओं का अध्ययन कर रहा है जो पदार्थ और एंटीमैटर को मिलाते समय होती हैं। आपको कुछ निश्चित अणुओं पर प्रयोगों की एक श्रृंखला आयोजित करने की आवश्यकता है।

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

- हम सबसे भारी अणुओं में से 2 पाते हैं।
- हम उनमें से एक को एंटीमैटर में बदल देते हैं।
- उन्हें मिलाएं। इसके अलावा, यदि वजन समान है, तो उनका सत्यानाश हो जाता है। यदि वजन अलग है, तो हमें एक नया अणु मिलता है, जिसका वजन पिछले दो के वजन में अंतर के बराबर है। परिणामी अणु ही पदार्थ है।
- अगर एक अणु बचा है, तो आपको उसका वजन पता करने की जरूरत है। यदि कई अणु हैं, तो हम चरण 1 पर लौटते हैं।

आपको प्रयोग के अंत में क्या वजन रहेगा, इसके अणु का पता लगाने की आवश्यकता है, इस ज्ञान की आवश्यकता दूसरे विभाग के वैज्ञानिकों को है।

पिछले डेवलपर ने इन गणनाओं में शामिल कोड को स्केच किया था, लेकिन बड़ी संख्या में अणुओं पर प्रयोग किए जाने पर कोड गणना समाप्त नहीं कर सकता है। आपको कोड को परिष्कृत करने की आवश्यकता है ताकि यह उचित समय पर काम करे।

कोड आपको विरासत में मिला है

इनपुट के रूप में, आपके पास आणविक भार के साथ एक सरणी होगी। आउटपुट के रूप में, आपको एक संख्या वापस करने की आवश्यकता है जो अंतिम अणु के वजन को इंगित करता है। यदि कोई अणु शेष नहीं हैं, तो 0 लौटना आवश्यक है।

var findLatestWeight = function(weights, i = weights.length - 1) { const cur = weights.length - 1 === i; if (i === 0) return weights[0]; weights.sort((a, b) => a - b); weights[i - 1] = (weights[i] === weights[i-1]) ? 0 : weights[i] - weights[i-1]; return findLatestWeight(weights, i - 1); }

उदाहरण और नोट्स

उदाहरण

प्रवेश: [2,7,4,1,8,1]
आउटपुट: १

हम अणुओं को 7 और 8 के वजन के साथ लेते हैं, 7 को एक एंटीमोलेक्यूल में बदल देते हैं और इसे वजन के अणु से टकराते हैं। वजन का एक अणु रहता है। 1. स्टील के शेष अणुओं का वजन [2,4,1,11,1]। हम 2 और 4 के वजन के साथ अणुओं को लेते हैं, 2 को एक एंटीमॉलेक्यूल में बदलते हैं और इसे 4 अणु के साथ टकराते हैं। वजन का एक अणु रहता है 2. स्टील के शेष अणुओं का वजन [2,1,1,1]। हम अणुओं को 2 और 1 के वजन के साथ लेते हैं, 1 को एक एंटीमॉलेक्यूल में बदल देते हैं और इसे 2 अणु के साथ टकराते हैं। वजन का एक अणु रहता है। स्टील के शेष अणुओं का वजन [1,1,1]। हम 1 और 1 के वजन के साथ अणुओं को लेते हैं, उनमें से एक को एक एंटीमॉलेक्यूल में बदल देते हैं और दूसरे के साथ टकराते हैं। उनका सर्वनाश हो जाता है। शेष अणुओं के वजन [1]। एक अणु बचा। परिणाम 1 है।

नोट

एक समाधान के रूप में, एक फ़ाइल प्रदान करें जो findLatestWeight फ़ंक्शन के सही संस्करण का निर्यात करती है:

 function findLatestWeight(weights) { // ... } module.exports = findLatestWeight;

समाधान Node.js 12 में चलेगा।

निर्णय

प्रदान किए गए "खराब" समाधान में एक साथ कई समस्याएं हैं। पहली पुनरावृत्ति है। जैसा कि स्थिति में कहा गया है, हम संख्याओं के बड़े सरणियों को संसाधित करेंगे, जो तुरंत एक पुनरावर्ती समाधान को समाप्त करता है।

 var findLatestWeight = function(weights) { let i = weights.length - 1; do { if (i === 0) return weights[0] || 0; weights.sort((a, b) => a - b); weights[i-1] = (weights[i]=== weights[i-1]) ? 0 : weights[i]-weights[i-1]; i--; } while (true); }

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

इस समस्या को हल करने का एक विकल्प यह है कि आप सरणी को लगातार ट्रिम करें।

 var findLatestWeight = function(weights) { let i = weights.length - 1; do { if (i === 0) return weights[0] || 0; weights.sort((a, b) => a - b); weights[i-1] = (weights[i]=== weights[i-1]) ? 0 : weights[i]-weights[i-1]; weights.length = i; // <---   i--; } while (true); }

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

 const maximumTwo = (arr) => { let max1 = arr[0]; let max2 = arr[1]; let max1I = 0; let max2I = 1; for(let i = 2; i < arr.length; i++) { if (arr[i] > max1) { if (max1 > max2) { max2 = arr[i]; max2I = i; } else { max1 = arr[i]; max1I = i; } } else if (arr[i] > max2) { max2 = arr[i]; max2I = i; } } if (max1 > max2) return [max2, max1, max2I, max1I]; return [max1, max2, max1I, max2I]; };

और हम खोज फ़ंक्शन को निम्नानुसार बदलते हैं:

 const fn = function(weights) { if (weights.length <= 1) { return weights[0]; } do { const [x, y, xI, yI] = maximumTwo(weights); if (x === 0) { return y; } weights[xI] = 0; weights[yI] = y - x; } while(true); };

इस प्रकार, हम हमेशा दो तत्वों में से छोटे को शून्य करेंगे, और बड़े को उनके बीच के अंतर में बदल देंगे। हमें छँटाई से छुटकारा मिला और इसके बदले एक रैखिक पास मिला।

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

B BEM

^{लेखक: यूजीन मिशेंको , व्लादिमीर ग्रिनेंको तदातुता}

शर्त

लेआउट अलेक्जेंडर बीईएम पद्धति का उपयोग करके कई परियोजनाओं में शामिल है। यहां तक कि उन्होंने अपने पसंदीदा आईडीई के लिए एक आसान प्लगइन बनाया, जो उन्हें संक्षिप्त नामकरण में वर्ग के नाम लिखने और उन्हें पूर्ण परिनियोजित करने की अनुमति देता है। लेकिन समस्या यह है कि प्रत्येक परियोजना के लिए, लोग ब्लॉक, तत्व और संशोधक (block__mod__val - elem, block - mod - val ___ elem) के बीच अलग-अलग सीमांकक सेट करते हैं, और हर बार उसे अपने प्लगइन में मैन्युअल रूप से इसे संपादित करना होता है। अलेक्जेंडर को एक मॉड्यूल लिखने में मदद करें जो वर्ग के आधार पर संस्थाओं के लिए विभाजक का निर्धारण करेगा। परिसीमन के लिए नियम वर्णों की एक मनमानी संख्या है (अक्षर नहीं)। संभावित नोटेशन के उदाहरण (इनपुट डेटा में एक ब्लॉक के लिए संशोधक बिना मूल्य के हो सकते हैं):

 block_mod__elem // ,     block_mod_mod__elem block__elem_mod_mod

शोधन:
- परियोजनाओं में कक्षाएं केवल छोटे अक्षरों में लिखी जाती हैं।
- एक वैध सीएसएस वर्ग के साथ एक स्ट्रिंग मॉड्यूल के इनपुट को खिलाया जाता है।

मॉड्यूल को फॉर्म की प्रतिक्रिया वापस करनी चाहिए:

 { mod: "_", //    elem: "__", //    }

मॉड्यूल को एक सामान्यJS मॉड्यूल के रूप में जारी किया जाना चाहिए:

 module.exports = function(str) { }

निर्णय

दूसरे कार्य में लगभग 20 मिनट लगे। इसकी मदद से, हम प्रतिभागियों के बीच नियमित भावों के ज्ञान का परीक्षण करना चाहते थे।

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

वर्ग नाम का पहला भाग हमेशा ब्लॉक का नाम होगा। यह एक या एक से अधिक अक्षरों का क्रम है। हम इसी नियमित अभिव्यक्ति को लिखते हैं: [az] +।

हमें शेष भागों की खोज करने के लिए समान अभिव्यक्तियों की आवश्यकता होगी: संशोधक का नाम और उसका मूल्य या तत्संबंधी तत्व और उसके नाम के साथ तत्व का नाम।

सीमांकक की खोज करने के लिए, हमें गैर-अक्षर अनुक्रम की आवश्यकता होती है, अभिव्यक्ति: [^ az] + उपयुक्त है।

इसे एक साथ रखें और उन समूहों को परिभाषित करें जिनके मूल्य हम उपयोग करेंगे:

 let [, mod, elem ] = str.match(/[az]+(?:([^az]+)[az]+(?:\1)?[az]+)([^az]+)[az]+(?:\2)?[az]+/);

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

हम एक फ़ंक्शन लिखेंगे जो मूल स्ट्रिंग और विभाजक को ले जाएगा जो कि घटनाओं की संख्या की गणना करने के लिए पाया जाता है:

 const substringCount = (source, substr) => (source.match(new RegExp('[az]' + substr + '[az]', 'g')) || []).length;

यदि यह पता चला है कि सीमांकक दो बार होता है, और मॉड - एक बार, तो वास्तव में विपरीत सच है। अंतिम निर्णय:

 module.exports = function(str) { let [, mod, elem ] = str.match(/[az]+(?:([^az]+)[az]+(?:\1)?[az]+)([^az]+)[az]+(?:\2)?[az]+/); const substringCount = (source, substr) => (source.match(new RegExp('[az]' + substr + '[az]', 'g')) || []).length; if (substringCount(str, elem) === 2 && substringCount(str, mod) === 1) { [mod, elem] = [elem, mod]; } return { mod, elem }; }

सी। क्लोन फैक्ट्री

^{लेखक: दिमित्री एंड्रियानोव dima117 , एलेक्सी गुसेव}

शर्त

खिड़की के बाहर 2319 है। निगम जटिल कार्यों को करने के लिए सफल कर्मचारियों को क्लोन करता है।

क्लोन के उत्पादन में, उन्होंने नए "उत्पादों" को अपने कंधे पर एक बारकोड टैटू के साथ लेबल करने का फैसला किया - क्लोन को एक दूसरे से अलग करने के लिए।

कारखाने के कर्मचारियों को एक फ़ंक्शन लिखने में मदद करें जो क्लोन के बारे में जानकारी के साथ एक बारकोड आकर्षित करेगा।

क्लोन सूचना प्रारूप

क्लोन के बारे में जानकारी निम्नानुसार संग्रहीत है:

 type CloneInfo = { /** *   —  'male'  'female' */ sex: string; /** *   —      *    ,  10  */ id: string; /** *   —      *     ( 0  26 ) */ name: string; }

बारकोड प्रतिपादन एल्गोरिथम

क्लोन फैक्ट्री में इस्तेमाल होने वाले बारकोड इस तरह दिखते हैं:

बारकोड का एक निश्चित आकार है - 148 बाय 156 पिक्सेल। बारकोड की परिधि के चारों ओर 3 पिक्सेल के काले और सफेद फ्रेम हैं। फ़्रेम के अंदर बारकोड सामग्री है, जिसमें प्रति पंक्ति 17 काले या सफेद वर्गों की 18 लाइनें शामिल हैं। प्रत्येक वर्ग का आकार 8 से 8 पिक्सेल है।

सामग्री में सफेद वर्ग 0, काले - 1 सांकेतिक शब्दों में बदलना।

बारकोड कंटेंट जेनरेशन एल्गोरिथम

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

इसके अलावा, प्रपत्र की एक पंक्ति <id> <name> फ़ील्ड आईडी और नाम से बनाई गई है। नाम फ़ील्ड 26 वर्णों के अंत में रिक्त स्थान के साथ गद्देदार है।

परिणामस्वरूप स्ट्रिंग को बाइट सरणी में बदल दिया जाता है - स्ट्रिंग के प्रत्येक वर्ण को संबंधित ASCII कोड (0 से 255 तक की संख्या) निर्दिष्ट किया जाता है।

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

सामग्री की अंतिम पंक्ति में नियंत्रण जानकारी होती है।

नियंत्रण सूचना गणना एल्गोरिथ्म

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

समाधान प्रारूप और उदाहरण

समाधान प्रारूप

आपके द्वारा लोड किए जाने वाले समाधान में रेंडर बारकोड फ़ंक्शन होना चाहिए:

 /** *       element * @param cloneInfo {CloneInfo} —    * @param element {HTMLDivElement} — div    * 148x156 ,      */ function renderBarcode(cloneInfo, element) { //   }</source lang="javascript">      Google Chrome 77. <h4> 1</h4>   : <source lang="javascript">{ "sex": "male", "id": "c5j818dyo5", "name": "Oleg Vladimirovich" }

बारकोड:

उदाहरण 2

क्लोन जानकारी:

 { "sex": "female", "id": "0owrgqqwfw", "name": "Dazdraperma Petrovna" }

बारकोड:

निर्णय

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

आइए बाइनरी प्रतिनिधित्व के साथ शुरू करें। सबसे पहले, सहायक कार्यों की घोषणा करें:

 //    ASCII- function charToByte(char) { return char.charCodeAt(0); } //      0  1 (      ) function byteToString(byte) { return byte.toString(2).padStart(8, '0'); }

हम स्रोत डेटा से एक स्ट्रिंग बनाते हैं जिसमें शून्य और अन्य शामिल हैं:

 let dataString = (cloneInfo.sex === 'female' ? '0' : '1') + cloneInfo.id.split('').map(charToByte).map(byteToString).join('') + cloneInfo.name.padEnd(26, ' ').split('').map(charToByte).map(byteToString).join('');

फिर हमारे बारकोड के लिए लेआउट और शैलियों को लिखें:

 //   ,    «» . //  ,      DOM API   innerHTML,     . //     ,      ,      «». //         —   ,        . const contentElId = 'content-' + Math.random(); element.style.display = 'flex'; element.innerHTML = ` <style> .barcode { border: 3px solid black; box-sizing: border-box; } .content { margin-top: 3px; margin-left: 3px; width: 136px; height: 144px; display: flex; flex-wrap: wrap; } .content__bit { width: 8px; height: 8px; } .content__bit_one { background: black; } </style> <div class="content" id="${contentElId}"></div> `; const contentDiv = document.getElementById(contentElId); element.className += ' barcode';

लेआउट में रेंडर बाइनरी डेटा:

 dataString .split('') .forEach((bit) => { const bitDiv = document.createElement('div'); bitDiv.className = 'content__bit content__bit_' + (bit === '0' ? 'zero' : 'one'); contentDiv.appendChild(bitDiv); });

यह चेकसम की गणना और प्रदर्शित करने के लिए रहता है। इसे इस तरह किया जा सकता है:

 for (let i = 0; i < 17; i++) { //   let sum = 0; for (let j = i; j < 17 ** 2; j += 17) { sum += parseInt(dataString[j], 2); } const check = 0; const bitDiv = document.createElement('div'); //       bitDiv.className = 'content__bit content__bit_' + (sum % 2 === 0 ? 'zero' : 'one'); contentDiv.appendChild(bitDiv); }

D. इसे स्वचालित करें

^{लेखक: व्लादिमीर रुसोव, दिमित्री कनाटनिकोव}

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

शर्त

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

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

आपको एक फ़ंक्शन लिखने की ज़रूरत है जो एक HTML तालिका को इनपुट के रूप में लेता है और इसे मार्कडाउन-जैसे मार्कअप में परिवर्तित करता है।

इस कार्य के समाधान के रूप में .js फ़ाइल भेजें जिसमें समाधान फ़ंक्शन घोषित किया गया है:

 function solution(input) { // ... }

इनपुट / आउटपुट प्रारूप और नोट्स

इनपुट प्रारूप

HTML तालिका एक स्ट्रिंग के रूप में आती है:

 <table> <colgroup> <col align="right" /> <col /> <col align="center" /> </colgroup> <thead> <tr> <td>Command </td> <td>Description </td> <th>Is implemented </th> </tr> </thead> <tbody> <tr> <th>git status</th> <td>List all new or modified files</td> <th>Yes</th> </tr> <tr> <th>git diff</th> <td>Show file differences that haven't been staged</td> <td>No</td> </tr> </tbody> </table>

तालिका में एक निश्चित क्रम में कोलग्रुप, थ्रेड और tbody टैग हो सकते हैं। ये सभी टैग वैकल्पिक हैं, लेकिन कम से कम थ्रेड या tbody हमेशा मौजूद रहेंगे।

- कोलग्रुप में ऐसे कोल टैग होते हैं जिनमें तीन में से एक मान के साथ वैकल्पिक संरेखित विशेषता हो सकती है (बाएं | केंद्र | दायां |
- thead और tbody में 1 या अधिक tr होते हैं
- tr, बदले में, td और th दोनों होते हैं
- तालिका में हमेशा कम से कम एक पंक्ति होगी। - पंक्ति में हमेशा कम से कम एक सेल होगा। - सेल में कम से कम एक गैर-व्हाट्सएप प्रतीक हमेशा मौजूद होता है।
- लाइनों में वें / td तत्वों की संख्या हमेशा सभी लाइनों के बीच और कोलग्रुप में कोल तत्वों की संख्या के बीच मेल खाती है, अगर कोलग्रुप है।
- स्रोत HTML में स्पेस और लाइन ब्रेक कहीं भी हो सकता है जो HTML की वैधता का उल्लंघन नहीं करता है।

आउटपुट स्वरूप

आउटपुट मार्कडाउन मार्कअप के साथ एक पंक्ति होनी चाहिए:

| Command | Description | **Is implemented** |
| ---: | :--- | :---: |
| **git status** | List all new or modified files | **Yes** |
| **git diff** | Show file differences that haven't been staged | No |

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

| : --- | का अर्थ है बाएं संरेखण
| : ---: | केंद्र संरेखण का मतलब है
| ---: | सही संरेखण का मतलब है

यदि कॉल टैग में कोई संरेखित विशेषता निर्दिष्ट नहीं है, तो संरेखण को बाईं ओर सेट किया जाना चाहिए।

नोट

- लाइन फ़ीड के लिए आपको \ n वर्ण का उपयोग करने की आवश्यकता होती है।
- समाधान को दस्तावेज़ और विंडो ऑब्जेक्ट तक पहुंच के साथ एक ब्राउज़र वातावरण (क्रोम 78) में परीक्षण किया जाएगा।
- आप वाक्यविन्यास का उपयोग es2018 समावेशी तक कर सकते हैं।

निर्णय

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

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

सबसे पहले, हमें स्ट्रिंग को HTML से DOM ट्री में बदलने की आवश्यकता है:

 const div = document.createElement('div'); div.innerHTML = input; const table = div.firstChild;

DOM ट्री प्राप्त करने के बाद, हम बस इसके माध्यम से जा सकते हैं और विभिन्न DOM नोड्स से डेटा प्रोसेस कर सकते हैं। ऐसा करने के लिए, यह विभिन्न DOM तत्वों के बच्चों के अनुक्रम को पुनरावृत्ति करने के लिए पर्याप्त है:

 const processors = { 'colgroup': processColgroup, 'thead': processThead, 'tbody': processTbody, }; for (let child of table.children) { processors[child.tagName.toLowerCase()](child); }

Colgroup और col टैग्स से, हम टेबल कॉलम के संरेखण को जानने में रुचि रखते हैं:

 const alignments = []; const defaultAlign = 'left'; const processColgroup = (colgroup) => { alignments.push(...Array(...colgroup.children).map(col => { return col.align || defaultAlign; })); };

थ्रेड, tbody और tr टैग्स में, हम केवल बच्चों में रुचि रखते हैं:

 const rows = []; const processThead = (thead) => { rows.push(...Array(...thead.children).map(processTr)); }; const processTbody = (tbody) => { rows.push(...Array(...tbody.children).map(processTr)); }; const processTr = (tr) => { return Array(...tr.children).map(processCell); };

यह महत्वपूर्ण है कि यह न भूलें कि, कन्वेंशन द्वारा, td और th को अलग-अलग स्वरूपित किया जाता है:

 const processCell = (cell) => { const tag = cell.tagName.toLowerCase(); const content = clearString(cell.innerHTML); return { 'td': content, 'th': `**${content}**`, }[tag]; };

DOM के परीक्षण सामग्री के साथ काम करने के लिए, आपको शर्त में वर्णित आवश्यकताओं को पूरा करना होगा:

 const clearLineBreaks = (str) => str.replace(/\r?\n|\r/g, ''); const clearSpaces = (str) => str.replace(/\s+/g, ' '); const clearString = (str) => clearSpaces(clearLineBreaks(str)).trim();

डोम ट्री के चारों ओर घूमने के बाद, हमारी मेज के बड़े हिस्से को पंक्तियों के लिए लिखा गया था:

[
["Command","Description","**Is implemented**"],
["**git status**","List all new or modified files","**Yes**"],
["**git diff**","Show file differences that haven't been staged","No"]
]

कॉलम संरेखण जानकारी संरेखण सरणी में थी:

["right","left","center"]

यह याद रखना महत्वपूर्ण है कि कॉलम संरेखण जानकारी इनपुट में नहीं हो सकती है:

 const updateAlignments = () => { if (alignments.length > 0) return; alignments.push(...rows[0].map(x => defaultAlign)); }; updateAlignments();

संरेखण को अंतिम रूप में बदलें:

 const alignmentsContents = alignments.map(align => { return { 'left': ' :--- ', 'center': ' :---: ', 'right': ' ---: ' }[align]; }); const delimiter = `|${alignmentsContents.join('|')}|`;

उदाहरण सीमांकक मान:

"| ---: | :--- | :---: |"

अंतिम चरण एक मार्कडाउन लाइन का निर्माण होगा जिसमें HTML से पढ़े गए सभी डेटा होंगे:

 const lineEnd = '\n'; rows.forEach((row, i) => { if (i > 0) markdown += lineEnd; const mdRow = `| ${row.join(' | ')} |`; markdown += mdRow; if (i === 0) { markdown += lineEnd; markdown += delimiter; } }); return markdown;

वापसी निर्माण का मतलब है कि उपरोक्त सभी कोड समाधान (इनपुट) फ़ंक्शन का निकाय था। इस फ़ंक्शन के परिणामस्वरूप, हमें कार्य स्थिति से उदाहरण आउटपुट में वांछित मार्कडाउन तालिका कोड प्राप्त होता है।

ई। महामारी वायरस

^{लेखक: एंड्री मोख्रुसेव, इवान पेटुखोव}

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

रिपोर्ट में उल्लेख किया गया है कि Zyn फ़ंक्शन कॉल के तर्क द्वारा पारित फ़ंक्शन के पहले तर्क के उपयोग को देखकर वायरस सक्रिय हो जाता है, अर्थात, संक्रमित व्यक्ति Zyn (फ़ंक्शन (a, b, c) {कंसोल .log (a)}) जैसी अभिव्यक्ति नहीं दिखा सकता है।

गलती से अपने सभी फ्रंट-एंड को खोने के लिए नहीं, एएसटी एंड कंपनी ने यह जांचने का फैसला किया कि क्या उनके कोड में उपरोक्त अभिव्यक्ति है। कंपनी के इंजीनियरों को ऐसा चेक लिखने में मदद करें।

एएसटी एंड कंपनी के कोड के बारे में, हम जानते हैं कि:

- यह ES3 में लिखा गया है,
- एक बिंदु के माध्यम से और कोष्ठक (अब और ['बी']) के माध्यम से किसी वस्तु के गुणों तक पहुंच संभव है,
- अभिव्यक्ति का हिस्सा एक चर में संग्रहित किया जा सकता है, लेकिन इसे पैरामीटर (ए (एक्स) - निषिद्ध) द्वारा फ़ंक्शन को कभी नहीं पारित किया जाता है,
- कोई कार्य नहीं हैं जो वांछित अभिव्यक्ति का हिस्सा लौटाते हैं,
— , ,
— (a[x], x — ),
— , . . var a = x; a = y; var a = b = 1.

समाधान प्रारूप

CommonJS-, , (ast) .

ast-, callback-, Zyn , .

 module.exports = function (ast) { ... return [...]; }

नोट

 /** *   .     , *   callback- onNodeEnter (  ) *  onNodeLeave (  )    *     (  Scope ). * * @param {object} ast  ast. * @param {Function} [onNodeEnter=(node, scope)=>{}]       . * @param {Function} [onNodeLeave=(node, scope)=>{}]       . */ function traverse( ast, onNodeEnter = (node, scope) => {}, onNodeLeave = (node, scope) => {} ) { const rootScope = new Scope(ast); _inner(ast, rootScope); /** *    . *     scope,   . * * @param {object} astNode ast-. * @param {Scope} currentScope   . * @return {Scope}      astNode. */ function resolveScope(astNode, currentScope) { let isFunctionExpression = ast.type === 'FunctionExpression', isFunctionDeclaration = ast.type === 'FunctionDeclaration'; if (!isFunctionExpression && !isFunctionDeclaration) { //      . return currentScope; } //      . const newScope = new Scope(ast, currentScope); ast.params.forEach(param => { //     . newScope.add(param.name); }); if (isFunctionDeclaration) { //       . currentScope.add(ast.id.name); } else { //  -    . newScope.add(ast.id.name); } return newScope; } /** *    ast. * * @param {object} astNode  ast-. * @param {Scope} scope     ast-. */ function _inner(astNode, scope) { if (Array.isArray(astNode)) { astNode.forEach(node => { /*    . *  , ,  . */ _inner(node, scope); }); } else if (astNode && typeof astNode === 'object') { onNodeEnter(astNode, scope); const innerScope = resolveScope(astNode, scope), keys = Object.keys(astNode).filter(key => { // loc -  ,   ast-. return key !== 'loc' && astNode[key] && typeof astNode[key] === 'object'; }); keys.forEach(key => { //   . _inner(astNode[key], innerScope); }); onNodeLeave(astNode, scope); } } } /** *   . * * @class Scope (name) * @param {object} astNode ast-,    . * @param {object} parentScope   . */ function Scope(astNode, parentScope) { this._node = astNode; this._parent = parentScope; this._vars = new Set(); } Scope.prototype = { /** *      . * * @param {string} name  . */ add(name) { this._vars.add(name); }, /** *       . * * @param {string} name  . * @return {boolean}          . */ isDefined(name) { return this._vars.has(name) || (this._parent && this._parent.isDefined(name)); } };

निर्णय

— ES3

, . , .

— , (ab a['b'])

Zyn, Z['y'].n, Zy['n'] Z['y']['n'].

, (a(x) — )

, . , : var x = Zy; xn(...).

— , ,
— , ,
— , .. var a = x; a = y; var a = b = 1.

( ) , - .

— , (a[x], x — )

, : var x = 'y'; Z[x].n(...).

C :
1. , , .
2. , .

, , — . 2.

: Zyn(function(a, b, c){...}), — .

FunctionExpression — CallExpression, callee — MemberExpression. property — n, object ( MemberExpression object property y) — Z.

, — — . — Identifier , MemberExpression ObjectLiteral (xa var x = {a: ...} ).

 +++ b/traverse.js @@ -120,3 +120,59 @@ Scope.prototype = { return this._vars.has(name) || (this._parent && this._parent.isDefined(name)); } }; + +module.exports = function (ast) { + var result = []; + + traverse(ast, (node, scope) => { + if (node.type !== 'CallExpression') { + return; + } + let args = node.arguments; + if (args.length !== 1 || + args[0].type !== 'FunctionExpression') { + return; + } + let callee = node.callee; + if (callee.type !== 'MemberExpression') { + return; + } + let property = callee.property, + object = callee.object; + if (property.name !== 'n') { + return; + } + if (object.type !== 'MemberExpression') { + return; + } + property = object.property; + object = object.object; + if (property.name !== 'y') { + return; + } + if (object.type !== 'Identifier' || + object.name !== 'Z') { + return; + } + + checkFunction(args[0]); + }); + + function checkFunction(ast) { + let firstArg = ast.params[0]; + if (!firstArg) { + return; + } + + traverse(ast.body, (node, scope) => { + if (node.type !== 'Identifier') { + return; + } + if (node.name === firstArg.name) { + result.push(node); + } + }); + } + + return result; +};

traverse , , MemberExpression ObjectProperty. :

 --- a/traverse.js +++ b/traverse.js @@ -60,16 +60,16 @@ function traverse( * @param {object} astNode  ast- * @param {Scope} scope     ast- */ - function _inner(astNode, scope) { + function _inner(astNode, scope, parent) { if (Array.isArray(astNode)) { astNode.forEach(node => { /*    . *  , ,   */ - _inner(node, scope); + _inner(node, scope, parent); }); } else if (astNode && typeof astNode === 'object') { - onNodeEnter(astNode, scope); + onNodeEnter(astNode, scope, parent); const innerScope = resolveScope(astNode, scope), keys = Object.keys(astNode).filter(key => { @@ -80,10 +80,10 @@ function traverse( keys.forEach(key => { //    - _inner(astNode[key], innerScope); + _inner(astNode[key], innerScope, astNode); }); - onNodeLeave(astNode, scope); + onNodeLeave(astNode, scope, parent); } } } @@ -164,10 +164,22 @@ module.exports = function (ast) { return; } - traverse(ast.body, (node, scope) => { + traverse(ast.body, (node, scope, parent) => { if (node.type !== 'Identifier') { return; } + if (!parent) { + return; + } + if (parent.type === 'MemberExpression' && + parent.computed === false && + parent.property === node) { + return; + } + if (parent.type === 'ObjectProperty' && + parent.key === node) { + return; + } if (node.name === firstArg.name) { result.push(node); }

. getPropName:

 --- a/traverse.js +++ b/traverse.js @@ -121,6 +121,18 @@ Scope.prototype = { } }; +function getPropName(node) { + let prop = node.property; + + if (!node.computed) { + return prop.name; + } + + if (prop.type === 'StringLiteral') { + return prop.value; + } +} + module.exports = function (ast) { var result = []; @@ -137,17 +149,17 @@ module.exports = function (ast) { if (callee.type !== 'MemberExpression') { return; } - let property = callee.property, + let property = getPropName(callee), object = callee.object; - if (property.name !== 'n') { + if (property !== 'n') { return; } if (object.type !== 'MemberExpression') { return; } - property = object.property; + property = getPropName(object); object = object.object; - if (property.name !== 'y') { + if (property !== 'y') { return; } if (object.type !== 'Identifier' ||

: . . 1.

Scope

Scope . , , traverse:

 --- a/traverse.js +++ b/traverse.js @@ -1,3 +1,12 @@ +const scopeStorage = new Map(); + +function getScopeFor(ast, outerScope) { + if (!scopeStorage.has(ast)) { + scopeStorage.set(ast, new Scope(ast, outerScope)); + } + + return scopeStorage.get(ast); +} /** *   .     , *   callback- onNodeEnter (  ). @@ -13,7 +22,7 @@ function traverse( onNodeEnter = (node, scope) => {}, onNodeLeave = (node, scope) => {} ) { - const rootScope = new Scope(ast); + const rootScope = getScopeFor(ast); _inner(ast, rootScope); @@ -36,19 +45,19 @@ function traverse( } //      . - const newScope = new Scope(ast, currentScope); + const newScope = getScopeFor(ast, currentScope); ast.params.forEach(param => { //     . - newScope.add(param.name); + newScope.add(param.name, param); }); if (isFunctionDeclaration) { //       . - currentScope.add(ast.id.name); + currentScope.add(ast.id.name, ast); } else if (ast.id) { //  -    . - newScope.add(ast.id.name); + newScope.add(ast.id.name, ast); } return newScope; @@ -98,7 +107,7 @@ function traverse( function Scope(astNode, parentScope) { this._node = astNode; this._parent = parentScope; - this._vars = new Set(); + this._vars = new Map(); } Scope.prototype = { @@ -107,8 +116,24 @@ Scope.prototype = { * * @param {string} name   */ - add(name) { - this._vars.add(name); + add(name, value) { + this._vars.set(name, { + value: value, + scope: this + }); + }, + resolve(node) { + if (!node) { + return node; + } + if (node.type === 'Identifier') { + let value = this._vars.get(node.name); + if (value) { + return value; + } + value = (this._parent && this._parent.resolve(node)); + return value; + } }, /** *       . @@ -136,6 +161,12 @@ function getPropName(node) { module.exports = function (ast) { var result = []; + traverse(ast, (node, scope) => { + if (node.type === 'VariableDeclarator') { + scope.add(node.id.name, node.init); + } + }); + traverse(ast, (node, scope) => { if (node.type !== 'CallExpression') { return;

Scope

. , Scope . , Scope , :

 --- a/traverse.js +++ b/traverse.js @@ -146,13 +146,17 @@ Scope.prototype = { } }; -function getPropName(node) { +function getPropName(node, scope) { let prop = node.property; if (!node.computed) { return prop.name; } + let resolved = scope.resolve(prop); + if (resolved) { + prop = resolved.value; + } if (prop.type === 'StringLiteral') { return prop.value; } @@ -177,22 +181,43 @@ module.exports = function (ast) { return; } let callee = node.callee; + + let resolved = scope.resolve(callee); + if (resolved) { + callee = resolved.value; + scope = resolved.scope; + } + if (callee.type !== 'MemberExpression') { return; } - let property = getPropName(callee), + let property = getPropName(callee, scope), object = callee.object; if (property !== 'n') { return; } + + resolved = scope.resolve(object); + if (resolved) { + object = resolved.value; + scope = resolved.scope; + } + if (object.type !== 'MemberExpression') { return; } - property = getPropName(object); + property = getPropName(object, scope); object = object.object; if (property !== 'y') { return; } + + resolved = scope.resolve(object); + if (resolved) { + object = resolved.value; + scope = resolved.scope; + } + if (object.type !== 'Identifier' || object.name !== 'Z') { return;

: . :

— , Z — , - .
— , , .
— , var a = 'x', b = a.

, .

 --- a/traverse.js +++ b/traverse.js @@ -128,10 +128,23 @@ Scope.prototype = { } if (node.type === 'Identifier') { let value = this._vars.get(node.name); - if (value) { - return value; + if (!value) { + if (this._parent) { + value = this._parent.resolve(node); + } else { + //   scope,  node — + //   . + this.add(node.name, node); + return this.resolve(node); + } + } + if (!value) { + return; + } + if (value.value.type === 'Identifier' && + value.value !== node) { + return value.scope.resolve(value.value) || value; } - value = (this._parent && this._parent.resolve(node)); return value; } }, @@ -165,12 +178,15 @@ function getPropName(node, scope) { module.exports = function (ast) { var result = []; + traverse(ast, (node, scope) => { if (node.type === 'VariableDeclarator') { scope.add(node.id.name, node.init); } }); + let rootScope = getScopeFor(ast); + traverse(ast, (node, scope) => { if (node.type !== 'CallExpression') { return; @@ -213,9 +229,10 @@ module.exports = function (ast) { } resolved = scope.resolve(object); + let zScope; if (resolved) { object = resolved.value; - scope = resolved.scope; + zScope = resolved.scope; } if (object.type !== 'Identifier' || @@ -223,6 +240,10 @@ module.exports = function (ast) { return; } + if (zScope && zScope !== rootScope) { + return; + } + checkFunction(args[0]); }); @@ -232,7 +253,10 @@ module.exports = function (ast) { return; } - traverse(ast.body, (node, scope, parent) => { + traverse(ast, (node, scope, parent) => { + if (parent === ast) { + return; + } if (node.type !== 'Identifier') { return; } @@ -248,7 +272,9 @@ module.exports = function (ast) { parent.key === node) { return; } - if (node.name === firstArg.name) { + + let resolved = scope.resolve(node); + if (resolved && resolved.value === firstArg) { result.push(node); } });

 const scopeStorage = new Map(); function getScopeFor(ast, outerScope) { if (!scopeStorage.has(ast)) { scopeStorage.set(ast, new Scope(ast, outerScope)); } return scopeStorage.get(ast); } /** *   .     , *  callback- onNodeEnter (  ) *  onNodeLeave (  )    *     (  Scope ) * * @param {object} ast  ast * @param {Function} [onNodeEnter=(node, scope)=>{}]        * @param {Function} [onNodeLeave=(node, scope)=>{}]        */ function traverse( ast, onNodeEnter = (node, scope) => {}, onNodeLeave = (node, scope) => {} ) { const rootScope = getScopeFor(ast); _inner(ast, rootScope); /** *    . *     scope,    * * @param {object} ast ast- * @param {Scope} currentScope    * @return {Scope}      astNode */ function resolveScope(ast, currentScope) { let isFunctionExpression = ast.type === 'FunctionExpression', isFunctionDeclaration = ast.type === 'FunctionDeclaration'; if (!isFunctionExpression && !isFunctionDeclaration) { //       return currentScope; } //       const newScope = getScopeFor(ast, currentScope); ast.params.forEach(param => { //      newScope.add(param.name, param); }); if (isFunctionDeclaration) { //        currentScope.add(ast.id.name, ast); } else if (ast.id) { //  -     newScope.add(ast.id.name, ast); } return newScope; } /** *    ast * * @param {object} astNode  ast- * @param {Scope} scope     ast- */ function _inner(astNode, scope, parent) { if (Array.isArray(astNode)) { astNode.forEach(node => { /*    . *  , ,   */ _inner(node, scope, parent); }); } else if (astNode && typeof astNode === 'object') { onNodeEnter(astNode, scope, parent); const innerScope = resolveScope(astNode, scope), keys = Object.keys(astNode).filter(key => { // loc -  ,   ast- return key !== 'loc' && astNode[key] && typeof astNode[key] === 'object'; }); keys.forEach(key => { //    _inner(astNode[key], innerScope, astNode); }); onNodeLeave(astNode, scope, parent); } } } /** *    * * @class Scope (name) * @param {object} astNode ast-,     * @param {object} parentScope    */ function Scope(astNode, parentScope) { this._node = astNode; this._parent = parentScope; this._vars = new Map(); } Scope.prototype = { /** *       * * @param {string} name   */ add(name, value) { this._vars.set(name, { value: value, scope: this }); }, resolve(node) { if (!node) { return node; } if (node.type === 'Identifier') { let value = this._vars.get(node.name); if (!value) { if (this._parent) { value = this._parent.resolve(node); } else { //   scope,  node - //    this.add(node.name, node); return this.resolve(node); } } if (!value) { return; } if (value.value.type === 'Identifier' && value.value !== node) { return value.scope.resolve(value.value) || value; } return value; } }, /** *       . * * @param {string} name   * @return {boolean}           */ isDefined(name) { return this._vars.has(name) || (this._parent && this._parent.isDefined(name)); } }; function getPropName(node, scope) { let prop = node.property; if (!node.computed) { return prop.name; } let resolved = scope.resolve(prop); if (resolved) { prop = resolved.value; } if (prop.type === 'StringLiteral') { return prop.value; } } module.exports = function (ast) { var result = []; traverse(ast, (node, scope) => { if (node.type === 'VariableDeclarator') { scope.add(node.id.name, node.init); } }); let rootScope = getScopeFor(ast); traverse(ast, (node, scope) => { if (node.type !== 'CallExpression') { return; } let args = node.arguments; if (args.length !== 1 || args[0].type !== 'FunctionExpression') { return; } let callee = node.callee; let resolved = scope.resolve(callee); if (resolved) { callee = resolved.value; scope = resolved.scope; } if (callee.type !== 'MemberExpression') { return; } let property = getPropName(callee, scope), object = callee.object; if (property !== 'n') { return; } resolved = scope.resolve(object); if (resolved) { object = resolved.value; scope = resolved.scope; } if (object.type !== 'MemberExpression') { return; } property = getPropName(object, scope); object = object.object; if (property !== 'y') { return; } resolved = scope.resolve(object); let zScope; if (resolved) { object = resolved.value; zScope = resolved.scope; } if (object.type !== 'Identifier' || object.name !== 'Z') { return; } if (zScope && zScope !== rootScope) { return; } checkFunction(args[0]); }); function checkFunction(ast) { let firstArg = ast.params[0]; if (!firstArg) { return; } traverse(ast, (node, scope, parent) => { if (parent === ast) { return; } if (node.type !== 'Identifier') { return; } if (!parent) { return; } if (parent.type === 'MemberExpression' && parent.computed === false && parent.property === node) { return; } if (parent.type === 'ObjectProperty' && parent.key === node) { return; } let resolved = scope.resolve(node); if (resolved && resolved.value === firstArg) { result.push(node); } }); } return result; };

F. Framework-

^{: , collapsus}

API. — , . .

— . . , . !

. , . , , , ( ). , , 0 (0 , 0 , 0 ).

, , . JavaScript JS- Framework.

: , . ( , ). () . ( ).

0. , ( time) .

 const ONE_SECOND_DEGREES = 6; const ONE_SECOND_FACTOR = 1 / Framework.SPEED * ONE_SECOND_DEGREES; class MyClock extends Framework.Clock { constructor() { super(); this.arrows.push(new Framework.Arrow("seconds", { color: "red" })); this.arrows.push(new Framework.Arrow("minutes", { weight: 3, length: 80 })); this.arrows.push(new Framework.Arrow("hours", { weight: 3, length: 60 })); this.buttons.push(new Framework.Button("A", () => { alert("A"); })); this.tick = 0; } onBeforeTick() { const [arrow] = this.arrows; this.tick++; arrow.rotateFactor = this.tick % 10 ? 0 : ONE_SECOND_FACTOR; console.log("before: " + arrow.pos); } onAfterTick() { const [arrow] = this.arrows; console.log("after: " + arrow.pos); } }

:
— — , ,
— ,
— , ; (100 ) ; , .

निर्णय

, -, « », . , , , .

: , . . , , .

:

 const TPS = 1000 / Framework.INTERVAL; //

// .

 function getTarget(ticks, planet) { const { h, m, s } = planet; //    const ts = Math.floor(ticks / TPS); //   const ss = ts % s * 360 / s; const mm = Math.floor(ts / s) % m * 360 / m; const hh = Math.floor(ts / (s * m)) % h * 360 / h; return { hh, mm, ss }; }

, — rotateFactor. getRotateFactor, , , . :
1. ,
2. .

. .

 function getRotateFactor(pos, target, forward = true) { let angle = target - pos; //        if (forward) { //      angle < 0 && (angle += 360); //        0  360 ( 360   0),    } else { //         Math.abs(angle) > 180 && (angle -= Math.sign(angle) * 360) } return angle / Framework.SPEED; }

, MAX_SPEED . getRotateFactor.

 const MAX_FACTOR = Framework.MAX_SPEED / Framework.SPEED; function getRotateFactor(pos, target, forward = true) { let angle = target - pos; if (forward) { angle < 0 && (angle += 360); } else { Math.abs(angle) > 180 && (angle -= Math.sign(angle) * 360) } const factor = angle / Framework.SPEED; //      ,    return Math.abs(factor) > MAX_FACTOR ? Math.sign(factor) * MAX_FACTOR : factor; }

 buttonAHandler() { //     this.pos = (this.pos + 1) % this.planets.length; //      this.forward = false; }

, :

 onBeforeTick() { const [sec, min, hour] = this.arrows; const time = ++this.ticks; const planet = this.planets[this.pos]; //        const target = getTarget(time, planet); //      sec.rotateFactor = getRotateFactor(sec.pos, target.ss, this.forward); min.rotateFactor = getRotateFactor(min.pos, target.mm, this.forward); hour.rotateFactor = getRotateFactor(hour.pos, target.hh, this.forward); //       ,       !sec.rotateFactor && !min.rotateFactor && !hour.rotateFactor && (this.forward = true); }

 const TPS = 1000 / Framework.INTERVAL; const MAX_FACTOR = Framework.MAX_SPEED / Framework.SPEED; function getTarget(ticks, planet) { const { h, m, s } = planet; const ts = Math.floor(ticks / TPS); // total seconds const ss = ts % s * 360 / s; const mm = Math.floor(ts / s) % m * 360 / m; const hh = Math.floor(ts / (s * m)) % h * 360 / h; return { hh, mm, ss }; } function getRotateFactor(pos, target, forward = true) { let angle = target - pos; if (forward) { angle < 0 && (angle += 360); } else { Math.abs(angle) > 180 && (angle -= Math.sign(angle) * 360) } const factor = angle / Framework.SPEED; return Math.abs(factor) > MAX_FACTOR ? Math.sign(factor) * MAX_FACTOR : factor; } class MyClock extends Clock { // planets -   // [ { h: 4, m: 20, s: 10 }, ... ] constructor({ planets, time }) { super(); this.arrows.push(new Arrow('seconds', { color: 'red' })); this.arrows.push(new Arrow('minutes', { weight: 3, length: 80 })); this.arrows.push(new Arrow('hours', { weight: 3, length: 60 })); this.buttons.push(new Button('Switch', this.buttonAHandler.bind(this))); this.planets = planets; this.ticks = time * TPS; this.pos = 0; this.forward = false; } onBeforeTick() { const [sec, min, hour] = this.arrows; const time = ++this.ticks; const planet = this.planets[this.pos]; const target = getTarget(time, planet); sec.rotateFactor = getRotateFactor(sec.pos, target.ss, this.forward); min.rotateFactor = getRotateFactor(min.pos, target.mm, this.forward); hour.rotateFactor = getRotateFactor(hour.pos, target.hh, this.forward); !sec.rotateFactor && !min.rotateFactor && !hour.rotateFactor && (this.forward = true); } buttonAHandler() { this.pos = (this.pos + 1) % this.planets.length; this.forward = false; } }

. . , , , .

: , , , , (, , ).

निष्कर्ष

. . — , . .

, . , ( ) 18 .

:

— ML-
— -
— -

एक घड़ी का प्रबंधन कैसे करें? दूसरी प्रोग्रामिंग चैम्पियनशिप के फ्रंट-एंड ट्रैक का विश्लेषण

उ। इसे चिन्हित करें

शर्त

उदाहरण

नोट

निर्णय

B BEM

शर्त

निर्णय

सी। क्लोन फैक्ट्री

शर्त

उदाहरण 2

निर्णय

D. इसे स्वचालित करें

शर्त

इनपुट प्रारूप

आउटपुट स्वरूप

नोट

निर्णय

ई। महामारी वायरस

समाधान प्रारूप

नोट

निर्णय

F. Framework-

निर्णय

More articles: