जांचें कि क्या सरणी के सभी मूल्य समान हैं

Question

मुझे उन सरणियों को खोजने की आवश्यकता है जहां सभी मूल्य समान हैं। ऐसा करने का सबसे तेज़ तरीका क्या है? क्या मुझे इसके माध्यम से लूप करना चाहिए और सिर्फ मूल्यों की तुलना करनी चाहिए?

['a', 'a', 'a', 'a'] // true
['a', 'a', 'b', 'a'] // false

Comments

@TJCrowder मुझे यकीन है कि आप पहले से ही सबसे अच्छा समाधान के बारे में सोच रहे हैं;)

— VisioN

@TJCrowder: वास्तव में उत्तरों को स्वीकार करने के लिए पूछने वालों की इच्छा का उल्लेख नहीं करना। 1 प्रतिनिधि वाले उपयोगकर्ताओं को अक्सर ऐसा लगता है कि वे एक कॉपी-पेस्ट-सक्षम उत्तर के रूप में, हाल ही में छोड़ते हैं और प्रकार चलाते हैं।

— सेरेब्रस

इस दृष्टिकोण के आसपास कुछ काम करना चाहिए? a.join(',').split(a[0]).length === a.length + 1

— जशवंत

@ TomášZato: "ओपी" का अर्थ है "मूल पोस्टर" (सवाल पूछने वाला व्यक्ति)।

— टीजे क्राउडर

चेक में

— एंडरसन ग्रीन

Answer 1

const allEqual = arr => arr.every( v => v === arr[0] )
allEqual( [1,1,1,1] )  // true

या एक-लाइनर:

[1,1,1,1].every( (val, i, arr) => val === arr[0] )   // true

Array.prototype.every (MDN से): every()विधि परीक्षण करती है कि क्या सरणी के सभी तत्व प्रदान किए गए फ़ंक्शन द्वारा लागू किए गए परीक्षण को पास करते हैं या नहीं।

Comments

Brevity बुद्धि की आत्मा है

— svarog

मैंने एक jsperf केस बनाया है । यह विधि अधिकांश उम्मीदवारों को बेहतर बनाती है।

— जून्लिआंग हुआंग

const everythings_equal = array => array.every(thing => thing === array[0]);

— Константин Ван

का प्रयोग करें someबजाय every: arr.some( v => v !== arr[0] )। यह असमान पाए जाने वाले पहले तत्व पर जल्दी लौट आएगा arr[0]।

— Jan

@ जान everyजल्दी वापसी भी करती है।

— गोलोपोट

Answer 2

संपादित करें: एक लाल निंजा बनें:

!!array.reduce(function(a, b){ return (a === b) ? a : NaN; });

परिणाम:

var array = ["a", "a", "a"] => result: "true"
var array = ["a", "b", "a"] => result: "false"
var array = ["false", ""] => result: "false"
var array = ["false", false] => result: "false"
var array = ["false", "false"] => result: "true"
var array = [NaN, NaN] => result: "false" 

---

चेतावनी:

var array = [] => result: TypeError thrown

इसका कारण यह है कि हम एक इनिशियलव्यू पास नहीं करते हैं । तो, आप array.lengthपहले जांच करना चाह सकते हैं ।

Comments

