दिलचस्प पोस्ट
चेरी-चुने-चुने कई कमान कैसे करें क्रोम के अंतर्गत संसाधन लोड करने में विफल जेड इंडेक्स इंटरनेट एक्सप्लोरर में iframe में पीडीएफ के साथ काम नहीं करता है क्या आप एक एम्बेडेड नल के साथ एक std :: स्ट्रिंग का निर्माण करते हैं? स्विंग में जेटीबल के लिए पेजिंग सहायता कैसे प्रदान करें? पायथन: किसी FTP सर्वर पर फ़ाइल डाउनलोड करें जेनकिंस / हडसन जॉब कैसे करें, कुछ अन्य नौकरियों का सर्वेक्षण करें और तय करें कि क्या बनाना है या नहीं? ट्रेस पायथन आयात MySQL: रैंडम एंट्री चुनें, लेकिन कुछ प्रविष्टियों के लिए वजन ऐप ठीक आईओएस 8 आईफोन सिम्युलेटर का आकार नहीं है I पीएचपी में अनुरोध प्रकार का पता लगाना (GET, POST, PUT या DELETE) संसाधन से भाषा की विशिष्ट स्ट्रिंग लोड करें? SQLite DB को देखने के लिए एंड्रॉइड स्टूडियो में एडीबी का उपयोग कैसे करें अद्वितीय बाध्यता का उल्लंघन किए बिना, MySQL में दो पंक्तियों के मानों को स्वैप कैसे करें? गैर-स्थिर विधि के लिए एक स्थिर संदर्भ नहीं बना सकते

जांचें कि एक सरणी में हर तत्व दूसरे एरे में है या नहीं

मेरे पास दो arr2 हैं और मैं यह जानना चाहता हूं कि arr2 में हर तत्व arr2 है। अगर किसी तत्व का मान दोबारा में दोहराया जाता है, तो उसे बराबर संख्या में arr1 में होना चाहिए। ऐसा करने का सबसे अच्छा तरीका क्या है?

 arr1 = [1, 2, 3, 4] arr2 = [1, 2] checkSuperbag(arr1, arr2) > true //both 1 and 2 are in arr1 arr1 = [1, 2, 3, 4] arr2 = [1, 2, 5] checkSuperbag(arr1, arr2) > false //5 is not in arr1 arr1 = [1, 2, 3] arr2 = [1, 2, 3, 3] checkSuperbag(arr1, arr2) > false //3 is not in arr1 twice 

Solutions Collecting From Web of "जांचें कि एक सरणी में हर तत्व दूसरे एरे में है या नहीं"

