স্ট্রিং অ্যারেটিতে দীর্ঘতম স্ট্রিংটি খুঁজে পাওয়ার জন্য কি কোনও ছোট্ট উপায় আছে?
এরকম কিছু arr.Max(x => x.Length);?
উত্তর:
উপলভ্য যেহেতু জাভাস্ক্রিপ্ট 1.8 / এর নাম ECMAScript 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];
reduceকলব্যাক ফাংশন ব্যবহার করতে পারবেন যা অ্যারে ফেরত দেয়।
একটি পুরানো প্রশ্নের নতুন উত্তর: ES6 এ আপনি সংক্ষিপ্ত করতে পারেন:
Math.max(...(x.map(el => el.length)));
O(n^2)যেখানে অন্যান্য বিকল্পগুলি কেবল একবার সংগ্রহকে অতিক্রম করবে O(n)। কাস্টম sortO(log(n))
O(n) + O(n) = O(n), তা নয় O(n^2)।
আমি এই জাতীয় কিছু করব
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);অ্যারে.প্রোটোটাইপ ব্যবহার করে - (@ ক্যাটসপফ পোস্ট করেছেন এমনভাবে সাজান এবং আমি ফিডল করার সময় @ ডেসেজ)
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());
আমি একটি কার্যকরী + পুনরাবৃত্ত পদ্ধতির সরবরাহ করি। এটি কীভাবে কাজ করে তা বুঝতে মন্তব্যগুলি দেখুন:
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)সম্ভবত দ্রুততম না, তবে অবশ্যই বেশ পাঠযোগ্য:
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 + থেকে সমর্থিত ।
ES6- 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']))arr.reduce(function(savedText, text) { return text.length > savedText.length ? text : savedText; }, '');
আমি জেসনের ফাংশন থেকে অনুপ্রাণিত হয়ে তাতে কিছুটা উন্নতি করেছি এবং ফলস্বরূপ দ্রুত অনুসন্ধানকারী হয়েছি:
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
আমি এরকম কিছু করব:
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");
যদি আপনার স্ট্রিং ইতিমধ্যে একটি অ্যারেতে বিভক্ত হয়ে গেছে, আপনার বিভক্ত অংশের প্রয়োজন হবে না।
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");
আপনি যদি একাধিকের বেশি আশা করেন তবে এটি কাজ করবে:
_.maxBy(Object.entries(_.groupBy(x, y => y.length)), y => parseInt(y[0]))[1]
এটি লোডাশ ব্যবহার করে এবং একটি অ্যারে দেয়।
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");
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))
আধুনিক ব্রাউজারগুলি একটি for...ofলুপ সমর্থন করে । ক্রোম, সাফারি, এজ এবং ফায়ারফক্সে এই সমস্যা সমাধানের দ্রুত এবং সংক্ষিপ্ততম উপায়টিও সবচেয়ে পরিষ্কার:
let largest = '';
for (let item of arr) {
if (item.length > largest.length) largest = item
}
আইই, আপনি ব্যবহার করতে পারেনArray.forEach ; এটি অ্যারে বাছাই বা হ্রাস করার চেয়ে আরও দ্রুত এবং স্পষ্ট।
var largest = '';
arr.forEach(function(item) {
if (item.length > largest.length) largest = item
});
এটি আমার সহজ সমাধান
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])
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;
}
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);