কিভাবে পূর্ণসংখ্যার অ্যারে সঠিকভাবে সাজান


845

আমি জানি যে কেবলমাত্র পূর্ণসংখ্যা থাকবে এমন কোনও অ্যারের থেকে সর্বাধিক এবং সর্বনিম্ন মান অর্জনের চেষ্টা করা আমার ধারণা থেকে আরও শক্ত বলে মনে হচ্ছে।

var numArray = [140000, 104, 99];
numArray = numArray.sort();
alert(numArray)

আমি এটি প্রদর্শন আশা করি 99, 104, 140000। পরিবর্তে এটি দেখায় 104, 140000, 99। সুতরাং মনে হচ্ছে সাজানোর মানগুলি স্ট্রিং হিসাবে পরিচালনা করছে।

বাছাইয়ের কার্যকারিতাটি আসলে পূর্ণসংখ্যার মান অনুসারে সাজানোর কোনও উপায় আছে কি?


10
লক্ষ্য করুন যে শীর্ষস্থানীয় উত্তরগুলির মধ্যে কেউই সমস্ত ভাসমান-পয়েন্টের মানগুলি সঠিকভাবে মোকাবেলা করে না; বিশেষত, তাদের কেউই পরিচালনা করেন না NaN। এমন একটি উচ্চ-স্থানের উত্তরটি দেখতে ভাল লাগবে যেটি এর সাথে সম্পর্কিত NaN
কুইকসপ্লসোন

3
বিটিডাব্লু, আপনি যদি প্রচুর সংখ্যক পূর্ণসংখ্যার বাছাই করে থাকেন তবে গণনা বাছাইয়ের মতো একটি পূর্ণসংখ্যা বাছাই অ্যালগরিদম ব্যবহার করা সুবিধা হবে । সময় গণনার ক্রমটি আপনার অ্যারের আকারের সাথে সুশৃঙ্খলভাবে স্কেলগুলি চালাতে সময় নেবে: O (n)। যদিও এখানে সমস্ত সমাধান তুলনামূলক ধরণের ব্যবহার করে যা কম দক্ষ: ও (এন * লগ এন)।
ওয়েব_ডিজাইনার

1
@ ওয়েব_ডিজাইনার কাউন্টিং সাজ্ট অ্যারে নয়, সংখ্যা পরিসীমা সম্পর্কিত রৈখিক। উদাহরণস্বরূপ, [1,1000000] বাছাই করা 2 টিরও বেশি পদক্ষেপ গ্রহণ করবে, যেহেতু অ্যালগরিদমটি প্রতিটি ঘরের সূচক 1 থেকে 1000000 এর মধ্যে স্ক্যান করতে হবে কোন কোষের মান 0 এর চেয়ে বেশি হবে তা দেখতে
yters

2
@ ইয়াইটার্স হ্যাশম্যাপ ব্যবহার করে আপনি কেবল পূর্ণসংখ্যার দিকে মনোযোগ দিতে পারেন যা সাজানো অ্যারেটিতে প্রদর্শিত হয়। এটি সাজানোর রৈখিক আর্টের আকারটি রিট করে।
কেভিন

1
দ্রুততম উপায় হ'ল isomorphic সারণি -অ্যারে মডিউলটি যা ব্রাউজার এবং নোড উভয় ক্ষেত্রেই স্থানীয়ভাবে কাজ করে, যে কোনও ধরণের ইনপুট, গণিত ক্ষেত্র এবং কাস্টম সাজানোর আদেশকে সমর্থন করে।
লয়েড

উত্তর:


1230

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

var numArray = [140000, 104, 99];
numArray.sort(function(a, b) {
  return a - b;
});

console.log(numArray);

ES6 এ, আপনি এটি তীর ফাংশন দিয়ে সহজ করতে পারেন:

numArray.sort((a, b) => a - b); // For ascending sort
numArray.sort((a, b) => b - a); // For descending sort

ডকুমেন্টেশন:

মোজিলা Array.prototype.sort()এই অ্যারেগুলির জন্য এই তুলনা কার্যটি সুপারিশ করে যা ইনফিনিটি বা নাএন থাকে না। (কারণ Inf - InfNaN, 0 নয়)।

কী দ্বারা বস্তু বাছাইয়ের উদাহরণ।


147
খুশী হলাম। তবে জাভাস্ক্রিপ্ট থেকে সংখ্যার মতো বাছাই করার সত্যিই বাইরের কোনও উপায় নেই?
পিয়ারিক্স

39
আহ এই বাক্সের বাইরে! তবে আপনি যদি সত্যই অবাস্তব হন তবে আপনি আপনার জাভাস্ক্রিপ্টের একেবারে শুরুতে অ্যারে শ্রেণীর শ্রেণিতে ফাংশনগুলিকে আবদ্ধ করতে পারেন: // অ্যারে.প্রোটোটাইপ.সোর্টনরমাল = ফাংশন () {ফেরত এই.সোর্ট (ফাংশন (ক, খ) {ফিরিয়ে দিন) - বি})} // এখন কোনও অ্যারেতে .sortNormal () কল করা এটি সংখ্যাগতভাবে বাছাই করবে
জ্যাক ফ্রাঞ্জেন