एक विकल्प दो सरणियों को सॉर्ट करने के लिए है, फिर तत्वों की तुलना करते हुए दोनों पार करते हैं यदि उप बैग के उम्मीदवार में कोई तत्व सुपर-बैग में नहीं मिला है, तो पूर्व उप-बैग नहीं है छंटनी सामान्यतः हे (एन * लॉग (एन)) है और तुलना O (अधिकतम (एस, टी)) है, जहां ओ और एम टी के कुल समय की जटिलता के लिए सरणी आकार हैं (एम * लॉग (एम)) , जहां m = अधिकतम (एस, टी)

 function superbag(sup, sub) { sup.sort(); sub.sort(); var i, j; for (i=0,j=0; i<sup.length && j<sub.length;) { if (sup[i] < sub[j]) { ++i; } else if (sup[i] == sub[j]) { ++i; ++j; } else { // sub[j] not in sup, so sub not subbag return false; } } // make sure there are no elements left in sub return j == sub.length; } 

यदि वास्तविक कोड के तत्व पूर्णांक हैं, तो आप समग्र ओ (अधिकतम (एस, टी)) समय की जटिलता के लिए एक विशेष-उद्देश्य पूर्णांक सॉर्टिंग एल्गोरिदम (जैसे रेडिक्स सॉर्ट ) का उपयोग कर सकते हैं, यद्यपि बैग छोटे हैं, तो निर्मित Array.sort कस्टम पूर्णांक सॉर्ट की तुलना में तेज़ी से चलेंगे

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

निम्नलिखित परीक्षण न किया गया है। एक व्यायाम के रूप में isInt कार्यान्वयन बाकी है

 function IntBag(from) { if (from instanceof IntBag) { return from.clone(); } else if (from instanceof Array) { for (var i=0; i < from.length) { this.add(from[i]); } } else if (from) { for (p in from) { /* don't test from.hasOwnProperty(p); all that matters is that p and from[p] are ints */ if (isInt(p) && isInt(from[p])) { this.add(p, from[p]); } } } } IntBag.prototype=[]; IntBag.prototype.size=0; IntBag.prototype.clone = function() { var clone = new IntBag(); this.each(function(i, count) { clone.add(i, count); }); return clone; }; IntBag.prototype.contains = function(i) { if (i in this) { return this[i]; } return 0; }; IntBag.prototype.add = function(i, count) { if (!count) { count = 1; } if (i in this) { this[i] += count; } else { this[i] = count; } this.size += count; }; IntBag.prototype.remove = function(i, count) { if (! i in this) { return; } if (!count) { count = 1; } this[i] -= count; if (this[i] > 0) { // element is still in bag this.size -= count; } else { // remove element entirely this.size -= count + this[i]; delete this[i]; } }; IntBag.prototype.each = function(f) { var i; foreach (i in this) { f(i, this[i]); } }; IntBag.prototype.find = function(p) { var result = []; var i; foreach (i in this.elements) { if (p(i, this[i])) { return i; } } return null; }; IntBag.prototype.sub = function(other) { other.each(function(i, count) { this.remove(i, count); }); return this; }; IntBag.prototype.union = function(other) { var union = this.clone(); other.each(function(i, count) { if (union.contains(i) < count) { union.add(i, count - union.contains(i)); } }); return union; }; IntBag.prototype.intersect = function(other) { var intersection = new IntBag(); this.each(function (i, count) { if (other.contains(i)) { intersection.add(i, Math.min(count, other.contains(i))); } }); return intersection; }; IntBag.prototype.diff = function(other) { var mine = this.clone(); mine.sub(other); var others = other.clone(); others.sub(this); mine.union(others); return mine; }; IntBag.prototype.subbag = function(super) { return this.size <= super.size && null !== this.find( function (i, count) { return super.contains(i) < this.contains(i); })); }; 

ऑब्जेक्ट्स के एक उदाहरण के कार्यान्वयन के उदाहरण के लिए " जावास्क्रिप्ट एरेज़ की तुलना करना " भी देखें, क्या आपको कभी भी तत्वों के पुनरावृत्ति को अस्वीकार करना चाहिए?

क्या आपको क्रमी ब्राउज़र का समर्थन करना है? यदि नहीं, तो प्रत्येक फ़ंक्शन को यह आसान बनाना चाहिए।

यदि arr1 arr2 का एक सुपरसेट है, तो arr2 में प्रत्येक सदस्य arr1 में उपस्थित होना चाहिए

 var isSuperset = arr2.every(function(val) { return arr1.indexOf(val) >= 0; }); 

यहाँ एक बेला है

संपादित करें

तो आप सुपरसेट को परिभाषित कर रहे हैं जैसे कि arr2 में प्रत्येक तत्व के लिए, यह उसी समय की संख्या में arr1 में होता है? मुझे लगता है कि फिल्टर आपको ऐसा करने में मदद करेगा (पूर्ववर्ती एमडीएन लिंक से पुराने ब्राउज़रों को समर्थन देने के लिए शिम को पकड़ो):

 var isSuperset = arr2.every(function (val) { var numIn1 = arr1.filter(function(el) { return el === val; }).length; var numIn2 = arr2.filter(function(el) { return el === val; }).length; return numIn1 === numIn2; }); 

नवीनीकृत बेला

END संपादित करें


यदि आप पुराने ब्राउज़रों का समर्थन करना चाहते हैं, तो ऊपर दी गई एमडीएन लिंक में आप जोड़ सकते हैं, जो आपकी सुविधा के लिए मैं यहां पुन: उत्पन्न करता हूं:

 if (!Array.prototype.every) { Array.prototype.every = function(fun /*, thisp */) { "use strict"; if (this == null) throw new TypeError(); var t = Object(this); var len = t.length >>> 0; if (typeof fun != "function") throw new TypeError(); var thisp = arguments[1]; for (var i = 0; i < len; i++) { if (i in t && !fun.call(thisp, t[i], i, t)) return false; } return true; }; } 

संपादित करें

ध्यान दें कि यह एक ओ (एन 2 ) एल्गोरिथ्म होगा, इसलिए इसे बड़े सरणियों पर चलने से बचें

किसी ने अभी तक एक रिकर्सिव फ़ंक्शन पोस्ट नहीं किया है और ये हमेशा मज़ेदार होते हैं। इसे arr1.containsArray( arr2 ) जैसे कॉल करें

डेमो: http://jsfiddle.net/ThinkingStiff/X9jed/

 Array.prototype.containsArray = function ( array /*, index, last*/ ) { if( arguments[1] ) { var index = arguments[1], last = arguments[2]; } else { var index = 0, last = 0; this.sort(); array.sort(); }; return index == array.length || ( last = this.indexOf( array[index], last ) ) > -1 && this.containsArray( array, ++index, ++last ); }; 

ऑब्जेक्ट्स का उपयोग (पढ़ा: हैश टेबल) सॉर्टिंग के स्थान पर amortized जटिलता को O (m + n) को कम करना चाहिए:

 function bagContains(arr1, arr2) { var o = {} var result = true; // Count all the objects in container for(var i=0; i < arr1.length; i++) { if(!o[arr1[i]]) { o[arr1[i]] = 0; } o[arr1[i]]++; } // Subtract all the objects in containee // And exit early if possible for(var i=0; i < arr2.length; i++) { if(!o[arr2[i]]) { o[arr2[i]] = 0; } if(--o[arr2[i]] < 0) { result = false; break; } } return result; } console.log(bagContains([1, 2, 3, 4], [1, 3])); console.log(bagContains([1, 2, 3, 4], [1, 3, 3])); console.log(bagContains([1, 2, 3, 4], [1, 3, 7])); 

कौन सी उपज true , false , false

एक अन्य दृष्टिकोण के लिए आप निम्नानुसार कर सकते हैं;

 function checkIn(a,b){ return b.every(function(e){ return e === this.splice(this.indexOf(e),1)[0]; }, a.slice()); // a.slice() is the "this" in the every method } var arr1 = [1, 2, 3, 4], arr2 = [1, 2], arr3 = [1,2,3,3]; console.log(checkIn(arr1,arr2)); console.log(checkIn(arr1,arr3)); 

त्वरित समाधान यहां दो सरणियां लेते हैं, यदि b लंबे समय से अधिक है तो यह सुपर सेट नहीं हो सकता है इसलिए झूठी वापसी करता है। फिर b माध्यम से लूप देखने के लिए कि इसमें तत्व शामिल है यदि ऐसा है तो इसे हटा दें और आगे बढ़ें, अगर गलत नहीं लौटाया जाए इससे भी बदतर मामला यह है कि अगर b एक सबसेट है तो समय b.length होगा।

 function isSuper(a,b){ var l=b.length,i=0,c; if(l>a.length){return false} else{ for(i;i<l;i++){ c=a.indexOf(b[i]); if(c>-1){ a.splice(c,1); } else{return false} } return true; } } 

यह मानता है कि इनपुट हमेशा क्रम में नहीं होंगे और यदि a 1,2,3 और b 3,2,1 तो यह अभी भी सच हो जाएगी

छोटा संस्करण:

 function checkSuperbag(arr1, arr2) { return !!~arr2.join('').indexOf(arr1.join('')) }