জাভাস্ক্রিপ্টের একটি অ্যারেতে উপাদানগুলি ঘোরান

Question 1

আমি ভাবছিলাম জাভাস্ক্রিপ্ট অ্যারে ঘোরানোর সবচেয়ে কার্যকর উপায় কোনটি?

আমি এই সমাধানটি নিয়ে এসেছি, যেখানে ইতিবাচক nডানদিকে অ্যারেটি ঘোরায় এবং nবাম দিকে একটি নেতিবাচক -length < n < length:

Array.prototype.rotateRight = function( n ) {
  this.unshift( this.splice( n, this.length ) );
}

যা এরপরে এভাবে ব্যবহার করা যেতে পারে:

var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
months.rotate( new Date().getMonth() );

উপরে আমার মূল সংস্করণটির একটি ত্রুটি রয়েছে, যেমন মন্তব্যগুলিতে ক্রিস্টোফের দ্বারা উল্লেখ করা হয়েছে , সঠিক সংস্করণটি হ'ল (অতিরিক্ত রিটার্ন শৃঙ্খলা দেয়):

Array.prototype.rotateRight = function( n ) {
  this.unshift.apply( this, this.splice( n, this.length ) );
  return this;
}

সম্ভবত কোনও জাভাস্ক্রিপ্ট কাঠামোর প্রসঙ্গে আরও কি কমপ্যাক্ট এবং / বা দ্রুত সমাধান রয়েছে? (প্রস্তাবিত সংস্করণগুলির কোনওটিই কমপ্যাক্ট বা দ্রুত নয়)

সেখানে কি কোনও জাভাস্ক্রিপ্ট ফ্রেমওয়ার্ক অন্তর্নির্মিত অ্যারে ঘোরানো সহ আছে? (এখনও কারও উত্তর দেওয়া হয়নি)

Question 2

টাইপ-নিরাপদ, জেনেরিক সংস্করণ যা অ্যারেটিকে পরিবর্তিত করে:

Array.prototype.rotate = (function() {
    // save references to array functions to make lookup faster
    var push = Array.prototype.push,
        splice = Array.prototype.splice;

    return function(count) {
        var len = this.length >>> 0, // convert to uint
            count = count >> 0; // convert to int

        // convert count to value in range [0, len)
        count = ((count % len) + len) % len;

        // use splice.call() instead of this.splice() to make function generic
        push.apply(this, splice.call(this, 0, count));
        return this;
    };
})();

মন্তব্যে জিন এই বিষয়টি উত্থাপন করেছিলেন যে কোডটি ওভারলোডিং সমর্থন করে না push()এবং splice()। আমি মনে করি না এটি সত্যিই দরকারী (মন্তব্য দেখুন), তবে একটি দ্রুত সমাধান (কিছুটা হ্যাক, যদিও) লাইনটি প্রতিস্থাপন করা হবে

push.apply(this, splice.call(this, 0, count));

এটার সাথে:

(this.push || push).apply(this, (this.splice || splice).call(this, 0, count));

অপেরা 10-তে unshift()এর পরিবর্তে ব্যবহার করা push()প্রায় দ্বিগুণ দ্রুত, যখন এফএফের পার্থক্য ছিল নগণ্য; কোড:

Array.prototype.rotate = (function() {
    var unshift = Array.prototype.unshift,
        splice = Array.prototype.splice;

    return function(count) {
        var len = this.length >>> 0,
            count = count >> 0;

        unshift.apply(this, splice.call(this, count % len, len));
        return this;
    };
})();

Question 3

আপনি ব্যবহার করতে পারেন push(), pop(), shift()এবং unshift()পদ্ধতি:

function arrayRotate(arr, reverse) {
  if (reverse) arr.unshift(arr.pop());
  else arr.push(arr.shift());
  return arr;
}

ব্যবহার:

arrayRotate(['h','e','l','l','o']);       // ['e','l','l','o','h'];
arrayRotate(['h','e','l','l','o'], true); // ['o','h','e','l','l'];

আপনার যদি countযুক্তির প্রয়োজন হয় তবে আমার অন্য উত্তরটি দেখুন: https://stackoverflow.com/a/33451102 🖤🧡💚💙💜 🖤🧡💚💙💜

Question 4

আমি সম্ভবত এটি কিছু করতে হবে:

Array.prototype.rotate = function(n) {
    return this.slice(n, this.length).concat(this.slice(0, n));
}

সম্পাদনা করুন এখানে রূপান্তরকারী সংস্করণ:

Array.prototype.rotate = function(n) {
    while (this.length && n < 0) n += this.length;
    this.push.apply(this, this.splice(0, n));
    return this;
}

Question 5

এই ফাংশনটি উভয় পথেই কাজ করে এবং যে কোনও সংখ্যার সাথে (এমনকি অ্যারের দৈর্ঘ্যের চেয়ে বেশি সংখ্যার সাথেও) কাজ করে:

function arrayRotate(arr, count) {
  count -= arr.length * Math.floor(count / arr.length);
  arr.push.apply(arr, arr.splice(0, count));
  return arr;
}

ব্যবহার:

for(let i = -6 ; i <= 6 ; i++) {
  console.log(arrayRotate(["🧡","💚","💙","💜","🖤"], i), i);
}

ফলাফল:

[ "🖤", "🧡", "💚", "💙", "💜" ]    -6
[ "🧡", "💚", "💙", "💜", "🖤" ]    -5
[ "💚", "💙", "💜", "🖤", "🧡" ]    -4
[ "💙", "💜", "🖤", "🧡", "💚" ]    -3
[ "💜", "🖤", "🧡", "💚", "💙" ]    -2
[ "🖤", "🧡", "💚", "💙", "💜" ]    -1
[ "🧡", "💚", "💙", "💜", "🖤" ]    0
[ "💚", "💙", "💜", "🖤", "🧡" ]    1
[ "💙", "💜", "🖤", "🧡", "💚" ]    2
[ "💜", "🖤", "🧡", "💚", "💙" ]    3
[ "🖤", "🧡", "💚", "💙", "💜" ]    4
[ "🧡", "💚", "💙", "💜", "🖤" ]    5
[ "💚", "💙", "💜", "🖤", "🧡" ]    6

Question 6

সুতরাং এই উত্তরগুলির মধ্যে অনেকগুলি জটিল ও জটিল মনে হয়। আমি মনে করি না যে আমি কাউকে কনক্যাট দিয়ে স্প্লাইস ব্যবহার করতে দেখেছি ...

function rotateCalendar(){
    var cal=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],
    cal=cal.concat(cal.splice(0,new Date().getMonth()));
    console.log(cal);  // return cal;
}

কনসোল.লগ আউটপুট (* মে মাসে উত্পন্ন):