पार्टी के लिए थोड़ी देर हो सकती है ... मुझे लगता है कि यह काम नहीं करता है अगर आपका सरणी एस से बना है false! उदाहरण के लिए, [झूठा, झूठा, झूठा] की कोशिश करें। (फ़ंक्शन (ए, बी) {वापसी (एक === बी): (ए: गलत;});

— जॉर्ज फ्लौरेंत्ज़ोस

@ मर्टिन: ["false", ""]रिटर्न true: /

— डैलगार्ड

इसका उपयोग करके एक पायदान ऊपर ले जाया जा सकता है NaN। चूंकि दोनों झूठे हैं NaN === NaNऔर NaN !== NaNयह गारंटी देता है कि एक बार prevNaN पर सेट हो जाने के बाद कोई मूल्य नहीं ले सकता। इसके अलावा, एक दोहरी नकारात्मकता में जोड़ने के परिणाम को धर्मान्तरित trueऔर false, के बाद NaNसे मिथ्या है। अंतिम रूप:!!array.reduce(function(a, b){ return (a === b) ? a : NaN; });

— फिल्प सिल्वा

डाउनलोड किया गया । क्या होगा अगर तत्व समान हैं लेकिन मिथ्या हैं ?

— Константин Ван

मैंने यह मान लिया क्योंकि यह बूलियन मूल्यों के साथ काम नहीं करता है।

— Tyguy7

Answer 3

यह काम। आप प्रोटोटाइप का उपयोग करके ऐरे पर एक विधि बनाते हैं।

if (Array.prototype.allValuesSame === undefined) {
  Array.prototype.allValuesSame = function() {
    for (let i = 1; i < this.length; i++) {
      if (this[i] !== this[0]) {
        return false;
      }
    }
    return true;
  }
}

इसे इस तरह से कॉल करें:

let a = ['a', 'a', 'a'];
let b = a.allValuesSame(); // true
a = ['a', 'b', 'a'];
b = a.allValuesSame();     // false

Comments

बहुत अच्छा, लेकिन सावधान रहें: IE प्रोटोटाइप को असाइन करने के इस तरीके का समर्थन नहीं करता है। मैं वैसे भी इसका इस्तेमाल करता हूं।

— टॉम ज़ातो -

@ TomášZato: IE Array.prototypeसिर्फ ठीक (भी IE6) बढ़ाने का समर्थन करता है । यह केवल DOM एलिमेंट प्रोटोटाइप है जो IE के कुछ पुराने संस्करणों को बढ़ाने का समर्थन नहीं करता है।

— टीजे क्राउडर

मुझे नहीं लगता कि निर्मित प्रोटोटाइप में बंदर पैचिंग करना एक अच्छा विचार है। यदि कई पुस्तकालय ऐसा करते हैं, तो यह अप्रत्याशित व्यवहार को जन्म दे सकता है जो डिबग करना बहुत मुश्किल है।

— मार्क विल्बर

@MarkWilbur +1 विशेष रूप से अगर आप for..in लूप को अगली सरणियों पर करते हैं, तो आप allValuesSameलूप में मिल जाएंगे

— ओलिवियर पॉन्स

मैंने इरादे में बदलाव किए बिना इसे आगे बढ़ाया और इसे आधुनिक बनाया।

— श्री पॉलीविरल at

Answer 4

जावास्क्रिप्ट 1.6 में, आप उपयोग कर सकते हैं Array.every:

function AllTheSame(array) {
    var first = array[0];
    return array.every(function(element) {
        return element === first;
    });
}

आपको संभवतः कुछ पवित्रता जांचों की आवश्यकता है, उदाहरण के लिए जब सरणी में कोई तत्व नहीं है। (इसके अलावा, इस काम नहीं होगा जब सभी तत्व हैं NaNके बाद से NaN !== NaN, लेकिन यह एक मुद्दा नहीं होना चाहिए ... है ना?)

Answer 5

आप ऐरे को सेट में बदल सकते हैं। यदि सेट का आकार 1 के बराबर है, तो एरे के सभी तत्व समान हैं।

function allEqual(arr) {
  return new Set(arr).size == 1;
}

allEqual(['a', 'a', 'a', 'a']); // true
allEqual(['a', 'a', 'b', 'a']); // false

Comments

प्रतिभाशाली। बस ध्यान दें जो इस मामले में allEqual([NaN, NaN])देता trueहै।

— Константин Ван

Answer 6

और प्रदर्शन की तुलना के लिए मैंने एक बेंचमार्क भी किया:

function allAreEqual(array){
    if(!array.length) return true;
    // I also made sure it works with [false, false] array
    return array.reduce(function(a, b){return (a === b)?a:(!b);}) === array[0];
}
function same(a) {
    if (!a.length) return true;
    return !a.filter(function (e) {
        return e !== a[0];
    }).length;
}

function allTheSame(array) {
    var first = array[0];
    return array.every(function(element) {
        return element === first;
    });
}

function useSome(array){
    return !array.some(function(value, index, array){
        return value !== array[0];
    });
}

परिणाम:

allAreEqual x 47,565 ops/sec ±0.16% (100 runs sampled)
same x 42,529 ops/sec ±1.74% (92 runs sampled)
allTheSame x 66,437 ops/sec ±0.45% (102 runs sampled)
useSome x 70,102 ops/sec ±0.27% (100 runs sampled)

तो जाहिरा तौर पर बिलियन array.some () का उपयोग करना सैंपल वाले लोगों का सबसे तेज़ तरीका है।

Comments

यह देखने के लिए अच्छा विचार है कि यहां अधिक प्रदर्शन करने वाला क्या है। Array#someकभी-कभी आउटपरफॉर्म करने का कारण यह होता है कि कॉलबैक फ़ंक्शन के सही होने के बाद, यह चलना बंद कर देता है। इसलिए, यदि सभी तत्व वास्तव में समान हैं, तो प्रदर्शन समान होना चाहिए Array#every। और जब सभी तत्व समान नहीं होते हैं तो सापेक्ष प्रदर्शन पहले गैर-मिलान तत्व के सूचकांक के आधार पर अलग-अलग होगा।

— danmactough 12

अच्छा है। आप उपयोग किए गए फ़ंक्शन के साथ प्रत्येक का नाम रख सकते हैं। जैसे: घटाएँ, फ़िल्टर करें, हर, कुछ

— Z. Khullah

जहां लूप के लिए मूल निवासी है, मैं शर्त लगाता हूं कि इन सभी को 5 के एक कारक से बेहतर प्रदर्शन करता है

— PirateApp

Answer 7

अंडरस्कोर / लॉश का उपयोग करके सबसे छोटा उत्तर

function elementsEqual(arr) {
    return !_.without(arr, arr[0]).length
}

कल्पना:

elementsEqual(null) // throws error
elementsEqual([]) // true
elementsEqual({}) // true
elementsEqual([1]) // true
elementsEqual([1,2]) // false
elementsEqual(NaN) // true

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

या उससे भी कम, टॉम के जवाब से प्रेरित:

function elementsEqual2(arr) {
    return _.uniq(arr).length <= 1;
}

कल्पना:

elementsEqual2(null) // true (beware, it's different than above)
elementsEqual2([]) // true
elementsEqual2({}) // true
elementsEqual2([1]) // true
elementsEqual2([1,2]) // false
elementsEqual2(NaN) // true

Answer 8

यदि आप पहले से ही अंडरस्कोर का उपयोग कर रहे हैं , तो यहां एक और विकल्प का उपयोग कर रहे हैं _.uniq:

function allEqual(arr) {
    return _.uniq(arr).length === 1;
}

_.uniqसरणी का डुप्लिकेट-मुक्त संस्करण लौटाता है। यदि सभी मान समान हैं, तो लंबाई 1 होगी।

जैसा कि टिप्पणियों में उल्लेख किया गया है, यह देखते हुए कि आप खाली सरणी की वापसी की उम्मीद कर सकते हैं true, तो आपको उस मामले की भी जांच करनी चाहिए:

function allEqual(arr) {
    return arr.length === 0 || _.uniq(arr).length === 1;
}

Comments

लेकिन यदि सरणी खाली है, तो आपका उत्तर वापस आ जाएगा false। जबकि मुझे लगता है कि यह होना चाहिए true। .length <= 1हालांकि बदलना काफी होगा।

— औसत जो

@ कैस्केन एक उचित बिंदु है। मैंने उस मामले को कवर करने के लिए अपना जवाब अपडेट कर दिया है।

— टॉम फेनेच

Answer 9

हां, आप इसे नीचे दिए गए फ़िल्टर का उपयोग करके भी जांच सकते हैं, बहुत सरल है, हर मान की जाँच पहले वाले के समान है:

//ES6
function sameValues(arr) {
  return arr.filter((v,i,a)=>v===a[0]).length === arr.length;
} 

सरणी पर हर विधि का उपयोग करके भी किया जा सकता है:

//ES6
function sameValues(arr) {
  return arr.every((v,i,a)=>v===a[0]);
} 

और आप नीचे की तरह अपने सरणियों की जांच कर सकते हैं:

sameValues(['a', 'a', 'a', 'a']); // true
sameValues(['a', 'a', 'b', 'a']); // false

या यदि आप इसे फिर से उपयोग करते हैं, तो आप इसे जावास्क्रिप्ट में देशी ऐरे कार्यात्मकताओं में जोड़ सकते हैं:

//ES6
Array.prototype.sameValues = Array.prototype.sameValues || function(){
 this.every((v,i,a)=>v===a[0]);
}

और आप नीचे की तरह अपने सरणियों की जांच कर सकते हैं:

['a', 'a', 'a', 'a'].sameValues(); // true
['a', 'a', 'b', 'a'].sameValues(); // false

Answer 10

Array.everyसमर्थित होने पर आप उपयोग कर सकते हैं :

var equals = array.every(function(value, index, array){
    return value === array[0];
});

एक पाश के वैकल्पिक दृष्टिकोण कुछ इस तरह हो सकता है sort

var temp = array.slice(0).sort();
var equals = temp[0] === temp[temp.length - 1];

या, यदि आइटम प्रश्न की तरह हैं, तो कुछ गंदा है:

var equals = array.join('').split(array[0]).join('').length === 0;

भी काम करता है।

Comments

आपके पास पहला उदाहरण पीछे की तरफ है। होना चाहिए equals = !array.some( (v,i,a) => v!==a[0] )। अन्यथा आप बस जाँच कर रहे हैं कि कोई भी मूल्य पहले के बराबर है, जो निश्चित रूप से हमेशा सही होगा :)

