सरणी में सबसे लंबी स्ट्रिंग ढूँढना

Question

क्या एक स्ट्रिंग सरणी में सबसे लंबी स्ट्रिंग को खोजने का एक छोटा तरीका है?

कुछ पसंद है arr.Max(x => x.Length);?

Answer 1

जावास्क्रिप्ट 1.8 / ECMcript 5 के बाद से उपलब्ध है और अधिकांश पुराने ब्राउज़रों में उपलब्ध है :

var longest = arr.reduce(
    function (a, b) {
        return a.length > b.length ? a : b;
    }
);

अन्यथा, एक सुरक्षित विकल्प:

var longest = arr.sort(
    function (a, b) {
        return b.length - a.length;
    }
)[0];

Comments

क्या होगा अगर एक ही आकार के 2 या अधिक तार हैं और परिणाम एक सरणी होना चाहिए? कम करने से उस स्थिति में काम नहीं होगा और आपको पहले परिणाम पर पुनरावृत्त करना होगा।

— जिस्मो रणस

@GismoRanas यह एक अलग सवाल है, और आप अभी भी reduceएक कॉलबैक फ़ंक्शन के साथ उपयोग कर सकते हैं जो एक सरणी देता है।

— deceze

Answer 2

एक पुराने प्रश्न का नया उत्तर: ईएस 6 में आप कम कर सकते हैं:

Math.max(...(x.map(el => el.length)));

Comments

यह सबसे लंबे स्ट्रिंग की लंबाई लौटाता है, सबसे लंबी स्ट्रिंग नहीं।

— मिकेमाइक

ध्यान देने वाली एक और बात यह है कि यह संग्रह को दो बार पार कर लेगा O(n^2)जहां अधिकांश अन्य विकल्प केवल संग्रह को एक बार पार करेंगे O(n)। कस्टम तुलनित्रों का उपयोग sortभी हो सकता हैO(log(n))

— CTS_AE

Answer 3

मैं ऐसा कुछ करूंगा

var arr = [
  'first item',
  'second item is longer than the third one',
  'third longish item'
];

var lgth = 0;
var longest;

for (var i = 0; i < arr.length; i++) {
  if (arr[i].length > lgth) {
    var lgth = arr[i].length;
    longest = arr[i];
  }
}

console.log(longest);

Comments

यह सबसे अच्छा है क्योंकि यह आपके सरणी को प्रभावित नहीं करता है। जबकि यदि आप छांटे गए (चुने हुए उत्तर में) तो आपकी सरणी क्रमबद्ध हो जाती है, जब कभी-कभी आप ऐसा नहीं चाहते हैं। +1, धन्यवाद

— thatOneGuy

Answer 4

var arr = [ 'fdgdfgdfg', 'gdfgf', 'gdfgdfhawsdgd', 'gdf', 'gdfhdfhjurvweadsd' ];
arr.sort(function (a, b) { return b.length - a.length })[0];

Answer 5

Array.prototype का उपयोग करना - (जैसा कि मैंने फिडेल करते समय @katsPaugh और @deceze द्वारा पोस्ट किया गया था के समान है)

यहाँ डेमो

var arr = [
    "2 --",
    "3 ---",
    "4 ----",
    "1 -",
    "5 -----"
];

Array.prototype.longest=function() {
    return this.sort(
      function(a,b) {  
        if (a.length > b.length) return -1;
        if (a.length < b.length) return 1;
          return 0
      }
    )[0];
}
alert(arr.longest());    

Answer 6

मैं एक कार्यात्मक + पुनरावर्ती दृष्टिकोण प्रदान करता हूं। यह कैसे काम करता है यह समझने के लिए टिप्पणियां देखें:

const input1 = ['a', 'aa', 'aaa']
const input2 = ['asdf', 'qwer', 'zxcv']
const input3 = ['asdfasdf fdasdf a sd f', ' asdfsdf', 'asdfasdfds', 'asdfsdf', 'asdfsdaf']
const input4 = ['ddd', 'dddddddd', 'dddd', 'ddddd', 'ddd', 'dd', 'd', 'd', 'dddddddddddd']

// Outputs which words has the greater length
// greatestWord :: String -> String -> String
const greatestWord = x => y => 
      x.length > y.length ? x : y
      