13
কেন আব এবং অ> বি। অপারেশন মেশিনের ত্রুটিগুলি এড়াতে আমি সর্বশেষটির পরামর্শ দিচ্ছি
লুকা দাভানজো

35
@ ওয়েলথুন তুলনা ফাংশনটি -1, 0 বা +1 এ ফিরে আসবে। a> খ কেবল সত্য বা মিথ্যা প্রত্যাবর্তন করবে।
ইভান পেরেজ

48
এই কোডটি একটি তীর ফাংশন ব্যবহার করে সংক্ষিপ্ত করা যেতে পারে । numberArray.sort((a, b) => (a - b));হ্যাঁ! আমি মনে করি এটি বক্স-অফ-দ্য বক্সের কাছাকাছি। দ্রষ্টব্য: আপনার জেএস ইঞ্জিন তীর ফাংশন সমর্থন করে কিনা তা পরীক্ষা করে দেখুন।
Константин Ван

173

উপরের সমস্ত উত্তরগুলির উপর ভিত্তি করে, সেগুলিও এক লাইনে এইভাবে করা যেতে পারে:

var numArray = [140000, 104, 99];

// ES5
numArray = numArray.sort(function (a, b) {  return a - b;  });

// ES2015
numArray = numArray.sort((a, b) => a - b);

//outputs: 99, 104, 140000

8
ফিক্সড @bodyflex: var arr = [140000, 104, 99].sort(function(a,b) { return a-b; });। বা আরও কমপ্যাক্ট, ES6let arr = [140000, 104, 99].sort((a,b) => a-b);
00500005

1
আমি উপরের মন্তব্যে যেমন বলেছি, তীর ফাংশনগুলি এখানে একটি খারাপ ফিট এবং আমি যে কাউকে এইভাবে ব্যবহার করা থেকে নিরুৎসাহিত করব। শব্দগুলি কাটাতে আপনি তীর সিনট্যাক্সের একটি পার্শ্ব প্রতিক্রিয়া ব্যবহার করছেন functionএবং return, কিন্তু আসলে তীর ফাংশনের উত্তীর্ণের আসল উদ্দেশ্যটি ব্যবহার করছেন না this। এই কোডটি বোঝায় যে এখানে কিছু thisপ্রসঙ্গ ঘটছে, কিন্তু তা নেই। অন্য কয়েকটি বিকাশকারীকে আপনার কোড পড়ার জন্য বিভ্রান্ত করছে, কেবল কয়েকটি অক্ষর সংরক্ষণ করতে। পার্শ্ব প্রতিক্রিয়া - উদ্দেশ্য সহ কোডের উপর নির্ভর করবেন না!
বামবেরি

12
@ ব্যামবেরি আমি মনে করি না যে প্রসঙ্গ পরিবর্তনের জন্য আপনার কেবল একটি তীর ফাংশন ব্যবহার করা দরকার ...
টেড মরিন

7
@ বেমবেরি, আপনি আসলে তীর ফাংশনটি কী করছে তা ভুল বুঝবেন। আপনি মনে করেন যে এটি কোনওভাবে thisফাংশনে প্রবেশ করে তবে এটি সত্য নয়। এটি আসলে একটি thisএবং argumentsভেরিয়েবল তৈরি করতে অবহেলা করে যা সাধারণত প্যারেন্ট ভেরিয়েবলগুলিকে ওভাররাইট করে। thisতীর ফাংশনের অভ্যন্তরে আপনি কেবলমাত্র কারণটি ব্যবহার করতে পারেন তা হ'ল লেক্সিকাল স্কোপিং।
কুঠ

2
@ বেমব্রির যে বয়স ভাল ছিল না ... তিন বছর পরে এবং আধুনিক জাভাস্ক্রিপ্ট বিকাশ প্রায় একচেটিয়াভাবে তীর ফাংশন ব্যবহার করে। :)
কিপ করুন

71

অ্যারে.সর্ট একটি সংখ্যার বাছাইয়ের জন্য ডিফল্টরূপে একটি অভিধানিক সাজ সাজান, আপনার নিজের ফাংশন সরবরাহ করুন। এখানে একটি সাধারণ উদাহরণ:

function compareNumbers(a, b)
{
    return a - b;
}

numArray.sort(compareNumbers);

এছাড়াও নোট করুন যে বাছাই "স্থানে" কাজ করে, অ্যাসাইনমেন্টের কোনও প্রয়োজন নেই।


আমি উপরের কোডটি বুঝতে পারি নি, "রিটার্ন এ - বি" কীভাবে আরোহী বাছাই করে?
বিক্রমভি

যদি <b, তুলনা নম্বরগুলি একটি নেতিবাচক সংখ্যা প্রদান করে। যদি এ> বি হয় তবে এটি ইতিবাচক হবে। যদি সমান হয় তবে এটি 0 ফিরে আসে
পল ডিকসন

38