— मार्क कहन

नहीं बिल्कुल, मैं प्रयोग किया जाता है someके बजाय everyके रूप में मैं पहले अनुच्छेद में उल्लेख किया है। :) पकड़ने के लिए धन्यवाद!

— ZER0

Answer 11

Array.prototyp.every , Object.is , और ES6 एरो फ़ंक्शंस का उपयोग करके आप यह एक-लाइनर प्राप्त कर सकते हैं।

const all = arr => arr.every(x => Object.is(arr[0], x));

Comments

कृपया, उस समाधान का वर्णन करें जिसका आप प्रस्ताव कर रहे हैं।

— il_raffa

Answer 12

मुझे लगता है कि ऐसा करने का सबसे सरल तरीका यह है कि अगले मूल्य की तुलना करने के लिए एक लूप बनाया जाए। जब तक "चेन" में कोई विराम नहीं होता, तब तक यह गलत होता। यदि पहला दूसरे के बराबर है, दूसरा तीसरे के बराबर है और इसी तरह, तो हम यह निष्कर्ष निकाल सकते हैं कि सरणी के सभी तत्व एक दूसरे के बराबर हैं।

एक सरणी डेटा दिया गया [], फिर आप उपयोग कर सकते हैं:

for(x=0;x<data.length - 1;x++){
    if (data[x] != data[x+1]){
        isEqual = false;            
    }
}
alert("All elements are equal is " + isEqual);

