জাভাস্ক্রিপ্ট - অন্য অ্যারের উপর ভিত্তি করে অ্যারে সাজান

Question

এই জাতীয় দেখায় এমন অ্যারে বাছাই এবং পুনরায় সাজানো কি সম্ভব:

itemsArray = [ 
    ['Anne', 'a'],
    ['Bob', 'b'],
    ['Henry', 'b'],
    ['Andrew', 'd'],
    ['Jason', 'c'],
    ['Thomas', 'b']
]

এই অ্যারের বিন্যাসের সাথে মেলে:

sortingArr = [ 'b', 'c', 'b', 'b', 'a', 'd' ]

দুর্ভাগ্যক্রমে, আমার ট্র্যাক রাখতে কোনও আইডি নেই। যথাসম্ভব কাছাকাছি বাছাই করা অ্যারের সাথে মেলে আমার আইটেম-অ্যারে অগ্রাধিকার প্রয়োজন।

হালনাগাদ:

আমি যে আউটপুটটি সন্ধান করছি তা এখানে:

itemsArray = [    
    ['Bob', 'b'],
    ['Jason', 'c'],
    ['Henry', 'b'],
    ['Thomas', 'b']
    ['Anne', 'a'],
    ['Andrew', 'd'],
]

এটি কীভাবে করা যায় কোনও ধারণা?

Comments

আপনি যদি ম্যানুয়ালি সবকিছু করতে না চান তবে অ্যারে ফাংশন sin PHP.js দেখুন ।

— আদি

কেবল বাছাই অ্যারির উপর দিয়ে লুপিং করে আইটেমগুলি আবার লিখুন অ্যারে

— এমপি্লুঞ্জন

যেখানে একাধিক অ্যারে একই সাজানোর মান রয়েছে (অর্থাত্ 'বি') আপনি কীভাবে সিদ্ধান্ত নেবেন যে সাজানো অ্যারেটিতে কোন আইটেমটি যায়? 'বব', 'হেনরি' এবং 'থমাস' যার যার মূল্য 'বি' রয়েছে - আপনি কীভাবে সিদ্ধান্ত নেবেন যে কোনটি প্রথম, তৃতীয় এবং চতুর্থ হয়?

— মিচ স্কচওয়েল

@ মিচস কি বাম থেকে ডানে পড়াটিকে অগ্রাধিকার দেওয়া সম্ভব হবে? এটি সত্যিকারের মাথাব্যথা, যেহেতু আমার তুলনা করার মতো কোনও আইডি নেই।

— ব্যবহারকারী 1448892

বাম থেকে ডানে আপনি কি অর্ডারটি মূল আইটেমআরে প্রদর্শিত হবে?

— মিচ স্যাচওয়েল

Answer 1

কিছুটা এইরকম:

items = [ 
    ['Anne', 'a'],
    ['Bob', 'b'],
    ['Henry', 'b'],
    ['Andrew', 'd'],
    ['Jason', 'c'],
    ['Thomas', 'b']
]

sorting = [ 'b', 'c', 'b', 'b', 'c', 'd' ];
result = []

sorting.forEach(function(key) {
    var found = false;
    items = items.filter(function(item) {
        if(!found && item[1] == key) {
            result.push(item);
            found = true;
            return false;
        } else 
            return true;
    })
})

result.forEach(function(item) {
    document.writeln(item[0]) /// Bob Jason Henry Thomas Andrew
})

এখানে একটি সংক্ষিপ্ত কোড, তবে এটি sortingঅ্যারেটিকে ধ্বংস করে :

result = items.map(function(item) {
    var n = sorting.indexOf(item[1]);
    sorting[n] = '';
    return [n, item]
}).sort().map(function(j) { return j[1] })

Comments

চতুষ্কোণ জটিলতা! প্রচুর পরিমাণে ডেটা দিয়ে এটি ব্যবহার করে দেখুন…

— জুলিয়েন রয়ের