// Recursively outputs the first longest word in a series
// longestRec :: String -> [String] -> String
const longestRec = longestWord => ([ nextWord, ...words ]) =>
      //                                ^^^^^^^^^^^^
      // Destructuring lets us get the next word, and remaining ones!
      nextWord // <-- If next word is undefined, then it won't recurse.
        ? longestRec (greatestWord (nextWord) (longestWord)) (words) 
        : longestWord


// Outputs the first longest word in a series
// longest :: [String] -> String
const longest = longestRec ('')

const output1 = longest (input1)
const output2 = longest (input2) 
const output3 = longest (input3)
const output4 = longest (input4)

console.log ('output1: ', output1)
console.log ('output2: ', output2)
console.log ('output3: ', output3)
console.log ('output4: ', output4)

Comments

किसी भी विचार क्यों यह मेरे लिए काम नहीं करता है? const longestRec = longestWord => ([nextWord, ... शब्द]) => ^ TypeError: अपरिभाषित कोई फ़ंक्शन नहीं है

— duke

@ ड्यूक मैं एक नज़र डालूंगा, लेकिन मुझे लगता है कि इस मुद्दे के पीछे क्या है।

— मैटिस फिडेमाइजर 12

@ ड्यूक बीटीडब्ल्यू, क्या आप मुझे इनपुट दे सकते हैं? आप कोड का उपयोग कर रहे है के रूप में ?

— मैटिस फिडेमाइजर 13

निचे देखो। लेकिन यह प्रतीत होता है कि संकलन भी नहीं है। लेकिन आप सही हैं: केवल आपके कोड का उपयोग करना ठीक है .... चलो obj = {"HostName": {"Generated": "@logon", "Value": "openPI", "LastRun": "2018-11- 15 07: 57: 50,186 "}," HostIp ": {" उत्पन्न ":" @ क्रोन "," मूल्य ":" 192.168.178.70 "," लास्टRun ":" 2018-11-15 02: 49: 23,961 "} , "रिलीज़": {"उत्पन्न": "@ क्रोन", "मूल्य": "रास्पियन जीएनयू / लिनक्स 9 (खिंचाव)", "लास्ट रुन": "2018-11-15 02: 49: 24,099"}};

— ड्यूक

आपको परेशान करने के लिए खेद है, मुझे लगा कि यह संकलन नहीं किया गया है। मेरे पास एरे नहीं है।

— ड्यूक

Answer 7

मैं सबसे छोटा उपाय देखता हूं

function findLong(s){
  return Math.max.apply(null, s.split(' ').map(w => w.length));
}

Comments

मैं उस एक को पसंद करता हूं, हालांकि यह सबसे तेज़ एक नहीं हो सकता है

— गुह

यह लंबाई देता है लेकिन शब्द नहीं

— brk

Answer 8

शायद सबसे तेज़ नहीं, लेकिन निश्चित रूप से बहुत पठनीय:

function findLongestWord(array) {
  var longestWord = "";

  array.forEach(function(word) {
    if(word.length > longestWord.length) {
      longestWord = word;
    }
  });

  return longestWord;
}

var word = findLongestWord(["The","quick","brown", "fox", "jumped", "over", "the", "lazy", "dog"]);
console.log(word); // result is "jumped"

IE9 + के बाद से सरणी फ़ंक्शन फॉरएच का समर्थन किया गया है ।

Answer 9

ईएस 6 में इसे जटिलता के reduce()कॉल के साथ पूरा किया जा सकता है, जिसका O(n)उपयोग करने वाले समाधानों के विपरीत sort()है O(nlogn):

const getLongestText = (arr) => arr.reduce(
  (savedText, text) => (text.length > savedText.length ? text : savedText),
  '',
);

console.log(getLongestText(['word', 'even-longer-word', 'long-word']))

Comments

मुझे आशा है कि अधिक लोग इसे नीचे तक स्क्रॉल करेंगे, क्योंकि यह स्वीकृत उत्तर होना चाहिए। : किसी कारण से आप ES5 वाक्य रचना की जरूरत है और वसा तीर समारोह (उदास चेहरे) उपयोग नहीं कर सकते हैं, तो आप ऐसा कर सकते हैंarr.reduce(function(savedText, text) { return text.length > savedText.length ? text : savedText; }, '');

— maxshuty

Answer 10

