मैं एक सरणी के अंदर अद्वितीय तत्व खोजने के इस कार्य को हल करने का प्रयास कर रहा हूं। अब तक मैं ९५% हल करने में कामयाब रहा, लेकिन मैं ० पर असफल हो रहा हूं। मुझे यह कहते हुए एक त्रुटि मिलती है कि ० अपेक्षित है और १ प्राप्त हुआ है।

मुझे ///10 प्राप्त करना चाहिए, जो यह करता है, लेकिन मैं ऑनलाइन परीक्षा में असफल होने के बाद। अन्य सभी मूल्यों के लिए यह बीत चुका है।

इसे कैसे हल करें और मैं यहां क्या खो रहा हूं इसके बारे में कोई विचार?

function findOne(arr) {
  let x = arr[0];
  for (let i of arr) {
    if (i === x) {
      continue;
    } else {
      x = i;
    }
    return x;
  }
}
console.log(findOne([3, 10, 3, 3, 3]));
0
Tiago Ruivo 29 अक्टूबर 2019, 18:09

4 जवाब

सबसे बढ़िया उत्तर

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

const findUnique = arr => {
  const mapEntries = [...arr.reduce((a, v) => a.set(v, (a.get(v) || 0) + 1), new Map()).entries()]
  return mapEntries.reduce((a, v) => (v[1] === 1 && a.push(v[0]), a), [])
}

console.log(findUnique([3, 10, 3, 3, 3]))
console.log(findUnique([1, 2, 3, 2, 4]))
console.log(findUnique([4, 10, 4, 5, 3]))

यदि आप एकाधिक अद्वितीय मानों की परवाह नहीं करते हैं, तो आप केवल सरणी को सॉर्ट कर सकते हैं और प्रत्येक मान की जांच करने के बजाय तर्क का उपयोग कर सकते हैं, बशर्ते सरणी में केवल 2 अलग-अलग मान हों, और इसकी लंबाई 2 से अधिक हो:

const findUnique = arr => {
  a = arr.sort((a, b) => a - b)
  if (arr.length < 3 || new Set(a).size === 1) return null
  return a[0] === a[1] ? a[a.length-1] : a[0]
}

console.log(findUnique([3, 10, 3, 3, 3]))
console.log(findUnique([3, 3, 1]))
console.log(findUnique([3, 1]))
console.log(findUnique([3, 3, 3, 3, 3]))
-1
Kobe 29 अक्टूबर 2019, 15:54

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

इसके बजाय, आप प्रत्येक मान और उसके आपतन का एक मानचित्र बना सकते हैं, फिर अंत में 1 के बराबर वाले मानों को फ़िल्टर कर सकते हैं।

function findOne(arr) {
    const incidences = arr.reduce((map, val) => {
      map[val] = (map[val] || 0) + 1;
      return map;
    }, {});
    const values = Object.keys(incidences);
    for (let i = 0; i < values.length; ++i) {
      if (incidences[values[i]] === 1) { return values[i]; }
    }
    return null;
}

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

function findOne(arr) {
    const incidences = arr.reduce((map, val) => {
      map.set(val, (map.get(val) || 0) + 1);
      return map;
    }, new Map());
    const singletons = Array.from(incidences).filter(entry => entry[1] === 1);
    return singletons.map(singleton => singleton[0]);
}
0
IceMetalPunk 29 अक्टूबर 2019, 15:32

यह एक आसान और तेज़ तरीका है:

function findOne(arr) {
  const a = arr.reduce((acc, e) => {
    e in acc || (acc[e] = 0)
    acc[e]++
    return acc
  }, {})
  return Object.keys(a).filter(k => a[k] === 1)[0] || null
}
-1
fedeghe 30 अक्टूबर 2019, 08:21

आपका कोड जटिल है, इसे आजमाएं

function findOne(arr) {
  const uniqueItems = [];
  arr.forEach(item => {
    const sameItems = arr.filter(x => x === item);
    if (sameItems.length === 1) {
      uniqueItems.push(item);
    }
  });

  return uniqueItems;
}
console.log(findOne([0, 1, 1, 3, 3, 3, 4]));

मुझे पारित सरणी से सभी अद्वितीय आइटम मिल रहे हैं, इसमें कई अद्वितीय आइटम हो सकते हैं

-1
Abdelrhman ElSayed 29 अक्टूबर 2019, 15:28