@ থেগ ৪৩৫: "অপ্টিমাইজেশন" এর সাথে জটিলতার খুব কম সম্পর্ক রয়েছে, যদি না তথ্যের ভলিউম ছোট হওয়ার গ্যারান্টি দেওয়া হয় (যা এখানে পরিস্থিতি হতে পারে)।

— জুলিয়েন রয়ের

@ জর্জি যখন ডেটা স্ট্রাকচারের উপর অভিনয় করে অ্যালগরিদমগুলির জটিলতার কথা আসে, তখন চতুর্ভুজীয় (বা আরও খারাপ) জটিলতার সাথে অ্যালগরিদমগুলির অনুকূলকরণ কখনই অকাল হয় না এবং সর্বদা প্রয়োজনীয় হয় (যদি না আপনি ডেটা সেটের আকার ছোট হতে চলেছে তবে গ্যারান্টি দিতে পারবেন না) । পারফরম্যান্সের পার্থক্যটি (বেশ আক্ষরিক) আকারের ক্রমে প্রকাশ করা হয়।

— অ্যাবিয়ন 47

Answer 2

একটি লাইন উত্তর।

itemsArray.sort(function(a, b){  
  return sortingArr.indexOf(a) - sortingArr.indexOf(b);
});

Comments

এই পরিবর্তন হবে itemsArray। পারফরম্যান্সের প্রয়োজনীয়তার উপর নির্ভর করে এটি করা অনেক বেশি নিরাপদ হবে itemsArray.slice().sort(...)।

— সাওয়াতায়টিস

সাজানোর পদ্ধতি একটি অ্যারে ফিরিয়ে দেয়। বিকাশকারী.মোজিলা.অর্গ.ইন-

— ইউএস

এটি অ্যারেটি ফিরিয়ে দেয়, তবে এটি স্থানে বাছাই করে এবং আসলটি রূপান্তর করে।

— mynameistechno

এটি আসল উত্তর হওয়া উচিত

— urmurmur

@Morvael, এই এই উত্তর প্রয়োজন কারণে sortingArrসমস্ত মান ধারণ করার জন্য itemsArray। sortingArrallProducts.sort((product1, product2) => { const index1 = manualSort.indexOf(product1.id); const index2 = manualSort.indexOf(product2.id); return ( (index1 > -1 ? index1 : Infinity) - (index2 > -1 ? index2 : Infinity) ); });

— সমাধানটি হ'ল

Answer 3

আপনি যদি নেটিভ অ্যারে বাছাই করা ফাংশনটি ব্যবহার করেন তবে অ্যারে বাছাই করার সময় আপনি ব্যবহার করতে একটি কাস্টম তুলককে পাস করতে পারেন। প্রথম মানটি যদি দ্বিতীয়ের চেয়ে কম হয় তবে তুলনাকারীর একটি নেতিবাচক সংখ্যা, যদি সমান হয় তবে শূন্য এবং প্রথম মান বেশি হলে ধনাত্মক সংখ্যা প্রদান করা উচিত।

সুতরাং আপনি যদি উদাহরণটি সঠিকভাবে দিচ্ছেন তা যদি আমি বুঝতে পারি তবে আপনি এর মতো কিছু করতে পারেন:

function sortFunc(a, b) {
  var sortingArr = [ 'b', 'c', 'b', 'b', 'c', 'd' ];
  return sortingArr.indexOf(a[1]) - sortingArr.indexOf(b[1]);
}

itemsArray.sort(sortFunc);

Comments

এটি কাজ করবে না, ফলাফলটি indexOfপ্রথম সূচককে রিটার্ন হিসাবে খ, বি, বি, সি, সি, ডি হবে ।

— মিচ স্কচওয়েল

আপনাকে ধন্যবাদ, তবে আমি চাইছি আইটেম অ্যারে আউটপুটটি বাছাইয়ের অ্যারে মেলে।

— ব্যবহারকারী 1448892

আমি এই উত্তরটিকে প্রাধান্য দিচ্ছি যদি "আইডস" এর মধ্যে sortingArrঅনন্য হয় - যা, ধন্যবাদ, তারা আমার ক্ষেত্রে হয় :)

— dillondrenzek 16