["May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "Jan", "Feb", "Mar", "Apr"]

সংক্ষিপ্ততার জন্য, আমি বেশ কয়েকটি জেনেরিক ওয়ান-লাইনার ফাংশন (কনসোল.লগ | রিটার্ন অংশটি গণনা করছি না) অফার করতে পারি। আর্গুমেন্টগুলিতে কেবল এটিকে এবং লক্ষ্য মানটি খাওয়ান।

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

* লক্ষ্য করুন, ফাংশনগুলির মধ্যে একমাত্র পার্থক্য হ'ল "+ 1"।

function rotateToFirst(arr,val){  // val is Trump Declarer's seat, first to play
    arr=arr.concat(arr.splice(0,arr.indexOf(val)));
    console.log(arr); // return arr;
}
function rotateToLast(arr,val){  // val is Dealer's seat, last to bid
    arr=arr.concat(arr.splice(0,arr.indexOf(val)+1));
    console.log(arr); // return arr;
}

সমন্বয় ফাংশন ...

function rotateArray(arr,val,pos){
    // set pos to 0 if moving val to first position, or 1 for last position
    arr=arr.concat(arr.splice(0,arr.indexOf(val)+pos));
    return arr;
}
var adjustedArray=rotateArray(['N','E','S','W'],'S',1);

সমন্বিতআরে =

W,N,E,S

Question 7

অপরিবর্তনীয় উদাহরণের জন্য ES6 এর স্প্রেড ব্যবহার করে ...

[...array.slice(1, array.length), array[0]]

এবং

[array[array.items.length -1], ...array.slice(0, array.length -1)]

এটি সম্ভবত সবচেয়ে দক্ষ না হলেও এটি সংক্ষিপ্ত।

Question 8

স্লাইস এবং ডিস্ট্রাকচারিং সহ সহজ সমাধান:

const rotate = (arr, count = 1) => {
  return [...arr.slice(count, arr.length), ...arr.slice(0, count)];
};

const arr = [1,2,3,4,5];

console.log(rotate(arr, 1));  // [2, 3, 4, 5, 1]
console.log(rotate(arr, 2));  // [3, 4, 5, 1, 2]
console.log(rotate(arr, -2)); // [4, 5, 1, 2, 3]
console.log(rotate(arr, -1)); // [5, 1, 2, 3, 4]

স্নিপেট প্রসারিত করুন

Question 9

এখানে অ্যারে আইটেমগুলি স্থানান্তর করার খুব সহজ উপায়:

function rotate(array, stepsToShift) {

    for (var i = 0; i < stepsToShift; i++) {
        array.unshift(array.pop());
    }

    return array;
}

Question 10

@ ক্রিসটফ, আপনি একটি পরিষ্কার কোড করেছেন, তবে আমি এটি খুঁজে পেয়েছি তার চেয়ে 60% ধীর slow জেসফিউমের ফলাফলটি দেখুন: http://jsppha.com/js-rotate-array/2 [সম্পাদনা] ঠিক আছে এখন আরও ব্রাউজার রয়েছে যা স্পষ্ট নয় ডাইনি পদ্ধতিগুলি সেরা

var rotateArray = function(a, inc) {
    for (var l = a.length, inc = (Math.abs(inc) >= l && (inc %= l), inc < 0 && (inc += l), inc), i, x; inc; inc = (Math.ceil(l / inc) - 1) * inc - l + (l = inc))
    for (i = l; i > inc; x = a[--i], a[i] = a[i - inc], a[i - inc] = x);
    return a;
};

var array = ['a','b','c','d','e','f','g','h','i'];

console.log(array);
console.log(rotateArray(array.slice(), -1)); // Clone array with slice() to keep original

Question 11

দেখতে http://jsperf.com/js-rotate-array/8

function reverse(a, from, to) {
  --from;
  while (++from < --to) {
    var tmp = a[from];
    a[from] = a[to];
    a[to] = tmp;
  }
}

function rotate(a, from, to, k) {
  var n = to - from;
  k = (k % n + n) % n;
  if (k > 0) {
    reverse(a, from, from + k);
    reverse(a, from + k, to);
    reverse(a, from, to);
  }
}

Question 12

'আজ' দিয়ে দিনের তালিকা শুরু করার জন্য যখন আমি একটি রেডিমেড স্নিপেটটি খুঁজে পেলাম না, তখন আমি এটি পছন্দ করেছিলাম (উপরের উদাহরণগুলির তুলনায় বেশ জেনারিক নয়, সম্ভবত খুব কম পরিশ্রুত, তবে কাজটি করেছেন):

//returns 7 day names with today first
function startday() {
    const days = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'];
    let today = new Date();
    let start = today.getDay(); //gets day number
    if (start == 0) { //if Sunday, days are in order
        return days
    }
    else { //if not Sunday, start days with today
        return days.slice(start).concat(days.slice(0,start))
    }
}

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

Question 13

function rotate(arr, k) {
for (var i = 0; i < k+1; i++) {
    arr.push(arr.shift());
}
return arr;
}
//k work as an index array
console.log(rotate([1, 2, 7, 4, 5, 6, 7], 3)); //[5,6,7,1,2,7,4]
console.log(rotate([-1, -100, 3, 99], 2));     //[99,-1,-100,3]

Question 14

// Example of array to rotate
let arr = ['E', 'l', 'e', 'p', 'h', 'a', 'n', 't'];

// Getting array length
let length = arr.length;

// rotation < 0 (move left), rotation > 0 (move right)
let rotation = 5;

// Slicing array in two parts
let first  = arr.slice(   (length - rotation) % length, length); //['p', 'h', 'a' ,'n', 't']
let second = arr.slice(0, (length - rotation) % length); //['E', 'l', 'e']

// Rotated element
let rotated = [...first, ...second]; // ['p', 'h', 'a' ,'n', 't', 'E', 'l', 'e']

কোডের একটি লাইনে:

let rotated = [...arr.slice((length - rotation) % length, length), ...arr.slice(0, (length - rotation) % length)];

Question 15

গৃহীত উত্তরের মধ্যে কল স্ট্যাক আকারের চেয়ে বড় অ্যারেগুলি পরিচালনা করতে না পারার একটি ত্রুটি রয়েছে যা সেশনের উপর নির্ভর করে তবে এটি প্রায় 100 ~ 300K আইটেমের মতো হওয়া উচিত। উদাহরণস্বরূপ, বর্তমান ক্রোম সেশনে আমি চেষ্টা করেছি এটি 250891 many সুতরাং এটি একটি গুরুতর সমস্যা

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

Array.prototype.rotate = function(n) {
var len = this.length;
return !(n % len) ? this
                  : n > 0 ? this.map((e,i,a) => a[(i + n) % len])
                          : this.map((e,i,a) => a[(len - (len - i - n) % len) % len]);
};
var a = [1,2,3,4,5,6,7,8,9],
    b = a.rotate(2);
console.log(JSON.stringify(b));
    b = a.rotate(-1);
console.log(JSON.stringify(b));

স্নিপেট প্রসারিত করুন

আসলে দুটি বিষয় নিয়ে আমার নিম্নরূপ সমালোচনা হওয়ার পরে;

ধনাত্মক বা নেতিবাচক ইনপুটটির জন্য শর্তাধীন হওয়ার প্রয়োজন নেই কারণ এটি ডিআরওয়াইয়ের লঙ্ঘন প্রকাশ করে y
একটি অ্যারে ফাংশনটি হয় বর্তমান অ্যারে পরিবর্তন করতে হবে বা একটি নতুন অ্যারে তৈরি করা উচিত, আপনার ফাংশনটি শিফট প্রয়োজনীয় কিনা তা নির্ভর করে করতে পারে (সম্পূর্ণ সঠিক) ..

আমি নীচে কোডটি সংশোধন করার সিদ্ধান্ত নিয়েছি;

Array.prototype.rotate = function(n) {
var len = this.length;
return !(n % len) ? this.slice()
                  : this.map((e,i,a) => a[(i + (len + n % len)) % len]);
};
var a = [1,2,3,4,5,6,7,8,9],
    b = a.rotate(10);
console.log(JSON.stringify(b));
    b = a.rotate(-10);
console.log(JSON.stringify(b));

স্নিপেট প্রসারিত করুন

তারপরে আবার; অবশ্যই জেএস ফ্যান্টেক্টরগুলি Array.prototype.map()তাদের সমতুল্য জেএসে কোডড সমতুলের তুলনায় ধীর। ১০০% এর বেশি পারফরম্যান্স বাড়াতে নিম্নলিখিতগুলি সম্ভবত আমার পছন্দ হতে পারে Array.prototype.rotate()যদি আমার প্রয়াসে আমি যেভাবে ব্যবহৃত হয়েছিল তার মতো প্রোডাকশন কোডে কোনও অ্যারে ঘোরানো প্রয়োজনString.prototype.diff()

Array.prototype.rotate = function(n){
  var len = this.length,
      res = new Array(this.length);
  if (n % len === 0) return this.slice();
  else for (var i = 0; i < len; i++) res[i] = this[(i + (len + n % len)) % len];
  return res;
};

Question 16

এই ফাংশনটি ছোট অ্যারের জন্য গৃহীত উত্তরের চেয়ে কিছুটা দ্রুত তবে বড় অ্যারেগুলির জন্য খুব দ্রুত। এই ফাংশনটি অ্যারের দৈর্ঘ্যের চেয়েও বেশি সংখ্যক আবর্তনের অনুমতি দেয় যা মূল ফাংশনের সীমাবদ্ধতা।

শেষ অবধি, গৃহীত উত্তর বর্ণিত হিসাবে বিপরীত দিকে ঘোরে।

const rotateForEach = (a, n) => {
    const l = a.length;
    a.slice(0, -n % l).forEach(item => a.push( item ));
    return a.splice(n % l > 0 ? (-n % l) : l + (-n % l));
}

এবং কার্যক্ষম সমতুল্য (যা কিছু কার্যকারিতা বেনিফিট বলে মনে হয়):

const rotateReduce = (arr, n) => {
    const l = arr.length;
    return arr.slice(0, -n % l).reduce((a,b) => {
        a.push( b );
        return a;
    }, arr).splice(n % l> 0 ? l + (-n % l) : -n % l);
};

আপনি এখানে পারফরম্যান্স ব্রেকডাউন পরীক্ষা করে দেখতে পারেন ।

Question 17

সম্পাদনা করুন: আরে তাই দেখা যাচ্ছে যে খুব বেশি পুনরাবৃত্তি ঘটছে। লুপ নেই, শাখা নেই।

তবুও ডান ঘোরার জন্য নেতিবাচক এন এবং যে কোনও আকারের বাম রোটেশনের জন্য ধনাত্মক এন, মিউটেশন মুক্ত works

function rotate(A,n,l=A.length) {
  const offset = (((n % l) + l) %l)
  return A.slice(offset).concat(A.slice(0,offset))
}

গিগলসের জন্য কোড গল্ফ সংস্করণ এখানে

const r = (A,n,l=A.length,i=((n%l)+l)%l)=>A.slice(i).concat(A.slice(0,i))

EDIT1 :: * শাখাবিহীন, মিউটেশনহীন বাস্তবায়ন।

সুতরাং ওহে, দেখা যাচ্ছে আমার একটি শাখা ছিল যেখানে আমার এটির দরকার ছিল না। এখানে একটি কার্যনির্বাহী সমাধান দেওয়া হল। numণাত্মক num = ডানদিকে ঘুরান | num | ধনাত্মক সংখ্যা = বাম দ্বারা সংখ্যা দ্বারা ঘোরান

function r(A,n,l=A.length) {
  return A.map((x,i,a) => A[(((n+i)%l) + l) % l])
}

সমীকরণ ((n%l) + l) % lমানচিত্রের যেকোন যথেচ্ছ বৃহত মানগুলির ঠিক ধনাত্মক এবং negativeণাত্মক সংখ্যা maps

মূল

বাম এবং ডানদিকে ঘোরান। ধনাত্মক সহ বামদিকে ঘোরান n, নেতিবাচক দিয়ে ডানদিকে ঘোরান n।

অশ্লীলভাবে বড় ইনপুটগুলির জন্য কাজ করে n।

কোনও মিউটেশন মোড নেই। এই উত্তরে খুব বেশি মিউটেশন।

এছাড়াও, বেশিরভাগ উত্তরের চেয়ে কম অপারেশন। কোনও পপ, কোনও ধাক্কা, কোনও ছিটমহল, কোনও শিফট নেই।

const rotate = (A, num ) => {
   return A.map((x,i,a) => {
      const n = num + i
      return n < 0 
        ? A[(((n % A.length) + A.length) % A.length)]
        : n < A.length 
        ? A[n] 
        : A[n % A.length]
   })
}

বা

 const rotate = (A, num) => A.map((x,i,a, n = num + i) => 
  n < 0
    ? A[(((n % A.length) + A.length) % A.length)]
    : n < A.length 
    ? A[n] 
    : A[n % A.length])

//test
rotate([...Array(5000).keys()],4101)   //left rotation
rotate([...Array(5000).keys()],-4101000)  //right rotation, num is negative

// will print the first index of the array having been rotated by -i
// demonstrating that the rotation works as intended
[...Array(5000).keys()].forEach((x,i,a) => {
   console.log(rotate(a,-i)[0])
}) 
// prints even numbers twice by rotating the array by i * 2 and getting the first value
//demonstrates the propper mapping of positive number rotation when out of range
[...Array(5000).keys()].forEach((x,i,a) => {
   console.log(rotate(a,i*2)[0])
})

ব্যাখ্যা:

অফসেটের মান হিসাবে A এর প্রতিটি সূচি ম্যাপ করুন। এক্ষেত্রে

offset = num

যদি offset < 0তারপর offset + index + positive length of Aবিপরীত অফসেট নির্দেশ করবে।

তা হলে offset > 0 and offset < length of Aকেবল এ এর অফসেট সূচকে বর্তমান সূচকটি মানচিত্র করুন

অন্যথায়, অ্যারির সীমানায় অফসেটটি মানচিত্রের অফসেট এবং দৈর্ঘ্যটি মডুলো করুন।

উদাহরণস্বরূপ নিন offset = 4এবং offset = -4।

যখন offset = -4এবং A = [1,2,3,4,5]প্রতিটি সূচকের offset + indexজন্য, দৈর্ঘ্য (বা Math.abs(offset)) আরও ছোট করা হবে।

প্রথমে negativeণাত্মক এন এর সূচকের গণনাটি ব্যাখ্যা করি। A[(((n % A.length) + A.length) % A.length)+0]এবং ভয় দেখানো হয়েছে। হবেনা এটি কাজ করতে আমাকে একটি Repl এ 3 মিনিট সময় লেগেছে।

আমরা জানি nনেতিবাচক কারণ কেস n < 0। যদি সংখ্যাটি অ্যারের ব্যাপ্তির চেয়ে বড় n % A.lengthহয় তবে এটিকে পরিসরে মানচিত্র তৈরি করবে।
n + A.lengthA.lengthসঠিক পরিমাণে অফসেট করতে সেই সংখ্যাটি যুক্ত করুন ।
আমরা জানি nনেতিবাচক কারণ কেস n < 0। সঠিক পরিমাণে অফসেট n + A.lengthকরতে সেই সংখ্যাটি যুক্ত করুন A.length।
পরবর্তী এটিকে মডুলো ব্যবহার করে এ এর দৈর্ঘ্যের সীমাতে মানচিত্র করুন। দ্বিতীয় মডুলাসের গণনার ফলাফলকে সূচকযোগ্য পরিসরে মানচিত্রের জন্য প্রয়োজনীয়
প্রথম সূচক: -4 + 0 = -4। উঃ দৈর্ঘ্য = 5. দৈর্ঘ্য - 4 = 1. এ 2 2 মানচিত্র সূচক 0 থেকে 2।[2,... ]
পরবর্তী সূচি, -4 + 1 = -3। 5 + -3 = 2. এ 2 হয় 3. মানচিত্র সূচক 1 থেকে 3।[2,3... ]
ইত্যাদি

একই প্রক্রিয়া প্রযোজ্য offset = 4। প্রতিটি সূচকের জন্য কখন offset = -4এবং A = [1,2,3,4,5], offset + indexএর পরিমাণ আরও বাড়িয়ে তুলবে।

4 + 0 = 0। A [0] এ মান [4] এ মানচিত্র করুন।[5...]
4 + 1 = 5, 5 সূচকের বাইরে সীমা ছাড়িয়ে যায়, সুতরাং অবশিষ্ট 2 তে মান 2 এ মানচিত্র করুন 5 / 5, যা 0 এ। 2 = মান [0] এ [0]।[5,1...]
পুনরাবৃত্তি

Question 18

Follow a simpler approach of running a loop to n numbers and shifting places upto that element.

function arrayRotateOne(arr, n) {
  for (let i = 0; i < n; i++) {
    arr.unshift(arr.pop());
  }
  return arr;
}
console.log( arrayRotateOne([1,2,3,4,5,6],2));



function arrayRotateOne(arr,n) {
  for(let i=0; i<n;i++){
      arr.push(arr.shift());
      console.log('execute',arr)
    }
     return arr;
 }

কনসোল.লগ (অ্যারেরোটেটওন ([1,2,3,4,5,6], 2%));

Question 19

অ পরিবর্তনীয় সমাধান

var arr = ['a','b','c','d']
arr.slice(1,arr.length).concat(arr.slice(0,1)

রূপান্তর সঙ্গে

var arr = ['a','b','c','d']
arr = arr.concat(arr.splice(0,1))

Question 20

আমি আমার সমাধানটি ভাগ করছি যা আমি কারাউসেল ঘোরার জন্য ব্যবহার করছি। অ্যারের আকার এর চেয়ে ছোট হলে এটি ভেঙে যেতে পারে displayCountতবে আপনি যখন ছোট হন তখন আবর্তন বন্ধ করতে বা মূল অ্যারে * ডিসপ্লেকাউন্টের সময়কেও যুক্ত করে অতিরিক্ত শর্ত যুক্ত করতে পারেন।

function rotate(arr, moveCount, displayCount) {
  const size = arr.length;

  // making sure startIndex is between `-size` and `size`
  let startIndex = moveCount % size;
  if (startIndex < 0) startIndex += size; 

  return [...arr, ...arr].slice(startIndex, startIndex + displayCount);
}

// move 3 to the right and display 4 items
// rotate([1,2,3,4,5], 3, 4) -> [4,5,1,2]

// move 3 to the left and display 4 items
// rotate([1,2,3,4,5], -3, 4) -> [3,4,5,1]

// move 11 to the right and display 4
// rotate([1,2,3,4,5], 3, 4) -> [2,3,4,5]

Question 21

কাউন্টার বাড়ানো কীভাবে এবং তারপরে আপনার অনুমিত হয় যেখানে পাওয়ার জন্য অ্যারের দৈর্ঘ্য অনুসারে বিভাগের বাকী অংশটি কীভাবে পাবেন।

var i = 0;
while (true);
{
    var position = i % months.length;
    alert(months[position]);
    ++i;
}

ভাষার বাক্য গঠনটি এটিকে ঠিকভাবে কাজ করা উচিত।

Question 22

যদি আপনার অ্যারেটি বড় হতে চলেছে এবং / অথবা আপনি অনেকগুলি ঘুরতে চলেছেন তবে আপনি অ্যারের পরিবর্তে লিঙ্কযুক্ত তালিকাটি ব্যবহার করে বিবেচনা করতে চাইতে পারেন।

Question 23

@ মোলোকোলোকো আমার একটি ফাংশন দরকার যা আমি কোনও দিক ঘোরানোর জন্য কনফিগার করতে পারি - ফরওয়ার্ডের জন্য সত্য এবং পিছনের পক্ষে মিথ্যা। আমি একটি স্নিপেট তৈরি করেছি যা একটি দিকনির্দেশ, একটি কাউন্টার এবং একটি অ্যারে নিয়ে যায় এবং উপযুক্ত দিকের পাশাপাশি পূর্ব, বর্তমান এবং পরবর্তী মানগুলিতে বর্ধিত কাউন্টারটির সাথে কোনও বস্তু আউটপুট দেয়। এটি মূল অ্যারেটি পরিবর্তন করে না।

আমি এটিকে আপনার স্নিপেটের বিপরীতেও আটকে রেখেছি এবং যদিও এটি দ্রুত নয় তবে আপনি যেটির সাথে তুলনা করেন তার চেয়ে দ্রুত - 21% ধীর http://jsperf.com/js-rotate-array/7 ।

function directionalRotate(direction, counter, arr) {
  counter = direction ? (counter < arr.length - 1 ? counter + 1 : 0) : (counter > 0 ? counter - 1 : arr.length - 1)
  var currentItem = arr[counter]
  var priorItem = arr[counter - 1] ? arr[counter - 1] : arr[arr.length - 1]
  var nextItem = arr[counter + 1] ? arr[counter + 1] : arr[0]
  return {
    "counter": counter,
    "current": currentItem,
    "prior": priorItem,
    "next": nextItem
  }
}
var direction = true // forward
var counter = 0
var arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'];

directionalRotate(direction, counter, arr)

Question 24

আমি দেরিতে আসছি তবে এই ভাল উত্তরগুলি যুক্ত করার জন্য আমার একটি ইট রয়েছে। আমাকে এই জাতীয় ফাংশন কোড করতে বলা হয়েছিল এবং আমি প্রথমে এটি করেছি:

Array.prototype.rotate = function(n)
{
    for (var i = 0; i < n; i++)
    {
        this.push(this.shift());
    }
    return this;
}

তবে এটি কখন nবড় হবে তার চেয়ে কম দক্ষ বলে মনে হয়েছিল :

Array.prototype.rotate = function(n)
{
    var l = this.length;// Caching array length before map loop.

    return this.map(function(num, index) {
        return this[(index + n) % l]
    });
}

Question 25

আমি নিশ্চিত নই যে এটি সবচেয়ে দক্ষ উপায় কিনা তবে আমি এটি পড়ার পদ্ধতিটি পছন্দ করি, এটি বেশিরভাগ বড় কাজের জন্য যথেষ্ট পর্যাপ্ত কারণ আমি এটি পরীক্ষায় পরীক্ষা করেছি ...

function shiftRight(array) {
  return array.map((_element, index) => {
    if (index === 0) {
      return array[array.length - 1]
    } else return array[index - 1]
  })
}

function test() {
  var input = [{
    name: ''
  }, 10, 'left-side'];
  var expected = ['left-side', {
    name: ''
  }, 10]
  var actual = shiftRight(input)

  console.log(expected)
  console.log(actual)

}

test()

স্নিপেট প্রসারিত করুন

Question 26

নেটিভ, দ্রুত, ছোট, শব্দার্থক, পুরানো ইঞ্জিনগুলিতে এবং "তরকারিযোগ্য" কাজ করে।

function rotateArray(offset, array) {
    offset = -(offset % array.length) | 0 // ensure int
    return array.slice(offset).concat(
        array.slice(0, offset)
    )
}

Question 27

** জেএস এর সর্বশেষতম সংস্করণ ব্যবহার করে আমরা এটিকে প্রতিটি সহজেই তৈরি করতে পারি **

 Array.prototype.rotateLeft = function (n) {
   this.unshift(...this.splice(-(n), n));
    return this
  }

এখানে চলাফেরা করে: ঘূর্ণনের সংখ্যা , একটি অ্যারে যা আপনি এলোমেলো সংখ্যাটি পাস করতে পারেন

let a = [1, 2, 3, 4, 5, 6, 7];
let moves = 4;
let output = a.rotateLeft(moves);
console.log("Result:", output)

Question 28

Arrayজেএসে নীচে পদ্ধতিটি তৈরি করা হয়েছে যা একটি অ্যারে ঘোরানোর জন্য ব্যবহার করা যেতে পারে খুব সহজে এবং স্পষ্টতই এই পদ্ধতিগুলি প্রকৃতির অপরিবর্তনীয় ।

push: অ্যারের শেষে আইটেমটি সন্নিবেশ করান।
pop: অ্যারের প্রান্ত থেকে আইটেমটি সরিয়ে দেয়।
unshift: অ্যারের শুরুতে আইটেমটি সন্নিবেশ করান।
shift: অ্যারের শুরু থেকে আইটেমটি সরিয়ে দেয়।

নীচের সমাধানটি ( ES6) দুটি আর্গুমেন্ট গ্রহণ করে, অ্যারেটি ঘোরানো দরকার এবং n, অ্যারেটি কতবার ঘোরানো উচিত।

const rotateArray = (arr, n) => {
  while(arr.length && n--) {
    arr.unshift(arr.pop());
  }
  return arr;
}

rotateArray(['stack', 'overflow', 'is', 'Awesome'], 2) 
// ["is", "Awesome", "stack", "overflow"]

এটি অ্যারে.প্রোটোটাইপ যুক্ত করা যেতে পারে এবং আপনার অ্যাপ্লিকেশন জুড়ে ব্যবহার করা যেতে পারে

Array.prototype.rotate = function(n) {
 while(this.length && n--) {
   this.unshift(this.pop());
 }
 return this;
}
[1,2,3,4].rotate(3); //[2, 3, 4, 1]

Question 29

লুপের জন্য ব্যবহার করা হচ্ছে। পদক্ষেপগুলি এখানে

অ্যারির প্রথম উপাদানটি অস্থায়ী ভেরিয়েবল হিসাবে সংরক্ষণ করুন।
তারপরে বাম থেকে ডানে অদলবদল করুন।
তারপরে অ্যারের শেষ উপাদানটিতে টেম্প ভেরিয়েবল বরাদ্দ করুন।
ঘূর্ণন সংখ্যার জন্য এই পদক্ষেপগুলি পুনরাবৃত্তি করুন।

function rotateLeft(arr, rotations) {
    let len = arr.length;
    for(let i=0; i<rotations; i++){ 
        let temp = arr[0];
        for(let i=0; i< len; i++){
            arr[i]=arr[i+1];
        }
        arr[len-1]=temp;
    }
    return arr;
}

let arr = [1,2,3,4,5];

let rotations = 3;
let output = rotateLeft(arr, rotations);
console.log("Result Array => ", output);

স্নিপেট প্রসারিত করুন

Question 30

এস synt সিনট্যাক্স সহ

function rotLeft(a, d) {
    const removed = a.splice(0,d);
    return [...a, ...removed];
}

Question 31

নিম্নলিখিত ব্যবহার -

arr=[1,2,3,4,5]  
let arrs=[]
arrs=arr.slice(d%arr.length).concat(arr.slice(0,d%arr.length))

কোথায়, dকোন আবর্তনের
সেরা সমাধান, ও (1) সময়ের জটিলতার সাথে পপিং পুশিংয়ের ব্রুট ফোর্স কৌশল প্রয়োগের প্রয়োজন নেই