Answer 13

arr.length && arr.reduce(function(a, b){return (a === b)?a:false;}) === arr[0];

Answer 14

नया समाधान अपडेट करें: इंडेक्स चेक करें

 let a = ['a', 'a', 'b', 'a'];
 let a = ['a', 'a', 'a', 'a'];
 let check = (list) => list.every(item => list.indexOf(item) === 0);
 check(a); // false;
 check(b); // true;

ES6 के साथ अपडेट किया गया: उपयोग list.everyसबसे तेज़ तरीका है:

 let a = ['a', 'a', 'b', 'a'];
 let check = (list) => list.every(item => item === list[0]);

पुराना संस्करण:

      var listTrue = ['a', 'a', 'a', 'a'];
      var listFalse = ['a', 'a', 'a', 'ab'];

      function areWeTheSame(list) { 
         var sample = list[0];
         return (list.every((item) => item === sample));
      }

Answer 15

आप इसका उपयोग कर सकते हैं:

function same(a) {
    if (!a.length) return true;
    return !a.filter(function (e) {
        return e !== a[0];
    }).length;
}

फ़ंक्शन पहले जाँचता है कि सरणी खाली है या नहीं। यदि यह मान है तो यह समान है .. अन्यथा यह सरणी को फ़िल्टर करता है और सभी तत्वों को लेता है जो पहले वाले से अलग हैं। यदि ऐसा कोई मूल्य नहीं हैं => सरणी में केवल समान तत्व हैं अन्यथा यह नहीं है।

Answer 16

अंडरस्कोर का _.isEqual(object, other)फ़ंक्शन सरणियों के लिए अच्छी तरह से काम करता है। सरणी में वस्तुओं का क्रम जब यह समानता के लिए जाँच करता है। Http://underscorejs.org/#isEqual देखें ।

Answer 17

var listTrue = ['a', 'a', 'a', 'a'];
var listFalse = ['a', 'a', 'a', 'ab'];