এই উত্তরটি বিদ্যমান কয়েকটি প্রশ্নের উত্তরের সমতুল্য, তবে ECMAScript 6 টি তীর ফাংশনগুলি আরও অনেকগুলি কমপ্যাক্ট বাক্য গঠন প্রদান করে যা আমাদের পাঠযোগ্যতার ত্যাগ ছাড়াই একটি ইনলাইন সাজানোর ক্রিয়াটি সংজ্ঞায়িত করতে দেয়:

numArray = numArray.sort((a, b) => a - b);

এটি বর্তমানে বেশিরভাগ ব্রাউজারে সমর্থিত ।


1
"পাঠযোগ্যতার ত্যাগ ছাড়াই"। এটি বিষয়গত। কিছু সাধারণ পূর্ণসংখ্যার সাথে এটি পঠনযোগ্য। জটিল বস্তুগুলির সাথে কাজ করার সময় এবং আপনি কোনও সম্পত্তি বাছাই করতে চান, এত বেশি নয়।
ত্রিস্তান

3
@ ত্রিস্তান, কোনও সামগ্রীর সম্পত্তি বাছাই করা এখনও এই সিনট্যাক্সটি ব্যবহার করে খুব পরিষ্কারভাবে করা যায়। আপনি যে objArray=objArray.sort((a,b)=>a.numProperty - b.numProperty);objArray=objArray.sort((a,b)=>a.strProperty.localeCompare(b.strProperty))‌​;
জিনিসটির

34

আমি অবাক হয়েছি কেন সকলে তুলনামূলক ফানসিটন পাস করার পরামর্শ দেয় sort() , এটি বাছাই করা সত্যিই ধীর করে দেয়!

সংখ্যা বাছাই করতে, কেবল যে কোনও টাইপড্রেই তৈরি করুন :

var numArray = new Uint32Array([140000, 104, 99]);
numArray = numArray.sort();
alert(numArray)


4
একটি টাইপড্রাই ব্যবহার করে গতি অনুসারে প্রায় 5 এক্স গতি বাড়ানো হয়। আপনি যদি আরও দ্রুত এইচপিসি-অ্যালগরিদম এনপিএম প্যাকেজ যেতে চান তবে Radix Sort এবং গণনা অনুসারে বাছাই করুন যা বেশ কয়েকটি উত্তর এখানে প্রস্তাবিত করে।
ড্রাগনস্পিট

বাহ, জানত না এই অস্তিত্ব!
পিক্সিলিথ

21

সাজানোর কাজটি এত অদ্ভুত আচরণ করার কারণ

ডকুমেন্টেশন থেকে :

[...] অ্যারের প্রতিটি অক্ষরের স্ট্রিং রূপান্তর অনুসারে প্রতিটি চরিত্রের ইউনিকোড কোড পয়েন্ট মান অনুসারে বাছাই করা হয়।

আপনি যদি অ্যারের ইউনিকোড পয়েন্ট মানগুলি মুদ্রণ করেন তবে তা পরিষ্কার হয়ে যাবে।

console.log("140000".charCodeAt(0));
console.log("104".charCodeAt(0));
console.log("99".charCodeAt(0));

//Note that we only look at the first index of the number "charCodeAt(  0  )"

এটি ফিরে আসে: "49, 49, 57"।

49 (unicode value of first number at 140000)
49 (unicode value of first number at 104)
57 (unicode value of first number at 99)

এখন, কারণ 140000 এবং 104 একই মানগুলি ফেরত দিয়েছে (49) এটি প্রথম সূচকটি কেটে দেয় এবং আবার চেক করে:

console.log("40000".charCodeAt(0));
console.log("04".charCodeAt(0));

//Note that we only look at the first index of the number "charCodeAt(  0  )"

52 (unicode value of first number at 40000)
40 (unicode value of first number at 04)

যদি আমরা এটি বাছাই করি, তবে আমরা পাবেন:

40 (unicode value of first number at 04)
52 (unicode value of first number at 40000)

সুতরাং 104 140000 এর আগে আসে।

সুতরাং চূড়ান্ত ফলাফল হবে:

var numArray = [140000, 104, 99];
numArray = numArray.sort();
console.log(numArray)

104, 140000, 99

উপসংহার:

sort() সংখ্যাগুলির প্রথম সূচকটি দেখে বাছাই করে। sort()পুরো সংখ্যাটি অন্যটির চেয়ে বড় কিনা তা বিবেচ্য নয়, এটি অঙ্কগুলির ইউনিকোডের মান তুলনা করে এবং যদি দুটি সমান ইউনিকোড মান থাকে তবে এটি পরের সংখ্যাটি রয়েছে কিনা তা পরীক্ষা করে এটিও তুলনা করে।

সঠিকভাবে বাছাই করতে, আপনাকে এখানেsort() বর্ণিত পছন্দ মতো তুলনা ফাংশনটি পাস করতে হবে ।


ইঙ্গিত: এটি কেবল আমার ব্যাখ্যা, আমি আসলে কোডটি দেখিনি। সুতরাং এই উত্তরটি পুরোপুরি বিশ্বাস করবেন না।
কালো

17

আমি aks এর সাথে একমত হই, তবে ব্যবহারের পরিবর্তে

return a - b;

আপনার ব্যবহার করা উচিত

return a > b ? 1 : a < b ? -1 : 0;