আপনার কি ডিক্লেয়ার করা উচিত sortingArrayavoir ফাংশন বাইরে প্রতিটি বাছাই পুনরাবৃত্তির তে এটি পুনরায় ঘোষণা

— aurumpotestasest

Answer 4

কেস 1: আসল প্রশ্ন (কোনও গ্রন্থাগার নেই)

প্রচুর অন্যান্য উত্তর কাজ করে। :)

কেস ২: আসল প্রশ্ন (লোডাশ.জেএস বা ইনডিসোর.জেএস)

var groups = _.groupBy(itemArray, 1);
var result = _.map(sortArray, function (i) { return groups[i].shift(); });

কেস 3: অ্যারে 1 সাজান যাতে এটি অ্যারে 2 হয়

আমি অনুমান করছি যে বেশিরভাগ লোকেরা এখানে পিএইচপি'র অ্যারে_মালটিসোর্টের সমতুল্য সন্ধান করতে এসেছিল (আমি করেছি) তাই আমি ভেবেছিলাম যে উত্তরটিও পোস্ট করব। কয়েকটি বিকল্প রয়েছে:

1. অ্যারে_মালটিসোর্ট () এর বিদ্যমান জেএস প্রয়োগ রয়েছে । মন্তব্যগুলিতে এটি নির্দেশ করার জন্য @ আদনানকে ধন্যবাদ যদিও এটি বেশ বড়।

2. আপনার নিজের লিখুন। ( জেএসফিডাল ডেমো )

function refSort (targetData, refData) {
  // Create an array of indices [0, 1, 2, ...N].
  var indices = Object.keys(refData);

  // Sort array of indices according to the reference data.
  indices.sort(function(indexA, indexB) {
    if (refData[indexA] < refData[indexB]) {
      return -1;
    } else if (refData[indexA] > refData[indexB]) {
      return 1;
    }
    return 0;
  });

  // Map array of indices to corresponding values of the target array.
  return indices.map(function(index) {
    return targetData[index];
  });
}

3. Lodash.js বা Underscore.js (উভয় জনপ্রিয়, ছোট লাইব্রেরি যে কর্মক্ষমতা উপর ফোকাস) অফার সাহায্যকারী ফাংশন যে আপনি এটি করতে অনুমতি দেয়:

    var result = _.chain(sortArray)
      .pairs()
      .sortBy(1)
      .map(function (i) { return itemArray[i[0]]; })
      .value();

... (1) এর মধ্যে বাছাইআরআিকে গ্রুপ করবে [index, value] জোড়া হিসাবে ভাগ করবে, (২) মান অনুসারে বাছাই করুন (আপনি এখানে একটি করতে পারেন), (3) সূচীতে আইটেম অ্যারে থেকে আইটেমটির সাথে প্রতিটি জোড়া প্রতিস্থাপন করুন জোড়া উত্স থেকে।

Comments

দুর্দান্ত সমাধান, বিকল্প হিসাবে আপনি _.indexBy ব্যবহার করতে পারেন এবং যদি আপনার ডেটা কাঠামোটি আরও জটিল হয় তবে শিফটটি সরিয়ে ফেলতে পারেন

— ফ্রোজেনফায়ার

Answer 5

এটি সম্ভবত খুব দেরিতে তবে আপনি ES6 স্টাইলে নীচের কোডের কিছু সংশোধিত সংস্করণও ব্যবহার করতে পারেন। এই কোডটি অ্যারেগুলির মতো:

var arrayToBeSorted = [1,2,3,4,5];
var arrayWithReferenceOrder = [3,5,8,9];

আসল অপারেশন:

arrayToBeSorted = arrayWithReferenceOrder.filter(v => arrayToBeSorted.includes(v));

ES5 আসল অপারেশন:

arrayToBeSorted = arrayWithReferenceOrder.filter(function(v) {
    return arrayToBeSorted.includes(v);
});

ফলাফল হওয়া উচিত arrayToBeSorted = [3,5]

রেফারেন্স অ্যারে ধ্বংস করে না।

Comments