function areWeTheSame(list) { 
    var sample = list[0];
    return !(list.some(function(item) {
        return !(item == sample);
    }));
}

Comments

कृपया यह भी बताएं कि आपने कुछ कोड चिपकाने के बजाय क्या किया।

— राउटर जे

Answer 18

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

function isUniform(arra){
    var k=arra[0];
    for (var i = 0; i < arra.length; i++) {
        while(k!==arra[i]){
            return false;
        }
    }
    return true;
}

Answer 19

स्वीकार किए जाते हैं जवाब महान काम किया है, लेकिन मैं एक छोटा सा जोड़ना चाहते थे। यह मेरे लिए उपयोग करने के लिए काम नहीं करता ===था क्योंकि मैं ऑब्जेक्ट्स के सरणियों की तुलना कर रहा था, हालांकि मेरे पूरे ऐप में मैं तेज़-गहरे-समान पैकेज का उपयोग कर रहा हूं, जिसकी मैं अत्यधिक अनुशंसा करता हूं। इसके साथ, मेरा कोड इस तरह दिखता है:

let areAllEqual = arrs.every((val, i, arr) => equal(val, arr[0]) );

और मेरा डेटा इस तरह दिखता है:

[  
  [
    {
      "ID": 28,
      "AuthorID": 121,
      "VisitTypeID": 2
    },
    {
      "ID": 115,
      "AuthorID": 121,
      "VisitTypeID": 1
    },
    {
      "ID": 121,
      "AuthorID": 121,
      "VisitTypeID": 1
    }
  ],
  [
    {
      "ID": 121,
      "AuthorID": 121,
      "VisitTypeID": 1
    }
  ],
  [
    {
      "ID": 5,
      "AuthorID": 121,
      "VisitTypeID": 1
    },
    {
      "ID": 121,
      "AuthorID": 121,
      "VisitTypeID": 1
    }
  ]
]

Answer 20

1. सरणी से जुड़कर एक स्ट्रिंग बनाएं।
2. दिए गए सरणी के पहले वर्ण की पुनरावृत्ति द्वारा स्ट्रिंग बनाएं
3. दोनों तारों का मिलान करें

	function checkArray(array){
		return array.join("") == array[0].repeat(array.length);	
	}

	console.log('array: [a,a,a,a]: ' + checkArray(['a', 'a', 'a', 'a']));
	console.log('array: [a,a,b,a]: ' + checkArray(['a', 'a', 'b', 'a']));

और तुम हो गए!

Answer 21

अब आप आसानी से ऐसा करने के लिए सेट का उपयोग कर सकते हैं।

let a= ['a', 'a', 'a', 'a']; // true
let b =['a', 'a', 'b', 'a'];// false

console.log(new Set(a).size === 1);
console.log(new Set(b).size === 1);

Answer 22

आप लूप के लिए उपयोग कर सकते हैं:

function isEqual(arr) {
  var first = arr[0];
  for (let i = 1; i < arr.length; i++) {
    if (first !== arr[i]) {
      return false;
    }
  }
  return true;
}

Answer 23

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

Comments

मुझे यह उत्तर पसंद नहीं है। यह आपको यह बताने नहीं देगा कि क्या दूसरा मूल्य तीसरे के समान था, आदि जाहिर तौर पर नेस्टेड लूप ऐसा करेगा, लेकिन यह एक नौसिखिए के अलग से वैचारिक रूप से अलग है।

— jtromans

@jtromans: समानता की सकर्मक संपत्ति के कारण, यदि A == B और A == C तो हम B = C को जानते हैं; आपको नेस्टेड लूप आदि के साथ इसे "मैन्युअल रूप से" सत्यापित करने की आवश्यकता नहीं है। एकल मान के खिलाफ तुलना दोहराते हुए (सरणी में पहला मान, एक मनमाना नहीं है :) यह वही है जो यह उत्तर बताता है और इसलिए स्वीकृत उत्तर देता है।

— ओव