18
আপনি কেন ব্যাখ্যা করতে পারেন যে কারও কেন আপনার আরও অপঠনযোগ্য টেননারী অপারেশন ব্যবহার করা উচিত ? আমি যতদূর বলতে পারি এটির একই ফল হবে।
স্টিফাননিউ

6
এই উত্তরটিও সমান মূল্যবোধ বিবেচনা করে এবং তাদের একই জায়গায় ফেলে দেয়।
মার্টেন 100

23
এবং একটি - বি না?
ব্রায়ান রায়নার

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

8
>এবং <এখনো স্ট্রিং যেমন a ও b তুলনা করুন।
ভ্রিজডেমিকেল

11

নতুন ES6 বিশ্বে এটি বাছাই করা অনেক সহজ

numArray.sort((a,b) => a-b);

আপনার যা দরকার তা হ'ল :)


10

জাভাস্ক্রিপ্টে বাছাই () পদ্ধতির ডিফল্ট আচরণ হ'ল বর্ণগুলিতে অ্যারেতে মানগুলি বাছাই করা।

সংখ্যার অনুসারে বাছাই করতে আপনাকে একটি সংখ্যার সাজানোর ক্রিয়াটি নির্ধারণ করতে হবে (যা খুব সহজ):

...
function sortNumber(a, b)
{
  return a - b;
}

numArray = numArray.sort(sortNumber);

8

অ্যারে.প্রোটোটাইপ.সর্ট () হ'ল অ্যারে বাছাই করার পদ্ধতি যা তবে আমাদের কয়েকটি সচেতন হওয়া দরকার of

সাজানোর ক্রমটি অ্যারে মানের ধরণ নির্বিশেষে ডিফল্ট লিক্সোগ্রাফিক এবং সংখ্যাগত নয়। অ্যারেটি সমস্ত সংখ্যার হলেও, সমস্ত মান স্ট্রিংয়ে রূপান্তরিত হবে এবং অভিধানিকভাবে সাজানো হবে।

সুতরাং আমাদের নীচের মত বাছাই () এবং বিপরীত () পদ্ধতি কাস্টমাইজ করা প্রয়োজন।

রেফারেল ইউআরএল

অ্যারের ভিতরে সংখ্যা বাছাই করার জন্য

numArray.sort(function(a, b)
{
    return a - b;
});

অ্যারের ভিতরে নম্বরগুলি বিপরীত করার জন্য

numArray.sort(function(a, b)
{
    return b - a;
});

রেফারেল ইউআরএল


6

প্রশ্নের ইতিমধ্যে উত্তর দেওয়া হয়েছে, সবচেয়ে সংক্ষিপ্ততম sort()পদ্ধতিটি পদ্ধতি ব্যবহার করা । তবে আপনি যদি নিজের সংখ্যার অ্যারে বাছাই করার আরও উপায়গুলি অনুসন্ধান করে থাকেন এবং আপনি চক্রটিও পছন্দ করেন তবে নিম্নলিখিতটি দেখুন

সন্নিবেশ সাজান

আরোহী:

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length; i++) {
    var target = numArray[i];
    for (var j = i - 1; j >= 0 && (numArray[j] > target); j--) {
        numArray[j+1] = numArray[j];
    }
    numArray[j+1] = target
}
console.log(numArray);

নিম্নক্রম:

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length; i++) {
    var target = numArray[i];
    for (var j = i - 1; j >= 0 && (numArray[j] < target); j--) {
        numArray[j+1] = numArray[j];
    }
    numArray[j+1] = target
}
console.log(numArray);

নির্বাচনের ধরণ:

আরোহী:

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length - 1; i++) {
    var min = i;
    for (var j = i + 1; j < numArray.length; j++) {
        if (numArray[j] < numArray[min]) {
            min = j;
        }
    }
    if (min != i) {
        var target = numArray[i];
        numArray[i] = numArray[min];
        numArray[min] = target;
    }
}
console.log(numArray);

নিম্নক্রম:

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length - 1; i++) {
    var min = i;
    for (var j = i + 1; j < numArray.length; j++) {
        if (numArray[j] > numArray[min]) {
            min = j;
        }
    }
    if (min != i) {
        var target = numArray[i];
        numArray[i] = numArray[min];
        numArray[min] = target;
    }
}
console.log(numArray);

আনন্দ কর


এই উত্তরগুলির মতো টাইপড্ররে ব্যবহারের চেয়ে ক্ষুদ্রতর অ্যারেগুলির জন্য আসলে কি এগুলির মধ্যে কোনও দ্রুত ? অবশ্যই তারা মাঝারি থেকে বড় অ্যারেগুলির জন্য দ্রুত হবে না কারণ এগুলি হে (এন ^ 2) অ্যালগরিদম। sort()
পিটার

5

'সংখ্যার দিক দিয়ে' ফাংশনটি কলব্যাক ফাংশন হিসাবে সরবরাহ করার সময় অনেক ক্ষেত্রে সংখ্যার অ্যারে বাছাই করার উদ্দেশ্যে কাজ করে:

function numerically(a, b){
    return a-b;
}

array.sort(numerically); 