আমি যদি অ্যারেটিবোসর্টড অবজেক্টগুলির একটি অ্যারে অর্থাৎ: {1: {…}, 2: {…}, 3: {…}, 4: {…}, 5: {…}}? কিন্তু অ্যারেউইট রেফারেন্সআর্ডারটি কি কেবল একটি সাধারণ অ্যারে?

— ক্রিস্টাল

@ সুশ্রুত এই অ্যারেটিকে কীভাবে সাজান?

— হাইটাটোডস্ট্রাকচার

@ ক্রাইস্টাল, এটি একটি বস্তু, কোনও বস্তুর অ্যারে নয়। কোনও বস্তুর উপাদান / আইটেমগুলির কোনও অর্ডার নেই, অর্থাত্ তাদের ক্রমটি সেট করা নেই। একটি অ্যারের অবজেক্টের মতো দেখতে কিছু হবে [{name: "1"}, {name: "2"}, {name: "3"}, ...]।

— জনক

Answer 6

আমি মধ্যস্থতাকারী বস্তু ( itemsMap) ব্যবহার করব , এভাবে চতুর্ভুজ জটিলতা এড়ানো:

function createItemsMap(itemsArray) { // {"a": ["Anne"], "b": ["Bob", "Henry"], …}
  var itemsMap = {};
  for (var i = 0, item; (item = itemsArray[i]); ++i) {
    (itemsMap[item[1]] || (itemsMap[item[1]] = [])).push(item[0]);
  }
  return itemsMap;
}

function sortByKeys(itemsArray, sortingArr) {
  var itemsMap = createItemsMap(itemsArray), result = [];
  for (var i = 0; i < sortingArr.length; ++i) {
    var key = sortingArr[i];
    result.push([itemsMap[key].shift(), key]);
  }
  return result;
}

Http://jsfiddle.net/eUskE/ দেখুন

Answer 7

var sortedArray = [];
for(var i=0; i < sortingArr.length; i++) {
    var found = false;
    for(var j=0; j < itemsArray.length && !found; j++) {
        if(itemsArray[j][1] == sortingArr[i]) {
            sortedArray.push(itemsArray[j]);
            itemsArray.splice(j,1);
            found = true;
        }
    }
}

http://jsfiddle.net/s7b2P/

ফলাফলের আদেশ: বব, জেসন, হেনরি, থমাস, অ্যানি, অ্যান্ড্রু

Answer 8

কেন এমন কিছু হয় না

//array1: array of elements to be sorted
//array2: array with the indexes

array1 = array2.map((object, i) => array1[object]);

মানচিত্রের ফাংশন সমস্ত সংস্করণে উপলভ্য নাও হতে পারে Javascript

Comments

এটিই সবচেয়ে পরিষ্কার সমাধান এবং উত্তরটি গ্রহণ করা উচিত। ধন্যবাদ!

— নিউম্যান

Answer 9

let a = ['A', 'B', 'C' ]

let b = [3, 2, 1]

let c = [1.0, 5.0, 2.0]

// these array can be sorted by sorting order of b

const zip = rows => rows[0].map((_, c) => rows.map(row => row[c]))

const sortBy = (a, b, c) => {
  const zippedArray = zip([a, b, c])
  const sortedZipped = zippedArray.sort((x, y) => x[1] - y[1])

  return zip(sortedZipped)
}

sortBy(a, b, c)

Comments

এই কোডটি কেন / কীভাবে প্রশ্নের উত্তর দেয় তা ব্যাখ্যা করে একটি সংক্ষিপ্ত বিবরণ / বিবরণ যোগ করার বিষয়ে দয়া করে বিবেচনা করুন।

— ইয়ান্নিস

Answer 10

এটি আমি যা খুঁজছিলাম এবং আমি অন্য অ্যারের উপর ভিত্তি করে অ্যারে অ্যারে বাছাইয়ের জন্য করেছি:

এটি ^ 3 এ এবং সেরা অনুশীলন নাও হতে পারে (ES6)