@ वस्तुतः, मेरी जल्दबाजी में मैंने उस प्रश्न को गलत बताया, जो मैंने उस समय सोचा था कि केवल जाँच से अधिक आवश्यक है कि सभी समान हों ((दुह)!

— jtromans

यह जटिल नहीं है। और न ही पृष्ठ पर अन्य उत्तर हैं। लेकिन मेरे लिए, यह उत्तर कम से कम मददगार है।

— चार्ली

यह मूल रूप से ओपी के प्रति एक मजबूत बिंदु बनाने के लिए था, जिसमें वह सवाल पूछने से पहले सोचने की कोशिश करता था।

— टॉम ज़ातो -

Answer 24

सरल एक पंक्ति समाधान, बस इसे पहले प्रविष्टि से भरे हुए सरणी से तुलना करें।

if(arr.join('') === Array(arr.length).fill(arr[0]).join(''))

Comments

यह एक समाधान की तरह प्रतीत नहीं होता है जिसका उपयोग कहीं भी किया जा सकता है

— Lu4

यह ठीक है के करीब है। बेहतर कुछ इस तरह होगा: फ़ंक्शन arrayOfSame (गिरफ्तार) {वापसी (arr.join ('') == (नया ऐरे (arr.length + 1)) .join (गिरफ्तार [0])); }

— अरकैन

Answer 25

जब आप ES6 तीर फ़ंक्शन सिंटैक्स का उपयोग करते हैं, तो एक और दिलचस्प तरीका:

x = ['a', 'a', 'a', 'a']
!x.filter(e=>e!==x[0])[0]  // true

x = ['a', 'a', 'b', 'a']
!x.filter(e=>e!==x[0])[0] // false

x = []
!x.filter(e=>e!==x[0])[0]  // true

और जब आप सरणी (x) के लिए चर का पुन: उपयोग नहीं करना चाहते हैं:

!['a', 'a', 'a', 'a'].filter((e,i,a)=>e!==a[0])[0]    // true

IMO पिछले पोस्टर जिसने array.every (...) का उपयोग किया था, उसका सबसे साफ समाधान है।

Answer 26

function isUniform(array) {   
  for (var i=1; i< array.length; i++) {
    if (array[i] !== array[0]) { return false; }
  }

  for (var i=1; i< array.length; i++) {
    if (array[i] === array[0]) { return true; }
  }
}

• पहले लूप के लिए; जब भी यह असमान का पता लगाता है, "झूठा" लौटाता है
• पहला लूप चलता है, और यदि यह गलत है, तो हमारे पास "गलत" है
• जब यह गलत नहीं होता है, तो इसका मतलब है कि यह सच होगा, इसलिए हम दूसरा लूप करते हैं। और निश्चित रूप से हमारे पास दूसरे लूप से "सच" होगा (क्योंकि पहले लूप में पाया गया कि यह गलत नहीं है)

Answer 27

यह काम कर सकता है, आप टिप्पणी कोड का उपयोग कर सकते हैं और साथ ही दिए गए स्कैनेरियो के साथ अच्छी तरह से जाग सकते हैं।

function isUniform(){
	var arrayToMatch = [1,1,1,1,1];
	var temp = arrayToMatch[0];
	console.log(temp);
  /* return arrayToMatch.every(function(check){
    return check == temp;
   });*/
var bool;
   arrayToMatch.forEach(function(check){
    bool=(check == temp);
   })
  console.log(bool);
}
isUniform();

Answer 28

सीमांकित आकार और संगठित सूची के साथ एक और तरीका:

array1 = [1,2,3]; array2 = [1,2,3];

function isEqual(){

    return array1.toString()==array2.toString();
}

Answer 29

आप सरणी को सेट में परिवर्तित कर सकते हैं और उसके आकार की जांच कर सकते हैं

आदिम सरणी प्रविष्टियों के मामले में, यानी number, string:

const isArrayWithEqualEntries = array => new Set(array).size === 1

समतुल्यता के लिए कुछ क्षेत्र के साथ वस्तुओं के सरणी के मामले में, कहते हैं id:

const mapper = ({id}) => id
const isArrayWithEqualEntries = array => new Set(array.map(mapper)).size === 1

Answer 30

PHP में, बहुत सरल, एक लाइन विधि है:

(गिनती (array_count_values ​​($ array)) == 1)

उदाहरण के लिए :

$arr1 = ['a', 'a', 'a', 'a'];
$arr2 = ['a', 'a', 'b', 'a'];


print (count(array_count_values($arr1)) == 1 ? "identical" : "not identical"); // identical
print (count(array_count_values($arr2)) == 1 ? "identical" : "not identical"); // not identical

बस इतना ही।