তবে কিছু বিরল উদাহরণস্বরূপ, যেখানে অ্যারেতে খুব বড় এবং নেতিবাচক সংখ্যা রয়েছে, জাভাস্ক্রিপ্ট যে সামান্যতম সংখ্যার সাথে মোকাবিলা করতে পারে তার চেয়ে ছোট আকারের ফলে আবের ফলস্বরূপ ত্রুটি ঘটতে পারে।

সুতরাং সংখ্যাগতভাবে ফাংশন লেখার একটি আরও ভাল উপায় নিম্নরূপ:

function numerically(a, b){
   if(a < b){
      return -1;
   } else if(a > b){
      return 1;
   } else {
      return 0;
   }
}

1
জাভাস্ক্রিপ্ট নম্বরগুলি ভাসমান-পয়েন্ট। আইইইই 7575৫ ওভারফ্লো এবং আন্ডারফ্লো নিয়মগুলি সংজ্ঞায়িত করে, ওভারফ্লো + + ইনফিনিটি এবং আন্ডারফ্লো নিম্নতর বা + -0.0 এ। আমি মনে করি না যে দুটি সংখ্যার বিয়োগটি বড় এবং কাছাকাছি উভয় সমান হলেও এমনকি + -0.0 এ আন্ডারফ্লো হতে পারে। দুটি ডাবলের মধ্যে পার্থক্য সর্বদা অন্য শূন্য নন ডাবল হিসাবে প্রতিনিধিত্বযোগ্য (যদি না এটি ওভারফ্লো হয় তবে DBL_MIN - DBL_MAX) তবে আন্ডারফ্লো সম্ভব হয় না। বিপর্যয়কর বাতিলকরণ ফলাফলটিকে অদম্য করে তোলে, এর বেশিরভাগ "উল্লেখযোগ্য সংখ্যা" হারাতে থাকে, তবে a-bসর্বদা শূন্য নয় এবং এর জন্য একটি সঠিক চিহ্ন থাকবে! = খ।
পিটার

4

অপরিজ্ঞাত, নাল এবং NaN পরিচালনা করতে: নাল 0, NaN এর মতো আচরণ করে এবং অপরিবর্তিত শেষ হয়।

array = [3, 5, -1, 1, NaN, 6, undefined, 2, null]
array.sort((a,b) => isNaN(a) || a-b)
// [-1, null, 1, 2, 3, 5, 6, NaN, undefined]

3

উপাদানের সাধারণ অ্যারের মানগুলির জন্য:

function sortArrayOfElements(arrayToSort) {
    function compareElements(a, b) {
        if (a < b)
            return -1;
        if (a > b)
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareElements);
}

e.g. 1:
var array1 = [1,2,545,676,64,2,24]
**output : [1, 2, 2, 24, 64, 545, 676]**

var array2 = ["v","a",545,676,64,2,"24"]
**output: ["a", "v", 2, "24", 64, 545, 676]**

বস্তুর অ্যারের জন্য:

function sortArrayOfObjects(arrayToSort, key) {
    function compareObjects(a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareObjects);
}

e.g. 1: var array1= [{"name": "User4", "value": 4},{"name": "User3", "value": 3},{"name": "User2", "value": 2}]

**output : [{"name": "User2", "value": 2},{"name": "User3", "value": 3},{"name": "User4", "value": 4}]**

2

হালনাগাদ! smartSortপ্রোপ অ্যাডেটিভের জন্য উত্তরের নীচে স্ক্রোল করুন যা আরও মজাদার দেয়!
যে কোনও কিছুর অ্যারে !

আমার এই ক্রিয়াকলাপের ব্যক্তিগত পছন্দের ফর্মটি আরোহী বা উতরাইয়ের জন্য একটি প্যারামের অনুমতি দেয়:

function intArraySort(c, a) {
    function d(a, b) { return b - a; }
    "string" == typeof a && a.toLowerCase();
    switch (a) {
        default: return c.sort(function(a, b) { return a - b; });
        case 1:
                case "d":
                case "dc":
                case "desc":
                return c.sort(d)
    }
};

ব্যবহার যেমন সহজ:

var ara = function getArray() {
        var a = Math.floor(Math.random()*50)+1, b = [];
        for (i=0;i<=a;i++) b.push(Math.floor(Math.random()*50)+1);
        return b;
    }();

//    Ascending
intArraySort(ara);
console.log(ara);

//    Descending
intArraySort(ara, 1);
console.log(ara);

//    Ascending
intArraySort(ara, 'a');
console.log(ara);

//    Descending
intArraySort(ara, 'dc');
console.log(ara);

//    Ascending
intArraySort(ara, 'asc');
console.log(ara);

jsFiddle


বা কোড স্নিপেট উদাহরণ এখানে!

function intArraySort(c, a) {
	function d(a, b) { return b - a }
	"string" == typeof a && a.toLowerCase();
	switch (a) {
		default: return c.sort(function(a, b) { return a - b });
		case 1:
		case "d":
		case "dc":
		case "desc":
		return c.sort(d)
	}
};