function sortArray(arr, arr1){
      return arr.map(item => {
        let a = [];
        for(let i=0; i< arr1.length; i++){
          for (const el of item) {
            if(el == arr1[i]){
              a.push(el);
            }   
            }
          }
          return a;
      });
    }
    
    const arr1 = ['fname', 'city', 'name'];
  const arr = [['fname', 'city', 'name'],
  ['fname', 'city', 'name', 'name', 'city','fname']];
  console.log(sortArray(arr,arr1));

এটি কারও সাহায্য করতে পারে

Answer 11

আমি একটি এপিআই থেকে প্রাপ্ত জেএসএন পে-লোডের জন্য আমাকে এটি করতে হয়েছিল, তবে এটি আমার যে ক্রমটি চেয়েছিল সেটি ছিল না।

অ্যারেটি রেফারেন্স অ্যারে হতে হবে, আপনি দ্বিতীয় অ্যারে অনুসারে বাছাই করতে চান:

var columns = [
    {last_name: "last_name"},
    {first_name: "first_name"},
    {book_description: "book_description"},
    {book_id: "book_id"},
    {book_number: "book_number"},
    {due_date: "due_date"},
    {loaned_out: "loaned_out"}
];

আমি বস্তু হিসাবে এগুলি করেছি কারণ শেষ পর্যন্ত এগুলির অন্যান্য বৈশিষ্ট্য থাকবে।

তৈরি অ্যারে:

 var referenceArray= [];
 for (var key in columns) {
     for (var j in columns[key]){
         referenceArray.push(j);
     }
  }

এটি ডাটাবেস থেকে ফলাফল সেট সঙ্গে ব্যবহার। আমি জানি না এটি কতটা দক্ষ তবে আমি যে কয়েকটি কলাম ব্যবহার করেছি তার সাথে এটি দুর্দান্ত কাজ করেছে।

result.forEach((element, index, array) => {                            
    var tr = document.createElement('tr');
    for (var i = 0; i < referenceArray.length - 1; i++) {
        var td = document.createElement('td');
        td.innerHTML = element[referenceArray[i]];
        tr.appendChild(td);

    }
    tableBody.appendChild(tr);
}); 

Answer 12

নতুন অর্ডার করা অ্যারে পাওয়ার জন্য, আপনি Mapএকটি অ্যারেতে পছন্দসই চাবি সহ সমস্ত আইটেম সংগ্রহ করতে এবং পছন্দসই গ্রুপের শিফট উপাদানটি নিয়ে পছন্দসই অর্ডারযুক্ত কীগুলি ম্যাপ করতে পারেন।

var itemsArray = [['Anne', 'a'], ['Bob', 'b'], ['Henry', 'b'], ['Andrew', 'd'], ['Jason', 'c'], ['Thomas', 'b']],
    sortingArr = [ 'b', 'c', 'b', 'b', 'a', 'd' ],
    map = itemsArray.reduce((m, a) => m.set(a[1], (m.get(a[1]) || []).concat([a])), new Map),
    result = sortingArr.map(k => (map.get(k) || []).shift());

console.log(result);

Comments

Myএটি আমার পক্ষে, আমি yet‍♂️ এর {}পরিবর্তে এখনও একই ব্যবহার Mapকরছি

— রাউ

Answer 13

let sortedOrder = [ 'b', 'c', 'b', 'b' ]
let itemsArray = [ 
    ['Anne', 'a'],
    ['Bob', 'b'],
    ['Henry', 'b'],
    ['Andrew', 'd'],
    ['Jason', 'c'],
    ['Thomas', 'b']
]
a.itemsArray(function (a, b) {
    let A = a[1]
    let B = b[1]

    if(A != undefined)
        A = A.toLowerCase()

    if(B != undefined)
        B = B.toLowerCase()

    let indA = sortedOrder.indexOf(A)
    let indB = sortedOrder.indexOf(B)

    if (indA == -1 )
        indA = sortedOrder.length-1
    if( indB == -1)
        indB = sortedOrder.length-1

    if (indA < indB ) {
        return -1;
    } else if (indA > indB) {
        return 1;
    }
    return 0;
})