मैं जेसन के कार्य से प्रेरित था और इसमें थोड़ा सुधार किया और परिणाम तेजी से ढूंढने वाले के रूप में मिला:

function timo_longest(a) {
  var c = 0, d = 0, l = 0, i = a.length;
  if (i) while (i--) {
    d = a[i].length;
    if (d > c) {
      l = i; c = d;
    }
  }
  return a[l];
}
arr=["First", "Second", "Third"];
var longest = timo_longest(arr);

गति के परिणाम: http://jsperf.com/longest-string-in-array/7

Answer 11

मैं ऐसा कुछ करूंगा:

function findLongestWord(str) {
var array = str.split(" ");
var maxLength=array[0].length;
for(var i=0; i < array.length; i++ ) {
if(array[i].length > maxLength) maxLength = array[i].length}
return maxLength;}

findLongestWord("What if we try a super-long word such as otorhinolaryngology");

Answer 12

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

function findLongestWord(str) {
  str = str.split(' ');
  var longest = 0;

  for(var i = 0; i < str.length; i++) {
     if(str[i].length >= longest) {
       longest = str[i].length;
        } 
     }
  return longest;
}
findLongestWord("The quick brown fox jumped over the lazy dog");

Answer 13

यदि आप एक से अधिक की अपेक्षा करते हैं, तो यह काम करेगा:

_.maxBy(Object.entries(_.groupBy(x, y => y.length)), y => parseInt(y[0]))[1]

यह लॉश का उपयोग करता है और एक सरणी देता है।

Answer 14

var longest = (arr) => {
  let sum = 0
  arr.map((e) => {
    sum = e.length > sum ? e.length : sum
  })
  return sum
}

यह काम हो सकता है

Answer 15

function findLongestWord(str) {
  str = str.split(" ");
  var sorted = str.sort(function(prev,current){
    return prev.length - current.length;   
  });
  var index = sorted.length;
  str = sorted[index-1];
  return str;
}
findLongestWord("The quick brown fox jumped over the lazy dog");

Comments

क्या यह मौजूदा उत्तरों की पहले से व्यापक सूची में कुछ भी जोड़ता है? नंबर

— luk2302

Answer 16

ES6 समर्थित डुप्लिकेट स्ट्रिंग के साथ

var allLongestStrings = arrayOfStrings => {
  let maxLng = Math.max(...arrayOfStrings.map( elem => elem.length))
  return arrayOfStrings.filter(elem => elem.length === maxLng)
}

let arrayOfStrings = ["aba", "aa", "ad", "vcd","aba"]

console.log(allLongestStrings(arrayOfStrings))

Answer 17

आधुनिक ब्राउज़र एक for...ofलूप का समर्थन करते हैं । Chrome, Safari, Edge और Firefox में इस समस्या को हल करने का सबसे तेज़ और सबसे छोटा तरीका भी सबसे साफ़ है:

let largest = '';
for (let item of arr) {
  if (item.length > largest.length) largest = item
}

IE में, आप उपयोग कर सकते हैंArray.forEach ; यह अभी भी सरणी को कम करने या कम करने की तुलना में अधिक तेज़ और स्पष्ट है।

var largest = '';
arr.forEach(function(item) {
  if (item.length > largest.length) largest = item
});

Answer 18

यह मेरा सरल उपाय है

var arr = ["you", "are", "the", "love", "of", "my", "life"];
var sorted = arr.sort(function (a, b){
     return b.length - a.length;
});

console.log(sorted[0])

Answer 19

function allLongestStrings(array) {
    const newArr=[];
    let temp =    Math.max(...(array.map(el => el.length)));    
     array.forEach(item => {
        if(temp == item.length){
          newArr.push(item);
        }
    });
    return newArr;
}

Comments

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

— ysf

Answer 20

var array = ["hello","falsey","undefined"];
var findLongestWord = function(array){
    var longest = array.reduce(function(a,b){
    return (a.length > b.length) ? a : b;
  });
    return longest;
}
findLongestWord(array);

Comments

एरो फ़ंक्शन का उपयोग करके अधिक क्लीनर तरीका: var findLongestWord = function (array) {var longest = array.reduce ((a, b) => {return (a.length> b.length)?: a: b;}); सबसे लंबे समय तक वापसी; }

— ऐश खान