function tableExample() {
	var d = function() {
			var a = Math.floor(50 * Math.random()) + 1,
				b = [];
			for (i = 0; i <= a; i++) b.push(Math.floor(50 * Math.random()) + 1);
			return b
		},
		a = function(a) {
			var b = $("<tr/>"),
				c = $("<th/>").prependTo(b);
			$("<td/>", {
				text: intArraySort(d(), a).join(", ")
			}).appendTo(b);
			switch (a) {
				case 1:
				case "d":
				case "dc":
				case "desc":
					c.addClass("desc").text("Descending");
					break;
				default:
					c.addClass("asc").text("Ascending")
			}
			return b
		};
	return $("tbody").empty().append(a(), a(1), a(), a(1), a(), a(1), a(), a(1), a(), a(1), a(), a(1))
};

tableExample();
table { border-collapse: collapse; }
th, td { border: 1px solid; padding: .25em .5em; vertical-align: top; }
.asc { color: red; }
.desc { color: blue }
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<table><tbody></tbody></table>


.smartSort ('asc' | 'desc')

বাছাইয়ের পদ্ধতিতে এখন আরও মজা করুন যা একাধিক আইটেমগুলিতে পূর্ণ অ্যারে সাজায়! বর্তমানে "এসোসিয়েটিভ" (ওরফে, স্ট্রিং কীগুলি) কভার করে না, তবে এটি প্রতিটি ধরণের মানকে কভার করে! এটি কেবল একাধিক মান ascবা descতদনুসারে বাছাই করবে না , তবে এটি মানগুলির "গোষ্ঠীগুলির" ধ্রুবক "অবস্থান" বজায় রাখবে। অন্য কথায়; ইনটগুলি সর্বদা প্রথম থাকে, তারপরে স্ট্রিং আসে, তারপরে অ্যারেগুলি (হ্যাঁ, আমি এই বহুমাত্রিক তৈরি করছি!), তারপরে অবজেক্টস (আবদ্ধ, উপাদান, তারিখ), এবং অবশেষে অপরিবর্তিত এবং নাল!

"কেন?" আপনি জিজ্ঞাসা। কেন না!

এখন 2 স্বাদে আসে! যার মধ্যে প্রথমে নতুন ব্রাউজারগুলির প্রয়োজন যেমন এটি অবজেক্টটিতে Object.definePropertyপদ্ধতিটি যুক্ত করতে ব্যবহৃত হয় Array.protoype। এই কর্মের জন্য করতে পারবেন প্রাকৃতিক যেমন ব্যবহার: myArray.smartSort('a')। আপনার যদি পুরানো ব্রাউজারগুলির জন্য প্রয়োগ করতে হয়, বা আপনি কেবল নেটিভ অবজেক্টগুলি সংশোধন করতে পছন্দ করেন না তবে কেবল মেথড সংস্করণে স্ক্রোল করুন ।

/* begin */
/* KEY NOTE! Requires EcmaScript 5.1 (not compatible with older browsers) */
;;(function(){if(Object.defineProperty&&!Array.prototype.smartSort){var h=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return a-b;if(/^stringstring$/ig.test(e))return a>b;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.smartSort("a");b instanceof Array&&b.smartSort("a");if(a instanceof Date&&b instanceof Date)return a-b;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=e.concat(g).smartSort("a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=[a[c],b[c]].smartSort("a"),a[c]==d[0]?-1:1;var f=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("a");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=[a.id,b.id].smartSort("a"),a.id==e[0]?1:-1;e=[a.tagName, b.tagName].smartSort("a");return a.tagName==e[0]?1:-1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);e.concat(g).smartSort("a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=[a[d].id,b[f].id].smartSort("a"),a[d].id==c[0]?-1:1;c=[a[d].tagName,b[f].tagName].smartSort("d"); return a[d].tagName==c[0]?1:-1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=[a[d],b[f]].smartSort("a"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element||!a.hasOwnProperty(d))return-1;if(!b.hasOwnProperty(d))return 1}c=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]>g[1]},k=function(a,b){if(null== a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return b-a;if(/^stringstring$/ig.test(e))return b>a;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.smartSort("d");b instanceof Array&&b.smartSort("d");if(a instanceof Date&&b instanceof Date)return b-a;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=e.concat(g).smartSort("a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=[a[c],b[c]].smartSort("d"),a[c]==d[0]?-1:1;var f=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=[a.id,b.id].smartSort("d"),a.id==e[0]?-1:1;e=[a.tagName,b.tagName].smartSort("d");return a.tagName==e[0]?-1:1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);e.concat(g).smartSort("a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=[a[d].id,b[f].id].smartSort("d"),a[d].id==c[0]?-1:1;c=[a[d].tagName,b[f].tagName].smartSort("d");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=[a[d],b[f]].smartSort("d"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element)return-1;if(!a.hasOwnProperty(d))return 1;if(!b.hasOwnProperty(d))return-1}c=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]<g[1]};Object.defineProperty(Array.prototype,"smartSort",{value:function(){return arguments&& (!arguments.length||1==arguments.length&&/^a([sc]{2})?$|^d([esc]{3})?$/i.test(arguments[0]))?this.sort(!arguments.length||/^a([sc]{2})?$/i.test(arguments[0])?h:k):this.sort()}})}})();
/* end */