বাছাই কীটি রেফারেন্স অ্যারেতে উপস্থিত না থাকলে এই সমাধানটি শেষে অবজেক্টগুলিকে সংযোজন করবে

Answer 14

এটি কাজ করা উচিত:

var i,search, itemsArraySorted = [];
while(sortingArr.length) {
    search = sortingArr.shift();
    for(i = 0; i<itemsArray.length; i++) {
        if(itemsArray[i][1] == search) {
            itemsArraySorted.push(itemsArray[i]);
            break;
        }
    } 
}

itemsArray = itemsArraySorted;

Answer 15

আপনি এই পদ্ধতিটি চেষ্টা করতে পারেন।

const sortListByRanking = (rankingList, listToSort) => {
  let result = []

  for (let id of rankingList) {
    for (let item of listToSort) {
      if (item && item[1] === id) {
        result.push(item)
      }
    }
  }

  return result
}

Answer 16

ES6

const arrayMap = itemsArray.reduce(
  (accumulator, currentValue) => ({
    ...accumulator,
    [currentValue[1]]: currentValue,
  }),
  {}
);
const result = sortingArr.map(key => arrayMap[key]);

বিভিন্ন ইনপুট অ্যারে সহ আরও উদাহরণ

Answer 17

আপনার যদি এখানে কিছু বস্তুর অ্যারে দিয়ে কাজ করার প্রয়োজন হয় তবে এখানে @ দুর্গपाल সিং এর দুর্দান্ত উত্তরটির একটি রূপান্তর:

const itemsArray = [
  { name: 'Anne', id: 'a' },
  { name: 'Bob', id: 'b' },
  { name: 'Henry', id: 'b' },
  { name: 'Andrew', id: 'd' },
  { name: 'Jason', id: 'c' },
  { name: 'Thomas', id: 'b' }
]

const sortingArr = [ 'b', 'c', 'b', 'b', 'a', 'd' ]

Object.keys(itemsArray).sort((a, b) => {
  return sortingArr.indexOf(itemsArray[a].id) - sortingArr.indexOf(itemsArray[b].id);
})

Answer 18

JQuery থেকে $ .inArray () পদ্ধতিটি ব্যবহার করুন। আপনি তখন এরকম কিছু করতে পারেন

var sortingArr = [ 'b', 'c', 'b', 'b', 'c', 'd' ];
var newSortedArray = new Array();

for(var i=sortingArr.length; i--;) {
 var foundIn = $.inArray(sortingArr[i], itemsArray);
 newSortedArray.push(itemsArray[foundIn]);
}

Answer 19

দুটি অ্যারে ছেদ ব্যবহার করুন।

উদা:

var sortArray = ['a', 'b', 'c',  'd', 'e'];

var arrayToBeSort = ['z', 's', 'b',  'e', 'a'];

_.intersection(sortArray, arrayToBeSort) 

=> ['ক', 'বি', 'ই']

যদি 'z এবং' s 'প্রথম অ্যারের সীমার বাইরে থাকে, ফলাফলের শেষে এটি যুক্ত করুন

Answer 20

আপনি এর মতো কিছু করতে পারেন:

function getSorted(itemsArray , sortingArr ) {
  var result = [];
  for(var i=0; i<arr.length; i++) {
    result[i] = arr[sortArr[i]];
  }
  return result;
}

আপনি এটি এখানে পরীক্ষা করতে পারেন ।

দ্রষ্টব্য: এটি ধরে নেয় যে আপনি যে অ্যারে পাস করেছেন সেগুলি আকারের সমতুল্য, যদি এটি না হয় তবে আপনাকে কিছু অতিরিক্ত চেক যুক্ত করতে হবে।

লিঙ্ক উল্লেখ করুন

পড়ুন

Comments

এটিকে খারাপভাবে সম্পাদনার দরকার। শুধু জফিটালই ভুল ফলটি দেয় না, ফাংশন আর্গুমেন্টের নামগুলি অন্তর্ের সামগ্রীর সাথে মেলে না?

— twobob