jsFiddle অ্যারে.প্রোটোটাইপ.স্মার্টসোর্ট ('এসএসসি | ডেস্ক')


ব্যবহার সহজ! প্রথমে কিছু ক্রেজি অ্যারে তৈরি করুন:

window.z = [ 'one', undefined, $('<span />'), 'two', null, 2, $('<div />', { id: 'Thing' }), $('<div />'), 4, $('<header />') ];
z.push(new Date('1/01/2011'));
z.push('three');
z.push(undefined);
z.push([ 'one', 'three', 'four' ]);
z.push([ 'one', 'three', 'five' ]);
z.push({ a: 'a', b: 'b' });
z.push({ name: 'bob', value: 'bill' });
z.push(new Date());
z.push({ john: 'jill', jack: 'june' });
z.push([ 'abc', 'def', [ 'abc', 'def', 'cba' ], [ 'cba', 'def', 'bca' ], 'cba' ]);
z.push([ 'cba', 'def', 'bca' ]);
z.push({ a: 'a', b: 'b', c: 'c' });
z.push({ a: 'a', b: 'b', c: 'd' });

তারপর কেবল এটি সাজান!

z.smartSort('asc'); // Ascending
z.smartSort('desc'); // Descending

শুধুমাত্র পদ্ধতি

পূর্ববর্তী হিসাবে একই, কেবল একটি সহজ পদ্ধতি ছাড়া!

/* begin */
/* KEY NOTE! Method `smartSort` is appended to native `window` for global use. If you'd prefer a more local scope, simple change `window.smartSort` to `var smartSort` and place inside your class/method */
window.smartSort=function(){if(arguments){var a,b,c;for(c in arguments)arguments[c]instanceof Array&&(a=arguments[c],void 0==b&&(b="a")),"string"==typeof arguments[c]&&(b=/^a([sc]{2})?$/i.test(arguments[c])?"a":"d");if(a instanceof Array)return a.sort("a"==b?smartSort.asc:smartSort.desc)}return this.sort()};smartSort.asc=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return a-b;if(/^stringstring$/ig.test(e))return a> b;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.sort(smartSort.asc);b instanceof Array&&b.sort(smartSort.asc);if(a instanceof Date&&b instanceof Date)return a-b;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=smartSort(e.concat(g),"a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=smartSort([a[c], b[c]],"a"),a[c]==d[0]?-1:1;var f=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"a");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=smartSort([a.id,b.id],"a"),a.id==e[0]?1:-1;e=smartSort([a.tagName,b.tagName],"a");return a.tagName==e[0]?1:-1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);smartSort(e.concat(g), "a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=smartSort([a[d].id,b[f].id],"a"),a[d].id==c[0]?-1:1;c=smartSort([a[d].tagName,b[f].tagName],"a");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=smartSort([a[d],b[f]],"a"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1; if(b.hasOwnProperty(f)&&b[f]instanceof Element||!a.hasOwnProperty(d))return-1;if(!b.hasOwnProperty(d))return 1}c=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"a");return a[Object.keys(a)[0]]==c[0]?1:-1}g=[a,b].sort();return g[0]>g[1]};smartSort.desc=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return b-a;if(/^stringstring$/ig.test(e))return b>a;if(/(string|number){2}/ig.test(e))return/string/i.test(c)? 1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.sort(smartSort.desc);b instanceof Array&&b.sort(smartSort.desc);if(a instanceof Date&&b instanceof Date)return b-a;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=smartSort(e.concat(g),"a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=smartSort([a[c],b[c]],"d"),a[c]==d[0]?-1:1;var f=smartSort([a[Object.keys(a)[0]], b[Object.keys(b)[0]]],"d");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=smartSort([a.id,b.id],"d"),a.id==e[0]?-1:1;e=smartSort([a.tagName,b.tagName],"d");return a.tagName==e[0]?-1:1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);smartSort(e.concat(g),"a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&& b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=smartSort([a[d].id,b[f].id],"d"),a[d].id==c[0]?-1:1;c=smartSort([a[d].tagName,b[f].tagName],"d");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=smartSort([a[d],b[f]],"d"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element)return-1; if(!a.hasOwnProperty(d))return 1;if(!b.hasOwnProperty(d))return-1}c=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]<g[1]}
/* end */

ব্যবহার করুন:

z = smartSort(z, 'asc'); // Ascending
z = smartSort(z, 'desc'); // Descending

jsFizz পদ্ধতি স্মার্টসোর্ট (অ্যারে, "এসএসসি | ডেস্ক")


2

এই কোড ব্যবহার করে দেখুন:

এইচটিএমএল:

<div id="demo"></div>

জাভাস্ক্রিপ্ট কোড:

<script>
    (function(){
        var points = [40, 100, 1, 5, 25, 10];
        document.getElementById("demo").innerHTML = points;
        points.sort(function(a, b){return a-b});
        document.getElementById("demo").innerHTML = points;
    })();
</script>

2

নীচের মত এই কোড চেষ্টা করুন

var a = [5, 17, 29, 48, 64, 21];
function sortA(arr) {
return arr.sort(function(a, b) {
return a - b;
})
;} 
alert(sortA(a));

এটা কি সত্য নয়?
user7125929

1
var numArray = [140000, 104, 99];
numArray = numArray.sort((a,b) => a-b);
alert(numArray)

4
স্ট্যাকওভারফ্লোতে আপনাকে স্বাগতম। আপনার উত্তর গৃহীত উত্তরের মতো। কেন আপনি নিজের উত্তরের সাথে কোনও ব্যাখ্যা যুক্ত করতে পারেন যে এটি কেন গৃহীত উত্তরের চেয়ে বেশি পছন্দ করা উচিত?
সহজভাবে গেড

1

জাভাস্ক্রিপ্টে প্রয়োজনীয় না থাকা অবস্থায়, আপনি যদি কঠোরভাবে -1, 0, বা 1 ( স্পেসশিপ অপারেটরটি পিএইচপি- তে কীভাবে কাজ করে তার অনুরূপ) ফিরে আসতে চান , তবে আপনি ব্যবহার করতে পারেন ।sort() compareFunctionMath.sign()

compareFunctionনিচে কঠোরভাবে ফেরৎ -1, 0, অথবা 1:

numArray.sort((a, b) => Math.sign(a - b));

দ্রষ্টব্য: Math.sign() ইন্টারনেট এক্সপ্লোরারে সমর্থিত নয়।


0

এটি অ্যারে প্রোটোটাইপের একটি পদ্ধতি হিসাবে ইতিমধ্যে প্রস্তাবিত এবং স্বীকৃত সমাধান:

Array.prototype.sortNumeric = function () {
    return this.sort((a, b) => a - b);
};
Array.prototype.sortNumericDesc = function () {
    return this.sort((a, b) => b - a);
};

0

সাজানোর পদ্ধতি অ্যারে উপাদানগুলিকে স্ট্রিংয়ে রূপান্তর করে। সুতরাং, নীচে উপায় অ্যারের উপাদানগুলির সাথে দশমিক সংখ্যার সাথেও সূক্ষ্মভাবে কাজ করে।

let productPrices = [10.33, 2.55, 1.06, 5.77];
console.log(productPrices.sort((a,b)=>a-b));

এবং আপনাকে প্রত্যাশিত ফলাফল দেয়।


0

বাছাই পদ্ধতিটি ওভাররাইড করা।

Array.prototype.sortInt = function(){
    this.sort(function(a,b){return a-b});
}


numbers = [12,8,21,5,1,34];
numbers.sortInt()
//output -> [1,5,8,12,21,34]

0

ডিফল্ট বাছাই ফাংশন অভিধান ক্রমে সাজানো:

var ar = [10000,3,200];
console.log(ar.sort());
//it will sort like :=> [10000, 200, 3]

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

var ar = [10000,3,-09,200];
function customSortHelpForNumber(number1, number2){
     return number1-number2;
}
console.log(ar.sort(customSortHelpForNumber));
//it will sort like :=> [3, 200, 10000]

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

  • - বা মান বা 0, এটি তার জায়গায় প্রথম সংখ্যা রাখে
  • + ভ্যালু এটি স্থান বিনিময়।

সমস্ত সংখ্যার জন্য এটি অনুসরণ করে এটি পূর্ণসংখ্যার অ্যারে বাছাই করে।

আপনি যদি ES6 ব্যবহার করছেন তবে একটি তীর ফাংশন লিখুন:

console.log(ar.sort((num1,num2)=> num1-num2));
    //it will sort like :=> [3, 200, 10000]

-1

ইউটিস লাইব্রেরিতে আমার সাজানোর অ্যারে ফাংশনটি এখানে:

sortArray: function(array) {
    array.sort(function(a, b) {
        return a > b;
    });
},

# Let's test a string array
var arr = ['bbc', 'chrome', 'aux', 'ext', 'dog'];
utils.sortArray(arr);
console.log(arr);
>>> ["aux", "bbc", "chrome", "dog", "ext", remove: function]

# Let's test a number array
var arr = [55, 22, 1425, 12, 78];
utils.sortArray(arr);
console.log(arr);
>>> [12, 22, 55, 78, 1425, remove: function]

3
এটি সাধারণ ভুল! বাছাই ফাংশনটি সত্য বা মিথ্যা নয়, নেতিবাচক 0 বা ধনাত্মক সংখ্যাগুলি ফেরত দরকার।
jperelli

@ জ্পেরেলি যেমন উল্লেখ করেছেন, সাজানোর ফাংশনটির ফিরিয়ে আনার জন্য একটি বুলিয়ান নয়, একটি সংখ্যক প্রয়োজন (এবং প্রদত্ত তিনটি সম্ভাব্য রাজ্য কীভাবে সমান, উপরে এবং নীচে দেওয়া হয়, এটি একটি স্থিতিশীল বাছাই করা প্রয়োজন)। আপনার উত্তর হিসাবে বলা হয়েছে, এটি কার্যকর হয় না। a-bপরিবর্তে ব্যবহার করা উচিত। (আপনি অভিনব পেতে পারেন এবং এটি করতে পারেন Number(a>b)-0.5, তবে এটি এখনও স্থিতিশীল সাজ নয়)।
ecc521
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.